758 files changed, 56831 insertions, 78042 deletions

diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
index cf8587c..2c25f43 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.cxx
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx
@@ -39,22 +39,22 @@ cmCPackIFWGenerator::~cmCPackIFWGenerator()
 {
 }
 
-bool cmCPackIFWGenerator::IsVersionLess(const char *version)
+bool cmCPackIFWGenerator::IsVersionLess(const char* version)
 {
   return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
-    FrameworkVersion.data(), version);
+                                       FrameworkVersion.data(), version);
 }
 
-bool cmCPackIFWGenerator::IsVersionGreater(const char *version)
+bool cmCPackIFWGenerator::IsVersionGreater(const char* version)
 {
   return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
-    FrameworkVersion.data(), version);
+                                       FrameworkVersion.data(), version);
 }
 
-bool cmCPackIFWGenerator::IsVersionEqual(const char *version)
+bool cmCPackIFWGenerator::IsVersionEqual(const char* version)
 {
   return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
-    FrameworkVersion.data(), version);
+                                       FrameworkVersion.data(), version);
 }
 
 int cmCPackIFWGenerator::PackageFiles()
@@ -72,168 +72,141 @@ int cmCPackIFWGenerator::PackageFiles()
   ifwTmpFile += "/IFWOutput.log";
 
   // Run repogen
-  if (!Installer.Repositories.empty())
-    {
+  if (!Installer.Repositories.empty()) {
     std::string ifwCmd = RepoGen;
 
-    if(IsVersionLess("2.0.0"))
-      {
+    if (IsVersionLess("2.0.0")) {
       ifwCmd += " -c " + this->toplevel + "/config/config.xml";
-      }
+    }
 
     ifwCmd += " -p " + this->toplevel + "/packages";
 
-    if(!PkgsDirsVector.empty())
-      {
-      for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
-          it != PkgsDirsVector.end(); ++it)
-        {
+    if (!PkgsDirsVector.empty()) {
+      for (std::vector<std::string>::iterator it = PkgsDirsVector.begin();
+           it != PkgsDirsVector.end(); ++it) {
         ifwCmd += " -p " + *it;
-        }
       }
+    }
 
-    if (!OnlineOnly && !DownloadedPackages.empty())
-      {
+    if (!OnlineOnly && !DownloadedPackages.empty()) {
       ifwCmd += " -i ";
-      std::set<cmCPackIFWPackage*>::iterator it
-        = DownloadedPackages.begin();
+      std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
       ifwCmd += (*it)->Name;
       ++it;
-      while(it != DownloadedPackages.end())
-        {
+      while (it != DownloadedPackages.end()) {
         ifwCmd += "," + (*it)->Name;
         ++it;
-        }
       }
+    }
     ifwCmd += " " + this->toplevel + "/repository";
-    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
-                  << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd << std::endl);
     std::string output;
     int retVal = 1;
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                  "- Generate repository" << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate repository"
+                    << std::endl);
     bool res = cmSystemTools::RunSingleCommand(
-      ifwCmd.c_str(), &output, &output,
-      &retVal, 0, this->GeneratorVerbose, 0);
-    if ( !res || retVal )
-      {
+      ifwCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
+    if (!res || retVal) {
       cmGeneratedFileStream ofs(ifwTmpFile.c_str());
       ofs << "# Run command: " << ifwCmd << std::endl
           << "# Output:" << std::endl
           << output << std::endl;
       cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
-                    << ifwCmd << std::endl
-                    << "Please check " << ifwTmpFile << " for errors"
-                    << std::endl);
+                      << ifwCmd << std::endl
+                      << "Please check " << ifwTmpFile << " for errors"
+                      << std::endl);
       return 0;
-      }
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: " << this->toplevel
-                  << "/repository generated" << std::endl);
     }
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- repository: "
+                    << this->toplevel << "/repository generated" << std::endl);
+  }
 
   // Run binary creator
   {
-  std::string ifwCmd = BinCreator;
-  ifwCmd += " -c " + this->toplevel + "/config/config.xml";
-  ifwCmd += " -p " + this->toplevel + "/packages";
-
-  if(!PkgsDirsVector.empty())
-    {
-    for(std::vector<std::string>::iterator it = PkgsDirsVector.begin();
-        it != PkgsDirsVector.end(); ++it)
-      {
-      ifwCmd += " -p " + *it;
+    std::string ifwCmd = BinCreator;
+    ifwCmd += " -c " + this->toplevel + "/config/config.xml";
+    ifwCmd += " -p " + this->toplevel + "/packages";
+
+    if (!PkgsDirsVector.empty()) {
+      for (std::vector<std::string>::iterator it = PkgsDirsVector.begin();
+           it != PkgsDirsVector.end(); ++it) {
+        ifwCmd += " -p " + *it;
       }
     }
 
-  if (OnlineOnly)
-    {
-    ifwCmd += " --online-only";
-    }
-  else if (!DownloadedPackages.empty() && !Installer.Repositories.empty())
-    {
-    ifwCmd += " -e ";
-    std::set<cmCPackIFWPackage*>::iterator it
-      = DownloadedPackages.begin();
-    ifwCmd += (*it)->Name;
-    ++it;
-    while(it != DownloadedPackages.end())
-      {
-      ifwCmd += "," + (*it)->Name;
+    if (OnlineOnly) {
+      ifwCmd += " --online-only";
+    } else if (!DownloadedPackages.empty() &&
+               !Installer.Repositories.empty()) {
+      ifwCmd += " -e ";
+      std::set<cmCPackIFWPackage*>::iterator it = DownloadedPackages.begin();
+      ifwCmd += (*it)->Name;
       ++it;
+      while (it != DownloadedPackages.end()) {
+        ifwCmd += "," + (*it)->Name;
+        ++it;
       }
-    }
-  else if (!DependentPackages.empty())
-    {
-    ifwCmd += " -i ";
-    // Binary
-    std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
-    while(bit != BinaryPackages.end())
-      {
-      ifwCmd += (*bit)->Name + ",";
-      ++bit;
+    } else if (!DependentPackages.empty()) {
+      ifwCmd += " -i ";
+      // Binary
+      std::set<cmCPackIFWPackage*>::iterator bit = BinaryPackages.begin();
+      while (bit != BinaryPackages.end()) {
+        ifwCmd += (*bit)->Name + ",";
+        ++bit;
       }
-    // Depend
-    DependenceMap::iterator it = DependentPackages.begin();
-    ifwCmd += it->second.Name;
-    ++it;
-    while(it != DependentPackages.end())
-      {
-      ifwCmd += "," + it->second.Name;
+      // Depend
+      DependenceMap::iterator it = DependentPackages.begin();
+      ifwCmd += it->second.Name;
       ++it;
+      while (it != DependentPackages.end()) {
+        ifwCmd += "," + it->second.Name;
+        ++it;
       }
     }
-  // TODO: set correct name for multipackages
-  if (!this->packageFileNames.empty())
-    {
-    ifwCmd += " " + packageFileNames[0];
-    }
-  else
-    {
-    ifwCmd += " installer";
+    // TODO: set correct name for multipackages
+    if (!this->packageFileNames.empty()) {
+      ifwCmd += " " + packageFileNames[0];
+    } else {
+      ifwCmd += " installer";
     }
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd
-                << std::endl);
-  std::string output;
-  int retVal = 1;
-  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl);
-  bool res = cmSystemTools::RunSingleCommand(
-    ifwCmd.c_str(), &output, &output,
-    &retVal, 0, this->GeneratorVerbose, 0);
-  if ( !res || retVal )
-    {
-    cmGeneratedFileStream ofs(ifwTmpFile.c_str());
-    ofs << "# Run command: " << ifwCmd << std::endl
-        << "# Output:" << std::endl
-        << output << std::endl;
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
-                  << ifwCmd << std::endl
-                  << "Please check " << ifwTmpFile << " for errors"
-                  << std::endl);
-    return 0;
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << ifwCmd << std::endl);
+    std::string output;
+    int retVal = 1;
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl);
+    bool res = cmSystemTools::RunSingleCommand(
+      ifwCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
+    if (!res || retVal) {
+      cmGeneratedFileStream ofs(ifwTmpFile.c_str());
+      ofs << "# Run command: " << ifwCmd << std::endl
+          << "# Output:" << std::endl
+          << output << std::endl;
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running IFW command: "
+                      << ifwCmd << std::endl
+                      << "Please check " << ifwTmpFile << " for errors"
+                      << std::endl);
+      return 0;
     }
   }
 
   return 1;
 }
 
-const char *cmCPackIFWGenerator::GetPackagingInstallPrefix()
+const char* cmCPackIFWGenerator::GetPackagingInstallPrefix()
 {
-  const char *defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
+  const char* defPrefix = cmCPackGenerator::GetPackagingInstallPrefix();
 
   std::string tmpPref = defPrefix ? defPrefix : "";
 
-  if(this->Components.empty())
-    {
+  if (this->Components.empty()) {
     tmpPref += "packages/" + GetRootPackageName() + "/data";
-    }
+  }
 
   this->SetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX", tmpPref.c_str());
 
   return this->GetOption("CPACK_IFW_PACKAGING_INSTALL_PREFIX");
 }
 
-const char *cmCPackIFWGenerator::GetOutputExtension()
+const char* cmCPackIFWGenerator::GetOutputExtension()
 {
   return ExecutableSuffix.c_str();
 }
@@ -246,56 +219,43 @@ int cmCPackIFWGenerator::InitializeInternal()
   const std::string RepoGenOpt = "CPACK_IFW_REPOGEN_EXECUTABLE";
   const std::string FrameworkVersionOpt = "CPACK_IFW_FRAMEWORK_VERSION";
 
-  if(!this->IsSet(BinCreatorOpt) ||
-     !this->IsSet(RepoGenOpt) ||
-     !this->IsSet(FrameworkVersionOpt))
-    {
+  if (!this->IsSet(BinCreatorOpt) || !this->IsSet(RepoGenOpt) ||
+      !this->IsSet(FrameworkVersionOpt)) {
     this->ReadListFile("CPackIFW.cmake");
-    }
+  }
 
   // Look 'binarycreator' executable (needs)
 
-  const char *BinCreatorStr = this->GetOption(BinCreatorOpt);
-  if(!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr))
-    {
+  const char* BinCreatorStr = this->GetOption(BinCreatorOpt);
+  if (!BinCreatorStr || cmSystemTools::IsNOTFOUND(BinCreatorStr)) {
     BinCreator = "";
-    }
-  else
-    {
+  } else {
     BinCreator = BinCreatorStr;
-    }
+  }
 
-  if (BinCreator.empty())
-    {
+  if (BinCreator.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "Cannot find QtIFW compiler \"binarycreator\": "
                   "likely it is not installed, or not in your PATH"
-                  << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
 
   // Look 'repogen' executable (optional)
 
-  const char *RepoGenStr = this->GetOption(RepoGenOpt);
-  if(!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr))
-    {
+  const char* RepoGenStr = this->GetOption(RepoGenOpt);
+  if (!RepoGenStr || cmSystemTools::IsNOTFOUND(RepoGenStr)) {
     RepoGen = "";
-    }
-  else
-    {
+  } else {
     RepoGen = RepoGenStr;
-    }
+  }
 
   // Framework version
-  if(const char* FrameworkVersionSrt =
-      this->GetOption(FrameworkVersionOpt))
-    {
+  if (const char* FrameworkVersionSrt = this->GetOption(FrameworkVersionOpt)) {
     FrameworkVersion = FrameworkVersionSrt;
-    }
-  else
-    {
+  } else {
     FrameworkVersion = "1.9.9";
-    }
+  }
 
   // Variables that Change Behavior
 
@@ -304,158 +264,130 @@ int cmCPackIFWGenerator::InitializeInternal()
 
   // Additional packages dirs
   PkgsDirsVector.clear();
-  if(const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES"))
-    {
-    cmSystemTools::ExpandListArgument(dirs,
-                                      PkgsDirsVector);
-    }
+  if (const char* dirs = this->GetOption("CPACK_IFW_PACKAGES_DIRECTORIES")) {
+    cmSystemTools::ExpandListArgument(dirs, PkgsDirsVector);
+  }
 
   // Installer
   Installer.Generator = this;
   Installer.ConfigureFromOptions();
 
-  if (const char* ifwDownloadAll =
-      this->GetOption("CPACK_IFW_DOWNLOAD_ALL"))
-    {
+  if (const char* ifwDownloadAll = this->GetOption("CPACK_IFW_DOWNLOAD_ALL")) {
     OnlineOnly = cmSystemTools::IsOn(ifwDownloadAll);
-    }
-  else if (const char* cpackDownloadAll =
-           this->GetOption("CPACK_DOWNLOAD_ALL"))
-    {
+  } else if (const char* cpackDownloadAll =
+               this->GetOption("CPACK_DOWNLOAD_ALL")) {
     OnlineOnly = cmSystemTools::IsOn(cpackDownloadAll);
-    }
-  else
-    {
+  } else {
     OnlineOnly = false;
-    }
+  }
 
   if (!Installer.Repositories.empty() && RepoGen.empty()) {
-  cmCPackLogger(cmCPackLog::LOG_ERROR,
-                "Cannot find QtIFW repository generator \"repogen\": "
-                "likely it is not installed, or not in your PATH"
-                << std::endl);
-  return 0;
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find QtIFW repository generator \"repogen\": "
+                  "likely it is not installed, or not in your PATH"
+                    << std::endl);
+    return 0;
   }
 
   // Executable suffix
-  if(const char *optExeSuffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX"))
-    {
+  if (const char* optExeSuffix = this->GetOption("CMAKE_EXECUTABLE_SUFFIX")) {
     ExecutableSuffix = optExeSuffix;
-    if(ExecutableSuffix.empty())
-      {
+    if (ExecutableSuffix.empty()) {
       std::string sysName(this->GetOption("CMAKE_SYSTEM_NAME"));
-      if(sysName == "Linux")
-        {
+      if (sysName == "Linux") {
         ExecutableSuffix = ".run";
-        }
       }
     }
-  else
-    {
+  } else {
     ExecutableSuffix = cmCPackGenerator::GetOutputExtension();
-    }
+  }
 
   return this->Superclass::InitializeInternal();
 }
 
-std::string
-cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
+std::string cmCPackIFWGenerator::GetComponentInstallDirNameSuffix(
   const std::string& componentName)
 {
   const std::string prefix = "packages/";
   const std::string suffix = "/data";
 
   if (componentPackageMethod == ONE_PACKAGE) {
-  return std::string(prefix + GetRootPackageName() + suffix);
+    return std::string(prefix + GetRootPackageName() + suffix);
   }
 
-  return prefix
-    + GetComponentPackageName(&Components[componentName])
-    + suffix;
+  return prefix + GetComponentPackageName(&Components[componentName]) + suffix;
 }
 
-cmCPackComponent*
-cmCPackIFWGenerator::GetComponent(const std::string &projectName,
-                                  const std::string &componentName)
+cmCPackComponent* cmCPackIFWGenerator::GetComponent(
+  const std::string& projectName, const std::string& componentName)
 {
   ComponentsMap::iterator cit = Components.find(componentName);
-  if ( cit != Components.end() ) return &(cit->second);
+  if (cit != Components.end())
+    return &(cit->second);
 
-  cmCPackComponent* component
-    = cmCPackGenerator::GetComponent(projectName, componentName);
-  if(!component) return component;
+  cmCPackComponent* component =
+    cmCPackGenerator::GetComponent(projectName, componentName);
+  if (!component)
+    return component;
 
   std::string name = GetComponentPackageName(component);
   PackagesMap::iterator pit = Packages.find(name);
-  if(pit != Packages.end()) return component;
+  if (pit != Packages.end())
+    return component;
 
-  cmCPackIFWPackage *package = &Packages[name];
+  cmCPackIFWPackage* package = &Packages[name];
   package->Name = name;
   package->Generator = this;
-  if(package->ConfigureFromComponent(component))
-    {
+  if (package->ConfigureFromComponent(component)) {
     package->Installer = &Installer;
     Installer.Packages.insert(
-      std::pair<std::string, cmCPackIFWPackage*>(
-        name, package));
+      std::pair<std::string, cmCPackIFWPackage*>(name, package));
     ComponentPackages.insert(
-      std::pair<cmCPackComponent*, cmCPackIFWPackage*>(
-        component, package));
-    if(component->IsDownloaded)
-      {
+      std::pair<cmCPackComponent*, cmCPackIFWPackage*>(component, package));
+    if (component->IsDownloaded) {
       DownloadedPackages.insert(package);
-      }
-    else
-      {
+    } else {
       BinaryPackages.insert(package);
-      }
     }
-  else
-    {
+  } else {
     Packages.erase(name);
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-                  "Cannot configure package \"" << name <<
-                  "\" for component \"" << component->Name << "\""
-                  << std::endl);
-    }
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot configure package \""
+                    << name << "\" for component \"" << component->Name << "\""
+                    << std::endl);
+  }
 
   return component;
 }
 
-cmCPackComponentGroup*
-cmCPackIFWGenerator::GetComponentGroup(const std::string &projectName,
-                                       const std::string &groupName)
+cmCPackComponentGroup* cmCPackIFWGenerator::GetComponentGroup(
+  const std::string& projectName, const std::string& groupName)
 {
-  cmCPackComponentGroup* group
-    = cmCPackGenerator::GetComponentGroup(projectName, groupName);
-  if(!group) return group;
+  cmCPackComponentGroup* group =
+    cmCPackGenerator::GetComponentGroup(projectName, groupName);
+  if (!group)
+    return group;
 
   std::string name = GetGroupPackageName(group);
   PackagesMap::iterator pit = Packages.find(name);
-  if(pit != Packages.end()) return group;
+  if (pit != Packages.end())
+    return group;
 
-  cmCPackIFWPackage *package = &Packages[name];
+  cmCPackIFWPackage* package = &Packages[name];
   package->Name = name;
   package->Generator = this;
-  if(package->ConfigureFromGroup(group))
-    {
+  if (package->ConfigureFromGroup(group)) {
     package->Installer = &Installer;
     Installer.Packages.insert(
-      std::pair<std::string, cmCPackIFWPackage*>(
-        name, package));
+      std::pair<std::string, cmCPackIFWPackage*>(name, package));
     GroupPackages.insert(
-      std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(
-        group, package));
+      std::pair<cmCPackComponentGroup*, cmCPackIFWPackage*>(group, package));
     BinaryPackages.insert(package);
-    }
-  else
-    {
+  } else {
     Packages.erase(name);
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-                  "Cannot configure package \"" << name <<
-                  "\" for component group \"" << group->Name << "\""
-                  << std::endl);
-    }
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot configure package \""
+                    << name << "\" for component group \"" << group->Name
+                    << "\"" << std::endl);
+  }
   return group;
 }
 
@@ -485,123 +417,106 @@ std::string cmCPackIFWGenerator::GetRootPackageName()
   // Default value
   std::string name = "root";
   if (const char* optIFW_PACKAGE_GROUP =
-      this->GetOption("CPACK_IFW_PACKAGE_GROUP"))
-    {
+        this->GetOption("CPACK_IFW_PACKAGE_GROUP")) {
     // Configure from root group
     cmCPackIFWPackage package;
     package.Generator = this;
     package.ConfigureFromGroup(optIFW_PACKAGE_GROUP);
     name = package.Name;
-    }
-  else if (const char* optIFW_PACKAGE_NAME =
-           this->GetOption("CPACK_IFW_PACKAGE_NAME"))
-    {
+  } else if (const char* optIFW_PACKAGE_NAME =
+               this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
     // Configure from root package name
     name = optIFW_PACKAGE_NAME;
-    }
-  else if (const char* optPACKAGE_NAME =
-           this->GetOption("CPACK_PACKAGE_NAME"))
-    {
+  } else if (const char* optPACKAGE_NAME =
+               this->GetOption("CPACK_PACKAGE_NAME")) {
     // Configure from package name
     name = optPACKAGE_NAME;
-    }
+  }
   return name;
 }
 
-std::string
-cmCPackIFWGenerator::GetGroupPackageName(cmCPackComponentGroup *group) const
+std::string cmCPackIFWGenerator::GetGroupPackageName(
+  cmCPackComponentGroup* group) const
 {
   std::string name;
-  if (!group) return name;
-  if (cmCPackIFWPackage* package = GetGroupPackage(group))
-    {
+  if (!group)
+    return name;
+  if (cmCPackIFWPackage* package = GetGroupPackage(group)) {
     return package->Name;
-    }
-  const char* option = GetOption(
-    "CPACK_IFW_COMPONENT_GROUP_"
-    + cmsys::SystemTools::UpperCase(group->Name)
-    + "_NAME");
+  }
+  const char* option =
+    GetOption("CPACK_IFW_COMPONENT_GROUP_" +
+              cmsys::SystemTools::UpperCase(group->Name) + "_NAME");
   name = option ? option : group->Name;
-  if(group->ParentGroup)
-    {
+  if (group->ParentGroup) {
     cmCPackIFWPackage* package = GetGroupPackage(group->ParentGroup);
     bool dot = !ResolveDuplicateNames;
-    if(dot && name.substr(0, package->Name.size()) == package->Name)
-      {
+    if (dot && name.substr(0, package->Name.size()) == package->Name) {
       dot = false;
-      }
-    if(dot)
-      {
+    }
+    if (dot) {
       name = package->Name + "." + name;
-      }
     }
+  }
   return name;
 }
 
 std::string cmCPackIFWGenerator::GetComponentPackageName(
-  cmCPackComponent *component) const
+  cmCPackComponent* component) const
 {
   std::string name;
-  if (!component) return name;
-  if (cmCPackIFWPackage* package = GetComponentPackage(component))
-    {
+  if (!component)
+    return name;
+  if (cmCPackIFWPackage* package = GetComponentPackage(component)) {
     return package->Name;
-    }
-  std::string prefix = "CPACK_IFW_COMPONENT_"
-    + cmsys::SystemTools::UpperCase(component->Name)
-    + "_";
+  }
+  std::string prefix = "CPACK_IFW_COMPONENT_" +
+    cmsys::SystemTools::UpperCase(component->Name) + "_";
   const char* option = GetOption(prefix + "NAME");
   name = option ? option : component->Name;
-  if(component->Group)
-    {
+  if (component->Group) {
     cmCPackIFWPackage* package = GetGroupPackage(component->Group);
-    if((componentPackageMethod == ONE_PACKAGE_PER_GROUP)
-       || IsOn(prefix + "COMMON"))
-      {
+    if ((componentPackageMethod == ONE_PACKAGE_PER_GROUP) ||
+        IsOn(prefix + "COMMON")) {
       return package->Name;
-      }
+    }
     bool dot = !ResolveDuplicateNames;
-    if(dot && name.substr(0, package->Name.size()) == package->Name)
-      {
+    if (dot && name.substr(0, package->Name.size()) == package->Name) {
       dot = false;
-      }
-    if(dot)
-      {
+    }
+    if (dot) {
       name = package->Name + "." + name;
-      }
     }
+  }
   return name;
 }
 
 cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage(
-  cmCPackComponentGroup *group) const
+  cmCPackComponentGroup* group) const
 {
-  std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit
-    = GroupPackages.find(group);
+  std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit =
+    GroupPackages.find(group);
   return pit != GroupPackages.end() ? pit->second : 0;
 }
 
 cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage(
-  cmCPackComponent *component) const
+  cmCPackComponent* component) const
 {
-  std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit
-    = ComponentPackages.find(component);
+  std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit =
+    ComponentPackages.find(component);
   return pit != ComponentPackages.end() ? pit->second : 0;
 }
 
-void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmXMLWriter &xout)
+void cmCPackIFWGenerator::WriteGeneratedByToStrim(cmXMLWriter& xout)
 {
   std::stringstream comment;
   comment << "Generated by CPack " << CMake_VERSION << " IFW generator "
-       << "for QtIFW ";
-  if(IsVersionLess("2.0"))
-    {
+          << "for QtIFW ";
+  if (IsVersionLess("2.0")) {
     comment << "less 2.0";
-    }
-  else
-    {
+  } else {
     comment << FrameworkVersion;
-    }
+  }
   comment << " tools at " << cmTimestamp().CurrentTime("", true);
   xout.Comment(comment.str().c_str());
 }
diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h
index d02f9d2..d8cc562 100644
--- a/Source/CPack/IFW/cmCPackIFWGenerator.h
+++ b/Source/CPack/IFW/cmCPackIFWGenerator.h
@@ -49,17 +49,17 @@ public:
   /**
    * Compare \a version with QtIFW framework version
    */
-  bool IsVersionLess(const char *version);
+  bool IsVersionLess(const char* version);
 
   /**
    * Compare \a version with QtIFW framework version
    */
-  bool IsVersionGreater(const char *version);
+  bool IsVersionGreater(const char* version);
 
   /**
    * Compare \a version with QtIFW framework version
    */
-  bool IsVersionEqual(const char *version);
+  bool IsVersionEqual(const char* version);
 
 protected:
   // cmCPackGenerator reimplementation
@@ -90,9 +90,8 @@ protected:
    *
    * @return Pointer to component
    */
-  virtual cmCPackComponent* GetComponent(
-    const std::string& projectName,
-    const std::string& componentName);
+  virtual cmCPackComponent* GetComponent(const std::string& projectName,
+                                         const std::string& componentName);
 
   /**
    * @brief Get group of component
@@ -104,8 +103,7 @@ protected:
    * @return Pointer to component group
    */
   virtual cmCPackComponentGroup* GetComponentGroup(
-    const std::string& projectName,
-    const std::string& groupName);
+    const std::string& projectName, const std::string& groupName);
 
   enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
   virtual bool SupportsAbsoluteDestination() const;
@@ -118,11 +116,11 @@ protected:
 
   std::string GetRootPackageName();
 
-  std::string GetGroupPackageName(cmCPackComponentGroup *group) const;
-  std::string GetComponentPackageName(cmCPackComponent *component) const;
+  std::string GetGroupPackageName(cmCPackComponentGroup* group) const;
+  std::string GetComponentPackageName(cmCPackComponent* component) const;
 
-  cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup *group) const;
-  cmCPackIFWPackage* GetComponentPackage(cmCPackComponent *component) const;
+  cmCPackIFWPackage* GetGroupPackage(cmCPackComponentGroup* group) const;
+  cmCPackIFWPackage* GetComponentPackage(cmCPackComponent* component) const;
 
   void WriteGeneratedByToStrim(cmXMLWriter& xout);
 
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
index dfb336c..b9a9861 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx
@@ -20,310 +20,239 @@
 #include <cmXMLWriter.h>
 
 #ifdef cmCPackLogger
-# undef cmCPackLogger
+#undef cmCPackLogger
 #endif
-#define cmCPackLogger(logType, msg)                                     \
-  do {                                                                  \
-  std::ostringstream cmCPackLog_msg;                                    \
-  cmCPackLog_msg << msg;                                                \
-  if(Generator) {                                                       \
-  Generator->Logger->Log(logType, __FILE__, __LINE__,                   \
-                         cmCPackLog_msg.str().c_str());                 \
-  }                                                                     \
-  } while ( 0 )
-
-cmCPackIFWInstaller::cmCPackIFWInstaller() :
-  Generator(0)
+#define cmCPackLogger(logType, msg)                                           \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    if (Generator) {                                                          \
+      Generator->Logger->Log(logType, __FILE__, __LINE__,                     \
+                             cmCPackLog_msg.str().c_str());                   \
+    }                                                                         \
+  } while (0)
+
+cmCPackIFWInstaller::cmCPackIFWInstaller()
+  : Generator(0)
 {
 }
 
-const char *cmCPackIFWInstaller::GetOption(const std::string &op) const
+const char* cmCPackIFWInstaller::GetOption(const std::string& op) const
 {
   return Generator ? Generator->GetOption(op) : 0;
 }
 
-bool cmCPackIFWInstaller::IsOn(const std::string &op) const
+bool cmCPackIFWInstaller::IsOn(const std::string& op) const
 {
   return Generator ? Generator->IsOn(op) : false;
 }
 
-bool cmCPackIFWInstaller::IsVersionLess(const char *version)
+bool cmCPackIFWInstaller::IsVersionLess(const char* version)
 {
   return Generator ? Generator->IsVersionLess(version) : false;
 }
 
-bool cmCPackIFWInstaller::IsVersionGreater(const char *version)
+bool cmCPackIFWInstaller::IsVersionGreater(const char* version)
 {
   return Generator ? Generator->IsVersionGreater(version) : false;
 }
 
-bool cmCPackIFWInstaller::IsVersionEqual(const char *version)
+bool cmCPackIFWInstaller::IsVersionEqual(const char* version)
 {
   return Generator ? Generator->IsVersionEqual(version) : false;
 }
 
-
 void cmCPackIFWInstaller::ConfigureFromOptions()
 {
   // Name;
   if (const char* optIFW_PACKAGE_NAME =
-      this->GetOption("CPACK_IFW_PACKAGE_NAME"))
-    {
+        this->GetOption("CPACK_IFW_PACKAGE_NAME")) {
     Name = optIFW_PACKAGE_NAME;
-    }
-  else if (const char* optPACKAGE_NAME =
-           this->GetOption("CPACK_PACKAGE_NAME"))
-    {
+  } else if (const char* optPACKAGE_NAME =
+               this->GetOption("CPACK_PACKAGE_NAME")) {
     Name = optPACKAGE_NAME;
-    }
-  else
-    {
+  } else {
     Name = "Your package";
-    }
+  }
 
   // Title;
   if (const char* optIFW_PACKAGE_TITLE =
-      GetOption("CPACK_IFW_PACKAGE_TITLE"))
-    {
+        GetOption("CPACK_IFW_PACKAGE_TITLE")) {
     Title = optIFW_PACKAGE_TITLE;
-    }
-  else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
-           GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
-    {
+  } else if (const char* optPACKAGE_DESCRIPTION_SUMMARY =
+               GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
     Title = optPACKAGE_DESCRIPTION_SUMMARY;
-    }
-  else
-    {
+  } else {
     Title = "Your package description";
-    }
+  }
 
   // Version;
-  if (const char* option = GetOption("CPACK_PACKAGE_VERSION"))
-    {
+  if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) {
     Version = option;
-    }
-  else
-    {
+  } else {
     Version = "1.0.0";
-    }
+  }
 
   // Publisher
-  if(const char* optIFW_PACKAGE_PUBLISHER =
-     GetOption("CPACK_IFW_PACKAGE_PUBLISHER"))
-    {
+  if (const char* optIFW_PACKAGE_PUBLISHER =
+        GetOption("CPACK_IFW_PACKAGE_PUBLISHER")) {
     Publisher = optIFW_PACKAGE_PUBLISHER;
-    }
-  else if(const char* optPACKAGE_VENDOR = GetOption("CPACK_PACKAGE_VENDOR"))
-    {
+  } else if (const char* optPACKAGE_VENDOR =
+               GetOption("CPACK_PACKAGE_VENDOR")) {
     Publisher = optPACKAGE_VENDOR;
-    }
+  }
 
   // ProductUrl
-  if(const char* option = GetOption("CPACK_IFW_PRODUCT_URL"))
-    {
+  if (const char* option = GetOption("CPACK_IFW_PRODUCT_URL")) {
     ProductUrl = option;
-    }
+  }
 
   // ApplicationIcon
-  if(const char* option = GetOption("CPACK_IFW_PACKAGE_ICON"))
-    {
-    if(cmSystemTools::FileExists(option))
-      {
+  if (const char* option = GetOption("CPACK_IFW_PACKAGE_ICON")) {
+    if (cmSystemTools::FileExists(option)) {
       InstallerApplicationIcon = option;
-      }
-    else
-      {
+    } else {
       // TODO: implement warning
-      }
     }
+  }
 
   // WindowIcon
-  if(const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON"))
-    {
-    if(cmSystemTools::FileExists(option))
-      {
+  if (const char* option = GetOption("CPACK_IFW_PACKAGE_WINDOW_ICON")) {
+    if (cmSystemTools::FileExists(option)) {
       InstallerWindowIcon = option;
-      }
-    else
-      {
+    } else {
       // TODO: implement warning
-      }
     }
+  }
 
   // Logo
-  if(const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO"))
-    {
-    if(cmSystemTools::FileExists(option))
-      {
+  if (const char* option = GetOption("CPACK_IFW_PACKAGE_LOGO")) {
+    if (cmSystemTools::FileExists(option)) {
       Logo = option;
-      }
-    else
-      {
+    } else {
       // TODO: implement warning
-      }
     }
+  }
 
   // Start menu
   if (const char* optIFW_START_MENU_DIR =
-      this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY"))
-    {
+        this->GetOption("CPACK_IFW_PACKAGE_START_MENU_DIRECTORY")) {
     StartMenuDir = optIFW_START_MENU_DIR;
-    }
-  else
-    {
+  } else {
     StartMenuDir = Name;
-    }
+  }
 
   // Default target directory for installation
   if (const char* optIFW_TARGET_DIRECTORY =
-      GetOption("CPACK_IFW_TARGET_DIRECTORY"))
-    {
+        GetOption("CPACK_IFW_TARGET_DIRECTORY")) {
     TargetDir = optIFW_TARGET_DIRECTORY;
-    }
-  else if (const char *optPACKAGE_INSTALL_DIRECTORY =
-           GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY"))
-    {
+  } else if (const char* optPACKAGE_INSTALL_DIRECTORY =
+               GetOption("CPACK_PACKAGE_INSTALL_DIRECTORY")) {
     TargetDir = "@ApplicationsDir@/";
     TargetDir += optPACKAGE_INSTALL_DIRECTORY;
-    }
-  else
-    {
+  } else {
     TargetDir = "@RootDir@/usr/local";
-    }
+  }
 
   // Default target directory for installation with administrator rights
-  if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY"))
-    {
+  if (const char* option = GetOption("CPACK_IFW_ADMIN_TARGET_DIRECTORY")) {
     AdminTargetDir = option;
-    }
+  }
 
   // Repositories
   Repositories.clear();
   RepositoryStruct Repo;
-  if(const char *site = this->GetOption("CPACK_DOWNLOAD_SITE"))
-    {
+  if (const char* site = this->GetOption("CPACK_DOWNLOAD_SITE")) {
     Repo.Url = site;
     Repositories.push_back(Repo);
-    }
-  if(const char *RepoAllStr = this->GetOption("CPACK_IFW_REPOSITORIES_ALL"))
-    {
+  }
+  if (const char* RepoAllStr = this->GetOption("CPACK_IFW_REPOSITORIES_ALL")) {
     std::vector<std::string> RepoAllVector;
-    cmSystemTools::ExpandListArgument(RepoAllStr,
-                                      RepoAllVector);
-    for(std::vector<std::string>::iterator
-          rit = RepoAllVector.begin(); rit != RepoAllVector.end(); ++rit)
-      {
-        std::string prefix = "CPACK_IFW_REPOSITORY_"
-          + cmsys::SystemTools::UpperCase(*rit)
-          + "_";
-        // Url
-        if (const char* url = GetOption(prefix + "URL"))
-          {
-          Repo.Url = url;
-          }
-        else
-          {
-          Repo.Url = "";
-          }
-        // Enabled
-        if (IsOn(prefix + "DISABLED"))
-          {
-          Repo.Enabled = "0";
-          }
-        else
-          {
-          Repo.Enabled = "";
-          }
-        // Username
-        if (const char* username = GetOption(prefix + "USERNAME"))
-          {
-          Repo.Username = username;
-          }
-        else
-          {
-          Repo.Username = "";
-          }
-        // Password
-        if (const char* password = GetOption(prefix + "PASSWORD"))
-          {
-          Repo.Password = password;
-          }
-        else
-          {
-          Repo.Password = "";
-          }
-        // DisplayName
-        if (const char* displayName = GetOption(prefix + "DISPLAY_NAME"))
-          {
-          Repo.DisplayName = displayName;
-          }
-        else
-          {
-          Repo.DisplayName = "";
-          }
-
-        if(!Repo.Url.empty())
-          {
-          Repositories.push_back(Repo);
-          }
+    cmSystemTools::ExpandListArgument(RepoAllStr, RepoAllVector);
+    for (std::vector<std::string>::iterator rit = RepoAllVector.begin();
+         rit != RepoAllVector.end(); ++rit) {
+      std::string prefix =
+        "CPACK_IFW_REPOSITORY_" + cmsys::SystemTools::UpperCase(*rit) + "_";
+      // Url
+      if (const char* url = GetOption(prefix + "URL")) {
+        Repo.Url = url;
+      } else {
+        Repo.Url = "";
+      }
+      // Enabled
+      if (IsOn(prefix + "DISABLED")) {
+        Repo.Enabled = "0";
+      } else {
+        Repo.Enabled = "";
+      }
+      // Username
+      if (const char* username = GetOption(prefix + "USERNAME")) {
+        Repo.Username = username;
+      } else {
+        Repo.Username = "";
+      }
+      // Password
+      if (const char* password = GetOption(prefix + "PASSWORD")) {
+        Repo.Password = password;
+      } else {
+        Repo.Password = "";
+      }
+      // DisplayName
+      if (const char* displayName = GetOption(prefix + "DISPLAY_NAME")) {
+        Repo.DisplayName = displayName;
+      } else {
+        Repo.DisplayName = "";
+      }
+
+      if (!Repo.Url.empty()) {
+        Repositories.push_back(Repo);
       }
     }
+  }
 
   // Maintenance tool
-  if(const char* optIFW_MAINTENANCE_TOOL =
-      this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME"))
-    {
+  if (const char* optIFW_MAINTENANCE_TOOL =
+        this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_NAME")) {
     MaintenanceToolName = optIFW_MAINTENANCE_TOOL;
-    }
+  }
 
   // Maintenance tool ini file
-  if(const char* optIFW_MAINTENANCE_TOOL_INI =
-      this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE"))
-    {
+  if (const char* optIFW_MAINTENANCE_TOOL_INI =
+        this->GetOption("CPACK_IFW_PACKAGE_MAINTENANCE_TOOL_INI_FILE")) {
     MaintenanceToolIniFile = optIFW_MAINTENANCE_TOOL_INI;
-    }
+  }
 
   // Allow non-ASCII characters
-  if(this->GetOption("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS"))
-    {
-    if(IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS"))
-      {
+  if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
+    if (IsOn("CPACK_IFW_PACKAGE_ALLOW_NON_ASCII_CHARACTERS")) {
       AllowNonAsciiCharacters = "true";
-      }
-    else
-      {
+    } else {
       AllowNonAsciiCharacters = "false";
-      }
     }
+  }
 
   // Space in path
-  if(this->GetOption("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH"))
-    {
-    if(IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH"))
-      {
+  if (this->GetOption("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
+    if (IsOn("CPACK_IFW_PACKAGE_ALLOW_SPACE_IN_PATH")) {
       AllowSpaceInPath = "true";
-      }
-    else
-      {
+    } else {
       AllowSpaceInPath = "false";
-      }
     }
+  }
 
   // Control script
-  if(const char* optIFW_CONTROL_SCRIPT =
-      this->GetOption("CPACK_IFW_PACKAGE_CONTROL_SCRIPT"))
-    {
+  if (const char* optIFW_CONTROL_SCRIPT =
+        this->GetOption("CPACK_IFW_PACKAGE_CONTROL_SCRIPT")) {
     ControlScript = optIFW_CONTROL_SCRIPT;
-    }
+  }
 }
 
 void cmCPackIFWInstaller::GenerateInstallerFile()
 {
   // Lazy directory initialization
-  if(Directory.empty() && Generator)
-    {
+  if (Directory.empty() && Generator) {
     Directory = Generator->toplevel;
-    }
+  }
 
   // Output stream
   cmGeneratedFileStream fout((Directory + "/config/config.xml").data());
@@ -339,140 +268,118 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
   xout.Element("Version", Version);
   xout.Element("Title", Title);
 
-  if(!Publisher.empty())
-    {
+  if (!Publisher.empty()) {
     xout.Element("Publisher", Publisher);
-    }
+  }
 
-  if(!ProductUrl.empty())
-    {
+  if (!ProductUrl.empty()) {
     xout.Element("ProductUrl", ProductUrl);
-    }
+  }
 
   // ApplicationIcon
-  if(!InstallerApplicationIcon.empty())
-    {
+  if (!InstallerApplicationIcon.empty()) {
     std::string name =
       cmSystemTools::GetFilenameName(InstallerApplicationIcon);
     std::string path = Directory + "/config/" + name;
     name = cmSystemTools::GetFilenameWithoutExtension(name);
-    cmsys::SystemTools::CopyFileIfDifferent(
-      InstallerApplicationIcon.data(), path.data());
+    cmsys::SystemTools::CopyFileIfDifferent(InstallerApplicationIcon.data(),
+                                            path.data());
     xout.Element("InstallerApplicationIcon", name);
-    }
+  }
 
   // WindowIcon
-  if(!InstallerWindowIcon.empty())
-    {
+  if (!InstallerWindowIcon.empty()) {
     std::string name = cmSystemTools::GetFilenameName(InstallerWindowIcon);
     std::string path = Directory + "/config/" + name;
-    cmsys::SystemTools::CopyFileIfDifferent(
-      InstallerWindowIcon.data(), path.data());
+    cmsys::SystemTools::CopyFileIfDifferent(InstallerWindowIcon.data(),
+                                            path.data());
     xout.Element("InstallerWindowIcon", name);
-    }
+  }
 
   // Logo
-  if(!Logo.empty())
-    {
+  if (!Logo.empty()) {
     std::string name = cmSystemTools::GetFilenameName(Logo);
     std::string path = Directory + "/config/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(Logo.data(), path.data());
     xout.Element("Logo", name);
-    }
+  }
 
   // Start menu
-  if(!IsVersionLess("2.0"))
-    {
+  if (!IsVersionLess("2.0")) {
     xout.Element("StartMenuDir", StartMenuDir);
-    }
+  }
 
   // Target dir
-  if(!TargetDir.empty())
-    {
+  if (!TargetDir.empty()) {
     xout.Element("TargetDir", TargetDir);
-    }
+  }
 
   // Admin target dir
-  if(!AdminTargetDir.empty())
-    {
+  if (!AdminTargetDir.empty()) {
     xout.Element("AdminTargetDir", AdminTargetDir);
-    }
+  }
 
   // Remote repositories
-  if (!Repositories.empty())
-    {
+  if (!Repositories.empty()) {
     xout.StartElement("RemoteRepositories");
-    for(std::vector<RepositoryStruct>::iterator
-        rit = Repositories.begin(); rit != Repositories.end(); ++rit)
-      {
+    for (std::vector<RepositoryStruct>::iterator rit = Repositories.begin();
+         rit != Repositories.end(); ++rit) {
       xout.StartElement("Repository");
       // Url
       xout.Element("Url", rit->Url);
       // Enabled
-      if(!rit->Enabled.empty())
-        {
+      if (!rit->Enabled.empty()) {
         xout.Element("Enabled", rit->Enabled);
-        }
+      }
       // Username
-      if(!rit->Username.empty())
-        {
+      if (!rit->Username.empty()) {
         xout.Element("Username", rit->Username);
-        }
+      }
       // Password
-      if(!rit->Password.empty())
-        {
+      if (!rit->Password.empty()) {
         xout.Element("Password", rit->Password);
-        }
+      }
       // DisplayName
-      if(!rit->DisplayName.empty())
-        {
+      if (!rit->DisplayName.empty()) {
         xout.Element("DisplayName", rit->DisplayName);
-        }
-      xout.EndElement();
       }
-    xout.EndElement();
+      xout.EndElement();
     }
+    xout.EndElement();
+  }
 
   // Maintenance tool
-  if(!IsVersionLess("2.0") && !MaintenanceToolName.empty())
-    {
+  if (!IsVersionLess("2.0") && !MaintenanceToolName.empty()) {
     xout.Element("MaintenanceToolName", MaintenanceToolName);
-    }
+  }
 
   // Maintenance tool ini file
-  if(!IsVersionLess("2.0") && !MaintenanceToolIniFile.empty())
-    {
+  if (!IsVersionLess("2.0") && !MaintenanceToolIniFile.empty()) {
     xout.Element("MaintenanceToolIniFile", MaintenanceToolIniFile);
-    }
+  }
 
   // Different allows
-  if(IsVersionLess("2.0"))
-    {
+  if (IsVersionLess("2.0")) {
     // CPack IFW default policy
     xout.Comment("CPack IFW default policy for QtIFW less 2.0");
     xout.Element("AllowNonAsciiCharacters", "true");
     xout.Element("AllowSpaceInPath", "true");
+  } else {
+    if (!AllowNonAsciiCharacters.empty()) {
+      xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
     }
-  else
-    {
-      if(!AllowNonAsciiCharacters.empty())
-        {
-        xout.Element("AllowNonAsciiCharacters", AllowNonAsciiCharacters);
-        }
-      if(!AllowSpaceInPath.empty())
-        {
-        xout.Element("AllowSpaceInPath", AllowSpaceInPath);
-        }
+    if (!AllowSpaceInPath.empty()) {
+      xout.Element("AllowSpaceInPath", AllowSpaceInPath);
     }
+  }
 
   // Control script (copy to config dir)
-  if(!IsVersionLess("2.0") && !ControlScript.empty())
-    {
+  if (!IsVersionLess("2.0") && !ControlScript.empty()) {
     std::string name = cmSystemTools::GetFilenameName(ControlScript);
     std::string path = Directory + "/config/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(ControlScript.data(), path.data());
     xout.Element("ControlScript", name);
-    }
+  }
 
   xout.EndElement();
   xout.EndDocument();
@@ -480,36 +387,32 @@ void cmCPackIFWInstaller::GenerateInstallerFile()
 
 void cmCPackIFWInstaller::GeneratePackageFiles()
 {
-  if (Packages.empty() || Generator->IsOnePackage())
-    {
+  if (Packages.empty() || Generator->IsOnePackage()) {
     // Generate default package
     cmCPackIFWPackage package;
     package.Generator = Generator;
     package.Installer = this;
     // Check package group
-    if (const char* option = GetOption("CPACK_IFW_PACKAGE_GROUP"))
-      {
+    if (const char* option = GetOption("CPACK_IFW_PACKAGE_GROUP")) {
       package.ConfigureFromGroup(option);
       package.ForcedInstallation = "true";
-      }
-    else
-      {
+    } else {
       package.ConfigureFromOptions();
-      }
+    }
     package.GeneratePackageFile();
     return;
-    }
+  }
 
   // Generate packages meta information
-  for(PackagesMap::iterator pit = Packages.begin();
-      pit != Packages.end(); ++pit)
-    {
+  for (PackagesMap::iterator pit = Packages.begin(); pit != Packages.end();
+       ++pit) {
     cmCPackIFWPackage* package = pit->second;
     package->GeneratePackageFile();
   }
 }
 
-void cmCPackIFWInstaller::WriteGeneratedByToStrim(cmXMLWriter &xout)
+void cmCPackIFWInstaller::WriteGeneratedByToStrim(cmXMLWriter& xout)
 {
-  if(Generator) Generator->WriteGeneratedByToStrim(xout);
+  if (Generator)
+    Generator->WriteGeneratedByToStrim(xout);
 }
diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.h b/Source/CPack/IFW/cmCPackIFWInstaller.h
index 9cb7d5b..84a789e 100644
--- a/Source/CPack/IFW/cmCPackIFWInstaller.h
+++ b/Source/CPack/IFW/cmCPackIFWInstaller.h
@@ -103,9 +103,9 @@ public:
   const char* GetOption(const std::string& op) const;
   bool IsOn(const std::string& op) const;
 
-  bool IsVersionLess(const char *version);
-  bool IsVersionGreater(const char *version);
-  bool IsVersionEqual(const char *version);
+  bool IsVersionLess(const char* version);
+  bool IsVersionGreater(const char* version);
+  bool IsVersionEqual(const char* version);
 
   void ConfigureFromOptions();
 
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx
index a22c0b9..5bc1a0b 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.cxx
+++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx
@@ -22,21 +22,21 @@
 
 //----------------------------------------------------------------- Logger ---
 #ifdef cmCPackLogger
-# undef cmCPackLogger
+#undef cmCPackLogger
 #endif
-#define cmCPackLogger(logType, msg)                                     \
-  do {                                                                  \
-  std::ostringstream cmCPackLog_msg;                                    \
-  cmCPackLog_msg << msg;                                                \
-  if(Generator) {                                                       \
-  Generator->Logger->Log(logType, __FILE__, __LINE__,                   \
-                         cmCPackLog_msg.str().c_str());                 \
-  }                                                                     \
-  } while ( 0 )
+#define cmCPackLogger(logType, msg)                                           \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    if (Generator) {                                                          \
+      Generator->Logger->Log(logType, __FILE__, __LINE__,                     \
+                             cmCPackLog_msg.str().c_str());                   \
+    }                                                                         \
+  } while (0)
 
 //---------------------------------------------------------- CompareStruct ---
-cmCPackIFWPackage::CompareStruct::CompareStruct() :
-  Type(CompareNone)
+cmCPackIFWPackage::CompareStruct::CompareStruct()
+  : Type(CompareNone)
 {
 }
 
@@ -46,64 +46,47 @@ cmCPackIFWPackage::DependenceStruct::DependenceStruct()
 }
 
 cmCPackIFWPackage::DependenceStruct::DependenceStruct(
-  const std::string &dependence)
+  const std::string& dependence)
 {
   // Search compare section
   size_t pos = std::string::npos;
-  if((pos = dependence.find("<=")) != std::string::npos)
-    {
+  if ((pos = dependence.find("<=")) != std::string::npos) {
     Compare.Type = CompareLessOrEqual;
     Compare.Value = dependence.substr(pos + 2);
-    }
-  else if((pos = dependence.find(">=")) != std::string::npos)
-    {
+  } else if ((pos = dependence.find(">=")) != std::string::npos) {
     Compare.Type = CompareGreaterOrEqual;
     Compare.Value = dependence.substr(pos + 2);
-    }
-  else if((pos = dependence.find("<")) != std::string::npos)
-    {
+  } else if ((pos = dependence.find("<")) != std::string::npos) {
     Compare.Type = CompareLess;
     Compare.Value = dependence.substr(pos + 1);
-    }
-  else if((pos = dependence.find("=")) != std::string::npos)
-    {
+  } else if ((pos = dependence.find("=")) != std::string::npos) {
     Compare.Type = CompareEqual;
     Compare.Value = dependence.substr(pos + 1);
-    }
-  else if((pos = dependence.find(">")) != std::string::npos)
-    {
+  } else if ((pos = dependence.find(">")) != std::string::npos) {
     Compare.Type = CompareGreater;
     Compare.Value = dependence.substr(pos + 1);
-    }
+  }
   Name = pos == std::string::npos ? dependence : dependence.substr(0, pos);
 }
 
 std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
 {
-  if (Compare.Type == CompareNone) return Name;
+  if (Compare.Type == CompareNone)
+    return Name;
 
   std::string result = Name;
 
-  if (Compare.Type == CompareLessOrEqual)
-    {
+  if (Compare.Type == CompareLessOrEqual) {
     result += "<=";
-    }
-  else if (Compare.Type == CompareGreaterOrEqual)
-    {
+  } else if (Compare.Type == CompareGreaterOrEqual) {
     result += ">=";
-    }
-  else if (Compare.Type == CompareLess)
-    {
+  } else if (Compare.Type == CompareLess) {
     result += "<";
-    }
-  else if (Compare.Type == CompareEqual)
-    {
+  } else if (Compare.Type == CompareEqual) {
     result += "=";
-    }
-  else if (Compare.Type == CompareGreater)
-    {
+  } else if (Compare.Type == CompareGreater) {
     result += ">";
-    }
+  }
 
   result += Compare.Value;
 
@@ -111,45 +94,45 @@ std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const
 }
 
 //------------------------------------------------------ cmCPackIFWPackage ---
-cmCPackIFWPackage::cmCPackIFWPackage() :
-  Generator(0),
-  Installer(0)
+cmCPackIFWPackage::cmCPackIFWPackage()
+  : Generator(0)
+  , Installer(0)
 {
 }
 
-const char *cmCPackIFWPackage::GetOption(const std::string &op) const
+const char* cmCPackIFWPackage::GetOption(const std::string& op) const
 {
-  const char *option = Generator ? Generator->GetOption(op) : 0;
+  const char* option = Generator ? Generator->GetOption(op) : 0;
   return option && *option ? option : 0;
 }
 
-bool cmCPackIFWPackage::IsOn(const std::string &op) const
+bool cmCPackIFWPackage::IsOn(const std::string& op) const
 {
   return Generator ? Generator->IsOn(op) : false;
 }
 
-bool cmCPackIFWPackage::IsVersionLess(const char *version)
+bool cmCPackIFWPackage::IsVersionLess(const char* version)
 {
   return Generator ? Generator->IsVersionLess(version) : false;
 }
 
-bool cmCPackIFWPackage::IsVersionGreater(const char *version)
+bool cmCPackIFWPackage::IsVersionGreater(const char* version)
 {
   return Generator ? Generator->IsVersionGreater(version) : false;
 }
 
-bool cmCPackIFWPackage::IsVersionEqual(const char *version)
+bool cmCPackIFWPackage::IsVersionEqual(const char* version)
 {
   return Generator ? Generator->IsVersionEqual(version) : false;
 }
 
-std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent *component)
+std::string cmCPackIFWPackage::GetComponentName(cmCPackComponent* component)
 {
-  if (!component) return "";
-  const char* option = GetOption(
-    "CPACK_IFW_COMPONENT_"
-    + cmsys::SystemTools::UpperCase(component->Name)
-    + "_NAME");
+  if (!component)
+    return "";
+  const char* option =
+    GetOption("CPACK_IFW_COMPONENT_" +
+              cmsys::SystemTools::UpperCase(component->Name) + "_NAME");
   return option ? option : component->Name;
 }
 
@@ -177,51 +160,42 @@ int cmCPackIFWPackage::ConfigureFromOptions()
   Name = Generator->GetRootPackageName();
 
   // Display name
-  if (const char *option = this->GetOption("CPACK_PACKAGE_NAME"))
-    {
+  if (const char* option = this->GetOption("CPACK_PACKAGE_NAME")) {
     DisplayName = option;
-    }
-  else
-    {
+  } else {
     DisplayName = "Your package";
-    }
+  }
 
   // Description
   if (const char* option =
-      this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY"))
-    {
+        this->GetOption("CPACK_PACKAGE_DESCRIPTION_SUMMARY")) {
     Description = option;
-    }
-  else
-    {
+  } else {
     Description = "Your package description";
-    }
+  }
 
   // Version
-  if(const char* option = GetOption("CPACK_PACKAGE_VERSION"))
-    {
+  if (const char* option = GetOption("CPACK_PACKAGE_VERSION")) {
     Version = option;
-    }
-  else
-    {
+  } else {
     Version = "1.0.0";
-    }
+  }
 
   ForcedInstallation = "true";
 
   return 1;
 }
 
-int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
+int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent* component)
 {
-  if(!component) return 0;
+  if (!component)
+    return 0;
 
   // Restore defaul configuration
   DefaultConfiguration();
 
-  std::string prefix = "CPACK_IFW_COMPONENT_"
-    + cmsys::SystemTools::UpperCase(component->Name)
-    + "_";
+  std::string prefix = "CPACK_IFW_COMPONENT_" +
+    cmsys::SystemTools::UpperCase(component->Name) + "_";
 
   // Display name
   DisplayName = component->DisplayName;
@@ -230,81 +204,65 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
   Description = component->Description;
 
   // Version
-  if(const char* optVERSION = GetOption(prefix + "VERSION"))
-    {
+  if (const char* optVERSION = GetOption(prefix + "VERSION")) {
     Version = optVERSION;
-    }
-  else if(const char* optPACKAGE_VERSION =
-          GetOption("CPACK_PACKAGE_VERSION"))
-    {
+  } else if (const char* optPACKAGE_VERSION =
+               GetOption("CPACK_PACKAGE_VERSION")) {
     Version = optPACKAGE_VERSION;
-    }
-  else
-    {
+  } else {
     Version = "1.0.0";
-    }
+  }
 
   // Script
-  if (const char* option = GetOption(prefix + "SCRIPT"))
-    {
+  if (const char* option = GetOption(prefix + "SCRIPT")) {
     Script = option;
-    }
+  }
 
   // CMake dependencies
-  if (!component->Dependencies.empty())
-    {
+  if (!component->Dependencies.empty()) {
     std::vector<cmCPackComponent*>::iterator dit;
-    for(dit = component->Dependencies.begin();
-        dit != component->Dependencies.end();
-        ++dit)
-      {
+    for (dit = component->Dependencies.begin();
+         dit != component->Dependencies.end(); ++dit) {
       Dependencies.insert(Generator->ComponentPackages[*dit]);
-      }
     }
+  }
 
   // QtIFW dependencies
-  if(const char* option = this->GetOption(prefix + "DEPENDS"))
-    {
+  if (const char* option = this->GetOption(prefix + "DEPENDS")) {
     std::vector<std::string> deps;
-    cmSystemTools::ExpandListArgument(option,
-                                      deps);
-    for(std::vector<std::string>::iterator
-          dit = deps.begin(); dit != deps.end(); ++dit)
-      {
+    cmSystemTools::ExpandListArgument(option, deps);
+    for (std::vector<std::string>::iterator dit = deps.begin();
+         dit != deps.end(); ++dit) {
       DependenceStruct dep(*dit);
-      if (!Generator->Packages.count(dep.Name))
-        {
+      if (!Generator->Packages.count(dep.Name)) {
         bool hasDep = Generator->DependentPackages.count(dep.Name) > 0;
-        DependenceStruct &depRef =
-          Generator->DependentPackages[dep.Name];
-        if(!hasDep)
-          {
+        DependenceStruct& depRef = Generator->DependentPackages[dep.Name];
+        if (!hasDep) {
           depRef = dep;
-          }
-        AlienDependencies.insert(&depRef);
         }
+        AlienDependencies.insert(&depRef);
       }
     }
+  }
 
   // Licenses
-  if (const char* option = this->GetOption(prefix + "LICENSES"))
-    {
+  if (const char* option = this->GetOption(prefix + "LICENSES")) {
     Licenses.clear();
-    cmSystemTools::ExpandListArgument( option, Licenses );
-    if ( Licenses.size() % 2 != 0 )
-      {
-      cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
-        << " should contain pairs of <display_name> and <file_path>."
-        << std::endl);
+    cmSystemTools::ExpandListArgument(option, Licenses);
+    if (Licenses.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_WARNING, prefix
+          << "LICENSES"
+          << " should contain pairs of <display_name> and <file_path>."
+          << std::endl);
       Licenses.clear();
-      }
     }
+  }
 
   // Priority
-  if(const char* option = this->GetOption(prefix + "PRIORITY"))
-    {
+  if (const char* option = this->GetOption(prefix + "PRIORITY")) {
     SortingPriority = option;
-    }
+  }
 
   // Default
   Default = component->IsDisabledByDefault ? "false" : "true";
@@ -318,87 +276,74 @@ int cmCPackIFWPackage::ConfigureFromComponent(cmCPackComponent *component)
   return 1;
 }
 
-int
-cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup *group)
+int cmCPackIFWPackage::ConfigureFromGroup(cmCPackComponentGroup* group)
 {
-  if(!group) return 0;
+  if (!group)
+    return 0;
 
   // Restore defaul configuration
   DefaultConfiguration();
 
-  std::string prefix = "CPACK_IFW_COMPONENT_GROUP_"
-    + cmsys::SystemTools::UpperCase(group->Name)
-    + "_";
+  std::string prefix = "CPACK_IFW_COMPONENT_GROUP_" +
+    cmsys::SystemTools::UpperCase(group->Name) + "_";
 
   DisplayName = group->DisplayName;
   Description = group->Description;
 
   // Version
-  if(const char* optVERSION = GetOption(prefix + "VERSION"))
-    {
+  if (const char* optVERSION = GetOption(prefix + "VERSION")) {
     Version = optVERSION;
-    }
-  else if(const char* optPACKAGE_VERSION =
-          GetOption("CPACK_PACKAGE_VERSION"))
-    {
+  } else if (const char* optPACKAGE_VERSION =
+               GetOption("CPACK_PACKAGE_VERSION")) {
     Version = optPACKAGE_VERSION;
-    }
-  else
-    {
+  } else {
     Version = "1.0.0";
-    }
+  }
 
   // Script
-  if (const char* option = GetOption(prefix + "SCRIPT"))
-    {
+  if (const char* option = GetOption(prefix + "SCRIPT")) {
     Script = option;
-    }
+  }
 
   // Licenses
-  if (const char* option = this->GetOption(prefix + "LICENSES"))
-    {
+  if (const char* option = this->GetOption(prefix + "LICENSES")) {
     Licenses.clear();
-    cmSystemTools::ExpandListArgument( option, Licenses );
-    if ( Licenses.size() % 2 != 0 )
-      {
-      cmCPackLogger(cmCPackLog::LOG_WARNING, prefix << "LICENSES"
-        << " should contain pairs of <display_name> and <file_path>."
-        << std::endl);
+    cmSystemTools::ExpandListArgument(option, Licenses);
+    if (Licenses.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_WARNING, prefix
+          << "LICENSES"
+          << " should contain pairs of <display_name> and <file_path>."
+          << std::endl);
       Licenses.clear();
-      }
     }
+  }
 
   // Priority
-  if(const char* option = this->GetOption(prefix + "PRIORITY"))
-    {
+  if (const char* option = this->GetOption(prefix + "PRIORITY")) {
     SortingPriority = option;
-    }
+  }
 
   return 1;
 }
 
-int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
+int cmCPackIFWPackage::ConfigureFromGroup(const std::string& groupName)
 {
   // Group configuration
 
   cmCPackComponentGroup group;
-  std::string prefix = "CPACK_COMPONENT_GROUP_"
-      + cmsys::SystemTools::UpperCase(groupName)
-      + "_";
+  std::string prefix =
+    "CPACK_COMPONENT_GROUP_" + cmsys::SystemTools::UpperCase(groupName) + "_";
 
-  if (const char *option = GetOption(prefix + "DISPLAY_NAME"))
-    {
+  if (const char* option = GetOption(prefix + "DISPLAY_NAME")) {
     group.DisplayName = option;
-    }
-  else
-    {
+  } else {
     group.DisplayName = group.Name;
-    }
+  }
 
-  if (const char* option = GetOption(prefix + "DESCRIPTION"))
-    {
+  if (const char* option = GetOption(prefix + "DESCRIPTION")) {
     group.Description = option;
-    }
+  }
   group.IsBold = IsOn(prefix + "BOLD_TITLE");
   group.IsExpandedByDefault = IsOn(prefix + "EXPANDED");
 
@@ -406,14 +351,11 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
 
   group.Name = groupName;
 
-  if(Generator)
-    {
+  if (Generator) {
     Name = Generator->GetGroupPackageName(&group);
-    }
-  else
-    {
+  } else {
     Name = group.Name;
-    }
+  }
 
   return ConfigureFromGroup(&group);
 }
@@ -421,17 +363,13 @@ int cmCPackIFWPackage::ConfigureFromGroup(const std::string &groupName)
 void cmCPackIFWPackage::GeneratePackageFile()
 {
   // Lazy directory initialization
-  if (Directory.empty())
-    {
-    if(Installer)
-      {
+  if (Directory.empty()) {
+    if (Installer) {
       Directory = Installer->Directory + "/packages/" + Name;
-      }
-    else if (Generator)
-      {
+    } else if (Generator) {
       Directory = Generator->toplevel + "/packages/" + Name;
-      }
     }
+  }
 
   // Output stream
   cmGeneratedFileStream fout((Directory + "/meta/package.xml").data());
@@ -448,98 +386,83 @@ void cmCPackIFWPackage::GeneratePackageFile()
   xout.Element("Name", Name);
   xout.Element("Version", Version);
 
-  if (!ReleaseDate.empty())
-    {
+  if (!ReleaseDate.empty()) {
     xout.Element("ReleaseDate", ReleaseDate);
-    }
-  else
-    {
+  } else {
     xout.Element("ReleaseDate", cmTimestamp().CurrentTime("%Y-%m-%d", true));
-    }
+  }
 
   // Script (copy to meta dir)
-  if(!Script.empty())
-    {
+  if (!Script.empty()) {
     std::string name = cmSystemTools::GetFilenameName(Script);
     std::string path = Directory + "/meta/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(Script.data(), path.data());
     xout.Element("Script", name);
-    }
+  }
 
   // Dependencies
   std::set<DependenceStruct> compDepSet;
-  for(std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
-      ait != AlienDependencies.end(); ++ait)
-    {
+  for (std::set<DependenceStruct*>::iterator ait = AlienDependencies.begin();
+       ait != AlienDependencies.end(); ++ait) {
     compDepSet.insert(*(*ait));
-    }
-  for(std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
-      it != Dependencies.end(); ++it)
-    {
+  }
+  for (std::set<cmCPackIFWPackage*>::iterator it = Dependencies.begin();
+       it != Dependencies.end(); ++it) {
     compDepSet.insert(DependenceStruct((*it)->Name));
-    }
+  }
   // Write dependencies
-  if  (!compDepSet.empty())
-    {
+  if (!compDepSet.empty()) {
     std::stringstream dependencies;
     std::set<DependenceStruct>::iterator it = compDepSet.begin();
     dependencies << it->NameWithCompare();
     ++it;
-    while(it != compDepSet.end())
-      {
+    while (it != compDepSet.end()) {
       dependencies << "," << it->NameWithCompare();
       ++it;
-      }
-    xout.Element("Dependencies", dependencies.str());
     }
+    xout.Element("Dependencies", dependencies.str());
+  }
 
   // Licenses (copy to meta dir)
   std::vector<std::string> licenses = Licenses;
-  for(size_t i = 1; i < licenses.size(); i += 2)
-    {
+  for (size_t i = 1; i < licenses.size(); i += 2) {
     std::string name = cmSystemTools::GetFilenameName(licenses[i]);
     std::string path = Directory + "/meta/" + name;
     cmsys::SystemTools::CopyFileIfDifferent(licenses[i].data(), path.data());
     licenses[i] = name;
-    }
-  if(!licenses.empty())
-    {
+  }
+  if (!licenses.empty()) {
     xout.StartElement("Licenses");
-    for(size_t i = 0; i < licenses.size(); i += 2)
-      {
+    for (size_t i = 0; i < licenses.size(); i += 2) {
       xout.StartElement("License");
       xout.Attribute("name", licenses[i]);
       xout.Attribute("file", licenses[i + 1]);
       xout.EndElement();
-      }
-    xout.EndElement();
     }
+    xout.EndElement();
+  }
 
-  if (!ForcedInstallation.empty())
-    {
+  if (!ForcedInstallation.empty()) {
     xout.Element("ForcedInstallation", ForcedInstallation);
-    }
+  }
 
-  if (!Virtual.empty())
-    {
+  if (!Virtual.empty()) {
     xout.Element("Virtual", Virtual);
-    }
-  else if (!Default.empty())
-    {
+  } else if (!Default.empty()) {
     xout.Element("Default", Default);
-    }
+  }
 
   // Priority
-  if(!SortingPriority.empty())
-    {
+  if (!SortingPriority.empty()) {
     xout.Element("SortingPriority", SortingPriority);
-    }
+  }
 
   xout.EndElement();
   xout.EndDocument();
 }
 
-void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter &xout)
+void cmCPackIFWPackage::WriteGeneratedByToStrim(cmXMLWriter& xout)
 {
-  if(Generator) Generator->WriteGeneratedByToStrim(xout);
+  if (Generator)
+    Generator->WriteGeneratedByToStrim(xout);
 }
diff --git a/Source/CPack/IFW/cmCPackIFWPackage.h b/Source/CPack/IFW/cmCPackIFWPackage.h
index 4f3f40b..8a566cb 100644
--- a/Source/CPack/IFW/cmCPackIFWPackage.h
+++ b/Source/CPack/IFW/cmCPackIFWPackage.h
@@ -31,11 +31,11 @@ public:
 
   enum CompareTypes
   {
-    CompareNone           = 0x0,
-    CompareEqual          = 0x1,
-    CompareLess           = 0x2,
-    CompareLessOrEqual    = 0x3,
-    CompareGreater        = 0x4,
+    CompareNone = 0x0,
+    CompareEqual = 0x1,
+    CompareLess = 0x2,
+    CompareLessOrEqual = 0x3,
+    CompareGreater = 0x4,
     CompareGreaterOrEqual = 0x5
   };
 
@@ -50,17 +50,17 @@ public:
   struct DependenceStruct
   {
     DependenceStruct();
-    DependenceStruct(const std::string &dependence);
+    DependenceStruct(const std::string& dependence);
 
     std::string Name;
     CompareStruct Compare;
 
     std::string NameWithCompare() const;
 
-    bool operator < (const DependenceStruct &other) const
-      {
+    bool operator<(const DependenceStruct& other) const
+    {
       return Name < other.Name;
-      }
+    }
   };
 
 public:
@@ -113,18 +113,18 @@ public:
   const char* GetOption(const std::string& op) const;
   bool IsOn(const std::string& op) const;
 
-  bool IsVersionLess(const char *version);
-  bool IsVersionGreater(const char *version);
-  bool IsVersionEqual(const char *version);
+  bool IsVersionLess(const char* version);
+  bool IsVersionGreater(const char* version);
+  bool IsVersionEqual(const char* version);
 
-  std::string GetComponentName(cmCPackComponent *component);
+  std::string GetComponentName(cmCPackComponent* component);
 
   void DefaultConfiguration();
 
   int ConfigureFromOptions();
-  int ConfigureFromComponent(cmCPackComponent *component);
-  int ConfigureFromGroup(cmCPackComponentGroup *group);
-  int ConfigureFromGroup(const std::string &groupName);
+  int ConfigureFromComponent(cmCPackComponent* component);
+  int ConfigureFromGroup(cmCPackComponentGroup* group);
+  int ConfigureFromGroup(const std::string& groupName);
 
   void GeneratePackageFile();
 
diff --git a/Source/CPack/OSXScriptLauncher.cxx b/Source/CPack/OSXScriptLauncher.cxx
index b3ddeee..19204a2 100644
--- a/Source/CPack/OSXScriptLauncher.cxx
+++ b/Source/CPack/OSXScriptLauncher.cxx
@@ -20,72 +20,65 @@
 // For the PATH_MAX constant
 #include <sys/syslimits.h>
 
-#define DebugError(x) \
-  ofs << x << std::endl; \
+#define DebugError(x)                                                         \
+  ofs << x << std::endl;                                                      \
   std::cout << x << std::endl
 
 int main(int argc, char* argv[])
 {
-  //if ( cmsys::SystemTools::FileExists(
+  // if ( cmsys::SystemTools::FileExists(
   std::string cwd = cmsys::SystemTools::GetCurrentWorkingDirectory();
   cmsys::ofstream ofs("/tmp/output.txt");
 
   CFStringRef fileName;
   CFBundleRef appBundle;
   CFURLRef scriptFileURL;
-  UInt8 *path;
+  UInt8* path;
 
-  //get CF URL for script
-  if (! (appBundle = CFBundleGetMainBundle()))
-    {
+  // get CF URL for script
+  if (!(appBundle = CFBundleGetMainBundle())) {
     DebugError("Cannot get main bundle");
     return 1;
-    }
+  }
   fileName = CFSTR("RuntimeScript");
-  if (! (scriptFileURL = CFBundleCopyResourceURL(appBundle, fileName, NULL,
-        NULL)))
-    {
+  if (!(scriptFileURL =
+          CFBundleCopyResourceURL(appBundle, fileName, NULL, NULL))) {
     DebugError("CFBundleCopyResourceURL failed");
     return 1;
-    }
+  }
 
-  //create path string
-  if (! (path = new UInt8[PATH_MAX]))
-    {
+  // create path string
+  if (!(path = new UInt8[PATH_MAX])) {
     return 1;
-    }
+  }
 
-  //get the file system path of the url as a cstring
-  //in an encoding suitable for posix apis
-  if ( CFURLGetFileSystemRepresentation(scriptFileURL, true, path,
-        PATH_MAX) == false)
-    {
+  // get the file system path of the url as a cstring
+  // in an encoding suitable for posix apis
+  if (CFURLGetFileSystemRepresentation(scriptFileURL, true, path, PATH_MAX) ==
+      false) {
     DebugError("CFURLGetFileSystemRepresentation failed");
     return 1;
-    }
+  }
 
-  //dispose of the CF variable
+  // dispose of the CF variable
   CFRelease(scriptFileURL);
 
   std::string fullScriptPath = reinterpret_cast<char*>(path);
-  delete [] path;
+  delete[] path;
 
-
-  if (! cmsys::SystemTools::FileExists(fullScriptPath.c_str()))
-    {
+  if (!cmsys::SystemTools::FileExists(fullScriptPath.c_str())) {
     return 1;
-    }
+  }
 
-  std::string scriptDirectory = cmsys::SystemTools::GetFilenamePath(
-    fullScriptPath);
+  std::string scriptDirectory =
+    cmsys::SystemTools::GetFilenamePath(fullScriptPath);
   ofs << fullScriptPath.c_str() << std::endl;
   std::vector<const char*> args;
   args.push_back(fullScriptPath.c_str());
   int cc;
-  for ( cc = 1; cc < argc; ++ cc )
-    {
+  for (cc = 1; cc < argc; ++cc) {
     args.push_back(argv[cc]);
-    }
+  }
   args.push_back(0);
 
   cmsysProcess* cp = cmsysProcess_New();
@@ -98,49 +91,38 @@ int main(int argc, char* argv[])
   std::vector<char> tempOutput;
   char* data;
   int length;
-  while(cmsysProcess_WaitForData(cp, &data, &length, 0))
-    {
+  while (cmsysProcess_WaitForData(cp, &data, &length, 0)) {
     // Translate NULL characters in the output into valid text.
     // Visual Studio 7 puts these characters in the output of its
     // build process.
-    for(int i=0; i < length; ++i)
-      {
-      if(data[i] == '\0')
-        {
+    for (int i = 0; i < length; ++i) {
+      if (data[i] == '\0') {
         data[i] = ' ';
-        }
       }
-    std::cout.write(data, length);
     }
+    std::cout.write(data, length);
+  }
 
   cmsysProcess_WaitForExit(cp, 0);
 
   bool result = true;
-  if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exited)
-    {
-    if ( cmsysProcess_GetExitValue(cp) !=  0 )
-      {
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
+    if (cmsysProcess_GetExitValue(cp) != 0) {
       result = false;
-      }
     }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exception)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exception) {
     const char* exception_str = cmsysProcess_GetExceptionString(cp);
     std::cerr << exception_str << std::endl;
     result = false;
-    }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Error)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
     const char* error_str = cmsysProcess_GetErrorString(cp);
     std::cerr << error_str << std::endl;
     result = false;
-    }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Expired)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Expired) {
     const char* error_str = "Process terminated due to timeout\n";
     std::cerr << error_str << std::endl;
     result = false;
-    }
+  }
 
   cmsysProcess_Delete(cp);
 
diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.cxx b/Source/CPack/WiX/cmCPackWIXGenerator.cxx
index a98c684..8777296 100644
--- a/Source/CPack/WiX/cmCPackWIXGenerator.cxx
+++ b/Source/CPack/WiX/cmCPackWIXGenerator.cxx
@@ -32,18 +32,16 @@
 
 #include <rpc.h> // for GUID generation
 
-cmCPackWIXGenerator::cmCPackWIXGenerator():
-  Patch(0)
+cmCPackWIXGenerator::cmCPackWIXGenerator()
+  : Patch(0)
 {
-
 }
 
 cmCPackWIXGenerator::~cmCPackWIXGenerator()
 {
-  if(this->Patch)
-    {
+  if (this->Patch) {
     delete this->Patch;
-    }
+  }
 }
 
 int cmCPackWIXGenerator::InitializeInternal()
@@ -58,41 +56,39 @@ bool cmCPackWIXGenerator::RunWiXCommand(std::string const& command)
 {
   std::string logFileName = this->CPackTopLevel + "/wix.log";
 
-  cmCPackLogger(cmCPackLog::LOG_DEBUG,
-    "Running WiX command: " << command << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Running WiX command: " << command
+                                                               << std::endl);
 
   std::string output;
 
   int returnValue = 0;
-  bool status = cmSystemTools::RunSingleCommand(
-    command.c_str(), &output, &output,
-    &returnValue, 0, cmSystemTools::OUTPUT_NONE);
+  bool status = cmSystemTools::RunSingleCommand(command.c_str(), &output,
+                                                &output, &returnValue, 0,
+                                                cmSystemTools::OUTPUT_NONE);
 
   cmsys::ofstream logFile(logFileName.c_str(), std::ios::app);
   logFile << command << std::endl;
   logFile << output;
   logFile.close();
 
-  if(!status || returnValue)
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Problem running WiX candle. "
-      "Please check '" << logFileName << "' for errors." << std::endl);
+  if (!status || returnValue) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running WiX candle. "
+                                         "Please check '"
+                    << logFileName << "' for errors." << std::endl);
 
     return false;
-    }
+  }
 
   return true;
 }
 
-bool cmCPackWIXGenerator::RunCandleCommand(
-  std::string const& sourceFile, std::string const& objectFile)
+bool cmCPackWIXGenerator::RunCandleCommand(std::string const& sourceFile,
+                                           std::string const& objectFile)
 {
   std::string executable;
-  if(!RequireOption("CPACK_WIX_CANDLE_EXECUTABLE", executable))
-    {
+  if (!RequireOption("CPACK_WIX_CANDLE_EXECUTABLE", executable)) {
     return false;
-    }
+  }
 
   std::stringstream command;
   command << QuotePath(executable);
@@ -100,11 +96,10 @@ bool cmCPackWIXGenerator::RunCandleCommand(
   command << " -arch " << GetArchitecture();
   command << " -out " << QuotePath(objectFile);
 
-  for(extension_set_t::const_iterator i = CandleExtensions.begin();
-      i != CandleExtensions.end(); ++i)
-    {
+  for (extension_set_t::const_iterator i = CandleExtensions.begin();
+       i != CandleExtensions.end(); ++i) {
     command << " -ext " << QuotePath(*i);
-    }
+  }
 
   AddCustomFlags("CPACK_WIX_CANDLE_EXTRA_FLAGS", command);
 
@@ -116,27 +111,24 @@ bool cmCPackWIXGenerator::RunCandleCommand(
 bool cmCPackWIXGenerator::RunLightCommand(std::string const& objectFiles)
 {
   std::string executable;
-  if(!RequireOption("CPACK_WIX_LIGHT_EXECUTABLE", executable))
-    {
+  if (!RequireOption("CPACK_WIX_LIGHT_EXECUTABLE", executable)) {
     return false;
-    }
+  }
 
   std::stringstream command;
   command << QuotePath(executable);
   command << " -nologo";
   command << " -out " << QuotePath(packageFileNames.at(0));
 
-  for(extension_set_t::const_iterator i = this->LightExtensions.begin();
-      i != this->LightExtensions.end(); ++i)
-    {
+  for (extension_set_t::const_iterator i = this->LightExtensions.begin();
+       i != this->LightExtensions.end(); ++i) {
     command << " -ext " << QuotePath(*i);
-    }
+  }
 
   const char* const cultures = GetOption("CPACK_WIX_CULTURES");
-  if(cultures)
-    {
+  if (cultures) {
     command << " -cultures:" << cultures;
-    }
+  }
 
   AddCustomFlags("CPACK_WIX_LIGHT_EXTRA_FLAGS", command);
 
@@ -147,90 +139,80 @@ bool cmCPackWIXGenerator::RunLightCommand(std::string const& objectFiles)
 
 int cmCPackWIXGenerator::PackageFiles()
 {
-  if(!PackageFilesImpl() || cmSystemTools::GetErrorOccuredFlag())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Fatal WiX Generator Error" << std::endl);
+  if (!PackageFilesImpl() || cmSystemTools::GetErrorOccuredFlag()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Fatal WiX Generator Error"
+                    << std::endl);
     return false;
-    }
+  }
 
   return true;
 }
 
 bool cmCPackWIXGenerator::InitializeWiXConfiguration()
 {
-  if(!ReadListFile("CPackWIX.cmake"))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Error while executing CPackWIX.cmake" << std::endl);
+  if (!ReadListFile("CPackWIX.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while executing CPackWIX.cmake"
+                    << std::endl);
     return false;
-    }
+  }
 
-  if(GetOption("CPACK_WIX_PRODUCT_GUID") == 0)
-    {
+  if (GetOption("CPACK_WIX_PRODUCT_GUID") == 0) {
     std::string guid = GenerateGUID();
     SetOption("CPACK_WIX_PRODUCT_GUID", guid.c_str());
 
     cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-      "CPACK_WIX_PRODUCT_GUID implicitly set to " << guid << " . "
-      << std::endl);
-    }
+                  "CPACK_WIX_PRODUCT_GUID implicitly set to " << guid << " . "
+                                                              << std::endl);
+  }
 
-  if(GetOption("CPACK_WIX_UPGRADE_GUID") == 0)
-    {
+  if (GetOption("CPACK_WIX_UPGRADE_GUID") == 0) {
     std::string guid = GenerateGUID();
     SetOption("CPACK_WIX_UPGRADE_GUID", guid.c_str());
 
-    cmCPackLogger(cmCPackLog::LOG_WARNING,
-      "CPACK_WIX_UPGRADE_GUID implicitly set to " << guid << " . "
-      "Please refer to the documentation on how and why "
-      "you might want to set this explicitly." << std::endl);
-    }
+    cmCPackLogger(
+      cmCPackLog::LOG_WARNING, "CPACK_WIX_UPGRADE_GUID implicitly set to "
+        << guid << " . "
+                   "Please refer to the documentation on how and why "
+                   "you might want to set this explicitly."
+        << std::endl);
+  }
 
-  if(!RequireOption("CPACK_TOPLEVEL_DIRECTORY", this->CPackTopLevel))
-    {
+  if (!RequireOption("CPACK_TOPLEVEL_DIRECTORY", this->CPackTopLevel)) {
     return false;
-    }
+  }
 
-  if(GetOption("CPACK_WIX_LICENSE_RTF") == 0)
-    {
+  if (GetOption("CPACK_WIX_LICENSE_RTF") == 0) {
     std::string licenseFilename = this->CPackTopLevel + "/License.rtf";
     SetOption("CPACK_WIX_LICENSE_RTF", licenseFilename.c_str());
 
-    if(!CreateLicenseFile())
-      {
+    if (!CreateLicenseFile()) {
       return false;
-      }
     }
+  }
 
-  if(GetOption("CPACK_PACKAGE_VENDOR") == 0)
-    {
+  if (GetOption("CPACK_PACKAGE_VENDOR") == 0) {
     std::string defaultVendor = "Humanity";
     SetOption("CPACK_PACKAGE_VENDOR", defaultVendor.c_str());
 
     cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-      "CPACK_PACKAGE_VENDOR implicitly set to " << defaultVendor << " . "
-      << std::endl);
-    }
+                  "CPACK_PACKAGE_VENDOR implicitly set to "
+                    << defaultVendor << " . " << std::endl);
+  }
 
-  if(GetOption("CPACK_WIX_UI_REF") == 0)
-    {
+  if (GetOption("CPACK_WIX_UI_REF") == 0) {
     std::string defaultRef = "WixUI_InstallDir";
 
-    if(!this->Components.empty())
-      {
+    if (!this->Components.empty()) {
       defaultRef = "WixUI_FeatureTree";
-      }
+    }
 
     SetOption("CPACK_WIX_UI_REF", defaultRef.c_str());
-    }
+  }
 
   const char* packageContact = GetOption("CPACK_PACKAGE_CONTACT");
-  if(packageContact != 0 &&
-     GetOption("CPACK_WIX_PROPERTY_ARPCONTACT") == 0)
-    {
+  if (packageContact != 0 && GetOption("CPACK_WIX_PROPERTY_ARPCONTACT") == 0) {
     SetOption("CPACK_WIX_PROPERTY_ARPCONTACT", packageContact);
-    }
+  }
 
   CollectExtensions("CPACK_WIX_EXTENSIONS", this->CandleExtensions);
   CollectExtensions("CPACK_WIX_CANDLE_EXTENSIONS", this->CandleExtensions);
@@ -240,46 +222,40 @@ bool cmCPackWIXGenerator::InitializeWiXConfiguration()
   CollectExtensions("CPACK_WIX_LIGHT_EXTENSIONS", this->LightExtensions);
 
   const char* patchFilePath = GetOption("CPACK_WIX_PATCH_FILE");
-  if(patchFilePath)
-    {
+  if (patchFilePath) {
     std::vector<std::string> patchFilePaths;
     cmSystemTools::ExpandListArgument(patchFilePath, patchFilePaths);
 
-    for(size_t i = 0; i < patchFilePaths.size(); ++i)
-      {
-      if(!this->Patch->LoadFragments(patchFilePaths[i]))
-        {
+    for (size_t i = 0; i < patchFilePaths.size(); ++i) {
+      if (!this->Patch->LoadFragments(patchFilePaths[i])) {
         return false;
-        }
       }
     }
+  }
 
   return true;
 }
 
 bool cmCPackWIXGenerator::PackageFilesImpl()
 {
-  if(!InitializeWiXConfiguration())
-    {
+  if (!InitializeWiXConfiguration()) {
     return false;
-    }
+  }
 
   CreateWiXVariablesIncludeFile();
   CreateWiXPropertiesIncludeFile();
   CreateWiXProductFragmentIncludeFile();
 
-  if(!CreateWiXSourceFiles())
-    {
+  if (!CreateWiXSourceFiles()) {
     return false;
-    }
+  }
 
   AppendUserSuppliedExtraSources();
 
   std::set<std::string> usedBaseNames;
 
   std::stringstream objectFiles;
-  for(size_t i = 0; i < this->WixSources.size(); ++i)
-    {
+  for (size_t i = 0; i < this->WixSources.size(); ++i) {
     std::string const& sourceFilename = this->WixSources[i];
 
     std::string baseName =
@@ -288,25 +264,23 @@ bool cmCPackWIXGenerator::PackageFilesImpl()
     unsigned int counter = 0;
     std::string uniqueBaseName = baseName;
 
-    while(usedBaseNames.find(uniqueBaseName) != usedBaseNames.end())
-      {
+    while (usedBaseNames.find(uniqueBaseName) != usedBaseNames.end()) {
       std::stringstream tmp;
       tmp << baseName << ++counter;
       uniqueBaseName = tmp.str();
-      }
+    }
 
     usedBaseNames.insert(uniqueBaseName);
 
     std::string objectFilename =
       this->CPackTopLevel + "/" + uniqueBaseName + ".wixobj";
 
-    if(!RunCandleCommand(sourceFilename, objectFilename))
-      {
+    if (!RunCandleCommand(sourceFilename, objectFilename)) {
       return false;
-      }
+    }
 
     objectFiles << " " << QuotePath(objectFilename);
-    }
+  }
 
   AppendUserSuppliedExtraObjects(objectFiles);
 
@@ -315,35 +289,34 @@ bool cmCPackWIXGenerator::PackageFilesImpl()
 
 void cmCPackWIXGenerator::AppendUserSuppliedExtraSources()
 {
-  const char *cpackWixExtraSources = GetOption("CPACK_WIX_EXTRA_SOURCES");
-  if(!cpackWixExtraSources) return;
+  const char* cpackWixExtraSources = GetOption("CPACK_WIX_EXTRA_SOURCES");
+  if (!cpackWixExtraSources)
+    return;
 
   cmSystemTools::ExpandListArgument(cpackWixExtraSources, this->WixSources);
 }
 
 void cmCPackWIXGenerator::AppendUserSuppliedExtraObjects(std::ostream& stream)
 {
-  const char *cpackWixExtraObjects = GetOption("CPACK_WIX_EXTRA_OBJECTS");
-  if(!cpackWixExtraObjects) return;
+  const char* cpackWixExtraObjects = GetOption("CPACK_WIX_EXTRA_OBJECTS");
+  if (!cpackWixExtraObjects)
+    return;
 
   std::vector<std::string> expandedExtraObjects;
 
-  cmSystemTools::ExpandListArgument(
-    cpackWixExtraObjects, expandedExtraObjects);
+  cmSystemTools::ExpandListArgument(cpackWixExtraObjects,
+                                    expandedExtraObjects);
 
-  for(size_t i = 0; i < expandedExtraObjects.size(); ++i)
-    {
+  for (size_t i = 0; i < expandedExtraObjects.size(); ++i) {
     stream << " " << QuotePath(expandedExtraObjects[i]);
-    }
+  }
 }
 
 void cmCPackWIXGenerator::CreateWiXVariablesIncludeFile()
 {
-  std::string includeFilename =
-    this->CPackTopLevel + "/cpack_variables.wxi";
+  std::string includeFilename = this->CPackTopLevel + "/cpack_variables.wxi";
 
-  cmWIXSourceWriter includeFile(
-    this->Logger, includeFilename, true);
+  cmWIXSourceWriter includeFile(this->Logger, includeFilename, true);
 
   CopyDefinition(includeFile, "CPACK_WIX_PRODUCT_GUID");
   CopyDefinition(includeFile, "CPACK_WIX_UPGRADE_GUID");
@@ -355,29 +328,25 @@ void cmCPackWIXGenerator::CreateWiXVariablesIncludeFile()
   CopyDefinition(includeFile, "CPACK_WIX_UI_BANNER");
   CopyDefinition(includeFile, "CPACK_WIX_UI_DIALOG");
   SetOptionIfNotSet("CPACK_WIX_PROGRAM_MENU_FOLDER",
-    GetOption("CPACK_PACKAGE_NAME"));
+                    GetOption("CPACK_PACKAGE_NAME"));
   CopyDefinition(includeFile, "CPACK_WIX_PROGRAM_MENU_FOLDER");
   CopyDefinition(includeFile, "CPACK_WIX_UI_REF");
 }
 
 void cmCPackWIXGenerator::CreateWiXPropertiesIncludeFile()
 {
-  std::string includeFilename =
-    this->CPackTopLevel + "/properties.wxi";
+  std::string includeFilename = this->CPackTopLevel + "/properties.wxi";
 
-  cmWIXSourceWriter includeFile(
-    this->Logger, includeFilename, true);
+  cmWIXSourceWriter includeFile(this->Logger, includeFilename, true);
 
   std::string prefix = "CPACK_WIX_PROPERTY_";
   std::vector<std::string> options = GetOptions();
 
-  for(size_t i = 0; i < options.size(); ++i)
-    {
+  for (size_t i = 0; i < options.size(); ++i) {
     std::string const& name = options[i];
 
-    if(name.length() > prefix.length() &&
-       name.substr(0, prefix.length()) == prefix)
-      {
+    if (name.length() > prefix.length() &&
+        name.substr(0, prefix.length()) == prefix) {
       std::string id = name.substr(prefix.length());
       std::string value = GetOption(name.c_str());
 
@@ -385,11 +354,10 @@ void cmCPackWIXGenerator::CreateWiXPropertiesIncludeFile()
       includeFile.AddAttribute("Id", id);
       includeFile.AddAttribute("Value", value);
       includeFile.EndElement("Property");
-      }
     }
+  }
 
-  if(GetOption("CPACK_WIX_PROPERTY_ARPINSTALLLOCATION") == 0)
-    {
+  if (GetOption("CPACK_WIX_PROPERTY_ARPINSTALLLOCATION") == 0) {
     includeFile.BeginElement("Property");
     includeFile.AddAttribute("Id", "INSTALL_ROOT");
     includeFile.AddAttribute("Secure", "yes");
@@ -397,8 +365,9 @@ void cmCPackWIXGenerator::CreateWiXPropertiesIncludeFile()
     includeFile.BeginElement("RegistrySearch");
     includeFile.AddAttribute("Id", "FindInstallLocation");
     includeFile.AddAttribute("Root", "HKLM");
-    includeFile.AddAttribute("Key", "Software\\Microsoft\\Windows\\"
-      "CurrentVersion\\Uninstall\\[WIX_UPGRADE_DETECTED]");
+    includeFile.AddAttribute(
+      "Key", "Software\\Microsoft\\Windows\\"
+             "CurrentVersion\\Uninstall\\[WIX_UPGRADE_DETECTED]");
     includeFile.AddAttribute("Name", "InstallLocation");
     includeFile.AddAttribute("Type", "raw");
     includeFile.EndElement("RegistrySearch");
@@ -409,38 +378,36 @@ void cmCPackWIXGenerator::CreateWiXPropertiesIncludeFile()
     includeFile.AddAttribute("Value", "[INSTALL_ROOT]");
     includeFile.AddAttribute("After", "CostFinalize");
     includeFile.EndElement("SetProperty");
-    }
+  }
 }
 
 void cmCPackWIXGenerator::CreateWiXProductFragmentIncludeFile()
 {
-    std::string includeFilename =
-      this->CPackTopLevel + "/product_fragment.wxi";
+  std::string includeFilename = this->CPackTopLevel + "/product_fragment.wxi";
 
-    cmWIXSourceWriter includeFile(
-      this->Logger, includeFilename, true);
+  cmWIXSourceWriter includeFile(this->Logger, includeFilename, true);
 
-    this->Patch->ApplyFragment("#PRODUCT", includeFile);
+  this->Patch->ApplyFragment("#PRODUCT", includeFile);
 }
 
-void cmCPackWIXGenerator::CopyDefinition(
-  cmWIXSourceWriter &source, std::string const& name)
+void cmCPackWIXGenerator::CopyDefinition(cmWIXSourceWriter& source,
+                                         std::string const& name)
 {
   const char* value = GetOption(name.c_str());
-  if(value)
-    {
+  if (value) {
     AddDefinition(source, name, value);
-    }
+  }
 }
 
 void cmCPackWIXGenerator::AddDefinition(cmWIXSourceWriter& source,
-  std::string const& name, std::string const& value)
+                                        std::string const& name,
+                                        std::string const& value)
 {
   std::stringstream tmp;
   tmp << name << "=\"" << value << '"';
 
-  source.AddProcessingInstruction("define",
-    cmWIXSourceWriter::CMakeEncodingToUtf8(tmp.str()));
+  source.AddProcessingInstruction(
+    "define", cmWIXSourceWriter::CMakeEncodingToUtf8(tmp.str()));
 }
 
 bool cmCPackWIXGenerator::CreateWiXSourceFiles()
@@ -455,10 +422,9 @@ bool cmCPackWIXGenerator::CreateWiXSourceFiles()
   directoryDefinitions.BeginElement("Fragment");
 
   std::string installRoot;
-  if(!RequireOption("CPACK_PACKAGE_INSTALL_DIRECTORY", installRoot))
-    {
+  if (!RequireOption("CPACK_PACKAGE_INSTALL_DIRECTORY", installRoot)) {
     return false;
-    }
+  }
 
   directoryDefinitions.BeginElement("Directory");
   directoryDefinitions.AddAttribute("Id", "TARGETDIR");
@@ -468,23 +434,22 @@ bool cmCPackWIXGenerator::CreateWiXSourceFiles()
     directoryDefinitions.BeginInstallationPrefixDirectory(
       GetProgramFilesFolderId(), installRoot);
 
-  std::string fileDefinitionsFilename =
-    this->CPackTopLevel + "/files.wxs";
+  std::string fileDefinitionsFilename = this->CPackTopLevel + "/files.wxs";
 
   this->WixSources.push_back(fileDefinitionsFilename);
 
-  cmWIXFilesSourceWriter fileDefinitions(
-    this->Logger, fileDefinitionsFilename);
+  cmWIXFilesSourceWriter fileDefinitions(this->Logger,
+                                         fileDefinitionsFilename);
 
   fileDefinitions.BeginElement("Fragment");
 
   std::string featureDefinitionsFilename =
-      this->CPackTopLevel +"/features.wxs";
+    this->CPackTopLevel + "/features.wxs";
 
   this->WixSources.push_back(featureDefinitionsFilename);
 
-  cmWIXFeaturesSourceWriter featureDefinitions(
-    this->Logger, featureDefinitionsFilename);
+  cmWIXFeaturesSourceWriter featureDefinitions(this->Logger,
+                                               featureDefinitionsFilename);
 
   featureDefinitions.BeginElement("Fragment");
 
@@ -495,45 +460,39 @@ bool cmCPackWIXGenerator::CreateWiXSourceFiles()
   featureDefinitions.AddAttribute("ConfigurableDirectory", "INSTALL_ROOT");
 
   std::string cpackPackageName;
-  if(!RequireOption("CPACK_PACKAGE_NAME", cpackPackageName))
-    {
+  if (!RequireOption("CPACK_PACKAGE_NAME", cpackPackageName)) {
     return false;
-    }
+  }
 
   featureDefinitions.AddAttribute("Title", cpackPackageName);
   featureDefinitions.AddAttribute("Level", "1");
   this->Patch->ApplyFragment("#PRODUCTFEATURE", featureDefinitions);
 
   const char* package = GetOption("CPACK_WIX_CMAKE_PACKAGE_REGISTRY");
-  if(package)
-    {
+  if (package) {
     featureDefinitions.CreateCMakePackageRegistryEntry(
-        package, GetOption("CPACK_WIX_UPGRADE_GUID"));
-    }
+      package, GetOption("CPACK_WIX_UPGRADE_GUID"));
+  }
 
-  if(!CreateFeatureHierarchy(featureDefinitions))
-    {
+  if (!CreateFeatureHierarchy(featureDefinitions)) {
     return false;
-    }
+  }
 
   featureDefinitions.EndElement("Feature");
 
   std::set<cmWIXShortcuts::Type> emittedShortcutTypes;
 
   cmWIXShortcuts globalShortcuts;
-  if(Components.empty())
-    {
-    AddComponentsToFeature(toplevel, "ProductFeature",
-      directoryDefinitions, fileDefinitions, featureDefinitions,
-      globalShortcuts);
+  if (Components.empty()) {
+    AddComponentsToFeature(toplevel, "ProductFeature", directoryDefinitions,
+                           fileDefinitions, featureDefinitions,
+                           globalShortcuts);
 
     globalShortcuts.AddShortcutTypes(emittedShortcutTypes);
-    }
-  else
-    {
-    for(std::map<std::string, cmCPackComponent>::const_iterator
-      i = this->Components.begin(); i != this->Components.end(); ++i)
-      {
+  } else {
+    for (std::map<std::string, cmCPackComponent>::const_iterator i =
+           this->Components.begin();
+         i != this->Components.end(); ++i) {
       cmCPackComponent const& component = i->second;
 
       std::string componentPath = toplevel;
@@ -544,102 +503,91 @@ bool cmCPackWIXGenerator::CreateWiXSourceFiles()
 
       cmWIXShortcuts featureShortcuts;
       AddComponentsToFeature(componentPath, componentFeatureId,
-        directoryDefinitions, fileDefinitions,
-        featureDefinitions, featureShortcuts);
+                             directoryDefinitions, fileDefinitions,
+                             featureDefinitions, featureShortcuts);
 
       featureShortcuts.AddShortcutTypes(emittedShortcutTypes);
 
-      if(!CreateShortcuts(component.Name, componentFeatureId,
-        featureShortcuts, false, fileDefinitions, featureDefinitions))
-        {
+      if (!CreateShortcuts(component.Name, componentFeatureId,
+                           featureShortcuts, false, fileDefinitions,
+                           featureDefinitions)) {
         return false;
-        }
       }
     }
+  }
 
-  bool emitUninstallShortcut = emittedShortcutTypes.find(
-    cmWIXShortcuts::START_MENU) != emittedShortcutTypes.end();
+  bool emitUninstallShortcut =
+    emittedShortcutTypes.find(cmWIXShortcuts::START_MENU) !=
+    emittedShortcutTypes.end();
 
-  if(!CreateShortcuts(std::string(), "ProductFeature",
-      globalShortcuts, emitUninstallShortcut,
-      fileDefinitions, featureDefinitions))
-    {
+  if (!CreateShortcuts(std::string(), "ProductFeature", globalShortcuts,
+                       emitUninstallShortcut, fileDefinitions,
+                       featureDefinitions)) {
     return false;
-    }
+  }
 
   featureDefinitions.EndElement("Fragment");
   fileDefinitions.EndElement("Fragment");
 
-  directoryDefinitions.EndInstallationPrefixDirectory(
-    installRootSize);
+  directoryDefinitions.EndInstallationPrefixDirectory(installRootSize);
 
-  if(emittedShortcutTypes.find(cmWIXShortcuts::START_MENU) !=
-      emittedShortcutTypes.end())
-    {
+  if (emittedShortcutTypes.find(cmWIXShortcuts::START_MENU) !=
+      emittedShortcutTypes.end()) {
     directoryDefinitions.EmitStartMenuFolder(
       GetOption("CPACK_WIX_PROGRAM_MENU_FOLDER"));
-    }
+  }
 
-  if(emittedShortcutTypes.find(cmWIXShortcuts::DESKTOP) !=
-      emittedShortcutTypes.end())
-    {
+  if (emittedShortcutTypes.find(cmWIXShortcuts::DESKTOP) !=
+      emittedShortcutTypes.end()) {
     directoryDefinitions.EmitDesktopFolder();
-    }
+  }
 
-  if(emittedShortcutTypes.find(cmWIXShortcuts::STARTUP) !=
-      emittedShortcutTypes.end())
-    {
+  if (emittedShortcutTypes.find(cmWIXShortcuts::STARTUP) !=
+      emittedShortcutTypes.end()) {
     directoryDefinitions.EmitStartupFolder();
-    }
+  }
 
   directoryDefinitions.EndElement("Directory");
   directoryDefinitions.EndElement("Fragment");
 
-  if(!GenerateMainSourceFileFromTemplate())
-    {
+  if (!GenerateMainSourceFileFromTemplate()) {
     return false;
-    }
+  }
 
   return this->Patch->CheckForUnappliedFragments();
 }
 
 std::string cmCPackWIXGenerator::GetProgramFilesFolderId() const
 {
-  if(GetArchitecture() == "x86")
-    {
+  if (GetArchitecture() == "x86") {
     return "ProgramFilesFolder";
-    }
-  else
-    {
+  } else {
     return "ProgramFiles64Folder";
-    }
+  }
 }
 
 bool cmCPackWIXGenerator::GenerateMainSourceFileFromTemplate()
 {
   std::string wixTemplate = FindTemplate("WIX.template.in");
-  if(GetOption("CPACK_WIX_TEMPLATE") != 0)
-    {
+  if (GetOption("CPACK_WIX_TEMPLATE") != 0) {
     wixTemplate = GetOption("CPACK_WIX_TEMPLATE");
-    }
+  }
 
-  if(wixTemplate.empty())
-    {
+  if (wixTemplate.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Could not find CPack WiX template file WIX.template.in" << std::endl);
+                  "Could not find CPack WiX template file WIX.template.in"
+                    << std::endl);
     return false;
-    }
+  }
 
   std::string mainSourceFilePath = this->CPackTopLevel + "/main.wxs";
 
-  if(!ConfigureFile(wixTemplate.c_str(), mainSourceFilePath .c_str()))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Failed creating '" << mainSourceFilePath  <<
-      "'' from template." << std::endl);
+  if (!ConfigureFile(wixTemplate.c_str(), mainSourceFilePath.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed creating '"
+                    << mainSourceFilePath << "'' from template." << std::endl);
 
     return false;
-    }
+  }
 
   this->WixSources.push_back(mainSourceFilePath);
 
@@ -649,70 +597,64 @@ bool cmCPackWIXGenerator::GenerateMainSourceFileFromTemplate()
 bool cmCPackWIXGenerator::CreateFeatureHierarchy(
   cmWIXFeaturesSourceWriter& featureDefinitions)
 {
-  for(std::map<std::string, cmCPackComponentGroup>::const_iterator
-    i = ComponentGroups.begin(); i != ComponentGroups.end(); ++i)
-    {
+  for (std::map<std::string, cmCPackComponentGroup>::const_iterator i =
+         ComponentGroups.begin();
+       i != ComponentGroups.end(); ++i) {
     cmCPackComponentGroup const& group = i->second;
-    if(group.ParentGroup == 0)
-      {
+    if (group.ParentGroup == 0) {
       featureDefinitions.EmitFeatureForComponentGroup(group);
-      }
     }
+  }
 
-  for(std::map<std::string, cmCPackComponent>::const_iterator
-    i = this->Components.begin(); i != this->Components.end(); ++i)
-    {
+  for (std::map<std::string, cmCPackComponent>::const_iterator i =
+         this->Components.begin();
+       i != this->Components.end(); ++i) {
     cmCPackComponent const& component = i->second;
 
-    if(!component.Group)
-      {
+    if (!component.Group) {
       featureDefinitions.EmitFeatureForComponent(component);
-      }
     }
+  }
 
   return true;
 }
 
 bool cmCPackWIXGenerator::AddComponentsToFeature(
-  std::string const& rootPath,
-  std::string const& featureId,
+  std::string const& rootPath, std::string const& featureId,
   cmWIXDirectoriesSourceWriter& directoryDefinitions,
   cmWIXFilesSourceWriter& fileDefinitions,
-  cmWIXFeaturesSourceWriter& featureDefinitions,
-  cmWIXShortcuts& shortcuts)
+  cmWIXFeaturesSourceWriter& featureDefinitions, cmWIXShortcuts& shortcuts)
 {
   featureDefinitions.BeginElement("FeatureRef");
   featureDefinitions.AddAttribute("Id", featureId);
 
   std::vector<std::string> cpackPackageExecutablesList;
-  const char *cpackPackageExecutables = GetOption("CPACK_PACKAGE_EXECUTABLES");
-  if(cpackPackageExecutables)
-    {
-      cmSystemTools::ExpandListArgument(cpackPackageExecutables,
-        cpackPackageExecutablesList);
-      if(cpackPackageExecutablesList.size() % 2 != 0 )
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
-          "<text label>." << std::endl);
-        return false;
-        }
+  const char* cpackPackageExecutables = GetOption("CPACK_PACKAGE_EXECUTABLES");
+  if (cpackPackageExecutables) {
+    cmSystemTools::ExpandListArgument(cpackPackageExecutables,
+                                      cpackPackageExecutablesList);
+    if (cpackPackageExecutablesList.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
+        "<text label>."
+          << std::endl);
+      return false;
     }
+  }
 
   std::vector<std::string> cpackPackageDesktopLinksList;
-  const char *cpackPackageDesktopLinks =
+  const char* cpackPackageDesktopLinks =
     GetOption("CPACK_CREATE_DESKTOP_LINKS");
-  if(cpackPackageDesktopLinks)
-    {
-      cmSystemTools::ExpandListArgument(cpackPackageDesktopLinks,
-        cpackPackageDesktopLinksList);
-    }
+  if (cpackPackageDesktopLinks) {
+    cmSystemTools::ExpandListArgument(cpackPackageDesktopLinks,
+                                      cpackPackageDesktopLinksList);
+  }
 
-  AddDirectoryAndFileDefinitons(
-    rootPath, "INSTALL_ROOT",
-    directoryDefinitions, fileDefinitions, featureDefinitions,
-    cpackPackageExecutablesList, cpackPackageDesktopLinksList,
-    shortcuts);
+  AddDirectoryAndFileDefinitons(rootPath, "INSTALL_ROOT", directoryDefinitions,
+                                fileDefinitions, featureDefinitions,
+                                cpackPackageExecutablesList,
+                                cpackPackageDesktopLinksList, shortcuts);
 
   featureDefinitions.EndElement("FeatureRef");
 
@@ -720,62 +662,48 @@ bool cmCPackWIXGenerator::AddComponentsToFeature(
 }
 
 bool cmCPackWIXGenerator::CreateShortcuts(
-  std::string const& cpackComponentName,
-  std::string const& featureId,
-  cmWIXShortcuts const& shortcuts,
-  bool emitUninstallShortcut,
+  std::string const& cpackComponentName, std::string const& featureId,
+  cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
   cmWIXFilesSourceWriter& fileDefinitions,
   cmWIXFeaturesSourceWriter& featureDefinitions)
 {
-  if(!shortcuts.empty(cmWIXShortcuts::START_MENU))
-    {
-    if(!this->CreateShortcutsOfSpecificType(cmWIXShortcuts::START_MENU,
-      cpackComponentName, featureId, "",
-      shortcuts, emitUninstallShortcut,
-      fileDefinitions, featureDefinitions))
-      {
+  if (!shortcuts.empty(cmWIXShortcuts::START_MENU)) {
+    if (!this->CreateShortcutsOfSpecificType(
+          cmWIXShortcuts::START_MENU, cpackComponentName, featureId, "",
+          shortcuts, emitUninstallShortcut, fileDefinitions,
+          featureDefinitions)) {
       return false;
-      }
     }
+  }
 
-  if(!shortcuts.empty(cmWIXShortcuts::DESKTOP))
-    {
-    if(!this->CreateShortcutsOfSpecificType(cmWIXShortcuts::DESKTOP,
-      cpackComponentName, featureId, "DESKTOP",
-      shortcuts, false,
-      fileDefinitions, featureDefinitions))
-      {
+  if (!shortcuts.empty(cmWIXShortcuts::DESKTOP)) {
+    if (!this->CreateShortcutsOfSpecificType(
+          cmWIXShortcuts::DESKTOP, cpackComponentName, featureId, "DESKTOP",
+          shortcuts, false, fileDefinitions, featureDefinitions)) {
       return false;
-      }
     }
+  }
 
-  if(!shortcuts.empty(cmWIXShortcuts::STARTUP))
-    {
-    if(!this->CreateShortcutsOfSpecificType(cmWIXShortcuts::STARTUP,
-      cpackComponentName, featureId, "STARTUP",
-      shortcuts, false,
-      fileDefinitions, featureDefinitions))
-      {
+  if (!shortcuts.empty(cmWIXShortcuts::STARTUP)) {
+    if (!this->CreateShortcutsOfSpecificType(
+          cmWIXShortcuts::STARTUP, cpackComponentName, featureId, "STARTUP",
+          shortcuts, false, fileDefinitions, featureDefinitions)) {
       return false;
-      }
     }
+  }
 
   return true;
 }
 
 bool cmCPackWIXGenerator::CreateShortcutsOfSpecificType(
-  cmWIXShortcuts::Type type,
-  std::string const& cpackComponentName,
-  std::string const& featureId,
-  std::string const& idPrefix,
-  cmWIXShortcuts const& shortcuts,
-  bool emitUninstallShortcut,
+  cmWIXShortcuts::Type type, std::string const& cpackComponentName,
+  std::string const& featureId, std::string const& idPrefix,
+  cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
   cmWIXFilesSourceWriter& fileDefinitions,
   cmWIXFeaturesSourceWriter& featureDefinitions)
 {
   std::string directoryId;
-  switch(type)
-    {
+  switch (type) {
     case cmWIXShortcuts::START_MENU:
       directoryId = "PROGRAM_MENU_FOLDER";
       break;
@@ -787,35 +715,31 @@ bool cmCPackWIXGenerator::CreateShortcutsOfSpecificType(
       break;
     default:
       return false;
-    }
+  }
 
   featureDefinitions.BeginElement("FeatureRef");
   featureDefinitions.AddAttribute("Id", featureId);
 
   std::string cpackVendor;
-  if(!RequireOption("CPACK_PACKAGE_VENDOR", cpackVendor))
-    {
+  if (!RequireOption("CPACK_PACKAGE_VENDOR", cpackVendor)) {
     return false;
-    }
+  }
 
   std::string cpackPackageName;
-  if(!RequireOption("CPACK_PACKAGE_NAME", cpackPackageName))
-    {
+  if (!RequireOption("CPACK_PACKAGE_NAME", cpackPackageName)) {
     return false;
-    }
+  }
 
   std::string idSuffix;
-  if(!cpackComponentName.empty())
-    {
-      idSuffix += "_";
-      idSuffix += cpackComponentName;
-    }
+  if (!cpackComponentName.empty()) {
+    idSuffix += "_";
+    idSuffix += cpackComponentName;
+  }
 
   std::string componentId = "CM_SHORTCUT";
-  if(idPrefix.size())
-    {
+  if (idPrefix.size()) {
     componentId += "_" + idPrefix;
-    }
+  }
 
   componentId += idSuffix;
 
@@ -828,22 +752,20 @@ bool cmCPackWIXGenerator::CreateShortcutsOfSpecificType(
 
   this->Patch->ApplyFragment(componentId, fileDefinitions);
 
-  std::string registryKey = std::string("Software\\") +
-    cpackVendor + "\\" + cpackPackageName;
+  std::string registryKey =
+    std::string("Software\\") + cpackVendor + "\\" + cpackPackageName;
 
-  shortcuts.EmitShortcuts(type, registryKey,
-    cpackComponentName, fileDefinitions);
+  shortcuts.EmitShortcuts(type, registryKey, cpackComponentName,
+                          fileDefinitions);
 
-  if(type == cmWIXShortcuts::START_MENU)
-    {
-    fileDefinitions.EmitRemoveFolder(
-      "CM_REMOVE_PROGRAM_MENU_FOLDER" + idSuffix);
-    }
+  if (type == cmWIXShortcuts::START_MENU) {
+    fileDefinitions.EmitRemoveFolder("CM_REMOVE_PROGRAM_MENU_FOLDER" +
+                                     idSuffix);
+  }
 
-  if(emitUninstallShortcut)
-    {
+  if (emitUninstallShortcut) {
     fileDefinitions.EmitUninstallShortcut(cpackPackageName);
-    }
+  }
 
   fileDefinitions.EndElement("Component");
   fileDefinitions.EndElement("DirectoryRef");
@@ -857,53 +779,43 @@ bool cmCPackWIXGenerator::CreateShortcutsOfSpecificType(
 bool cmCPackWIXGenerator::CreateLicenseFile()
 {
   std::string licenseSourceFilename;
-  if(!RequireOption("CPACK_RESOURCE_FILE_LICENSE", licenseSourceFilename))
-    {
+  if (!RequireOption("CPACK_RESOURCE_FILE_LICENSE", licenseSourceFilename)) {
     return false;
-    }
+  }
 
   std::string licenseDestinationFilename;
-  if(!RequireOption("CPACK_WIX_LICENSE_RTF", licenseDestinationFilename))
-    {
+  if (!RequireOption("CPACK_WIX_LICENSE_RTF", licenseDestinationFilename)) {
     return false;
-    }
+  }
 
   std::string extension = GetRightmostExtension(licenseSourceFilename);
 
-  if(extension == ".rtf")
-    {
-    cmSystemTools::CopyAFile(
-      licenseSourceFilename.c_str(),
-      licenseDestinationFilename.c_str());
-    }
-  else if(extension == ".txt")
-    {
+  if (extension == ".rtf") {
+    cmSystemTools::CopyAFile(licenseSourceFilename.c_str(),
+                             licenseDestinationFilename.c_str());
+  } else if (extension == ".txt") {
     cmWIXRichTextFormatWriter rtfWriter(licenseDestinationFilename);
 
     cmsys::ifstream licenseSource(licenseSourceFilename.c_str());
 
     std::string line;
-    while(std::getline(licenseSource, line))
-      {
+    while (std::getline(licenseSource, line)) {
       rtfWriter.AddText(line);
       rtfWriter.AddText("\n");
-      }
     }
-  else
-    {
+  } else {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "unsupported WiX License file extension '" <<
-      extension << "'" << std::endl);
+                  "unsupported WiX License file extension '"
+                    << extension << "'" << std::endl);
 
     return false;
-    }
+  }
 
   return true;
 }
 
 void cmCPackWIXGenerator::AddDirectoryAndFileDefinitons(
-  std::string const& topdir,
-  std::string const& directoryId,
+  std::string const& topdir, std::string const& directoryId,
   cmWIXDirectoriesSourceWriter& directoryDefinitions,
   cmWIXFilesSourceWriter& fileDefinitions,
   cmWIXFeaturesSourceWriter& featureDefinitions,
@@ -917,61 +829,51 @@ void cmCPackWIXGenerator::AddDirectoryAndFileDefinitons(
   std::string relativeDirectoryPath =
     cmSystemTools::RelativePath(toplevel.c_str(), topdir.c_str());
 
-  if(relativeDirectoryPath.empty())
-    {
+  if (relativeDirectoryPath.empty()) {
     relativeDirectoryPath = ".";
-    }
+  }
 
   cmInstalledFile const* directoryInstalledFile = this->GetInstalledFile(
-      this->RelativePathWithoutComponentPrefix(relativeDirectoryPath)
-  );
+    this->RelativePathWithoutComponentPrefix(relativeDirectoryPath));
 
   bool emptyDirectory = dir.GetNumberOfFiles() == 2;
   bool createDirectory = false;
 
-  if(emptyDirectory)
-    {
+  if (emptyDirectory) {
     createDirectory = true;
-    }
+  }
 
-  if(directoryInstalledFile)
-    {
-    if(directoryInstalledFile->HasProperty("CPACK_WIX_ACL"))
-      {
+  if (directoryInstalledFile) {
+    if (directoryInstalledFile->HasProperty("CPACK_WIX_ACL")) {
       createDirectory = true;
-      }
     }
+  }
 
-  if(createDirectory)
-    {
+  if (createDirectory) {
     std::string componentId = fileDefinitions.EmitComponentCreateFolder(
       directoryId, GenerateGUID(), directoryInstalledFile);
     featureDefinitions.EmitComponentRef(componentId);
-    }
+  }
 
-  if(emptyDirectory)
-    {
+  if (emptyDirectory) {
     return;
-    }
+  }
 
-  for(size_t i = 0; i < dir.GetNumberOfFiles(); ++i)
-    {
+  for (size_t i = 0; i < dir.GetNumberOfFiles(); ++i) {
     std::string fileName = dir.GetFile(static_cast<unsigned long>(i));
 
-    if(fileName == "." || fileName == "..")
-      {
+    if (fileName == "." || fileName == "..") {
       continue;
-      }
+    }
 
     std::string fullPath = topdir + "/" + fileName;
 
-    std::string relativePath = cmSystemTools::RelativePath(
-      toplevel.c_str(), fullPath.c_str());
+    std::string relativePath =
+      cmSystemTools::RelativePath(toplevel.c_str(), fullPath.c_str());
 
     std::string id = PathToId(relativePath);
 
-    if(cmSystemTools::FileIsDirectory(fullPath.c_str()))
-      {
+    if (cmSystemTools::FileIsDirectory(fullPath.c_str())) {
       std::string subDirectoryId = std::string("CM_D") + id;
 
       directoryDefinitions.BeginElement("Directory");
@@ -979,77 +881,60 @@ void cmCPackWIXGenerator::AddDirectoryAndFileDefinitons(
       directoryDefinitions.AddAttribute("Name", fileName);
 
       AddDirectoryAndFileDefinitons(
-        fullPath, subDirectoryId,
-        directoryDefinitions,
-        fileDefinitions,
-        featureDefinitions,
-        packageExecutables,
-        desktopExecutables,
-        shortcuts);
+        fullPath, subDirectoryId, directoryDefinitions, fileDefinitions,
+        featureDefinitions, packageExecutables, desktopExecutables, shortcuts);
 
       this->Patch->ApplyFragment(subDirectoryId, directoryDefinitions);
       directoryDefinitions.EndElement("Directory");
-      }
-    else
-      {
+    } else {
       cmInstalledFile const* installedFile = this->GetInstalledFile(
-        this->RelativePathWithoutComponentPrefix(relativePath)
-      );
+        this->RelativePathWithoutComponentPrefix(relativePath));
 
-      if(installedFile)
-        {
+      if (installedFile) {
         shortcuts.CreateFromProperties(id, directoryId, *installedFile);
-        }
+      }
 
       std::string componentId = fileDefinitions.EmitComponentFile(
         directoryId, id, fullPath, *(this->Patch), installedFile);
 
       featureDefinitions.EmitComponentRef(componentId);
 
-      for(size_t j = 0; j < packageExecutables.size(); ++j)
-        {
+      for (size_t j = 0; j < packageExecutables.size(); ++j) {
         std::string const& executableName = packageExecutables[j++];
         std::string const& textLabel = packageExecutables[j];
 
-        if(cmSystemTools::LowerCase(fileName) ==
-            cmSystemTools::LowerCase(executableName) + ".exe")
-          {
+        if (cmSystemTools::LowerCase(fileName) ==
+            cmSystemTools::LowerCase(executableName) + ".exe") {
           cmWIXShortcut shortcut;
-          shortcut.label= textLabel;
+          shortcut.label = textLabel;
           shortcut.workingDirectoryId = directoryId;
           shortcuts.insert(cmWIXShortcuts::START_MENU, id, shortcut);
 
-          if(!desktopExecutables.empty() &&
-             std::find(desktopExecutables.begin(),
-                       desktopExecutables.end(),
-                       executableName)
-             != desktopExecutables.end())
-            {
-              shortcuts.insert(cmWIXShortcuts::DESKTOP, id, shortcut);
-            }
+          if (!desktopExecutables.empty() &&
+              std::find(desktopExecutables.begin(), desktopExecutables.end(),
+                        executableName) != desktopExecutables.end()) {
+            shortcuts.insert(cmWIXShortcuts::DESKTOP, id, shortcut);
           }
         }
       }
     }
+  }
 }
 
-bool cmCPackWIXGenerator::RequireOption(
-  std::string const& name, std::string &value) const
+bool cmCPackWIXGenerator::RequireOption(std::string const& name,
+                                        std::string& value) const
 {
   const char* tmp = GetOption(name.c_str());
-  if(tmp)
-    {
+  if (tmp) {
     value = tmp;
 
     return true;
-    }
-  else
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Required variable " << name << " not set" << std::endl);
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Required variable "
+                    << name << " not set" << std::endl);
 
     return false;
-    }
+  }
 }
 
 std::string cmCPackWIXGenerator::GetArchitecture() const
@@ -1057,14 +942,11 @@ std::string cmCPackWIXGenerator::GetArchitecture() const
   std::string void_p_size;
   RequireOption("CPACK_WIX_SIZEOF_VOID_P", void_p_size);
 
-  if(void_p_size == "8")
-    {
+  if (void_p_size == "8") {
     return "x64";
-    }
-  else
-    {
+  } else {
     return "x86";
-    }
+  }
 }
 
 std::string cmCPackWIXGenerator::GenerateGUID()
@@ -1072,7 +954,7 @@ std::string cmCPackWIXGenerator::GenerateGUID()
   UUID guid;
   UuidCreate(&guid);
 
-  unsigned short *tmp = 0;
+  unsigned short* tmp = 0;
   UuidToStringW(&guid, &tmp);
 
   std::string result =
@@ -1093,10 +975,9 @@ std::string cmCPackWIXGenerator::GetRightmostExtension(
   std::string extension;
 
   std::string::size_type i = filename.rfind(".");
-  if(i != std::string::npos)
-    {
+  if (i != std::string::npos) {
     extension = filename.substr(i);
-    }
+  }
 
   return cmSystemTools::LowerCase(extension);
 }
@@ -1104,7 +985,8 @@ std::string cmCPackWIXGenerator::GetRightmostExtension(
 std::string cmCPackWIXGenerator::PathToId(std::string const& path)
 {
   id_map_t::const_iterator i = PathToIdMap.find(path);
-  if(i != PathToIdMap.end()) return i->second;
+  if (i != PathToIdMap.end())
+    return i->second;
 
   std::string id = CreateNewIdForPath(path);
   return id;
@@ -1120,41 +1002,37 @@ std::string cmCPackWIXGenerator::CreateNewIdForPath(std::string const& path)
   std::string identifier;
   std::string currentComponent;
 
-  for(size_t i = 1; i < components.size(); ++i)
-    {
-    if(i != 1) identifier += '.';
+  for (size_t i = 1; i < components.size(); ++i) {
+    if (i != 1)
+      identifier += '.';
 
-    currentComponent = NormalizeComponentForId(
-      components[i], replacementCount);
+    currentComponent =
+      NormalizeComponentForId(components[i], replacementCount);
 
     identifier += currentComponent;
-    }
+  }
 
   std::string idPrefix = "P";
   size_t replacementPercent = replacementCount * 100 / identifier.size();
-  if(replacementPercent > 33 || identifier.size() > 60)
-    {
+  if (replacementPercent > 33 || identifier.size() > 60) {
     identifier = CreateHashedId(path, currentComponent);
     idPrefix = "H";
-    }
+  }
 
   std::stringstream result;
   result << idPrefix << "_" << identifier;
 
   size_t ambiguityCount = ++IdAmbiguityCounter[identifier];
 
-  if(ambiguityCount > 999)
-    {
+  if (ambiguityCount > 999) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Error while trying to generate a unique Id for '" <<
-      path << "'" << std::endl);
+                  "Error while trying to generate a unique Id for '"
+                    << path << "'" << std::endl);
 
     return std::string();
-    }
-  else if(ambiguityCount > 1)
-    {
+  } else if (ambiguityCount > 1) {
     result << "_" << ambiguityCount;
-    }
+  }
 
   std::string resultString = result.str();
 
@@ -1173,15 +1051,12 @@ std::string cmCPackWIXGenerator::CreateHashedId(
   identifier += hash.substr(0, 7) + "_";
 
   const size_t maxFileNameLength = 52;
-  if(normalizedFilename.length() > maxFileNameLength)
-    {
+  if (normalizedFilename.length() > maxFileNameLength) {
     identifier += normalizedFilename.substr(0, maxFileNameLength - 3);
     identifier += "...";
-    }
-  else
-    {
+  } else {
     identifier += normalizedFilename;
-    }
+  }
 
   return identifier;
 }
@@ -1192,65 +1067,59 @@ std::string cmCPackWIXGenerator::NormalizeComponentForId(
   std::string result;
   result.resize(component.size());
 
-  for(size_t i = 0; i < component.size(); ++i)
-    {
+  for (size_t i = 0; i < component.size(); ++i) {
     char c = component[i];
-    if(IsLegalIdCharacter(c))
-      {
+    if (IsLegalIdCharacter(c)) {
       result[i] = c;
-      }
-    else
-      {
+    } else {
       result[i] = '_';
-      ++ replacementCount;
-      }
+      ++replacementCount;
     }
+  }
 
   return result;
 }
 
 bool cmCPackWIXGenerator::IsLegalIdCharacter(char c)
 {
-  return (c >= '0' && c <= '9') ||
-      (c >= 'a' && c <= 'z') ||
-      (c >= 'A' && c <= 'Z') ||
-      c == '_' || c == '.';
+  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
+    (c >= 'A' && c <= 'Z') || c == '_' || c == '.';
 }
 
-void cmCPackWIXGenerator::CollectExtensions(
-     std::string const& variableName, extension_set_t& extensions)
+void cmCPackWIXGenerator::CollectExtensions(std::string const& variableName,
+                                            extension_set_t& extensions)
 {
-  const char *variableContent = GetOption(variableName.c_str());
-  if(!variableContent) return;
+  const char* variableContent = GetOption(variableName.c_str());
+  if (!variableContent)
+    return;
 
   std::vector<std::string> list;
   cmSystemTools::ExpandListArgument(variableContent, list);
   extensions.insert(list.begin(), list.end());
 }
 
-void cmCPackWIXGenerator::AddCustomFlags(
-  std::string const& variableName, std::ostream& stream)
+void cmCPackWIXGenerator::AddCustomFlags(std::string const& variableName,
+                                         std::ostream& stream)
 {
-  const char *variableContent = GetOption(variableName.c_str());
-  if(!variableContent) return;
+  const char* variableContent = GetOption(variableName.c_str());
+  if (!variableContent)
+    return;
 
   std::vector<std::string> list;
   cmSystemTools::ExpandListArgument(variableContent, list);
 
-  for(std::vector<std::string>::const_iterator i = list.begin();
-    i != list.end(); ++i)
-    {
-      stream << " " << QuotePath(*i);
-    }
+  for (std::vector<std::string>::const_iterator i = list.begin();
+       i != list.end(); ++i) {
+    stream << " " << QuotePath(*i);
+  }
 }
 
 std::string cmCPackWIXGenerator::RelativePathWithoutComponentPrefix(
   std::string const& path)
 {
-  if(this->Components.empty())
-    {
+  if (this->Components.empty()) {
     return path;
-    }
+  }
 
   std::string::size_type pos = path.find('/');
 
diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.h b/Source/CPack/WiX/cmCPackWIXGenerator.h
index 871527b..9d3a522 100644
--- a/Source/CPack/WiX/cmCPackWIXGenerator.h
+++ b/Source/CPack/WiX/cmCPackWIXGenerator.h
@@ -42,25 +42,16 @@ protected:
 
   virtual int PackageFiles();
 
-  virtual const char* GetOutputExtension()
-    {
-    return ".msi";
-    }
+  virtual const char* GetOutputExtension() { return ".msi"; }
 
   virtual enum CPackSetDestdirSupport SupportsSetDestdir() const
-    {
+  {
     return SETDESTDIR_UNSUPPORTED;
-    }
+  }
 
-  virtual bool SupportsAbsoluteDestination() const
-    {
-    return false;
-    }
+  virtual bool SupportsAbsoluteDestination() const { return false; }
 
-  virtual bool SupportsComponentInstallation() const
-    {
-    return true;
-    }
+  virtual bool SupportsComponentInstallation() const { return true; }
 
 private:
   typedef std::map<std::string, std::string> id_map_t;
@@ -77,11 +68,10 @@ private:
 
   void CreateWiXProductFragmentIncludeFile();
 
-  void CopyDefinition(
-    cmWIXSourceWriter &source, std::string const& name);
+  void CopyDefinition(cmWIXSourceWriter& source, std::string const& name);
 
-  void AddDefinition(cmWIXSourceWriter& source,
-    std::string const& name, std::string const& value);
+  void AddDefinition(cmWIXSourceWriter& source, std::string const& name,
+                     std::string const& value);
 
   bool CreateWiXSourceFiles();
 
@@ -89,32 +79,25 @@ private:
 
   bool GenerateMainSourceFileFromTemplate();
 
-  bool CreateFeatureHierarchy(
-    cmWIXFeaturesSourceWriter& featureDefinitions);
+  bool CreateFeatureHierarchy(cmWIXFeaturesSourceWriter& featureDefinitions);
 
   bool AddComponentsToFeature(
-    std::string const& rootPath,
-    std::string const& featureId,
+    std::string const& rootPath, std::string const& featureId,
     cmWIXDirectoriesSourceWriter& directoryDefinitions,
     cmWIXFilesSourceWriter& fileDefinitions,
-    cmWIXFeaturesSourceWriter& featureDefinitions,
-    cmWIXShortcuts& shortcuts);
+    cmWIXFeaturesSourceWriter& featureDefinitions, cmWIXShortcuts& shortcuts);
 
-  bool CreateShortcuts(
-    std::string const& cpackComponentName,
-    std::string const& featureId,
-    cmWIXShortcuts const& shortcuts,
-    bool emitUninstallShortcut,
-    cmWIXFilesSourceWriter& fileDefinitions,
-    cmWIXFeaturesSourceWriter& featureDefinitions);
+  bool CreateShortcuts(std::string const& cpackComponentName,
+                       std::string const& featureId,
+                       cmWIXShortcuts const& shortcuts,
+                       bool emitUninstallShortcut,
+                       cmWIXFilesSourceWriter& fileDefinitions,
+                       cmWIXFeaturesSourceWriter& featureDefinitions);
 
   bool CreateShortcutsOfSpecificType(
-    cmWIXShortcuts::Type type,
-    std::string const& cpackComponentName,
-    std::string const& featureId,
-    std::string const& idPrefix,
-    cmWIXShortcuts const& shortcuts,
-    bool emitUninstallShortcut,
+    cmWIXShortcuts::Type type, std::string const& cpackComponentName,
+    std::string const& featureId, std::string const& idPrefix,
+    cmWIXShortcuts const& shortcuts, bool emitUninstallShortcut,
     cmWIXFilesSourceWriter& fileDefinitions,
     cmWIXFeaturesSourceWriter& featureDefinitions);
 
@@ -126,13 +109,13 @@ private:
 
   bool RunWiXCommand(std::string const& command);
 
-  bool RunCandleCommand(
-    std::string const& sourceFile, std::string const& objectFile);
+  bool RunCandleCommand(std::string const& sourceFile,
+                        std::string const& objectFile);
 
   bool RunLightCommand(std::string const& objectFiles);
 
-  void AddDirectoryAndFileDefinitons(std::string const& topdir,
-    std::string const& directoryId,
+  void AddDirectoryAndFileDefinitons(
+    std::string const& topdir, std::string const& directoryId,
     cmWIXDirectoriesSourceWriter& directoryDefinitions,
     cmWIXFilesSourceWriter& fileDefinitions,
     cmWIXFeaturesSourceWriter& featureDefinitions,
@@ -154,22 +137,20 @@ private:
 
   std::string CreateNewIdForPath(std::string const& path);
 
-  static std::string CreateHashedId(
-    std::string const& path, std::string const& normalizedFilename);
+  static std::string CreateHashedId(std::string const& path,
+                                    std::string const& normalizedFilename);
 
-  std::string NormalizeComponentForId(
-    std::string const& component, size_t& replacementCount);
+  std::string NormalizeComponentForId(std::string const& component,
+                                      size_t& replacementCount);
 
   static bool IsLegalIdCharacter(char c);
 
-  void CollectExtensions(
-       std::string const& variableName, extension_set_t& extensions);
+  void CollectExtensions(std::string const& variableName,
+                         extension_set_t& extensions);
 
-  void AddCustomFlags(
-    std::string const& variableName, std::ostream& stream);
+  void AddCustomFlags(std::string const& variableName, std::ostream& stream);
 
-  std::string RelativePathWithoutComponentPrefix(
-    std::string const& path);
+  std::string RelativePathWithoutComponentPrefix(std::string const& path);
 
   std::vector<std::string> WixSources;
   id_map_t PathToIdMap;
diff --git a/Source/CPack/WiX/cmWIXAccessControlList.cxx b/Source/CPack/WiX/cmWIXAccessControlList.cxx
index 16a71e0..043cdff 100644
--- a/Source/CPack/WiX/cmWIXAccessControlList.cxx
+++ b/Source/CPack/WiX/cmWIXAccessControlList.cxx
@@ -17,14 +17,12 @@
 #include <cmSystemTools.h>
 
 cmWIXAccessControlList::cmWIXAccessControlList(
-      cmCPackLog *logger,
-      cmInstalledFile const& installedFile,
-      cmWIXSourceWriter &sourceWriter):
-        Logger(logger),
-        InstalledFile(installedFile),
-        SourceWriter(sourceWriter)
+  cmCPackLog* logger, cmInstalledFile const& installedFile,
+  cmWIXSourceWriter& sourceWriter)
+  : Logger(logger)
+  , InstalledFile(installedFile)
+  , SourceWriter(sourceWriter)
 {
-
 }
 
 bool cmWIXAccessControlList::Apply()
@@ -32,23 +30,20 @@ bool cmWIXAccessControlList::Apply()
   std::vector<std::string> entries;
   this->InstalledFile.GetPropertyAsList("CPACK_WIX_ACL", entries);
 
-  for(size_t i = 0; i < entries.size(); ++i)
-    {
+  for (size_t i = 0; i < entries.size(); ++i) {
     this->CreatePermissionElement(entries[i]);
-    }
+  }
 
   return true;
 }
 
-void cmWIXAccessControlList::CreatePermissionElement(
-  std::string const& entry)
+void cmWIXAccessControlList::CreatePermissionElement(std::string const& entry)
 {
   std::string::size_type pos = entry.find('=');
-  if(pos == std::string::npos)
-    {
+  if (pos == std::string::npos) {
     this->ReportError(entry, "Did not find mandatory '='");
     return;
-    }
+  }
 
   std::string user_and_domain = entry.substr(0, pos);
   std::string permission_string = entry.substr(pos + 1);
@@ -56,46 +51,38 @@ void cmWIXAccessControlList::CreatePermissionElement(
   pos = user_and_domain.find('@');
   std::string user;
   std::string domain;
-  if(pos != std::string::npos)
-    {
+  if (pos != std::string::npos) {
     user = user_and_domain.substr(0, pos);
     domain = user_and_domain.substr(pos + 1);
-    }
-  else
-    {
+  } else {
     user = user_and_domain;
-    }
+  }
 
   std::vector<std::string> permissions =
     cmSystemTools::tokenize(permission_string, ",");
 
   this->SourceWriter.BeginElement("Permission");
   this->SourceWriter.AddAttribute("User", user);
-  if(!domain.empty())
-    {
+  if (!domain.empty()) {
     this->SourceWriter.AddAttribute("Domain", domain);
-    }
-  for(size_t i = 0; i < permissions.size(); ++i)
-    {
+  }
+  for (size_t i = 0; i < permissions.size(); ++i) {
     this->EmitBooleanAttribute(entry,
-      cmSystemTools::TrimWhitespace(permissions[i]));
-    }
+                               cmSystemTools::TrimWhitespace(permissions[i]));
+  }
   this->SourceWriter.EndElement("Permission");
 }
 
-void cmWIXAccessControlList::ReportError(
-  std::string const& entry,
-  std::string const& message)
+void cmWIXAccessControlList::ReportError(std::string const& entry,
+                                         std::string const& message)
 {
-  cmCPackLogger(cmCPackLog::LOG_ERROR,
-    "Failed processing ACL entry '" << entry <<
-    "': " << message << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed processing ACL entry '"
+                  << entry << "': " << message << std::endl);
 }
 
 bool cmWIXAccessControlList::IsBooleanAttribute(std::string const& name)
 {
-  static const char* validAttributes[] =
-  {
+  static const char* validAttributes[] = {
     /* clang-format needs this comment to break after the opening brace */
     "Append",
     "ChangePermission",
@@ -128,23 +115,22 @@ bool cmWIXAccessControlList::IsBooleanAttribute(std::string const& name)
   };
 
   size_t i = 0;
-  while(validAttributes[i])
-    {
-    if(name == validAttributes[i++]) return true;
-    }
+  while (validAttributes[i]) {
+    if (name == validAttributes[i++])
+      return true;
+  }
 
   return false;
 }
 
-void cmWIXAccessControlList::EmitBooleanAttribute(
-  std::string const& entry, std::string const& name)
+void cmWIXAccessControlList::EmitBooleanAttribute(std::string const& entry,
+                                                  std::string const& name)
 {
-  if(!this->IsBooleanAttribute(name))
-    {
+  if (!this->IsBooleanAttribute(name)) {
     std::stringstream message;
     message << "Unknown boolean attribute '" << name << "'";
     this->ReportError(entry, message.str());
-    }
+  }
 
   this->SourceWriter.AddAttribute(name, "yes");
 }
diff --git a/Source/CPack/WiX/cmWIXAccessControlList.h b/Source/CPack/WiX/cmWIXAccessControlList.h
index 7293995..a1ac593 100644
--- a/Source/CPack/WiX/cmWIXAccessControlList.h
+++ b/Source/CPack/WiX/cmWIXAccessControlList.h
@@ -21,10 +21,9 @@
 class cmWIXAccessControlList
 {
 public:
-  cmWIXAccessControlList(
-        cmCPackLog *logger,
-        cmInstalledFile const& installedFile,
-        cmWIXSourceWriter &sourceWriter);
+  cmWIXAccessControlList(cmCPackLog* logger,
+                         cmInstalledFile const& installedFile,
+                         cmWIXSourceWriter& sourceWriter);
 
   bool Apply();
 
@@ -35,12 +34,11 @@ private:
 
   bool IsBooleanAttribute(std::string const& name);
 
-  void EmitBooleanAttribute(
-    std::string const& entry, std::string const& name);
+  void EmitBooleanAttribute(std::string const& entry, std::string const& name);
 
   cmCPackLog* Logger;
   cmInstalledFile const& InstalledFile;
-  cmWIXSourceWriter &SourceWriter;
+  cmWIXSourceWriter& SourceWriter;
 };
 
 #endif
diff --git a/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
index 7bd4315..60ecae6 100644
--- a/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
+++ b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.cxx
@@ -12,11 +12,10 @@
 
 #include "cmWIXDirectoriesSourceWriter.h"
 
-cmWIXDirectoriesSourceWriter::cmWIXDirectoriesSourceWriter(cmCPackLog* logger,
-  std::string const& filename):
-    cmWIXSourceWriter(logger, filename)
+cmWIXDirectoriesSourceWriter::cmWIXDirectoriesSourceWriter(
+  cmCPackLog* logger, std::string const& filename)
+  : cmWIXSourceWriter(logger, filename)
 {
-
 }
 
 void cmWIXDirectoriesSourceWriter::EmitStartMenuFolder(
@@ -60,25 +59,20 @@ size_t cmWIXDirectoriesSourceWriter::BeginInstallationPrefixDirectory(
 
   cmSystemTools::SplitPath(installRootString.c_str(), installRoot);
 
-  if(!installRoot.empty() && installRoot.back().empty())
-    {
+  if (!installRoot.empty() && installRoot.back().empty()) {
     installRoot.pop_back();
-    }
+  }
 
-  for(size_t i = 1; i < installRoot.size(); ++i)
-    {
+  for (size_t i = 1; i < installRoot.size(); ++i) {
     BeginElement("Directory");
 
-    if(i == installRoot.size() - 1)
-      {
+    if (i == installRoot.size() - 1) {
       AddAttribute("Id", "INSTALL_ROOT");
-      }
-    else
-      {
+    } else {
       std::stringstream tmp;
       tmp << "INSTALL_PREFIX_" << i;
       AddAttribute("Id", tmp.str());
-      }
+    }
 
     AddAttribute("Name", installRoot[i]);
   }
@@ -88,8 +82,7 @@ size_t cmWIXDirectoriesSourceWriter::BeginInstallationPrefixDirectory(
 
 void cmWIXDirectoriesSourceWriter::EndInstallationPrefixDirectory(size_t size)
 {
-  for(size_t i = 0; i < size; ++i)
-    {
+  for (size_t i = 0; i < size; ++i) {
     EndElement("Directory");
-    }
+  }
 }
diff --git a/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h
index f8c8166..023f4b8 100644
--- a/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h
+++ b/Source/CPack/WiX/cmWIXDirectoriesSourceWriter.h
@@ -26,7 +26,7 @@ class cmWIXDirectoriesSourceWriter : public cmWIXSourceWriter
 {
 public:
   cmWIXDirectoriesSourceWriter(cmCPackLog* logger,
-    std::string const& filename);
+                               std::string const& filename);
 
   void EmitStartMenuFolder(std::string const& startMenuFolder);
 
@@ -35,8 +35,8 @@ public:
   void EmitStartupFolder();
 
   size_t BeginInstallationPrefixDirectory(
-      std::string const& programFilesFolderId,
-      std::string const& installRootString);
+    std::string const& programFilesFolderId,
+    std::string const& installRootString);
 
   void EndInstallationPrefixDirectory(size_t size);
 };
diff --git a/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx
index 0bcfc38..16dd0ab 100644
--- a/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx
+++ b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.cxx
@@ -12,16 +12,14 @@
 
 #include "cmWIXFeaturesSourceWriter.h"
 
-cmWIXFeaturesSourceWriter::cmWIXFeaturesSourceWriter(cmCPackLog* logger,
-  std::string const& filename):
-    cmWIXSourceWriter(logger, filename)
+cmWIXFeaturesSourceWriter::cmWIXFeaturesSourceWriter(
+  cmCPackLog* logger, std::string const& filename)
+  : cmWIXSourceWriter(logger, filename)
 {
-
 }
 
 void cmWIXFeaturesSourceWriter::CreateCMakePackageRegistryEntry(
-    std::string const& package,
-    std::string const& upgradeGuid)
+  std::string const& package, std::string const& upgradeGuid)
 {
   BeginElement("Component");
   AddAttribute("Id", "CM_PACKAGE_REGISTRY");
@@ -29,7 +27,7 @@ void cmWIXFeaturesSourceWriter::CreateCMakePackageRegistryEntry(
   AddAttribute("Guid", "*");
 
   std::string registryKey =
-      std::string("Software\\Kitware\\CMake\\Packages\\") + package;
+    std::string("Software\\Kitware\\CMake\\Packages\\") + package;
 
   BeginElement("RegistryValue");
   AddAttribute("Root", "HKLM");
@@ -49,25 +47,24 @@ void cmWIXFeaturesSourceWriter::EmitFeatureForComponentGroup(
   BeginElement("Feature");
   AddAttribute("Id", "CM_G_" + group.Name);
 
-  if(group.IsExpandedByDefault)
-    {
+  if (group.IsExpandedByDefault) {
     AddAttribute("Display", "expand");
-    }
+  }
 
   AddAttributeUnlessEmpty("Title", group.DisplayName);
   AddAttributeUnlessEmpty("Description", group.Description);
 
-  for(std::vector<cmCPackComponentGroup*>::const_iterator
-    i = group.Subgroups.begin(); i != group.Subgroups.end(); ++i)
-    {
+  for (std::vector<cmCPackComponentGroup*>::const_iterator i =
+         group.Subgroups.begin();
+       i != group.Subgroups.end(); ++i) {
     EmitFeatureForComponentGroup(**i);
-    }
+  }
 
-  for(std::vector<cmCPackComponent*>::const_iterator
-    i = group.Components.begin(); i != group.Components.end(); ++i)
-    {
+  for (std::vector<cmCPackComponent*>::const_iterator i =
+         group.Components.begin();
+       i != group.Components.end(); ++i) {
     EmitFeatureForComponent(**i);
-    }
+  }
 
   EndElement("Feature");
 }
@@ -81,15 +78,13 @@ void cmWIXFeaturesSourceWriter::EmitFeatureForComponent(
   AddAttributeUnlessEmpty("Title", component.DisplayName);
   AddAttributeUnlessEmpty("Description", component.Description);
 
-  if(component.IsRequired)
-    {
+  if (component.IsRequired) {
     AddAttribute("Absent", "disallow");
-    }
+  }
 
-  if(component.IsHidden)
-    {
+  if (component.IsHidden) {
     AddAttribute("Display", "hidden");
-    }
+  }
 
   EndElement("Feature");
 }
diff --git a/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h
index ff12e6c..ee9c17a 100644
--- a/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h
+++ b/Source/CPack/WiX/cmWIXFeaturesSourceWriter.h
@@ -23,12 +23,10 @@
 class cmWIXFeaturesSourceWriter : public cmWIXSourceWriter
 {
 public:
-  cmWIXFeaturesSourceWriter(cmCPackLog* logger,
-    std::string const& filename);
+  cmWIXFeaturesSourceWriter(cmCPackLog* logger, std::string const& filename);
 
-  void CreateCMakePackageRegistryEntry(
-    std::string const& package,
-    std::string const& upgradeGuid);
+  void CreateCMakePackageRegistryEntry(std::string const& package,
+                                       std::string const& upgradeGuid);
 
   void EmitFeatureForComponentGroup(const cmCPackComponentGroup& group);
 
diff --git a/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx b/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx
index 2833d53..1341fa5 100644
--- a/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx
+++ b/Source/CPack/WiX/cmWIXFilesSourceWriter.cxx
@@ -21,25 +21,22 @@
 #include <sys/stat.h>
 
 cmWIXFilesSourceWriter::cmWIXFilesSourceWriter(cmCPackLog* logger,
-  std::string const& filename):
-    cmWIXSourceWriter(logger, filename)
+                                               std::string const& filename)
+  : cmWIXSourceWriter(logger, filename)
 {
-
 }
 
-void cmWIXFilesSourceWriter::EmitShortcut(
-  std::string const& id,
-  cmWIXShortcut const& shortcut,
-  std::string const& shortcutPrefix,
-  size_t shortcutIndex)
+void cmWIXFilesSourceWriter::EmitShortcut(std::string const& id,
+                                          cmWIXShortcut const& shortcut,
+                                          std::string const& shortcutPrefix,
+                                          size_t shortcutIndex)
 {
   std::stringstream shortcutId;
   shortcutId << shortcutPrefix << id;
 
-  if(shortcutIndex > 0)
-    {
-    shortcutId << "_"  << shortcutIndex;
-    }
+  if (shortcutIndex > 0) {
+    shortcutId << "_" << shortcutIndex;
+  }
 
   std::string fileId = std::string("CM_F") + id;
 
@@ -61,15 +58,13 @@ void cmWIXFilesSourceWriter::EmitRemoveFolder(std::string const& id)
 }
 
 void cmWIXFilesSourceWriter::EmitInstallRegistryValue(
-  std::string const& registryKey,
-  std::string const& cpackComponentName,
+  std::string const& registryKey, std::string const& cpackComponentName,
   std::string const& suffix)
 {
   std::string valueName;
-  if(!cpackComponentName.empty())
-    {
-      valueName = cpackComponentName + "_";
-    }
+  if (!cpackComponentName.empty()) {
+    valueName = cpackComponentName + "_";
+  }
 
   valueName += "installed";
   valueName += suffix;
@@ -97,12 +92,10 @@ void cmWIXFilesSourceWriter::EmitUninstallShortcut(
 }
 
 std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
-  std::string const& directoryId,
-  std::string const& guid,
+  std::string const& directoryId, std::string const& guid,
   cmInstalledFile const* installedFile)
 {
-  std::string componentId =
-    std::string("CM_C_EMPTY_") + directoryId;
+  std::string componentId = std::string("CM_C_EMPTY_") + directoryId;
 
   BeginElement("DirectoryRef");
   AddAttribute("Id", directoryId);
@@ -113,11 +106,10 @@ std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
 
   BeginElement("CreateFolder");
 
-  if(installedFile)
-    {
+  if (installedFile) {
     cmWIXAccessControlList acl(Logger, *installedFile, *this);
     acl.Apply();
-    }
+  }
 
   EndElement("CreateFolder");
   EndElement("Component");
@@ -127,10 +119,8 @@ std::string cmWIXFilesSourceWriter::EmitComponentCreateFolder(
 }
 
 std::string cmWIXFilesSourceWriter::EmitComponentFile(
-  std::string const& directoryId,
-  std::string const& id,
-  std::string const& filePath,
-  cmWIXPatch &patch,
+  std::string const& directoryId, std::string const& id,
+  std::string const& filePath, cmWIXPatch& patch,
   cmInstalledFile const* installedFile)
 {
   std::string componentId = std::string("CM_C") + id;
@@ -143,17 +133,14 @@ std::string cmWIXFilesSourceWriter::EmitComponentFile(
   AddAttribute("Id", componentId);
   AddAttribute("Guid", "*");
 
-  if(installedFile)
-    {
-    if(installedFile->GetPropertyAsBool("CPACK_NEVER_OVERWRITE"))
-      {
+  if (installedFile) {
+    if (installedFile->GetPropertyAsBool("CPACK_NEVER_OVERWRITE")) {
       AddAttribute("NeverOverwrite", "yes");
-      }
-    if(installedFile->GetPropertyAsBool("CPACK_PERMANENT"))
-      {
+    }
+    if (installedFile->GetPropertyAsBool("CPACK_PERMANENT")) {
       AddAttribute("Permanent", "yes");
-      }
     }
+  }
 
   BeginElement("File");
   AddAttribute("Id", fileId);
@@ -163,16 +150,14 @@ std::string cmWIXFilesSourceWriter::EmitComponentFile(
   mode_t fileMode = 0;
   cmSystemTools::GetPermissions(filePath.c_str(), fileMode);
 
-  if(!(fileMode & S_IWRITE))
-    {
+  if (!(fileMode & S_IWRITE)) {
     AddAttribute("ReadOnly", "yes");
-    }
+  }
 
-  if(installedFile)
-    {
+  if (installedFile) {
     cmWIXAccessControlList acl(Logger, *installedFile, *this);
     acl.Apply();
-    }
+  }
 
   patch.ApplyFragment(fileId, *this);
   EndElement("File");
diff --git a/Source/CPack/WiX/cmWIXFilesSourceWriter.h b/Source/CPack/WiX/cmWIXFilesSourceWriter.h
index 734f901..c577e5b 100644
--- a/Source/CPack/WiX/cmWIXFilesSourceWriter.h
+++ b/Source/CPack/WiX/cmWIXFilesSourceWriter.h
@@ -26,36 +26,27 @@
 class cmWIXFilesSourceWriter : public cmWIXSourceWriter
 {
 public:
-  cmWIXFilesSourceWriter(cmCPackLog* logger,
-    std::string const& filename);
+  cmWIXFilesSourceWriter(cmCPackLog* logger, std::string const& filename);
 
-  void EmitShortcut(
-      std::string const& id,
-      cmWIXShortcut const& shortcut,
-      std::string const& shortcutPrefix,
-      size_t shortcutIndex);
+  void EmitShortcut(std::string const& id, cmWIXShortcut const& shortcut,
+                    std::string const& shortcutPrefix, size_t shortcutIndex);
 
   void EmitRemoveFolder(std::string const& id);
 
-  void EmitInstallRegistryValue(
-    std::string const& registryKey,
-    std::string const& cpackComponentName,
-    std::string const& suffix);
+  void EmitInstallRegistryValue(std::string const& registryKey,
+                                std::string const& cpackComponentName,
+                                std::string const& suffix);
 
   void EmitUninstallShortcut(std::string const& packageName);
 
-  std::string EmitComponentCreateFolder(
-    std::string const& directoryId,
-    std::string const& guid,
-    cmInstalledFile const* installedFile);
-
-  std::string EmitComponentFile(
-    std::string const& directoryId,
-    std::string const& id,
-    std::string const& filePath,
-    cmWIXPatch &patch,
-    cmInstalledFile const* installedFile);
-};
+  std::string EmitComponentCreateFolder(std::string const& directoryId,
+                                        std::string const& guid,
+                                        cmInstalledFile const* installedFile);
 
+  std::string EmitComponentFile(std::string const& directoryId,
+                                std::string const& id,
+                                std::string const& filePath, cmWIXPatch& patch,
+                                cmInstalledFile const* installedFile);
+};
 
 #endif
diff --git a/Source/CPack/WiX/cmWIXPatch.cxx b/Source/CPack/WiX/cmWIXPatch.cxx
index 07375da..c9d010e 100644
--- a/Source/CPack/WiX/cmWIXPatch.cxx
+++ b/Source/CPack/WiX/cmWIXPatch.cxx
@@ -14,31 +14,29 @@
 
 #include <CPack/cmCPackGenerator.h>
 
-cmWIXPatch::cmWIXPatch(cmCPackLog* logger):
-  Logger(logger)
+cmWIXPatch::cmWIXPatch(cmCPackLog* logger)
+  : Logger(logger)
 {
-
 }
 
 bool cmWIXPatch::LoadFragments(std::string const& patchFilePath)
 {
   cmWIXPatchParser parser(Fragments, Logger);
-  if(!parser.ParseFile(patchFilePath.c_str()))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Failed parsing XML patch file: '" <<
-      patchFilePath << "'" << std::endl);
+  if (!parser.ParseFile(patchFilePath.c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Failed parsing XML patch file: '"
+                    << patchFilePath << "'" << std::endl);
     return false;
-    }
+  }
 
   return true;
 }
 
-void cmWIXPatch::ApplyFragment(
-  std::string const& id, cmWIXSourceWriter& writer)
+void cmWIXPatch::ApplyFragment(std::string const& id,
+                               cmWIXSourceWriter& writer)
 {
   cmWIXPatchParser::fragment_map_t::iterator i = Fragments.find(id);
-  if(i == Fragments.end()) return;
+  if (i == Fragments.end())
+    return;
 
   const cmWIXPatchElement& fragment = i->second;
 
@@ -47,36 +45,35 @@ void cmWIXPatch::ApplyFragment(
   Fragments.erase(i);
 }
 
-void cmWIXPatch::ApplyElementChildren(
-  const cmWIXPatchElement& element, cmWIXSourceWriter& writer)
+void cmWIXPatch::ApplyElementChildren(const cmWIXPatchElement& element,
+                                      cmWIXSourceWriter& writer)
 {
-  for(cmWIXPatchElement::child_list_t::const_iterator
-    j = element.children.begin(); j != element.children.end(); ++j)
-  {
-  cmWIXPatchNode *node = *j;
-
-  switch(node->type())
-    {
-    case cmWIXPatchNode::ELEMENT:
-      ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer);
-      break;
-    case cmWIXPatchNode::TEXT:
-      writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text);
-      break;
+  for (cmWIXPatchElement::child_list_t::const_iterator j =
+         element.children.begin();
+       j != element.children.end(); ++j) {
+    cmWIXPatchNode* node = *j;
+
+    switch (node->type()) {
+      case cmWIXPatchNode::ELEMENT:
+        ApplyElement(dynamic_cast<const cmWIXPatchElement&>(*node), writer);
+        break;
+      case cmWIXPatchNode::TEXT:
+        writer.AddTextNode(dynamic_cast<const cmWIXPatchText&>(*node).text);
+        break;
     }
   }
 }
 
-void cmWIXPatch::ApplyElement(
-  const cmWIXPatchElement& element, cmWIXSourceWriter& writer)
+void cmWIXPatch::ApplyElement(const cmWIXPatchElement& element,
+                              cmWIXSourceWriter& writer)
 {
   writer.BeginElement(element.name);
 
-  for(cmWIXPatchElement::attributes_t::const_iterator
-    i = element.attributes.begin(); i != element.attributes.end(); ++i)
-    {
+  for (cmWIXPatchElement::attributes_t::const_iterator i =
+         element.attributes.begin();
+       i != element.attributes.end(); ++i) {
     writer.AddAttribute(i->first, i->second);
-    }
+  }
 
   this->ApplyElementChildren(element, writer);
 
@@ -86,26 +83,23 @@ void cmWIXPatch::ApplyElement(
 bool cmWIXPatch::CheckForUnappliedFragments()
 {
   std::string fragmentList;
-  for(cmWIXPatchParser::fragment_map_t::const_iterator
-    i = Fragments.begin(); i != Fragments.end(); ++i)
-    {
-    if(!fragmentList.empty())
-      {
+  for (cmWIXPatchParser::fragment_map_t::const_iterator i = Fragments.begin();
+       i != Fragments.end(); ++i) {
+    if (!fragmentList.empty()) {
       fragmentList += ", ";
-      }
+    }
 
     fragmentList += "'";
     fragmentList += i->first;
     fragmentList += "'";
-    }
+  }
 
-  if(!fragmentList.empty())
-    {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Some XML patch fragments did not have matching IDs: " <<
-        fragmentList << std::endl);
-      return false;
-    }
+  if (!fragmentList.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Some XML patch fragments did not have matching IDs: "
+                    << fragmentList << std::endl);
+    return false;
+  }
 
   return true;
 }
diff --git a/Source/CPack/WiX/cmWIXPatch.h b/Source/CPack/WiX/cmWIXPatch.h
index 5b0eb3b..57b74cd 100644
--- a/Source/CPack/WiX/cmWIXPatch.h
+++ b/Source/CPack/WiX/cmWIXPatch.h
@@ -34,15 +34,14 @@ public:
 
 private:
   void ApplyElementChildren(const cmWIXPatchElement& element,
-    cmWIXSourceWriter& writer);
+                            cmWIXSourceWriter& writer);
 
   void ApplyElement(const cmWIXPatchElement& element,
-    cmWIXSourceWriter& writer);
+                    cmWIXSourceWriter& writer);
 
   cmCPackLog* Logger;
 
   cmWIXPatchParser::fragment_map_t Fragments;
 };
 
-
 #endif
diff --git a/Source/CPack/WiX/cmWIXPatchParser.cxx b/Source/CPack/WiX/cmWIXPatchParser.cxx
index 14c5413..b750dcf 100644
--- a/Source/CPack/WiX/cmWIXPatchParser.cxx
+++ b/Source/CPack/WiX/cmWIXPatchParser.cxx
@@ -28,149 +28,124 @@ cmWIXPatchNode::Type cmWIXPatchElement::type()
 
 cmWIXPatchNode::~cmWIXPatchNode()
 {
-
 }
 
 cmWIXPatchElement::~cmWIXPatchElement()
 {
-  for(child_list_t::iterator i = children.begin(); i != children.end(); ++i)
-    {
+  for (child_list_t::iterator i = children.begin(); i != children.end(); ++i) {
     delete *i;
-    }
+  }
 }
 
-cmWIXPatchParser::cmWIXPatchParser(
-  fragment_map_t& fragments, cmCPackLog* logger):
-    Logger(logger),
-    State(BEGIN_DOCUMENT),
-    Valid(true),
-    Fragments(fragments)
+cmWIXPatchParser::cmWIXPatchParser(fragment_map_t& fragments,
+                                   cmCPackLog* logger)
+  : Logger(logger)
+  , State(BEGIN_DOCUMENT)
+  , Valid(true)
+  , Fragments(fragments)
 {
-
 }
 
-void cmWIXPatchParser::StartElement(const std::string& name, const char **atts)
+void cmWIXPatchParser::StartElement(const std::string& name, const char** atts)
 {
-  if(State == BEGIN_DOCUMENT)
-    {
-    if(name == "CPackWiXPatch")
-      {
+  if (State == BEGIN_DOCUMENT) {
+    if (name == "CPackWiXPatch") {
       State = BEGIN_FRAGMENTS;
-      }
-    else
-      {
+    } else {
       ReportValidationError("Expected root element 'CPackWiXPatch'");
-      }
     }
-  else if(State == BEGIN_FRAGMENTS)
-    {
-      if(name == "CPackWiXFragment")
-        {
-        State = INSIDE_FRAGMENT;
-        StartFragment(atts);
-        }
-      else
-        {
-        ReportValidationError("Expected 'CPackWixFragment' element");
-        }
+  } else if (State == BEGIN_FRAGMENTS) {
+    if (name == "CPackWiXFragment") {
+      State = INSIDE_FRAGMENT;
+      StartFragment(atts);
+    } else {
+      ReportValidationError("Expected 'CPackWixFragment' element");
     }
-  else if(State == INSIDE_FRAGMENT)
-    {
-      cmWIXPatchElement &parent = *ElementStack.back();
-
-      cmWIXPatchElement *element = new cmWIXPatchElement;
-      parent.children.push_back(element);
+  } else if (State == INSIDE_FRAGMENT) {
+    cmWIXPatchElement& parent = *ElementStack.back();
 
-      element->name = name;
+    cmWIXPatchElement* element = new cmWIXPatchElement;
+    parent.children.push_back(element);
 
-      for(size_t i = 0; atts[i]; i += 2)
-        {
-        std::string key = atts[i];
-        std::string value = atts[i+1];
+    element->name = name;
 
-        element->attributes[key] = value;
-        }
+    for (size_t i = 0; atts[i]; i += 2) {
+      std::string key = atts[i];
+      std::string value = atts[i + 1];
 
-      ElementStack.push_back(element);
+      element->attributes[key] = value;
     }
+
+    ElementStack.push_back(element);
+  }
 }
 
-void cmWIXPatchParser::StartFragment(const char **attributes)
+void cmWIXPatchParser::StartFragment(const char** attributes)
 {
-  for(size_t i = 0; attributes[i]; i += 2)
-    {
+  for (size_t i = 0; attributes[i]; i += 2) {
     std::string key = attributes[i];
-    std::string value = attributes[i+1];
+    std::string value = attributes[i + 1];
 
-    if(key == "Id")
-      {
-      if(Fragments.find(value) != Fragments.end())
-        {
+    if (key == "Id") {
+      if (Fragments.find(value) != Fragments.end()) {
         std::stringstream tmp;
         tmp << "Invalid reuse of 'CPackWixFragment' 'Id': " << value;
         ReportValidationError(tmp.str());
-        }
+      }
 
       ElementStack.push_back(&Fragments[value]);
-      }
-    else
-      {
+    } else {
       ReportValidationError(
         "The only allowed 'CPackWixFragment' attribute is 'Id'");
-      }
     }
+  }
 }
 
 void cmWIXPatchParser::EndElement(const std::string& name)
 {
-  if(State == INSIDE_FRAGMENT)
-    {
-      if(name == "CPackWiXFragment")
-        {
-        State = BEGIN_FRAGMENTS;
-        ElementStack.clear();
-        }
-      else
-        {
-        ElementStack.pop_back();
-        }
+  if (State == INSIDE_FRAGMENT) {
+    if (name == "CPackWiXFragment") {
+      State = BEGIN_FRAGMENTS;
+      ElementStack.clear();
+    } else {
+      ElementStack.pop_back();
     }
+  }
 }
 
 void cmWIXPatchParser::CharacterDataHandler(const char* data, int length)
 {
   const char* whitespace = "\x20\x09\x0d\x0a";
 
-  if(State == INSIDE_FRAGMENT)
-    {
-    cmWIXPatchElement &parent = *ElementStack.back();
+  if (State == INSIDE_FRAGMENT) {
+    cmWIXPatchElement& parent = *ElementStack.back();
 
     std::string text(data, length);
 
     std::string::size_type first = text.find_first_not_of(whitespace);
     std::string::size_type last = text.find_last_not_of(whitespace);
 
-    if(first != std::string::npos && last != std::string::npos)
-      {
-      cmWIXPatchText *text_node = new cmWIXPatchText;
+    if (first != std::string::npos && last != std::string::npos) {
+      cmWIXPatchText* text_node = new cmWIXPatchText;
       text_node->text = text.substr(first, last - first + 1);
 
       parent.children.push_back(text_node);
-      }
     }
+  }
 }
 
 void cmWIXPatchParser::ReportError(int line, int column, const char* msg)
 {
   cmCPackLogger(cmCPackLog::LOG_ERROR,
-    "Error while processing XML patch file at " << line << ":" << column <<
-      ":  "<< msg << std::endl);
+                "Error while processing XML patch file at "
+                  << line << ":" << column << ":  " << msg << std::endl);
   Valid = false;
 }
 
 void cmWIXPatchParser::ReportValidationError(std::string const& message)
 {
-  ReportError(XML_GetCurrentLineNumber(static_cast<XML_Parser>(this->Parser)),
+  ReportError(
+    XML_GetCurrentLineNumber(static_cast<XML_Parser>(this->Parser)),
     XML_GetCurrentColumnNumber(static_cast<XML_Parser>(this->Parser)),
     message.c_str());
 }
diff --git a/Source/CPack/WiX/cmWIXPatchParser.h b/Source/CPack/WiX/cmWIXPatchParser.h
index 8ce4026..f9b85bd 100644
--- a/Source/CPack/WiX/cmWIXPatchParser.h
+++ b/Source/CPack/WiX/cmWIXPatchParser.h
@@ -65,9 +65,9 @@ public:
   cmWIXPatchParser(fragment_map_t& Fragments, cmCPackLog* logger);
 
 private:
-  virtual void StartElement(const std::string& name, const char **atts);
+  virtual void StartElement(const std::string& name, const char** atts);
 
-  void StartFragment(const char **attributes);
+  void StartFragment(const char** attributes);
 
   virtual void EndElement(const std::string& name);
 
diff --git a/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx b/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx
index f27caa9..f3dbcb9 100644
--- a/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx
+++ b/Source/CPack/WiX/cmWIXRichTextFormatWriter.cxx
@@ -15,8 +15,8 @@
 #include <cmVersion.h>
 
 cmWIXRichTextFormatWriter::cmWIXRichTextFormatWriter(
-  std::string const& filename):
-    File(filename.c_str(), std::ios::binary)
+  std::string const& filename)
+  : File(filename.c_str(), std::ios::binary)
 {
   StartGroup();
   WriteHeader();
@@ -37,74 +37,50 @@ void cmWIXRichTextFormatWriter::AddText(std::string const& text)
 {
   typedef unsigned char rtf_byte_t;
 
-  for(size_t i = 0; i < text.size(); ++i)
-    {
+  for (size_t i = 0; i < text.size(); ++i) {
     rtf_byte_t c = rtf_byte_t(text[i]);
 
-    switch(c)
-      {
-    case '\\':
-      File << "\\\\";
-      break;
-    case '{':
-      File << "\\{";
-      break;
-    case '}':
-      File << "\\}";
-      break;
-    case '\n':
-      File << "\\par\r\n";
-      break;
-    case '\r':
-      continue;
-    default:
-        {
-        if(c <= 0x7F)
-          {
+    switch (c) {
+      case '\\':
+        File << "\\\\";
+        break;
+      case '{':
+        File << "\\{";
+        break;
+      case '}':
+        File << "\\}";
+        break;
+      case '\n':
+        File << "\\par\r\n";
+        break;
+      case '\r':
+        continue;
+      default: {
+        if (c <= 0x7F) {
           File << c;
-          }
-        else
-          {
-            if(c <= 0xC0)
-              {
-              EmitInvalidCodepoint(c);
-              }
-            else if(c < 0xE0 && i+1 < text.size())
-              {
-              EmitUnicodeCodepoint(
-                (text[i+1] & 0x3F) |
-                ((c & 0x1F) << 6)
-              );
-              i+= 1;
-              }
-            else if(c < 0xF0 && i+2 < text.size())
-              {
-              EmitUnicodeCodepoint(
-                (text[i+2] & 0x3F) |
-                ((text[i+1] & 0x3F) << 6) |
-                ((c & 0xF) << 12)
-              );
-              i += 2;
-              }
-            else if(c < 0xF8 && i+3 < text.size())
-              {
-              EmitUnicodeCodepoint(
-                (text[i+3] & 0x3F) |
-                ((text[i+2] & 0x3F) << 6) |
-                ((text[i+1] & 0x3F) << 12) |
-                ((c & 0x7) << 18)
-              );
-              i += 3;
-              }
-            else
-              {
-              EmitInvalidCodepoint(c);
-              }
+        } else {
+          if (c <= 0xC0) {
+            EmitInvalidCodepoint(c);
+          } else if (c < 0xE0 && i + 1 < text.size()) {
+            EmitUnicodeCodepoint((text[i + 1] & 0x3F) | ((c & 0x1F) << 6));
+            i += 1;
+          } else if (c < 0xF0 && i + 2 < text.size()) {
+            EmitUnicodeCodepoint((text[i + 2] & 0x3F) |
+                                 ((text[i + 1] & 0x3F) << 6) |
+                                 ((c & 0xF) << 12));
+            i += 2;
+          } else if (c < 0xF8 && i + 3 < text.size()) {
+            EmitUnicodeCodepoint(
+              (text[i + 3] & 0x3F) | ((text[i + 2] & 0x3F) << 6) |
+              ((text[i + 1] & 0x3F) << 12) | ((c & 0x7) << 18));
+            i += 3;
+          } else {
+            EmitInvalidCodepoint(c);
           }
         }
-      break;
-      }
+      } break;
     }
+  }
 }
 
 void cmWIXRichTextFormatWriter::WriteHeader()
@@ -190,33 +166,25 @@ void cmWIXRichTextFormatWriter::EndGroup()
 void cmWIXRichTextFormatWriter::EmitUnicodeCodepoint(int c)
 {
   // Do not emit byte order mark (BOM)
-  if(c == 0xFEFF)
-    {
+  if (c == 0xFEFF) {
     return;
-    }
-  else if(c <= 0xFFFF)
-    {
+  } else if (c <= 0xFFFF) {
     EmitUnicodeSurrogate(c);
-    }
-  else
-    {
+  } else {
     c -= 0x10000;
     EmitUnicodeSurrogate(((c >> 10) & 0x3FF) + 0xD800);
     EmitUnicodeSurrogate((c & 0x3FF) + 0xDC00);
-    }
+  }
 }
 
 void cmWIXRichTextFormatWriter::EmitUnicodeSurrogate(int c)
 {
   ControlWord("u");
-  if(c <= 32767)
-    {
+  if (c <= 32767) {
     File << c;
-    }
-  else
-    {
+  } else {
     File << (c - 65536);
-    }
+  }
   File << "?";
 }
 
diff --git a/Source/CPack/WiX/cmWIXShortcut.cxx b/Source/CPack/WiX/cmWIXShortcut.cxx
index d721872..2685a23 100644
--- a/Source/CPack/WiX/cmWIXShortcut.cxx
+++ b/Source/CPack/WiX/cmWIXShortcut.cxx
@@ -14,8 +14,8 @@
 
 #include "cmWIXFilesSourceWriter.h"
 
-void cmWIXShortcuts::insert(
-  Type type, std::string const& id, cmWIXShortcut const& shortcut)
+void cmWIXShortcuts::insert(Type type, std::string const& id,
+                            cmWIXShortcut const& shortcut)
 {
   this->Shortcuts[type][id].push_back(shortcut);
 }
@@ -26,25 +26,22 @@ bool cmWIXShortcuts::empty(Type type) const
 }
 
 bool cmWIXShortcuts::EmitShortcuts(
-  Type type,
-  std::string const& registryKey,
+  Type type, std::string const& registryKey,
   std::string const& cpackComponentName,
   cmWIXFilesSourceWriter& fileDefinitions) const
 {
   shortcut_type_map_t::const_iterator i = this->Shortcuts.find(type);
 
-  if(i == this->Shortcuts.end())
-    {
+  if (i == this->Shortcuts.end()) {
     return false;
-    }
+  }
 
   shortcut_id_map_t const& id_map = i->second;
 
   std::string shortcutPrefix;
   std::string registrySuffix;
 
-  switch(type)
-    {
+  switch (type) {
     case START_MENU:
       shortcutPrefix = "CM_S";
       break;
@@ -58,68 +55,61 @@ bool cmWIXShortcuts::EmitShortcuts(
       break;
     default:
       return false;
-    }
+  }
 
-  for(shortcut_id_map_t::const_iterator j = id_map.begin();
-    j != id_map.end(); ++j)
-    {
+  for (shortcut_id_map_t::const_iterator j = id_map.begin(); j != id_map.end();
+       ++j) {
     std::string const& id = j->first;
     shortcut_list_t const& shortcutList = j->second;
 
-    for(size_t shortcutListIndex = 0;
-      shortcutListIndex < shortcutList.size(); ++shortcutListIndex)
-      {
+    for (size_t shortcutListIndex = 0; shortcutListIndex < shortcutList.size();
+         ++shortcutListIndex) {
       cmWIXShortcut const& shortcut = shortcutList[shortcutListIndex];
-      fileDefinitions.EmitShortcut(id, shortcut,
-        shortcutPrefix, shortcutListIndex);
-      }
+      fileDefinitions.EmitShortcut(id, shortcut, shortcutPrefix,
+                                   shortcutListIndex);
     }
+  }
 
-  fileDefinitions.EmitInstallRegistryValue(
-    registryKey, cpackComponentName, registrySuffix);
+  fileDefinitions.EmitInstallRegistryValue(registryKey, cpackComponentName,
+                                           registrySuffix);
 
   return true;
 }
 
 void cmWIXShortcuts::AddShortcutTypes(std::set<Type>& types)
 {
-  for(shortcut_type_map_t::const_iterator i = this->Shortcuts.begin();
-    i != this->Shortcuts.end(); ++i)
-    {
+  for (shortcut_type_map_t::const_iterator i = this->Shortcuts.begin();
+       i != this->Shortcuts.end(); ++i) {
     types.insert(i->first);
-    }
+  }
 }
 
-void cmWIXShortcuts::CreateFromProperties(
-  std::string const& id,
-  std::string const& directoryId,
-  cmInstalledFile const& installedFile)
+void cmWIXShortcuts::CreateFromProperties(std::string const& id,
+                                          std::string const& directoryId,
+                                          cmInstalledFile const& installedFile)
 {
-  CreateFromProperty("CPACK_START_MENU_SHORTCUTS",
-    START_MENU, id, directoryId, installedFile);
+  CreateFromProperty("CPACK_START_MENU_SHORTCUTS", START_MENU, id, directoryId,
+                     installedFile);
 
-  CreateFromProperty("CPACK_DESKTOP_SHORTCUTS",
-    DESKTOP, id, directoryId, installedFile);
+  CreateFromProperty("CPACK_DESKTOP_SHORTCUTS", DESKTOP, id, directoryId,
+                     installedFile);
 
-  CreateFromProperty("CPACK_STARTUP_SHORTCUTS",
-    STARTUP, id, directoryId, installedFile);
+  CreateFromProperty("CPACK_STARTUP_SHORTCUTS", STARTUP, id, directoryId,
+                     installedFile);
 }
 
-void cmWIXShortcuts::CreateFromProperty(
-  std::string const& propertyName,
-  Type type,
-  std::string const& id,
-  std::string const& directoryId,
-  cmInstalledFile const& installedFile)
+void cmWIXShortcuts::CreateFromProperty(std::string const& propertyName,
+                                        Type type, std::string const& id,
+                                        std::string const& directoryId,
+                                        cmInstalledFile const& installedFile)
 {
   std::vector<std::string> list;
   installedFile.GetPropertyAsList(propertyName, list);
 
-  for(size_t i = 0; i < list.size(); ++i)
-    {
+  for (size_t i = 0; i < list.size(); ++i) {
     cmWIXShortcut shortcut;
     shortcut.label = list[i];
     shortcut.workingDirectoryId = directoryId;
     insert(type, id, shortcut);
-    }
+  }
 }
diff --git a/Source/CPack/WiX/cmWIXShortcut.h b/Source/CPack/WiX/cmWIXShortcut.h
index 598aa0d..593ba34 100644
--- a/Source/CPack/WiX/cmWIXShortcut.h
+++ b/Source/CPack/WiX/cmWIXShortcut.h
@@ -45,26 +45,23 @@ public:
 
   bool empty(Type type) const;
 
-  bool EmitShortcuts(
-    Type type,
-    std::string const& registryKey,
-    std::string const& cpackComponentName,
-    cmWIXFilesSourceWriter& fileDefinitions) const;
+  bool EmitShortcuts(Type type, std::string const& registryKey,
+                     std::string const& cpackComponentName,
+                     cmWIXFilesSourceWriter& fileDefinitions) const;
 
   void AddShortcutTypes(std::set<Type>& types);
 
   void CreateFromProperties(std::string const& id,
-    std::string const& directoryId, cmInstalledFile const& installedFile);
+                            std::string const& directoryId,
+                            cmInstalledFile const& installedFile);
 
 private:
   typedef std::map<Type, shortcut_id_map_t> shortcut_type_map_t;
 
-  void CreateFromProperty(
-    std::string const& propertyName,
-    Type type,
-    std::string const& id,
-    std::string const& directoryId,
-    cmInstalledFile const& installedFile);
+  void CreateFromProperty(std::string const& propertyName, Type type,
+                          std::string const& id,
+                          std::string const& directoryId,
+                          cmInstalledFile const& installedFile);
 
   shortcut_type_map_t Shortcuts;
   shortcut_id_map_t EmptyIdMap;
diff --git a/Source/CPack/WiX/cmWIXSourceWriter.cxx b/Source/CPack/WiX/cmWIXSourceWriter.cxx
index 2e5194c..2c0384e 100644
--- a/Source/CPack/WiX/cmWIXSourceWriter.cxx
+++ b/Source/CPack/WiX/cmWIXSourceWriter.cxx
@@ -17,46 +17,41 @@
 #include <windows.h>
 
 cmWIXSourceWriter::cmWIXSourceWriter(cmCPackLog* logger,
-  std::string const& filename,
-  bool isIncludeFile):
-    Logger(logger),
-    File(filename.c_str()),
-    State(DEFAULT),
-    SourceFilename(filename)
+                                     std::string const& filename,
+                                     bool isIncludeFile)
+  : Logger(logger)
+  , File(filename.c_str())
+  , State(DEFAULT)
+  , SourceFilename(filename)
 {
   WriteXMLDeclaration();
 
-  if(isIncludeFile)
-    {
+  if (isIncludeFile) {
     BeginElement("Include");
-    }
-  else
-    {
+  } else {
     BeginElement("Wix");
-    }
+  }
 
   AddAttribute("xmlns", "http://schemas.microsoft.com/wix/2006/wi");
 }
 
 cmWIXSourceWriter::~cmWIXSourceWriter()
 {
-  if(Elements.size() > 1)
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      Elements.size() - 1 << " WiX elements were still open when closing '" <<
-      SourceFilename << "'" << std::endl);
+  if (Elements.size() > 1) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, Elements.size() - 1
+                    << " WiX elements were still open when closing '"
+                    << SourceFilename << "'" << std::endl);
     return;
-    }
+  }
 
   EndElement(Elements.back());
 }
 
 void cmWIXSourceWriter::BeginElement(std::string const& name)
 {
-  if(State == BEGIN)
-    {
+  if (State == BEGIN) {
     File << ">";
-    }
+  }
 
   File << "\n";
   Indent(Elements.size());
@@ -68,33 +63,27 @@ void cmWIXSourceWriter::BeginElement(std::string const& name)
 
 void cmWIXSourceWriter::EndElement(std::string const& name)
 {
-  if(Elements.empty())
-    {
+  if (Elements.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "can not end WiX element with no open elements in '" <<
-      SourceFilename << "'" << std::endl);
+                  "can not end WiX element with no open elements in '"
+                    << SourceFilename << "'" << std::endl);
     return;
-    }
+  }
 
-  if(Elements.back() != name)
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "WiX element <" << Elements.back() <<
-      "> can not be closed by </" << name << "> in '" <<
-      SourceFilename << "'" << std::endl);
+  if (Elements.back() != name) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "WiX element <"
+                    << Elements.back() << "> can not be closed by </" << name
+                    << "> in '" << SourceFilename << "'" << std::endl);
     return;
-    }
+  }
 
-  if(State == DEFAULT)
-    {
+  if (State == DEFAULT) {
     File << "\n";
-    Indent(Elements.size()-1);
+    Indent(Elements.size() - 1);
     File << "</" << Elements.back() << ">";
-    }
-  else
-    {
+  } else {
     File << "/>";
-    }
+  }
 
   Elements.pop_back();
   State = DEFAULT;
@@ -102,30 +91,27 @@ void cmWIXSourceWriter::EndElement(std::string const& name)
 
 void cmWIXSourceWriter::AddTextNode(std::string const& text)
 {
-  if(State == BEGIN)
-    {
+  if (State == BEGIN) {
     File << ">";
-    }
+  }
 
-  if(Elements.empty())
-    {
+  if (Elements.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "can not add text without open WiX element in '" <<
-      SourceFilename << "'" << std::endl);
+                  "can not add text without open WiX element in '"
+                    << SourceFilename << "'" << std::endl);
     return;
-    }
+  }
 
   File << this->EscapeAttributeValue(text);
   State = DEFAULT;
 }
 
-void cmWIXSourceWriter::AddProcessingInstruction(
-  std::string const& target, std::string const& content)
+void cmWIXSourceWriter::AddProcessingInstruction(std::string const& target,
+                                                 std::string const& content)
 {
-  if(State == BEGIN)
-    {
+  if (State == BEGIN) {
     File << ">";
-    }
+  }
 
   File << "\n";
   Indent(Elements.size());
@@ -134,21 +120,20 @@ void cmWIXSourceWriter::AddProcessingInstruction(
   State = DEFAULT;
 }
 
-void cmWIXSourceWriter::AddAttribute(
-  std::string const& key, std::string const& value)
+void cmWIXSourceWriter::AddAttribute(std::string const& key,
+                                     std::string const& value)
 {
   std::string utf8 = CMakeEncodingToUtf8(value);
 
   File << " " << key << "=\"" << EscapeAttributeValue(utf8) << '"';
 }
 
-void cmWIXSourceWriter::AddAttributeUnlessEmpty(
-    std::string const& key, std::string const& value)
+void cmWIXSourceWriter::AddAttributeUnlessEmpty(std::string const& key,
+                                                std::string const& value)
 {
-  if(!value.empty())
-    {
+  if (!value.empty()) {
     AddAttribute(key, value);
-    }
+  }
 }
 
 std::string cmWIXSourceWriter::CMakeEncodingToUtf8(std::string const& value)
@@ -156,43 +141,38 @@ std::string cmWIXSourceWriter::CMakeEncodingToUtf8(std::string const& value)
 #ifdef CMAKE_ENCODING_UTF8
   return value;
 #else
-  if(value.empty())
-    {
+  if (value.empty()) {
     return std::string();
-    }
+  }
 
   int characterCount = MultiByteToWideChar(
     CP_ACP, 0, value.c_str(), static_cast<int>(value.size()), 0, 0);
 
-  if(characterCount == 0)
-    {
+  if (characterCount == 0) {
     return std::string();
-    }
+  }
 
   std::vector<wchar_t> utf16(characterCount);
 
-  MultiByteToWideChar(
-    CP_ACP, 0, value.c_str(), static_cast<int>(value.size()),
-    &utf16[0], static_cast<int>(utf16.size()));
+  MultiByteToWideChar(CP_ACP, 0, value.c_str(), static_cast<int>(value.size()),
+                      &utf16[0], static_cast<int>(utf16.size()));
 
   int utf8ByteCount = WideCharToMultiByte(
     CP_UTF8, 0, &utf16[0], static_cast<int>(utf16.size()), 0, 0, 0, 0);
 
-  if(utf8ByteCount == 0)
-    {
+  if (utf8ByteCount == 0) {
     return std::string();
-    }
+  }
 
   std::vector<char> utf8(utf8ByteCount);
 
   WideCharToMultiByte(CP_UTF8, 0, &utf16[0], static_cast<int>(utf16.size()),
-    &utf8[0], static_cast<int>(utf8.size()), 0, 0);
+                      &utf8[0], static_cast<int>(utf8.size()), 0, 0);
 
   return std::string(&utf8[0], utf8.size());
 #endif
 }
 
-
 void cmWIXSourceWriter::WriteXMLDeclaration()
 {
   File << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
@@ -200,41 +180,37 @@ void cmWIXSourceWriter::WriteXMLDeclaration()
 
 void cmWIXSourceWriter::Indent(size_t count)
 {
-  for(size_t i = 0; i < count; ++i)
-    {
+  for (size_t i = 0; i < count; ++i) {
     File << "    ";
-    }
+  }
 }
 
-std::string cmWIXSourceWriter::EscapeAttributeValue(
-  std::string const& value)
+std::string cmWIXSourceWriter::EscapeAttributeValue(std::string const& value)
 {
   std::string result;
   result.reserve(value.size());
 
   char c = 0;
-  for(size_t i = 0 ; i < value.size(); ++i)
-    {
+  for (size_t i = 0; i < value.size(); ++i) {
     c = value[i];
-    switch(c)
-      {
-    case '<':
-      result += "&lt;";
-      break;
-    case '>':
-      result += "&gt;";
-      break;
-    case '&':
-      result +="&amp;";
-      break;
-    case '"':
-      result += "&quot;";
-      break;
-    default:
-      result += c;
-      break;
-      }
-    }
+    switch (c) {
+      case '<':
+        result += "&lt;";
+        break;
+      case '>':
+        result += "&gt;";
+        break;
+      case '&':
+        result += "&amp;";
+        break;
+      case '"':
+        result += "&quot;";
+        break;
+      default:
+        result += c;
+        break;
+    }
+  }
 
   return result;
 }
diff --git a/Source/CPack/WiX/cmWIXSourceWriter.h b/Source/CPack/WiX/cmWIXSourceWriter.h
index 2bf9674..4efc026 100644
--- a/Source/CPack/WiX/cmWIXSourceWriter.h
+++ b/Source/CPack/WiX/cmWIXSourceWriter.h
@@ -26,8 +26,8 @@
 class cmWIXSourceWriter
 {
 public:
-  cmWIXSourceWriter(cmCPackLog* logger,
-    std::string const& filename, bool isIncludeFile = false);
+  cmWIXSourceWriter(cmCPackLog* logger, std::string const& filename,
+                    bool isIncludeFile = false);
 
   ~cmWIXSourceWriter();
 
@@ -37,19 +37,18 @@ public:
 
   void AddTextNode(std::string const& text);
 
-  void AddProcessingInstruction(
-    std::string const& target, std::string const& content);
+  void AddProcessingInstruction(std::string const& target,
+                                std::string const& content);
 
-  void AddAttribute(
-    std::string const& key, std::string const& value);
+  void AddAttribute(std::string const& key, std::string const& value);
 
-  void AddAttributeUnlessEmpty(
-    std::string const& key, std::string const& value);
+  void AddAttributeUnlessEmpty(std::string const& key,
+                               std::string const& value);
 
   static std::string CMakeEncodingToUtf8(std::string const& value);
 
 protected:
-   cmCPackLog* Logger;
+  cmCPackLog* Logger;
 
 private:
   enum State
diff --git a/Source/CPack/cmCPack7zGenerator.cxx b/Source/CPack/cmCPack7zGenerator.cxx
index 06bf7e7..b01c216 100644
--- a/Source/CPack/cmCPack7zGenerator.cxx
+++ b/Source/CPack/cmCPack7zGenerator.cxx
@@ -13,8 +13,7 @@
 #include "cmCPack7zGenerator.h"
 
 cmCPack7zGenerator::cmCPack7zGenerator()
-  :cmCPackArchiveGenerator(cmArchiveWrite::CompressNone,
-                           "7zip")
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressNone, "7zip")
 {
 }
 
diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx
index 05ea1d8..7db20a4 100644
--- a/Source/CPack/cmCPackArchiveGenerator.cxx
+++ b/Source/CPack/cmCPackArchiveGenerator.cxx
@@ -25,7 +25,7 @@
 #include <cmsys/SystemTools.hxx>
 
 cmCPackArchiveGenerator::cmCPackArchiveGenerator(cmArchiveWrite::Compress t,
-  std::string const& format)
+                                                 std::string const& format)
 {
   this->Compress = t;
   this->ArchiveFormat = format;
@@ -40,48 +40,41 @@ int cmCPackArchiveGenerator::InitializeInternal()
   this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "1");
   return this->Superclass::InitializeInternal();
 }
-int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
-                             cmCPackComponent* component)
+int cmCPackArchiveGenerator::addOneComponentToArchive(
+  cmArchiveWrite& archive, cmCPackComponent* component)
 {
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "   - packaging component: "
-      << component->Name
-      << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "   - packaging component: " << component->Name << std::endl);
   // Add the files of this component to the archive
   std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
-  localToplevel += "/"+ component->Name;
+  localToplevel += "/" + component->Name;
   std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
   // Change to local toplevel
   cmSystemTools::ChangeDirectory(localToplevel);
   std::string filePrefix;
-  if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY"))
-    {
+  if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
     filePrefix = this->GetOption("CPACK_PACKAGE_FILE_NAME");
     filePrefix += "/";
-    }
+  }
   const char* installPrefix =
     this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
-  if(installPrefix && installPrefix[0] == '/' && installPrefix[1] != 0)
-    {
+  if (installPrefix && installPrefix[0] == '/' && installPrefix[1] != 0) {
     // add to file prefix and remove the leading '/'
-    filePrefix += installPrefix+1;
+    filePrefix += installPrefix + 1;
     filePrefix += "/";
-    }
+  }
   std::vector<std::string>::const_iterator fileIt;
   for (fileIt = component->Files.begin(); fileIt != component->Files.end();
-       ++fileIt )
-    {
+       ++fileIt) {
     std::string rp = filePrefix + *fileIt;
-    cmCPackLogger(cmCPackLog::LOG_DEBUG,"Adding file: "
-                  << rp << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file: " << rp << std::endl);
     archive.Add(rp, 0, 0, false);
-    if (!archive)
-      {
+    if (!archive) {
       cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: "
-            << archive.GetError()
-            << std::endl);
+                      << archive.GetError() << std::endl);
       return 0;
-      }
     }
+  }
   // Go back to previous dir
   cmSystemTools::ChangeDirectory(dir);
   return 1;
@@ -92,26 +85,21 @@ int cmCPackArchiveGenerator::addOneComponentToArchive(cmArchiveWrite& archive,
  * an declare and open the associated
  * cmArchiveWrite 'archive' object.
  */
-#define DECLARE_AND_OPEN_ARCHIVE(filename,archive) \
-cmGeneratedFileStream gf; \
-gf.Open(filename.c_str(), false, true); \
-if (!GenerateHeader(&gf)) \
-  { \
-   cmCPackLogger(cmCPackLog::LOG_ERROR, \
-    "Problem to generate Header for archive < "     \
-            << filename \
-            << ">." << std::endl); \
-    return 0; \
-  } \
-cmArchiveWrite archive(gf,this->Compress, this->ArchiveFormat); \
-if (!archive) \
-  { \
-  cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < " \
-     << filename \
-     << ">. ERROR =" \
-     << archive.GetError() \
-     << std::endl); \
-  return 0; \
+#define DECLARE_AND_OPEN_ARCHIVE(filename, archive)                           \
+  cmGeneratedFileStream gf;                                                   \
+  gf.Open(filename.c_str(), false, true);                                     \
+  if (!GenerateHeader(&gf)) {                                                 \
+    cmCPackLogger(cmCPackLog::LOG_ERROR,                                      \
+                  "Problem to generate Header for archive < "                 \
+                    << filename << ">." << std::endl);                        \
+    return 0;                                                                 \
+  }                                                                           \
+  cmArchiveWrite archive(gf, this->Compress, this->ArchiveFormat);            \
+  if (!archive) {                                                             \
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem to create archive < "       \
+                    << filename << ">. ERROR =" << archive.GetError()         \
+                    << std::endl);                                            \
+    return 0;                                                                 \
   }
 
 int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
@@ -119,99 +107,86 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
   packageFileNames.clear();
   // The default behavior is to have one package by component group
   // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
-  if (!ignoreGroup)
-    {
+  if (!ignoreGroup) {
     std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
-    for (compGIt=this->ComponentGroups.begin();
-        compGIt!=this->ComponentGroups.end(); ++compGIt)
-      {
+    for (compGIt = this->ComponentGroups.begin();
+         compGIt != this->ComponentGroups.end(); ++compGIt) {
       cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
-          << compGIt->first
-          << std::endl);
+                      << compGIt->first << std::endl);
       // Begin the archive for this group
-      std::string packageFileName= std::string(toplevel);
-      packageFileName += "/"+
-       GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-                                   compGIt->first,
-                                   true)
-         + this->GetOutputExtension();
+      std::string packageFileName = std::string(toplevel);
+      packageFileName += "/" +
+        GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                    compGIt->first, true) +
+        this->GetOutputExtension();
       // open a block in order to automatically close archive
       // at the end of the block
       {
-        DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
+        DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
         // now iterate over the component of this group
         std::vector<cmCPackComponent*>::iterator compIt;
-        for (compIt=(compGIt->second).Components.begin();
-            compIt!=(compGIt->second).Components.end();
-            ++compIt)
-          {
+        for (compIt = (compGIt->second).Components.begin();
+             compIt != (compGIt->second).Components.end(); ++compIt) {
           // Add the files of this component to the archive
-          addOneComponentToArchive(archive,*compIt);
-          }
+          addOneComponentToArchive(archive, *compIt);
+        }
       }
       // add the generated package to package file names list
       packageFileNames.push_back(packageFileName);
-      }
+    }
     // Handle Orphan components (components not belonging to any groups)
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt=this->Components.begin();
-         compIt!=this->Components.end(); ++compIt )
-      {
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
       // Does the component belong to a group?
-      if (compIt->second.Group==NULL)
-        {
-        cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-            "Component <"
-              << compIt->second.Name
-              << "> does not belong to any group, package it separately."
-              << std::endl);
+      if (compIt->second.Group == NULL) {
+        cmCPackLogger(
+          cmCPackLog::LOG_VERBOSE, "Component <"
+            << compIt->second.Name
+            << "> does not belong to any group, package it separately."
+            << std::endl);
         std::string localToplevel(
-          this->GetOption("CPACK_TEMPORARY_DIRECTORY")
-                                 );
+          this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
         std::string packageFileName = std::string(toplevel);
 
-        localToplevel += "/"+ compIt->first;
-        packageFileName += "/"+
-        GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-                                    compIt->first,
-                                    false)
-                              + this->GetOutputExtension();
+        localToplevel += "/" + compIt->first;
+        packageFileName += "/" + GetComponentPackageFileName(
+                                   this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                   compIt->first, false) +
+          this->GetOutputExtension();
         {
-          DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
+          DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
           // Add the files of this component to the archive
-          addOneComponentToArchive(archive,&(compIt->second));
+          addOneComponentToArchive(archive, &(compIt->second));
         }
         // add the generated package to package file names list
         packageFileNames.push_back(packageFileName);
-        }
       }
     }
+  }
   // CPACK_COMPONENTS_IGNORE_GROUPS is set
   // We build 1 package per component
-  else
-    {
+  else {
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt=this->Components.begin();
-         compIt!=this->Components.end(); ++compIt )
-      {
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
       std::string localToplevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
       std::string packageFileName = std::string(toplevel);
 
-      localToplevel += "/"+ compIt->first;
-      packageFileName += "/"+
-       GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-                                   compIt->first,
-                                   false)
-        + this->GetOutputExtension();
+      localToplevel += "/" + compIt->first;
+      packageFileName += "/" +
+        GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                    compIt->first, false) +
+        this->GetOutputExtension();
       {
-        DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
+        DECLARE_AND_OPEN_ARCHIVE(packageFileName, archive);
         // Add the files of this component to the archive
-        addOneComponentToArchive(archive,&(compIt->second));
+        addOneComponentToArchive(archive, &(compIt->second));
       }
       // add the generated package to package file names list
       packageFileNames.push_back(packageFileName);
-      }
     }
+  }
   return 1;
 }
 
@@ -220,23 +195,22 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
   // reset the package file names
   packageFileNames.clear();
   packageFileNames.push_back(std::string(toplevel));
-  packageFileNames[0] += "/"
-    +std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
-    + this->GetOutputExtension();
+  packageFileNames[0] += "/" +
+    std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
+    this->GetOutputExtension();
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "Packaging all groups in one package..."
                 "(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE is set)"
-      << std::endl);
-  DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
+                  << std::endl);
+  DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
 
   // The ALL COMPONENTS in ONE package case
   std::map<std::string, cmCPackComponent>::iterator compIt;
-  for (compIt=this->Components.begin();compIt!=this->Components.end();
-      ++compIt )
-    {
+  for (compIt = this->Components.begin(); compIt != this->Components.end();
+       ++compIt) {
     // Add the files of this component to the archive
-    addOneComponentToArchive(archive,&(compIt->second));
-    }
+    addOneComponentToArchive(archive, &(compIt->second));
+  }
 
   // archive goes out of scope so it will finalized and closed.
   return 1;
@@ -244,50 +218,42 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne()
 
 int cmCPackArchiveGenerator::PackageFiles()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
-                << toplevel << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
 
   if (WantsComponentInstallation()) {
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL COMPONENTS in ONE package has been requested
     // then the package file is unique and should be open here.
-    if (componentPackageMethod == ONE_PACKAGE)
-      {
+    if (componentPackageMethod == ONE_PACKAGE) {
       return PackageComponentsAllInOne();
-      }
+    }
     // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
     // There will be 1 package for each component group
     // however one may require to ignore component group and
     // in this case you'll get 1 package for each component.
-    else
-      {
+    else {
       return PackageComponents(componentPackageMethod ==
                                ONE_PACKAGE_PER_COMPONENT);
-      }
+    }
   }
 
   // CASE 3 : NON COMPONENT package.
-  DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
+  DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0], archive);
   std::vector<std::string>::const_iterator fileIt;
   std::string dir = cmSystemTools::GetCurrentWorkingDirectory();
   cmSystemTools::ChangeDirectory(toplevel);
-  for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
-    {
+  for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
     // Get the relative path to the file
-    std::string rp = cmSystemTools::RelativePath(toplevel.c_str(),
-                                                 fileIt->c_str());
+    std::string rp =
+      cmSystemTools::RelativePath(toplevel.c_str(), fileIt->c_str());
     archive.Add(rp, 0, 0, false);
-    if(!archive)
-      {
+    if (!archive) {
       cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< "
-          << *fileIt
-          << "> to archive <"
-          << packageFileNames[0] << "> .ERROR ="
-          << archive.GetError()
-          << std::endl);
+                      << *fileIt << "> to archive <" << packageFileNames[0]
+                      << "> .ERROR =" << archive.GetError() << std::endl);
       return 0;
-      }
     }
+  }
   cmSystemTools::ChangeDirectory(dir);
   // The destructor of cmArchiveWrite will close and finish the write
   return 1;
@@ -298,16 +264,14 @@ int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
   return 1;
 }
 
-bool cmCPackArchiveGenerator::SupportsComponentInstallation() const {
+bool cmCPackArchiveGenerator::SupportsComponentInstallation() const
+{
   // The Component installation support should only
   // be activated if explicitly requested by the user
   // (for backward compatibility reason)
-  if (IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL"))
-    {
+  if (IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL")) {
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
diff --git a/Source/CPack/cmCPackArchiveGenerator.h b/Source/CPack/cmCPackArchiveGenerator.h
index 8b07339..9eb38b1 100644
--- a/Source/CPack/cmCPackArchiveGenerator.h
+++ b/Source/CPack/cmCPackArchiveGenerator.h
@@ -17,7 +17,6 @@
 
 #include "cmArchiveWrite.h"
 
-
 /** \class cmCPackArchiveGenerator
  * \brief A generator base for libarchive generation.
  * The generator itself uses the libarchive wrapper
@@ -25,7 +24,7 @@
  *
  */
 class cmCPackArchiveGenerator : public cmCPackGenerator
-  {
+{
 public:
   cmTypeMacro(cmCPackArchiveGenerator, cmCPackGenerator);
 
@@ -38,6 +37,7 @@ public:
   virtual int GenerateHeader(std::ostream* os);
   // component support
   virtual bool SupportsComponentInstallation() const;
+
 protected:
   virtual int InitializeInternal();
   /**
@@ -70,6 +70,6 @@ protected:
   virtual const char* GetOutputExtension() = 0;
   cmArchiveWrite::Compress Compress;
   std::string ArchiveFormat;
-  };
+};
 
 #endif
diff --git a/Source/CPack/cmCPackBundleGenerator.cxx b/Source/CPack/cmCPackBundleGenerator.cxx
index 6cc48aa..1164021 100644
--- a/Source/CPack/cmCPackBundleGenerator.cxx
+++ b/Source/CPack/cmCPackBundleGenerator.cxx
@@ -28,29 +28,25 @@ cmCPackBundleGenerator::~cmCPackBundleGenerator()
 int cmCPackBundleGenerator::InitializeInternal()
 {
   const char* name = this->GetOption("CPACK_BUNDLE_NAME");
-  if(0 == name)
-    {
+  if (0 == name) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "CPACK_BUNDLE_NAME must be set to use the Bundle generator."
-      << std::endl);
+                  "CPACK_BUNDLE_NAME must be set to use the Bundle generator."
+                    << std::endl);
 
     return 0;
-    }
+  }
 
-  if(this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP"))
-    {
-    const std::string codesign_path = cmSystemTools::FindProgram("codesign",
-       std::vector<std::string>(), false);
+  if (this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")) {
+    const std::string codesign_path = cmSystemTools::FindProgram(
+      "codesign", std::vector<std::string>(), false);
 
-    if(codesign_path.empty())
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Cannot locate codesign command"
-        << std::endl);
+    if (codesign_path.empty()) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate codesign command"
+                      << std::endl);
       return 0;
-      }
-    this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
     }
+    this->SetOptionIfNotSet("CPACK_COMMAND_CODESIGN", codesign_path.c_str());
+  }
 
   return this->Superclass::InitializeInternal();
 }
@@ -69,42 +65,40 @@ int cmCPackBundleGenerator::ConstructBundle()
 
   // Get required arguments ...
   const std::string cpack_bundle_name = this->GetOption("CPACK_BUNDLE_NAME")
-    ? this->GetOption("CPACK_BUNDLE_NAME") : "";
-  if(cpack_bundle_name.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "CPACK_BUNDLE_NAME must be set."
-      << std::endl);
+    ? this->GetOption("CPACK_BUNDLE_NAME")
+    : "";
+  if (cpack_bundle_name.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_NAME must be set."
+                    << std::endl);
 
     return 0;
-    }
+  }
 
   const std::string cpack_bundle_plist = this->GetOption("CPACK_BUNDLE_PLIST")
-    ? this->GetOption("CPACK_BUNDLE_PLIST") : "";
-  if(cpack_bundle_plist.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "CPACK_BUNDLE_PLIST must be set."
-      << std::endl);
+    ? this->GetOption("CPACK_BUNDLE_PLIST")
+    : "";
+  if (cpack_bundle_plist.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_PLIST must be set."
+                    << std::endl);
 
     return 0;
-    }
+  }
 
   const std::string cpack_bundle_icon = this->GetOption("CPACK_BUNDLE_ICON")
-    ? this->GetOption("CPACK_BUNDLE_ICON") : "";
-  if(cpack_bundle_icon.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "CPACK_BUNDLE_ICON must be set."
-      << std::endl);
+    ? this->GetOption("CPACK_BUNDLE_ICON")
+    : "";
+  if (cpack_bundle_icon.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_BUNDLE_ICON must be set."
+                    << std::endl);
 
     return 0;
-    }
+  }
 
   // Get optional arguments ...
   const std::string cpack_bundle_startup_command =
     this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
-    ? this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND") : "";
+    ? this->GetOption("CPACK_BUNDLE_STARTUP_COMMAND")
+    : "";
 
   // The staging directory contains everything that will end-up inside the
   // final disk image ...
@@ -112,30 +106,33 @@ int cmCPackBundleGenerator::ConstructBundle()
   staging << toplevel;
 
   std::ostringstream contents;
-  contents << staging.str() << "/" << cpack_bundle_name
-    << ".app/" << "Contents";
+  contents << staging.str() << "/" << cpack_bundle_name << ".app/"
+           << "Contents";
 
   std::ostringstream application;
-  application << contents.str() << "/" << "MacOS";
+  application << contents.str() << "/"
+              << "MacOS";
 
   std::ostringstream resources;
-  resources << contents.str() << "/" << "Resources";
+  resources << contents.str() << "/"
+            << "Resources";
 
   // Install a required, user-provided bundle metadata file ...
   std::ostringstream plist_source;
   plist_source << cpack_bundle_plist;
 
   std::ostringstream plist_target;
-  plist_target << contents.str() << "/" << "Info.plist";
+  plist_target << contents.str() << "/"
+               << "Info.plist";
 
-  if(!this->CopyFile(plist_source, plist_target))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
+  if (!this->CopyFile(plist_source, plist_target)) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
       "Error copying plist.  Check the value of CPACK_BUNDLE_PLIST."
-      << std::endl);
+        << std::endl);
 
     return 0;
-    }
+  }
 
   // Install a user-provided bundle icon ...
   std::ostringstream icon_source;
@@ -144,52 +141,48 @@ int cmCPackBundleGenerator::ConstructBundle()
   std::ostringstream icon_target;
   icon_target << resources.str() << "/" << cpack_bundle_name << ".icns";
 
-  if(!this->CopyFile(icon_source, icon_target))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
+  if (!this->CopyFile(icon_source, icon_target)) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
       "Error copying bundle icon.  Check the value of CPACK_BUNDLE_ICON."
-      << std::endl);
+        << std::endl);
 
     return 0;
-    }
+  }
 
   // Optionally a user-provided startup command (could be an
   // executable or a script) ...
-  if(!cpack_bundle_startup_command.empty())
-    {
+  if (!cpack_bundle_startup_command.empty()) {
     std::ostringstream command_source;
     command_source << cpack_bundle_startup_command;
 
     std::ostringstream command_target;
     command_target << application.str() << "/" << cpack_bundle_name;
 
-    if(!this->CopyFile(command_source, command_target))
-      {
+    if (!this->CopyFile(command_source, command_target)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Error copying startup command. "
                     " Check the value of CPACK_BUNDLE_STARTUP_COMMAND."
-        << std::endl);
+                      << std::endl);
 
       return 0;
-      }
+    }
 
     cmSystemTools::SetPermissions(command_target.str().c_str(), 0777);
-    }
+  }
 
   return 1;
 }
 
 int cmCPackBundleGenerator::PackageFiles()
 {
-  if(!this->ConstructBundle())
-    {
+  if (!this->ConstructBundle()) {
     return 0;
-    }
+  }
 
-  if(!this->SignBundle(toplevel))
-    {
+  if (!this->SignBundle(toplevel)) {
     return 0;
-    }
+  }
 
   return this->CreateDMG(toplevel, packageFileNames[0]);
 }
@@ -199,16 +192,15 @@ bool cmCPackBundleGenerator::SupportsComponentInstallation() const
   return false;
 }
 
-
 int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
 {
   const std::string cpack_apple_cert_app =
     this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
-    ? this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP") : "";
+    ? this->GetOption("CPACK_BUNDLE_APPLE_CERT_APP")
+    : "";
 
   // codesign the application.
-  if(!cpack_apple_cert_app.empty())
-    {
+  if (!cpack_apple_cert_app.empty()) {
     std::string output;
     std::string bundle_path;
     bundle_path = src_dir + "/";
@@ -223,15 +215,15 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
 
     const std::string sign_files =
       this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
-      ? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES") : "";
+      ? this->GetOption("CPACK_BUNDLE_APPLE_CODESIGN_FILES")
+      : "";
 
     std::vector<std::string> relFiles;
     cmSystemTools::ExpandListArgument(sign_files, relFiles);
 
     // sign the files supplied by the user, ie. frameworks.
-    for(std::vector<std::string>::iterator it = relFiles.begin();
-      it != relFiles.end(); ++it)
-      {
+    for (std::vector<std::string>::iterator it = relFiles.begin();
+         it != relFiles.end(); ++it) {
       std::ostringstream temp_sign_file_cmd;
       temp_sign_file_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
       temp_sign_file_cmd << " " << sign_parameter << " -s \""
@@ -242,15 +234,14 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
       temp_sign_file_cmd << bundle_path;
       temp_sign_file_cmd << it->c_str() << "\"";
 
-      if(!this->RunCommand(temp_sign_file_cmd, &output))
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Error signing file:"
-          << bundle_path << it->c_str() << std::endl << output << std::endl);
+      if (!this->RunCommand(temp_sign_file_cmd, &output)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error signing file:"
+                        << bundle_path << it->c_str() << std::endl
+                        << output << std::endl);
 
         return 0;
-        }
       }
+    }
 
     // sign main binary
     std::ostringstream temp_sign_binary_cmd;
@@ -259,43 +250,42 @@ int cmCPackBundleGenerator::SignBundle(const std::string& src_dir)
                          << cpack_apple_cert_app;
     temp_sign_binary_cmd << "\" \"" << bundle_path << "\"";
 
-    if(!this->RunCommand(temp_sign_binary_cmd, &output))
-      {
+    if (!this->RunCommand(temp_sign_binary_cmd, &output)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error signing the application binary."
-        << std::endl << output << std::endl);
+                    "Error signing the application binary." << std::endl
+                                                            << output
+                                                            << std::endl);
 
       return 0;
-      }
+    }
 
     // sign app bundle
     std::ostringstream temp_codesign_cmd;
     temp_codesign_cmd << this->GetOption("CPACK_COMMAND_CODESIGN");
     temp_codesign_cmd << " " << sign_parameter << " -s \""
                       << cpack_apple_cert_app << "\"";
-    if(this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS"))
-      {
+    if (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")) {
       temp_codesign_cmd << " --entitlements ";
       temp_codesign_cmd << this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS");
-      }
+    }
     temp_codesign_cmd << " \"" << bundle_path << "\"";
 
-    if(!this->RunCommand(temp_codesign_cmd, &output))
-      {
+    if (!this->RunCommand(temp_codesign_cmd, &output)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error signing the application package."
-        << std::endl << output << std::endl);
+                    "Error signing the application package." << std::endl
+                                                             << output
+                                                             << std::endl);
 
       return 0;
-      }
+    }
 
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-      "- Application has been codesigned"
-      << std::endl);
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Application has been codesigned"
+                    << std::endl);
     cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-       (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")
-         ? "with entitlement sandboxing" : "without entitlement sandboxing")
-       << std::endl);
+                  (this->GetOption("CPACK_BUNDLE_APPLE_ENTITLEMENTS")
+                     ? "with entitlement sandboxing"
+                     : "without entitlement sandboxing")
+                    << std::endl);
   }
 
   return 1;
diff --git a/Source/CPack/cmCPackComponentGroup.cxx b/Source/CPack/cmCPackComponentGroup.cxx
index 88c59f3..d262ac9 100644
--- a/Source/CPack/cmCPackComponentGroup.cxx
+++ b/Source/CPack/cmCPackComponentGroup.cxx
@@ -18,28 +18,26 @@
 #include <vector>
 
 unsigned long cmCPackComponent::GetInstalledSize(
-    const std::string& installDir) const
+  const std::string& installDir) const
 {
-  if (this->TotalSize != 0)
-    {
+  if (this->TotalSize != 0) {
     return this->TotalSize;
-    }
+  }
 
   std::vector<std::string>::const_iterator fileIt;
-  for (fileIt = this->Files.begin(); fileIt != this->Files.end(); ++fileIt)
-    {
+  for (fileIt = this->Files.begin(); fileIt != this->Files.end(); ++fileIt) {
     std::string path = installDir;
     path += '/';
     path += *fileIt;
     this->TotalSize += cmSystemTools::FileLength(path);
-    }
+  }
 
   return this->TotalSize;
 }
 
-unsigned long
-cmCPackComponent::GetInstalledSizeInKbytes(const std::string& installDir) const
+unsigned long cmCPackComponent::GetInstalledSizeInKbytes(
+  const std::string& installDir) const
 {
   unsigned long result = (GetInstalledSize(installDir) + 512) / 1024;
-  return result? result : 1;
+  return result ? result : 1;
 }
diff --git a/Source/CPack/cmCPackComponentGroup.h b/Source/CPack/cmCPackComponentGroup.h
index 0679638..5361d95 100644
--- a/Source/CPack/cmCPackComponentGroup.h
+++ b/Source/CPack/cmCPackComponentGroup.h
@@ -42,9 +42,15 @@ public:
 class cmCPackComponent
 {
 public:
- cmCPackComponent() : Group(0), IsRequired(true), IsHidden(false),
-                      IsDisabledByDefault(false), IsDownloaded(false),
-                      TotalSize(0) { }
+  cmCPackComponent()
+    : Group(0)
+    , IsRequired(true)
+    , IsHidden(false)
+    , IsDisabledByDefault(false)
+    , IsDownloaded(false)
+    , TotalSize(0)
+  {
+  }
 
   /// The name of the component (used to reference the component).
   std::string Name;
@@ -53,7 +59,7 @@ public:
   std::string DisplayName;
 
   /// The component group that contains this component (if any).
-  cmCPackComponentGroup *Group;
+  cmCPackComponentGroup* Group;
 
   /// Whether this component group must always be installed.
   bool IsRequired : 1;
@@ -73,17 +79,17 @@ public:
   std::string Description;
 
   /// The installation types that this component is a part of.
-  std::vector<cmCPackInstallationType *> InstallationTypes;
+  std::vector<cmCPackInstallationType*> InstallationTypes;
 
   /// If IsDownloaded is true, the name of the archive file that
   /// contains the files that are part of this component.
   std::string ArchiveFile;
 
   /// The components that this component depends on.
-  std::vector<cmCPackComponent *> Dependencies;
+  std::vector<cmCPackComponent*> Dependencies;
 
   /// The components that depend on this component.
-  std::vector<cmCPackComponent *> ReverseDependencies;
+  std::vector<cmCPackComponent*> ReverseDependencies;
 
   /// The list of installed files that are part of this component.
   std::vector<std::string> Files;
@@ -100,7 +106,7 @@ public:
   /// kilobytes.
   unsigned long GetInstalledSizeInKbytes(const std::string& installDir) const;
 
- private:
+private:
   mutable unsigned long TotalSize;
 };
 
@@ -110,7 +116,10 @@ public:
 class cmCPackComponentGroup
 {
 public:
- cmCPackComponentGroup() : ParentGroup(0) { }
+  cmCPackComponentGroup()
+    : ParentGroup(0)
+  {
+  }
 
   /// The name of the group (used to reference the group).
   std::string Name;
@@ -131,7 +140,7 @@ public:
   std::vector<cmCPackComponent*> Components;
 
   /// The parent group of this component group (if any).
-  cmCPackComponentGroup *ParentGroup;
+  cmCPackComponentGroup* ParentGroup;
 
   /// The subgroups of this group.
   std::vector<cmCPackComponentGroup*> Subgroups;
diff --git a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx
index a3176e9..83af89e 100644
--- a/Source/CPack/cmCPackCygwinBinaryGenerator.cxx
+++ b/Source/CPack/cmCPackCygwinBinaryGenerator.cxx
@@ -45,8 +45,7 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
   std::string manifest = "/usr/share/doc/";
   manifest += packageName;
   manifest += "/MANIFEST";
-  std::string manifestFile
-    = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  std::string manifestFile = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
   // Create a MANIFEST file that contains all of the files in
   // the tar file
   std::string tempdir = manifestFile;
@@ -54,14 +53,13 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
   // create an extra scope to force the stream
   // to create the file before the super class is called
   {
-  cmGeneratedFileStream ofs(manifestFile.c_str());
-  for(std::vector<std::string>::const_iterator i = files.begin();
-      i != files.end(); ++i)
-    {
-    // remove the temp dir and replace with /usr
-    ofs << (*i).substr(tempdir.size()) << "\n";
+    cmGeneratedFileStream ofs(manifestFile.c_str());
+    for (std::vector<std::string>::const_iterator i = files.begin();
+         i != files.end(); ++i) {
+      // remove the temp dir and replace with /usr
+      ofs << (*i).substr(tempdir.size()) << "\n";
     }
-  ofs << manifest << "\n";
+    ofs << manifest << "\n";
   }
   // add the manifest file to the list of all files
   files.push_back(manifestFile);
@@ -73,14 +71,13 @@ int cmCPackCygwinBinaryGenerator::PackageFiles()
 const char* cmCPackCygwinBinaryGenerator::GetOutputExtension()
 {
   this->OutputExtension = "-";
-  const char* patchNumber =this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
-  if(!patchNumber)
-    {
+  const char* patchNumber = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
+  if (!patchNumber) {
     patchNumber = "1";
     cmCPackLogger(cmCPackLog::LOG_WARNING,
                   "CPACK_CYGWIN_PATCH_NUMBER not specified using 1"
-                  << std::endl);
-    }
+                    << std::endl);
+  }
   this->OutputExtension += patchNumber;
   this->OutputExtension += ".tar.bz2";
   return this->OutputExtension.c_str();
diff --git a/Source/CPack/cmCPackCygwinBinaryGenerator.h b/Source/CPack/cmCPackCygwinBinaryGenerator.h
index 38f6df1..8de4bae 100644
--- a/Source/CPack/cmCPackCygwinBinaryGenerator.h
+++ b/Source/CPack/cmCPackCygwinBinaryGenerator.h
@@ -28,6 +28,7 @@ public:
    */
   cmCPackCygwinBinaryGenerator();
   virtual ~cmCPackCygwinBinaryGenerator();
+
 protected:
   virtual int InitializeInternal();
   int PackageFiles();
diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.cxx b/Source/CPack/cmCPackCygwinSourceGenerator.cxx
index 132ebcf..5fcfaf4 100644
--- a/Source/CPack/cmCPackCygwinSourceGenerator.cxx
+++ b/Source/CPack/cmCPackCygwinSourceGenerator.cxx
@@ -25,8 +25,8 @@
 // system tools because it is not implemented robustly enough to move
 // files across directories.
 #ifdef _WIN32
-# include <sys/stat.h>
-# include <windows.h>
+#include <sys/stat.h>
+#include <windows.h>
 #endif
 
 cmCPackCygwinSourceGenerator::cmCPackCygwinSourceGenerator()
@@ -46,8 +46,8 @@ int cmCPackCygwinSourceGenerator::InitializeInternal()
 int cmCPackCygwinSourceGenerator::PackageFiles()
 {
   // Create a tar file of the sources
-  std::string packageDirFileName
-    = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  std::string packageDirFileName =
+    this->GetOption("CPACK_TEMPORARY_DIRECTORY");
   packageDirFileName += ".tar.bz2";
   packageFileNames[0] = packageDirFileName;
   std::string output;
@@ -55,10 +55,9 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
   // to create tar.bz2 file with the list of source
   // files
   this->Compress = cmArchiveWrite::CompressBZip2;
-  if ( !this->cmCPackTarBZip2Generator::PackageFiles() )
-    {
+  if (!this->cmCPackTarBZip2Generator::PackageFiles()) {
     return 0;
-    }
+  }
   // Now create a tar file that contains the above .tar.bz2 file
   // and the CPACK_CYGWIN_PATCH_FILE and CPACK_TOPLEVEL_DIRECTORY
   // files
@@ -76,47 +75,41 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
   // to the toplevel cpack temp dir
 
   // copy the patch file into place
-  if(!this->GetOption("CPACK_CYGWIN_PATCH_FILE"))
-    {
+  if (!this->GetOption("CPACK_CYGWIN_PATCH_FILE")) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "No patch file specified for cygwin sources.");
     return 0;
-    }
-  if(!cmSystemTools::CopyFileAlways(
-       this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
-       this->GetOption("CPACK_TOPLEVEL_DIRECTORY")))
-    {
+  }
+  if (!cmSystemTools::CopyFileAlways(
+        this->GetOption("CPACK_CYGWIN_PATCH_FILE"),
+        this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: ["
-                  << this->GetOption("CPACK_CYGWIN_PATCH_FILE") << "]\nto\n["
-                  << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
+                    << this->GetOption("CPACK_CYGWIN_PATCH_FILE") << "]\nto\n["
+                    << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
     return 0;
-    }
-  if(!this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"))
-    {
+  }
+  if (!this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT")) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "No build script specified for cygwin sources.");
     return 0;
-    }
+  }
   // copy the build script into place
-  if(!cmSystemTools::CopyFileAlways(
-       this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
-       this->GetOption("CPACK_TOPLEVEL_DIRECTORY")))
-    {
+  if (!cmSystemTools::CopyFileAlways(
+        this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"),
+        this->GetOption("CPACK_TOPLEVEL_DIRECTORY"))) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "problem copying: "
-                  << this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT") << "\nto\n"
-                  << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
+                    << this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT") << "\nto\n"
+                    << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "]\n");
     return 0;
-    }
-  std::string outerTarFile
-    = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  }
+  std::string outerTarFile = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
   outerTarFile += "-";
   const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
-  if(!patch)
-    {
+  if (!patch) {
     cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
-                  << " not specified, defaulting to 1\n");
+                    << " not specified, defaulting to 1\n");
     patch = "1";
-    }
+  }
   outerTarFile += patch;
   outerTarFile += "-src.tar.bz2";
   std::string tmpDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@@ -126,8 +119,8 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
     this->GetOption("CPACK_CYGWIN_BUILD_SCRIPT"));
   std::string patchFile = tmpDir;
   patchFile += "/";
-  patchFile += cmSystemTools::GetFilenameName(
-    this->GetOption("CPACK_CYGWIN_PATCH_FILE"));
+  patchFile +=
+    cmSystemTools::GetFilenameName(this->GetOption("CPACK_CYGWIN_PATCH_FILE"));
 
   std::string file = cmSystemTools::GetFilenameName(compressOutFile);
   std::string sourceTar = cmSystemTools::GetFilenamePath(compressOutFile);
@@ -146,10 +139,9 @@ int cmCPackCygwinSourceGenerator::PackageFiles()
   packageFileNames[0] = outerTarFile;
   /* update the toplevel dir */
   toplevel = tmpDir;
-  if ( !this->cmCPackTarBZip2Generator::PackageFiles() )
-    {
+  if (!this->cmCPackTarBZip2Generator::PackageFiles()) {
     return 0;
-    }
+  }
   return 1;
 }
 
@@ -164,14 +156,12 @@ const char* cmCPackCygwinSourceGenerator::GetOutputExtension()
 {
   this->OutputExtension = "-";
   const char* patch = this->GetOption("CPACK_CYGWIN_PATCH_NUMBER");
-  if(!patch)
-    {
+  if (!patch) {
     cmCPackLogger(cmCPackLog::LOG_WARNING, "CPACK_CYGWIN_PATCH_NUMBER"
-                  << " not specified, defaulting to 1\n");
+                    << " not specified, defaulting to 1\n");
     patch = "1";
-    }
+  }
   this->OutputExtension += patch;
   this->OutputExtension += "-src.tar.bz2";
   return this->OutputExtension.c_str();
 }
-
diff --git a/Source/CPack/cmCPackCygwinSourceGenerator.h b/Source/CPack/cmCPackCygwinSourceGenerator.h
index 9d98a9b..4aba8b9 100644
--- a/Source/CPack/cmCPackCygwinSourceGenerator.h
+++ b/Source/CPack/cmCPackCygwinSourceGenerator.h
@@ -28,6 +28,7 @@ public:
    */
   cmCPackCygwinSourceGenerator();
   virtual ~cmCPackCygwinSourceGenerator();
+
 protected:
   const char* GetPackagingInstallPrefix();
   virtual int InitializeInternal();
diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx
index aec06b7..7675677 100644
--- a/Source/CPack/cmCPackDebGenerator.cxx
+++ b/Source/CPack/cmCPackDebGenerator.cxx
@@ -30,7 +30,8 @@
 // a GNU ar.
 // See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=161593 for more info
 // Therefore we provide our own implementation of a BSD-ar:
-static int ar_append(const char*archive,const std::vector<std::string>& files);
+static int ar_append(const char* archive,
+                     const std::vector<std::string>& files);
 
 cmCPackDebGenerator::cmCPackDebGenerator()
 {
@@ -43,70 +44,63 @@ cmCPackDebGenerator::~cmCPackDebGenerator()
 int cmCPackDebGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
-  if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR")))
-    {
+  if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR"))) {
     this->SetOption("CPACK_SET_DESTDIR", "I_ON");
-    }
+  }
   return this->Superclass::InitializeInternal();
 }
 
 int cmCPackDebGenerator::PackageOnePack(std::string initialTopLevel,
                                         std::string packageName)
-  {
+{
   int retval = 1;
   // Begin the archive for this pack
   std::string localToplevel(initialTopLevel);
-  std::string packageFileName(
-      cmSystemTools::GetParentDirectory(toplevel)
-  );
-  std::string outputFileName(
-          cmsys::SystemTools::LowerCase(
-              std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")))
-          +"-"+packageName + this->GetOutputExtension()
-      );
-
-  localToplevel += "/"+ packageName;
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string outputFileName(cmsys::SystemTools::LowerCase(std::string(
+                               this->GetOption("CPACK_PACKAGE_FILE_NAME"))) +
+                             "-" + packageName + this->GetOutputExtension());
+
+  localToplevel += "/" + packageName;
   /* replace the TEMP DIRECTORY with the component one */
-  this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
-  packageFileName += "/"+ outputFileName;
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
   /* replace proposed CPACK_OUTPUT_FILE_NAME */
-  this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
   /* replace the TEMPORARY package file name */
   this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
-      packageFileName.c_str());
+                  packageFileName.c_str());
   // Tell CPackDeb.cmake the name of the component GROUP.
-  this->SetOption("CPACK_DEB_PACKAGE_COMPONENT",packageName.c_str());
+  this->SetOption("CPACK_DEB_PACKAGE_COMPONENT", packageName.c_str());
   // Tell CPackDeb.cmake the path where the component is.
   std::string component_path = "/";
   component_path += packageName;
   this->SetOption("CPACK_DEB_PACKAGE_COMPONENT_PART_PATH",
                   component_path.c_str());
-  if (!this->ReadListFile("CPackDeb.cmake"))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error while execution CPackDeb.cmake" << std::endl);
+  if (!this->ReadListFile("CPackDeb.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
+                    << std::endl);
     retval = 0;
     return retval;
-    }
+  }
 
   cmsys::Glob gl;
   std::string findExpr(this->GetOption("GEN_WDIR"));
   findExpr += "/*";
   gl.RecurseOn();
   gl.SetRecurseListDirs(true);
-  if ( !gl.FindFiles(findExpr) )
-    {
+  if (!gl.FindFiles(findExpr)) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Cannot find any files in the installed directory" << std::endl);
+                  "Cannot find any files in the installed directory"
+                    << std::endl);
     return 0;
-    }
+  }
   packageFiles = gl.GetFiles();
 
   int res = createDeb();
-  if (res != 1)
-    {
+  if (res != 1) {
     retval = 0;
-    }
+  }
   // add the generated package to package file names list
   packageFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   packageFileName += "/";
@@ -125,53 +119,46 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup)
 
   // The default behavior is to have one package by component group
   // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
-  if (!ignoreGroup)
-    {
+  if (!ignoreGroup) {
     std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
-    for (compGIt=this->ComponentGroups.begin();
-        compGIt!=this->ComponentGroups.end(); ++compGIt)
-      {
+    for (compGIt = this->ComponentGroups.begin();
+         compGIt != this->ComponentGroups.end(); ++compGIt) {
       cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
-          << compGIt->first
-          << std::endl);
+                      << compGIt->first << std::endl);
       // Begin the archive for this group
-      retval &= PackageOnePack(initialTopLevel,compGIt->first);
-      }
+      retval &= PackageOnePack(initialTopLevel, compGIt->first);
+    }
     // Handle Orphan components (components not belonging to any groups)
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt=this->Components.begin();
-        compIt!=this->Components.end(); ++compIt )
-      {
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
       // Does the component belong to a group?
-      if (compIt->second.Group==NULL)
-        {
-        cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-            "Component <"
+      if (compIt->second.Group == NULL) {
+        cmCPackLogger(
+          cmCPackLog::LOG_VERBOSE, "Component <"
             << compIt->second.Name
             << "> does not belong to any group, package it separately."
             << std::endl);
         // Begin the archive for this orphan component
-        retval &= PackageOnePack(initialTopLevel,compIt->first);
-        }
+        retval &= PackageOnePack(initialTopLevel, compIt->first);
       }
     }
+  }
   // CPACK_COMPONENTS_IGNORE_GROUPS is set
   // We build 1 package per component
-  else
-    {
+  else {
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt=this->Components.begin();
-         compIt!=this->Components.end(); ++compIt )
-      {
-      retval &= PackageOnePack(initialTopLevel,compIt->first);
-      }
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
+      retval &= PackageOnePack(initialTopLevel, compIt->first);
     }
+  }
   return retval;
 }
 
 //----------------------------------------------------------------------
 int cmCPackDebGenerator::PackageComponentsAllInOne(
-    const std::string& compInstDirName)
+  const std::string& compInstDirName)
 {
   int retval = 1;
   /* Reset package file name list it will be populated during the
@@ -182,65 +169,57 @@ int cmCPackDebGenerator::PackageComponentsAllInOne(
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "Packaging all groups in one package..."
                 "(CPACK_COMPONENTS_ALL_[GROUPS_]IN_ONE_PACKAGE is set)"
-      << std::endl);
+                  << std::endl);
 
   // The ALL GROUPS in ONE package case
   std::string localToplevel(initialTopLevel);
-  std::string packageFileName(
-      cmSystemTools::GetParentDirectory(toplevel)
-                             );
-  std::string outputFileName(
-            cmsys::SystemTools::LowerCase(
-                std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")))
-            + this->GetOutputExtension()
-                            );
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
+  std::string outputFileName(cmsys::SystemTools::LowerCase(std::string(
+                               this->GetOption("CPACK_PACKAGE_FILE_NAME"))) +
+                             this->GetOutputExtension());
   // all GROUP in one vs all COMPONENT in one
-  localToplevel += "/"+compInstDirName;
+  localToplevel += "/" + compInstDirName;
 
   /* replace the TEMP DIRECTORY with the component one */
-  this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
-  packageFileName += "/"+ outputFileName;
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
   /* replace proposed CPACK_OUTPUT_FILE_NAME */
-  this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
   /* replace the TEMPORARY package file name */
   this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
-      packageFileName.c_str());
+                  packageFileName.c_str());
 
-  if(!compInstDirName.empty())
-    {
+  if (!compInstDirName.empty()) {
     // Tell CPackDeb.cmake the path where the component is.
     std::string component_path = "/";
     component_path += compInstDirName;
     this->SetOption("CPACK_DEB_PACKAGE_COMPONENT_PART_PATH",
                     component_path.c_str());
-    }
-  if (!this->ReadListFile("CPackDeb.cmake"))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error while execution CPackDeb.cmake" << std::endl);
+  }
+  if (!this->ReadListFile("CPackDeb.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackDeb.cmake"
+                    << std::endl);
     retval = 0;
     return retval;
-    }
+  }
 
   cmsys::Glob gl;
   std::string findExpr(this->GetOption("GEN_WDIR"));
   findExpr += "/*";
   gl.RecurseOn();
   gl.SetRecurseListDirs(true);
-  if ( !gl.FindFiles(findExpr) )
-    {
+  if (!gl.FindFiles(findExpr)) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-    "Cannot find any files in the installed directory" << std::endl);
+                  "Cannot find any files in the installed directory"
+                    << std::endl);
     return 0;
-    }
+  }
   packageFiles = gl.GetFiles();
 
-
   int res = createDeb();
-  if (res != 1)
-    {
+  if (res != 1) {
     retval = 0;
-    }
+  }
   // add the generated package to package file names list
   packageFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   packageFileName += "/";
@@ -256,25 +235,22 @@ int cmCPackDebGenerator::PackageFiles()
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL GROUPS or ALL COMPONENTS in ONE package has been requested
     // then the package file is unique and should be open here.
-    if (componentPackageMethod == ONE_PACKAGE)
-      {
+    if (componentPackageMethod == ONE_PACKAGE) {
       return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
-      }
+    }
     // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
     // There will be 1 package for each component group
     // however one may require to ignore component group and
     // in this case you'll get 1 package for each component.
-    else
-      {
+    else {
       return PackageComponents(componentPackageMethod ==
                                ONE_PACKAGE_PER_COMPONENT);
-      }
+    }
   }
   // CASE 3 : NON COMPONENT package.
-  else
-    {
+  else {
     return PackageComponentsAllInOne("");
-    }
+  }
 }
 
 int cmCPackDebGenerator::createDeb()
@@ -282,11 +258,11 @@ int cmCPackDebGenerator::createDeb()
   // debian-binary file
   const std::string strGenWDIR(this->GetOption("GEN_WDIR"));
   const std::string dbfilename = strGenWDIR + "/debian-binary";
-    { // the scope is needed for cmGeneratedFileStream
+  { // the scope is needed for cmGeneratedFileStream
     cmGeneratedFileStream out(dbfilename.c_str());
     out << "2.0";
     out << std::endl; // required for valid debian package
-    }
+  }
 
   // control file
   std::string ctlfilename = strGenWDIR + "/control";
@@ -294,194 +270,171 @@ int cmCPackDebGenerator::createDeb()
   // debian policy enforce lower case for package name
   // mandatory entries:
   std::string debian_pkg_name = cmsys::SystemTools::LowerCase(
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME") );
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_NAME"));
   const char* debian_pkg_version =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_VERSION");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_VERSION");
   const char* debian_pkg_section =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SECTION");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SECTION");
   const char* debian_pkg_priority =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PRIORITY");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PRIORITY");
   const char* debian_pkg_arch =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ARCHITECTURE");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ARCHITECTURE");
   const char* maintainer =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER");
-  const char* desc =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_MAINTAINER");
+  const char* desc = this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DESCRIPTION");
 
   // optional entries
   const char* debian_pkg_dep =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DEPENDS");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_DEPENDS");
   const char* debian_pkg_rec =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_RECOMMENDS");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_RECOMMENDS");
   const char* debian_pkg_sug =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SUGGESTS");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SUGGESTS");
   const char* debian_pkg_url =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_HOMEPAGE");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_HOMEPAGE");
   const char* debian_pkg_predep =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PREDEPENDS");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PREDEPENDS");
   const char* debian_pkg_enhances =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ENHANCES");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_ENHANCES");
   const char* debian_pkg_breaks =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_BREAKS");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_BREAKS");
   const char* debian_pkg_conflicts =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONFLICTS");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONFLICTS");
   const char* debian_pkg_provides =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PROVIDES");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_PROVIDES");
   const char* debian_pkg_replaces =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_REPLACES");
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_REPLACES");
   const char* debian_pkg_source =
-      this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
-
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SOURCE");
 
-    { // the scope is needed for cmGeneratedFileStream
+  { // the scope is needed for cmGeneratedFileStream
     cmGeneratedFileStream out(ctlfilename.c_str());
     out << "Package: " << debian_pkg_name << "\n";
     out << "Version: " << debian_pkg_version << "\n";
     out << "Section: " << debian_pkg_section << "\n";
     out << "Priority: " << debian_pkg_priority << "\n";
     out << "Architecture: " << debian_pkg_arch << "\n";
-    if(debian_pkg_source && *debian_pkg_source)
-      {
+    if (debian_pkg_source && *debian_pkg_source) {
       out << "Source: " << debian_pkg_source << "\n";
-      }
-    if(debian_pkg_dep && *debian_pkg_dep)
-      {
+    }
+    if (debian_pkg_dep && *debian_pkg_dep) {
       out << "Depends: " << debian_pkg_dep << "\n";
-      }
-    if(debian_pkg_rec && *debian_pkg_rec)
-      {
+    }
+    if (debian_pkg_rec && *debian_pkg_rec) {
       out << "Recommends: " << debian_pkg_rec << "\n";
-      }
-    if(debian_pkg_sug && *debian_pkg_sug)
-      {
+    }
+    if (debian_pkg_sug && *debian_pkg_sug) {
       out << "Suggests: " << debian_pkg_sug << "\n";
-      }
-    if(debian_pkg_url && *debian_pkg_url)
-      {
+    }
+    if (debian_pkg_url && *debian_pkg_url) {
       out << "Homepage: " << debian_pkg_url << "\n";
-      }
-    if (debian_pkg_predep && *debian_pkg_predep)
-      {
+    }
+    if (debian_pkg_predep && *debian_pkg_predep) {
       out << "Pre-Depends: " << debian_pkg_predep << "\n";
-      }
-    if (debian_pkg_enhances && *debian_pkg_enhances)
-      {
+    }
+    if (debian_pkg_enhances && *debian_pkg_enhances) {
       out << "Enhances: " << debian_pkg_enhances << "\n";
-      }
-    if (debian_pkg_breaks && *debian_pkg_breaks)
-      {
+    }
+    if (debian_pkg_breaks && *debian_pkg_breaks) {
       out << "Breaks: " << debian_pkg_breaks << "\n";
-      }
-    if (debian_pkg_conflicts && *debian_pkg_conflicts)
-      {
+    }
+    if (debian_pkg_conflicts && *debian_pkg_conflicts) {
       out << "Conflicts: " << debian_pkg_conflicts << "\n";
-      }
-    if (debian_pkg_provides && *debian_pkg_provides)
-      {
+    }
+    if (debian_pkg_provides && *debian_pkg_provides) {
       out << "Provides: " << debian_pkg_provides << "\n";
-      }
-    if (debian_pkg_replaces && *debian_pkg_replaces)
-      {
+    }
+    if (debian_pkg_replaces && *debian_pkg_replaces) {
       out << "Replaces: " << debian_pkg_replaces << "\n";
-      }
+    }
     unsigned long totalSize = 0;
     {
       std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
       dirName += '/';
       for (std::vector<std::string>::const_iterator fileIt =
-           packageFiles.begin();
-           fileIt != packageFiles.end(); ++ fileIt )
-        {
+             packageFiles.begin();
+           fileIt != packageFiles.end(); ++fileIt) {
         totalSize += cmSystemTools::FileLength(*fileIt);
-        }
+      }
     }
     out << "Installed-Size: " << (totalSize + 1023) / 1024 << "\n";
     out << "Maintainer: " << maintainer << "\n";
     out << "Description: " << desc << "\n";
     out << std::endl;
-    }
+  }
 
   const std::string shlibsfilename = strGenWDIR + "/shlibs";
 
-  const char* debian_pkg_shlibs = this->GetOption(
-      "GEN_CPACK_DEBIAN_PACKAGE_SHLIBS");
-  const bool gen_shibs = this->IsOn("CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS")
-      && debian_pkg_shlibs && *debian_pkg_shlibs;
-  if( gen_shibs )
-    {
+  const char* debian_pkg_shlibs =
+    this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_SHLIBS");
+  const bool gen_shibs = this->IsOn("CPACK_DEBIAN_PACKAGE_GENERATE_SHLIBS") &&
+    debian_pkg_shlibs && *debian_pkg_shlibs;
+  if (gen_shibs) {
     cmGeneratedFileStream out(shlibsfilename.c_str());
     out << debian_pkg_shlibs;
     out << std::endl;
-    }
+  }
 
   const std::string postinst = strGenWDIR + "/postinst";
   const std::string postrm = strGenWDIR + "/postrm";
-  if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST"))
-    {
+  if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
     cmGeneratedFileStream out(postinst.c_str());
-     out <<
-       "#!/bin/sh\n\n"
-       "set -e\n\n"
-       "if [ \"$1\" = \"configure\" ]; then\n"
-       "\tldconfig\n"
-       "fi\n";
-    }
-  if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM"))
-    {
+    out << "#!/bin/sh\n\n"
+           "set -e\n\n"
+           "if [ \"$1\" = \"configure\" ]; then\n"
+           "\tldconfig\n"
+           "fi\n";
+  }
+  if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
     cmGeneratedFileStream out(postrm.c_str());
-    out <<
-      "#!/bin/sh\n\n"
-      "set -e\n\n"
-      "if [ \"$1\" = \"remove\" ]; then\n"
-      "\tldconfig\n"
-      "fi\n";
-    }
+    out << "#!/bin/sh\n\n"
+           "set -e\n\n"
+           "if [ \"$1\" = \"remove\" ]; then\n"
+           "\tldconfig\n"
+           "fi\n";
+  }
 
   cmArchiveWrite::Compress tar_compression_type = cmArchiveWrite::CompressGZip;
   const char* debian_compression_type =
-      this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE");
-  if(!debian_compression_type)
-    {
+    this->GetOption("GEN_CPACK_DEBIAN_COMPRESSION_TYPE");
+  if (!debian_compression_type) {
     debian_compression_type = "gzip";
-    }
+  }
 
   std::string compression_suffix;
-  if(!strcmp(debian_compression_type, "lzma")) {
-      compression_suffix = ".lzma";
-      tar_compression_type = cmArchiveWrite::CompressLZMA;
-  } else if(!strcmp(debian_compression_type, "xz")) {
-      compression_suffix = ".xz";
-      tar_compression_type = cmArchiveWrite::CompressXZ;
-  } else if(!strcmp(debian_compression_type, "bzip2")) {
-      compression_suffix = ".bz2";
-      tar_compression_type = cmArchiveWrite::CompressBZip2;
-  } else if(!strcmp(debian_compression_type, "gzip")) {
-      compression_suffix = ".gz";
-      tar_compression_type = cmArchiveWrite::CompressGZip;
-  } else if(!strcmp(debian_compression_type, "none")) {
-      compression_suffix = "";
-      tar_compression_type = cmArchiveWrite::CompressNone;
+  if (!strcmp(debian_compression_type, "lzma")) {
+    compression_suffix = ".lzma";
+    tar_compression_type = cmArchiveWrite::CompressLZMA;
+  } else if (!strcmp(debian_compression_type, "xz")) {
+    compression_suffix = ".xz";
+    tar_compression_type = cmArchiveWrite::CompressXZ;
+  } else if (!strcmp(debian_compression_type, "bzip2")) {
+    compression_suffix = ".bz2";
+    tar_compression_type = cmArchiveWrite::CompressBZip2;
+  } else if (!strcmp(debian_compression_type, "gzip")) {
+    compression_suffix = ".gz";
+    tar_compression_type = cmArchiveWrite::CompressGZip;
+  } else if (!strcmp(debian_compression_type, "none")) {
+    compression_suffix = "";
+    tar_compression_type = cmArchiveWrite::CompressNone;
   } else {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-                    "Error unrecognized compression type: "
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error unrecognized compression type: "
                     << debian_compression_type << std::endl);
   }
 
-
-  std::string filename_data_tar = strGenWDIR
-      + "/data.tar" + compression_suffix;
+  std::string filename_data_tar =
+    strGenWDIR + "/data.tar" + compression_suffix;
 
   // atomic file generation for data.tar
   {
     cmGeneratedFileStream fileStream_data_tar;
     fileStream_data_tar.Open(filename_data_tar.c_str(), false, true);
-    if(!fileStream_data_tar)
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Error opening the file \"" << filename_data_tar << "\" for writing"
-          << std::endl);
+    if (!fileStream_data_tar) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error opening the file \""
+                      << filename_data_tar << "\" for writing" << std::endl);
       return 0;
-      }
+    }
     cmArchiveWrite data_tar(fileStream_data_tar, tar_compression_type, "paxr");
 
     // uid/gid should be the one of the root user, and this root user has
@@ -495,81 +448,69 @@ int cmCPackDebGenerator::createDeb()
     // give /usr and /opt
     size_t topLevelLength = strGenWDIR.length();
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "WDIR: \""
-            << strGenWDIR
-            << "\", length = " << topLevelLength
-            << std::endl);
+                    << strGenWDIR << "\", length = " << topLevelLength
+                    << std::endl);
     std::set<std::string> orderedFiles;
 
     // we have to reconstruct the parent folders as well
 
     for (std::vector<std::string>::const_iterator fileIt =
-         packageFiles.begin();
-         fileIt != packageFiles.end(); ++ fileIt )
-      {
+           packageFiles.begin();
+         fileIt != packageFiles.end(); ++fileIt) {
       std::string currentPath = *fileIt;
-      while(currentPath != strGenWDIR)
-        {
+      while (currentPath != strGenWDIR) {
         // the last one IS strGenWDIR, but we do not want this one:
         // XXX/application/usr/bin/myprogram with GEN_WDIR=XXX/application
         // should not add XXX/application
         orderedFiles.insert(currentPath);
         currentPath = cmSystemTools::CollapseCombinedPath(currentPath, "..");
-        }
       }
+    }
 
-
-    for (std::set<std::string>::const_iterator fileIt =
-         orderedFiles.begin();
-         fileIt != orderedFiles.end(); ++ fileIt )
-      {
+    for (std::set<std::string>::const_iterator fileIt = orderedFiles.begin();
+         fileIt != orderedFiles.end(); ++fileIt) {
       cmCPackLogger(cmCPackLog::LOG_DEBUG, "FILEIT: \"" << *fileIt << "\""
-                    << std::endl);
-      std::string::size_type slashPos = fileIt->find('/', topLevelLength+1);
-      std::string relativeDir = fileIt->substr(topLevelLength,
-                                               slashPos - topLevelLength);
-      cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \"" << relativeDir
-                    << "\"" << std::endl);
+                                                        << std::endl);
+      std::string::size_type slashPos = fileIt->find('/', topLevelLength + 1);
+      std::string relativeDir =
+        fileIt->substr(topLevelLength, slashPos - topLevelLength);
+      cmCPackLogger(cmCPackLog::LOG_DEBUG, "RELATIVEDIR: \""
+                      << relativeDir << "\"" << std::endl);
 
       // do not recurse because the loop will do it
-      if(!data_tar.Add(*fileIt, topLevelLength, ".", false))
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-                      "Problem adding file to tar:" << std::endl
-                      << "#top level directory: "
-                      << strGenWDIR << std::endl
-                      << "#file: " << *fileIt << std::endl
-                      << "#error:" << data_tar.GetError() << std::endl);
+      if (!data_tar.Add(*fileIt, topLevelLength, ".", false)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: " << *fileIt << std::endl
+                        << "#error:" << data_tar.GetError() << std::endl);
         return 0;
-        }
       }
+    }
   } // scope for file generation
 
-
   std::string md5filename = strGenWDIR + "/md5sums";
   {
     // the scope is needed for cmGeneratedFileStream
     cmGeneratedFileStream out(md5filename.c_str());
 
     std::string topLevelWithTrailingSlash =
-        this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+      this->GetOption("CPACK_TEMPORARY_DIRECTORY");
     topLevelWithTrailingSlash += '/';
     for (std::vector<std::string>::const_iterator fileIt =
            packageFiles.begin();
-         fileIt != packageFiles.end(); ++ fileIt )
-      {
+         fileIt != packageFiles.end(); ++fileIt) {
       // hash only regular files
-      if(   cmSystemTools::FileIsDirectory(*fileIt)
-         || cmSystemTools::FileIsSymlink(*fileIt))
-        {
+      if (cmSystemTools::FileIsDirectory(*fileIt) ||
+          cmSystemTools::FileIsSymlink(*fileIt)) {
         continue;
-        }
+      }
 
       char md5sum[33];
-      if(!cmSystemTools::ComputeFileMD5(*fileIt, md5sum))
-        {
+      if (!cmSystemTools::ComputeFileMD5(*fileIt, md5sum)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem computing the md5 of "
-                      << *fileIt << std::endl);
-        }
+                        << *fileIt << std::endl);
+      }
 
       md5sum[32] = 0;
 
@@ -578,31 +519,27 @@ int cmCPackDebGenerator::createDeb()
       // debian md5sums entries are like this:
       // 014f3604694729f3bf19263bac599765  usr/bin/ccmake
       // thus strip the full path (with the trailing slash)
-      cmSystemTools::ReplaceString(output,
-                                   topLevelWithTrailingSlash.c_str(), "");
+      cmSystemTools::ReplaceString(output, topLevelWithTrailingSlash.c_str(),
+                                   "");
       out << output;
-      }
+    }
     // each line contains a eol.
     // Do not end the md5sum file with yet another (invalid)
   }
 
-
-
   std::string filename_control_tar = strGenWDIR + "/control.tar.gz";
   // atomic file generation for control.tar
   {
     cmGeneratedFileStream fileStream_control_tar;
     fileStream_control_tar.Open(filename_control_tar.c_str(), false, true);
-    if(!fileStream_control_tar)
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Error opening the file \"" << filename_control_tar
-          << "\" for writing" << std::endl);
+    if (!fileStream_control_tar) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error opening the file \""
+                      << filename_control_tar << "\" for writing"
+                      << std::endl);
       return 0;
-      }
+    }
     cmArchiveWrite control_tar(fileStream_control_tar,
-                               cmArchiveWrite::CompressGZip,
-                               "paxr");
+                               cmArchiveWrite::CompressGZip, "paxr");
 
     // sets permissions and uid/gid for the files
     control_tar.SetUIDAndGID(0u, 0u);
@@ -623,113 +560,96 @@ int cmCPackDebGenerator::createDeb()
     control_tar.SetPermissions(permission644);
 
     // adds control and md5sums
-    if(   !control_tar.Add(md5filename, strGenWDIR.length(), ".")
-       || !control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), "."))
-      {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-            "Error adding file to tar:" << std::endl
-            << "#top level directory: "
-               << strGenWDIR << std::endl
-            << "#file: \"control\" or \"md5sums\"" << std::endl
-            << "#error:" << control_tar.GetError() << std::endl);
-        return 0;
-      }
+    if (!control_tar.Add(md5filename, strGenWDIR.length(), ".") ||
+        !control_tar.Add(strGenWDIR + "/control", strGenWDIR.length(), ".")) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                      << std::endl
+                      << "#top level directory: " << strGenWDIR << std::endl
+                      << "#file: \"control\" or \"md5sums\"" << std::endl
+                      << "#error:" << control_tar.GetError() << std::endl);
+      return 0;
+    }
 
     // adds generated shlibs file
-    if( gen_shibs )
-      {
-      if( !control_tar.Add(shlibsfilename, strGenWDIR.length(), ".") )
-        {
-          cmCPackLogger(cmCPackLog::LOG_ERROR,
-              "Error adding file to tar:" << std::endl
-              << "#top level directory: "
-                 << strGenWDIR << std::endl
-              << "#file: \"shlibs\"" << std::endl
-              << "#error:" << control_tar.GetError() << std::endl);
-          return 0;
-        }
+    if (gen_shibs) {
+      if (!control_tar.Add(shlibsfilename, strGenWDIR.length(), ".")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: \"shlibs\"" << std::endl
+                        << "#error:" << control_tar.GetError() << std::endl);
+        return 0;
       }
+    }
 
     // adds LDCONFIG related files
-    if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST"))
-      {
+    if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTINST")) {
       control_tar.SetPermissions(permission755);
-      if(!control_tar.Add(postinst, strGenWDIR.length(), "."))
-        {
-          cmCPackLogger(cmCPackLog::LOG_ERROR,
-              "Error adding file to tar:" << std::endl
-              << "#top level directory: "
-                 << strGenWDIR << std::endl
-              << "#file: \"postinst\"" << std::endl
-              << "#error:" << control_tar.GetError() << std::endl);
-          return 0;
-        }
-      control_tar.SetPermissions(permission644);
+      if (!control_tar.Add(postinst, strGenWDIR.length(), ".")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: \"postinst\"" << std::endl
+                        << "#error:" << control_tar.GetError() << std::endl);
+        return 0;
       }
+      control_tar.SetPermissions(permission644);
+    }
 
-    if(this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM"))
-      {
+    if (this->IsOn("GEN_CPACK_DEBIAN_GENERATE_POSTRM")) {
       control_tar.SetPermissions(permission755);
-      if(!control_tar.Add(postrm, strGenWDIR.length(), "."))
-        {
-          cmCPackLogger(cmCPackLog::LOG_ERROR,
-              "Error adding file to tar:" << std::endl
-              << "#top level directory: "
-                 << strGenWDIR << std::endl
-              << "#file: \"postinst\"" << std::endl
-              << "#error:" << control_tar.GetError() << std::endl);
-          return 0;
-        }
-      control_tar.SetPermissions(permission644);
+      if (!control_tar.Add(postrm, strGenWDIR.length(), ".")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding file to tar:"
+                        << std::endl
+                        << "#top level directory: " << strGenWDIR << std::endl
+                        << "#file: \"postinst\"" << std::endl
+                        << "#error:" << control_tar.GetError() << std::endl);
+        return 0;
       }
+      control_tar.SetPermissions(permission644);
+    }
 
     // for the other files, we use
     // -either the original permission on the files
     // -either a permission strictly defined by the Debian policies
     const char* controlExtra =
       this->GetOption("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA");
-    if( controlExtra )
-      {
+    if (controlExtra) {
       // permissions are now controlled by the original file permissions
 
       const bool permissionStrictPolicy =
         this->IsSet("GEN_CPACK_DEBIAN_PACKAGE_CONTROL_STRICT_PERMISSION");
 
-      static const char* strictFiles[] = {
-        "config", "postinst", "postrm", "preinst", "prerm"
-        };
+      static const char* strictFiles[] = { "config", "postinst", "postrm",
+                                           "preinst", "prerm" };
       std::set<std::string> setStrictFiles(
         strictFiles,
-        strictFiles + sizeof(strictFiles)/sizeof(strictFiles[0]));
+        strictFiles + sizeof(strictFiles) / sizeof(strictFiles[0]));
 
       // default
       control_tar.ClearPermissions();
 
       std::vector<std::string> controlExtraList;
       cmSystemTools::ExpandListArgument(controlExtra, controlExtraList);
-      for(std::vector<std::string>::iterator i = controlExtraList.begin();
-          i != controlExtraList.end(); ++i)
-        {
-        std::string filenamename =
-          cmsys::SystemTools::GetFilenameName(*i);
+      for (std::vector<std::string>::iterator i = controlExtraList.begin();
+           i != controlExtraList.end(); ++i) {
+        std::string filenamename = cmsys::SystemTools::GetFilenameName(*i);
         std::string localcopy = strGenWDIR + "/" + filenamename;
 
-        if(permissionStrictPolicy)
-          {
-          control_tar.SetPermissions(setStrictFiles.count(filenamename) ?
-            permission755 : permission644);
-          }
+        if (permissionStrictPolicy) {
+          control_tar.SetPermissions(setStrictFiles.count(filenamename)
+                                       ? permission755
+                                       : permission644);
+        }
 
         // if we can copy the file, it means it does exist, let's add it:
-        if( cmsys::SystemTools::CopyFileIfDifferent(*i, localcopy) )
-          {
+        if (cmsys::SystemTools::CopyFileIfDifferent(*i, localcopy)) {
           control_tar.Add(localcopy, strGenWDIR.length(), ".");
-          }
         }
       }
+    }
   }
 
-
   // ar -r your-package-name.deb debian-binary control.tar.* data.tar.*
   // since debian packages require BSD ar (most Linux distros and even
   // FreeBSD and NetBSD ship GNU ar) we use a copy of OpenBSD ar here.
@@ -742,33 +662,29 @@ int cmCPackDebGenerator::createDeb()
   outputFileName += "/";
   outputFileName += this->GetOption("GEN_CPACK_OUTPUT_FILE_NAME");
   int res = ar_append(outputFileName.c_str(), arFiles);
-  if ( res!=0 )
-    {
-    std::string tmpFile = this->GetOption(
-        "GEN_CPACK_TEMPORARY_PACKAGE_FILE_NAME");
+  if (res != 0) {
+    std::string tmpFile =
+      this->GetOption("GEN_CPACK_TEMPORARY_PACKAGE_FILE_NAME");
     tmpFile += "/Deb.log";
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Problem creating archive using: " << res << std::endl;
     return 0;
-    }
+  }
   return 1;
 }
 
 bool cmCPackDebGenerator::SupportsComponentInstallation() const
-  {
-  if (IsOn("CPACK_DEB_COMPONENT_INSTALL"))
-    {
-      return true;
-    }
-  else
-    {
-      return false;
-    }
+{
+  if (IsOn("CPACK_DEB_COMPONENT_INSTALL")) {
+    return true;
+  } else {
+    return false;
   }
+}
 
 std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
-    const std::string& componentName)
-  {
+  const std::string& componentName)
+{
   if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
     return componentName;
   }
@@ -778,18 +694,14 @@ std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
   }
   // We have to find the name of the COMPONENT GROUP
   // the current COMPONENT belongs to.
-  std::string groupVar = "CPACK_COMPONENT_" +
-        cmSystemTools::UpperCase(componentName) + "_GROUP";
-    if (NULL != GetOption(groupVar))
-      {
-      return std::string(GetOption(groupVar));
-      }
-    else
-      {
-      return componentName;
-      }
+  std::string groupVar =
+    "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
+  if (NULL != GetOption(groupVar)) {
+    return std::string(GetOption(groupVar));
+  } else {
+    return componentName;
   }
-
+}
 
 // The following code is taken from OpenBSD ar:
 // http://www.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ar/
@@ -840,58 +752,61 @@ std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix(
 #include <stdlib.h>
 #include <string.h>
 
-#define ARMAG           "!<arch>\n"        /* ar "magic number" */
-#define SARMAG          8                  /* strlen(ARMAG); */
+#define ARMAG "!<arch>\n" /* ar "magic number" */
+#define SARMAG 8          /* strlen(ARMAG); */
 
-#define AR_EFMT1        "#1/"              /* extended format #1 */
-#define ARFMAG          "`\n"
+#define AR_EFMT1 "#1/" /* extended format #1 */
+#define ARFMAG "`\n"
 
 /* Header format strings. */
-#define HDR1            "%s%-13d%-12ld%-6u%-6u%-8o%-10lld%2s"
-#define HDR2             "%-16.16s%-12ld%-6u%-6u%-8o%-10lld%2s"
-
-struct ar_hdr {
-  char ar_name[16];                        /* name */
-  char ar_date[12];                        /* modification time */
-  char ar_uid[6];                          /* user id */
-  char ar_gid[6];                          /* group id */
-  char ar_mode[8];                         /* octal file permissions */
-  char ar_size[10];                        /* size in bytes */
-  char ar_fmag[2];                         /* consistency check */
+#define HDR1 "%s%-13d%-12ld%-6u%-6u%-8o%-10lld%2s"
+#define HDR2 "%-16.16s%-12ld%-6u%-6u%-8o%-10lld%2s"
+
+struct ar_hdr
+{
+  char ar_name[16]; /* name */
+  char ar_date[12]; /* modification time */
+  char ar_uid[6];   /* user id */
+  char ar_gid[6];   /* group id */
+  char ar_mode[8];  /* octal file permissions */
+  char ar_size[10]; /* size in bytes */
+  char ar_fmag[2];  /* consistency check */
 };
 
 /* Set up file copy. */
-#define SETCF(from, fromname, to, toname, pad) { \
-        cf.rFile = from; \
-        cf.rname = fromname; \
-        cf.wFile = to; \
-        cf.wname = toname; \
-        cf.flags = pad; \
-}
+#define SETCF(from, fromname, to, toname, pad)                                \
+  {                                                                           \
+    cf.rFile = from;                                                          \
+    cf.rname = fromname;                                                      \
+    cf.wFile = to;                                                            \
+    cf.wname = toname;                                                        \
+    cf.flags = pad;                                                           \
+  }
 
 /* File copy structure. */
-typedef struct {
-        FILE* rFile;                       /* read file descriptor */
-        const char *rname;                 /* read name */
-        FILE* wFile;                       /* write file descriptor */
-        const char *wname;                 /* write name */
-#define NOPAD        0x00                  /* don't pad */
-#define WPAD        0x02                   /* pad on writes */
-        unsigned int flags;                       /* pad flags */
+typedef struct
+{
+  FILE* rFile;        /* read file descriptor */
+  const char* rname;  /* read name */
+  FILE* wFile;        /* write file descriptor */
+  const char* wname;  /* write name */
+#define NOPAD 0x00    /* don't pad */
+#define WPAD 0x02     /* pad on writes */
+  unsigned int flags; /* pad flags */
 } CF;
 
 /* misc.c */
 
-static const char * ar_rname(const char *path)
+static const char* ar_rname(const char* path)
 {
-  const char *ind = strrchr(path, '/');
-  return (ind ) ? ind + 1 : path;
+  const char* ind = strrchr(path, '/');
+  return (ind) ? ind + 1 : path;
 }
 
 /* archive.c */
 
 typedef struct ar_hdr HDR;
-static char ar_hb[sizeof(HDR) + 1];        /* real header */
+static char ar_hb[sizeof(HDR) + 1]; /* real header */
 
 static size_t ar_already_written;
 
@@ -908,12 +823,12 @@ static size_t ar_already_written;
  *      because 16-bit word addressed copies were faster?)  Anyhow, it should
  *      have been ripped out long ago.
  */
-static int copy_ar(CF *cfp, off_t size)
+static int copy_ar(CF* cfp, off_t size)
 {
   static char pad = '\n';
   off_t sz = size;
   size_t nr, nw;
-  char buf[8*1024];
+  char buf[8 * 1024];
 
   if (sz == 0)
     return 0;
@@ -921,60 +836,59 @@ static int copy_ar(CF *cfp, off_t size)
   FILE* from = cfp->rFile;
   FILE* to = cfp->wFile;
   while (sz &&
-        (nr = fread(buf, 1, sz < static_cast<off_t>(sizeof(buf))
-                    ? static_cast<size_t>(sz) : sizeof(buf), from ))
-               > 0) {
+         (nr = fread(buf, 1, sz < static_cast<off_t>(sizeof(buf))
+                       ? static_cast<size_t>(sz)
+                       : sizeof(buf),
+                     from)) > 0) {
     sz -= nr;
     for (size_t off = 0; off < nr; nr -= off, off += nw)
       if ((nw = fwrite(buf + off, 1, nr, to)) < nr)
         return -1;
-    }
+  }
   if (sz)
     return -2;
 
-  if (cfp->flags & WPAD && (size + ar_already_written) & 1
-      && fwrite(&pad, 1, 1, to) != 1)
+  if (cfp->flags & WPAD && (size + ar_already_written) & 1 &&
+      fwrite(&pad, 1, 1, to) != 1)
     return -4;
 
   return 0;
 }
 
 /* put_arobj --  Write an archive member to a file. */
-static int put_arobj(CF *cfp, struct stat *sb)
+static int put_arobj(CF* cfp, struct stat* sb)
 {
   int result = 0;
-  struct ar_hdr *hdr;
+  struct ar_hdr* hdr;
 
- /* If passed an sb structure, reading a file from disk.  Get stat(2)
-  * information, build a name and construct a header.  (Files are named
-  * by their last component in the archive.) */
+  /* If passed an sb structure, reading a file from disk.  Get stat(2)
+   * information, build a name and construct a header.  (Files are named
+   * by their last component in the archive.) */
   const char* name = ar_rname(cfp->rname);
   (void)stat(cfp->rname, sb);
 
- /* If not truncating names and the name is too long or contains
-  * a space, use extended format 1.   */
+  /* If not truncating names and the name is too long or contains
+   * a space, use extended format 1.   */
   size_t lname = strlen(name);
   uid_t uid = sb->st_uid;
   gid_t gid = sb->st_gid;
   if (uid > USHRT_MAX) {
     uid = USHRT_MAX;
-    }
+  }
   if (gid > USHRT_MAX) {
     gid = USHRT_MAX;
-    }
+  }
   if (lname > sizeof(hdr->ar_name) || strchr(name, ' '))
-    (void)sprintf(ar_hb, HDR1, AR_EFMT1, (int)lname,
-                  (long int)sb->st_mtime, (unsigned)uid, (unsigned)gid,
-                  (unsigned)sb->st_mode, (long long)sb->st_size + lname,
+    (void)sprintf(ar_hb, HDR1, AR_EFMT1, (int)lname, (long int)sb->st_mtime,
+                  (unsigned)uid, (unsigned)gid, (unsigned)sb->st_mode,
+                  (long long)sb->st_size + lname, ARFMAG);
+  else {
+    lname = 0;
+    (void)sprintf(ar_hb, HDR2, name, (long int)sb->st_mtime, (unsigned)uid,
+                  (unsigned)gid, (unsigned)sb->st_mode, (long long)sb->st_size,
                   ARFMAG);
-    else {
-      lname = 0;
-      (void)sprintf(ar_hb, HDR2, name,
-                    (long int)sb->st_mtime, (unsigned)uid, (unsigned)gid,
-                    (unsigned)sb->st_mode, (long long)sb->st_size,
-                    ARFMAG);
-      }
-    off_t size = sb->st_size;
+  }
+  off_t size = sb->st_size;
 
   if (fwrite(ar_hb, 1, sizeof(HDR), cfp->wFile) != sizeof(HDR))
     return -1;
@@ -983,7 +897,7 @@ static int put_arobj(CF *cfp, struct stat *sb)
     if (fwrite(name, 1, lname, cfp->wFile) != lname)
       return -2;
     ar_already_written = lname;
-    }
+  }
   result = copy_ar(cfp, size);
   ar_already_written = 0;
   return result;
@@ -995,42 +909,41 @@ static int put_arobj(CF *cfp, struct stat *sb)
  *      Append files to the archive - modifies original archive or creates
  *      a new archive if named archive does not exist.
  */
-static int ar_append(const char* archive,const std::vector<std::string>& files)
+static int ar_append(const char* archive,
+                     const std::vector<std::string>& files)
 {
   int eval = 0;
   FILE* aFile = cmSystemTools::Fopen(archive, "wb+");
-  if (aFile!=NULL) {
+  if (aFile != NULL) {
     fwrite(ARMAG, SARMAG, 1, aFile);
     if (fseek(aFile, 0, SEEK_END) != -1) {
       CF cf;
       struct stat sb;
       /* Read from disk, write to an archive; pad on write. */
       SETCF(NULL, 0, aFile, archive, WPAD);
-      for(std::vector<std::string>::const_iterator fileIt = files.begin();
-          fileIt!=files.end(); ++fileIt) {
+      for (std::vector<std::string>::const_iterator fileIt = files.begin();
+           fileIt != files.end(); ++fileIt) {
         const char* filename = fileIt->c_str();
         FILE* file = cmSystemTools::Fopen(filename, "rb");
         if (file == NULL) {
           eval = -1;
           continue;
-          }
+        }
         cf.rFile = file;
         cf.rname = filename;
         int result = put_arobj(&cf, &sb);
         (void)fclose(file);
-        if (result!=0) {
+        if (result != 0) {
           eval = -2;
           break;
-          }
         }
       }
-      else {
-        eval = -3;
-      }
-    fclose(aFile);
+    } else {
+      eval = -3;
     }
-  else {
+    fclose(aFile);
+  } else {
     eval = -4;
-    }
+  }
   return eval;
 }
diff --git a/Source/CPack/cmCPackDebGenerator.h b/Source/CPack/cmCPackDebGenerator.h
index 439b7ea..f640ab4 100644
--- a/Source/CPack/cmCPackDebGenerator.h
+++ b/Source/CPack/cmCPackDebGenerator.h
@@ -31,18 +31,18 @@ public:
   virtual ~cmCPackDebGenerator();
 
   static bool CanGenerate()
-    {
+  {
 #ifdef __APPLE__
     // on MacOS enable CPackDeb iff dpkg is found
     std::vector<std::string> locations;
     locations.push_back("/sw/bin");        // Fink
     locations.push_back("/opt/local/bin"); // MacPorts
-    return cmSystemTools::FindProgram("dpkg",locations) != "" ? true : false;
+    return cmSystemTools::FindProgram("dpkg", locations) != "" ? true : false;
 #else
     // legacy behavior on other systems
     return true;
 #endif
-    }
+  }
 
 protected:
   virtual int InitializeInternal();
@@ -65,12 +65,11 @@ protected:
   virtual const char* GetOutputExtension() { return ".deb"; }
   virtual bool SupportsComponentInstallation() const;
   virtual std::string GetComponentInstallDirNameSuffix(
-      const std::string& componentName);
+    const std::string& componentName);
 
 private:
   int createDeb();
   std::vector<std::string> packageFiles;
-
 };
 
 #endif
diff --git a/Source/CPack/cmCPackDragNDropGenerator.cxx b/Source/CPack/cmCPackDragNDropGenerator.cxx
index ea90c67..e401657 100644
--- a/Source/CPack/cmCPackDragNDropGenerator.cxx
+++ b/Source/CPack/cmCPackDragNDropGenerator.cxx
@@ -31,35 +31,35 @@
 #endif
 
 static const char* SLAHeader =
-"data 'LPic' (5000) {\n"
-"    $\"0002 0011 0003 0001 0000 0000 0002 0000\"\n"
-"    $\"0008 0003 0000 0001 0004 0000 0004 0005\"\n"
-"    $\"0000 000E 0006 0001 0005 0007 0000 0007\"\n"
-"    $\"0008 0000 0047 0009 0000 0034 000A 0001\"\n"
-"    $\"0035 000B 0001 0020 000C 0000 0011 000D\"\n"
-"    $\"0000 005B 0004 0000 0033 000F 0001 000C\"\n"
-"    $\"0010 0000 000B 000E 0000\"\n"
-"};\n"
-"\n";
+  "data 'LPic' (5000) {\n"
+  "    $\"0002 0011 0003 0001 0000 0000 0002 0000\"\n"
+  "    $\"0008 0003 0000 0001 0004 0000 0004 0005\"\n"
+  "    $\"0000 000E 0006 0001 0005 0007 0000 0007\"\n"
+  "    $\"0008 0000 0047 0009 0000 0034 000A 0001\"\n"
+  "    $\"0035 000B 0001 0020 000C 0000 0011 000D\"\n"
+  "    $\"0000 005B 0004 0000 0033 000F 0001 000C\"\n"
+  "    $\"0010 0000 000B 000E 0000\"\n"
+  "};\n"
+  "\n";
 
 static const char* SLASTREnglish =
-"resource 'STR#' (5002, \"English\") {\n"
-"    {\n"
-"        \"English\",\n"
-"        \"Agree\",\n"
-"        \"Disagree\",\n"
-"        \"Print\",\n"
-"        \"Save...\",\n"
-"        \"You agree to the License Agreement terms when you click \"\n"
-"        \"the \\\"Agree\\\" button.\",\n"
-"        \"Software License Agreement\",\n"
-"        \"This text cannot be saved.  This disk may be full or locked, "
-"or the \"\n"
-"        \"file may be locked.\",\n"
-"        \"Unable to print.  Make sure you have selected a printer.\"\n"
-"    }\n"
-"};\n"
-"\n";
+  "resource 'STR#' (5002, \"English\") {\n"
+  "    {\n"
+  "        \"English\",\n"
+  "        \"Agree\",\n"
+  "        \"Disagree\",\n"
+  "        \"Print\",\n"
+  "        \"Save...\",\n"
+  "        \"You agree to the License Agreement terms when you click \"\n"
+  "        \"the \\\"Agree\\\" button.\",\n"
+  "        \"Software License Agreement\",\n"
+  "        \"This text cannot be saved.  This disk may be full or locked, "
+  "or the \"\n"
+  "        \"file may be locked.\",\n"
+  "        \"Unable to print.  Make sure you have selected a printer.\"\n"
+  "    }\n"
+  "};\n"
+  "\n";
 
 cmCPackDragNDropGenerator::cmCPackDragNDropGenerator()
   : singleLicense(false)
@@ -80,102 +80,84 @@ int cmCPackDragNDropGenerator::InitializeInternal()
   paths.push_back("/Applications/Xcode.app/Contents/Developer/Tools");
   paths.push_back("/Developer/Tools");
 
-  const std::string hdiutil_path = cmSystemTools::FindProgram("hdiutil",
-    std::vector<std::string>(), false);
-  if(hdiutil_path.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot locate hdiutil command"
-      << std::endl);
+  const std::string hdiutil_path =
+    cmSystemTools::FindProgram("hdiutil", std::vector<std::string>(), false);
+  if (hdiutil_path.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate hdiutil command"
+                    << std::endl);
     return 0;
-    }
+  }
   this->SetOptionIfNotSet("CPACK_COMMAND_HDIUTIL", hdiutil_path.c_str());
 
-  const std::string setfile_path = cmSystemTools::FindProgram("SetFile",
-    paths, false);
-  if(setfile_path.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot locate SetFile command"
-      << std::endl);
+  const std::string setfile_path =
+    cmSystemTools::FindProgram("SetFile", paths, false);
+  if (setfile_path.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate SetFile command"
+                    << std::endl);
     return 0;
-    }
+  }
   this->SetOptionIfNotSet("CPACK_COMMAND_SETFILE", setfile_path.c_str());
 
-  const std::string rez_path = cmSystemTools::FindProgram("Rez",
-    paths, false);
-  if(rez_path.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot locate Rez command"
-      << std::endl);
+  const std::string rez_path = cmSystemTools::FindProgram("Rez", paths, false);
+  if (rez_path.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot locate Rez command"
+                    << std::endl);
     return 0;
-    }
+  }
   this->SetOptionIfNotSet("CPACK_COMMAND_REZ", rez_path.c_str());
 
-  if(this->IsSet("CPACK_DMG_SLA_DIR"))
-    {
+  if (this->IsSet("CPACK_DMG_SLA_DIR")) {
     slaDirectory = this->GetOption("CPACK_DMG_SLA_DIR");
-    if(!slaDirectory.empty() && this->IsSet("CPACK_RESOURCE_FILE_LICENSE"))
-      {
+    if (!slaDirectory.empty() && this->IsSet("CPACK_RESOURCE_FILE_LICENSE")) {
       std::string license_file =
         this->GetOption("CPACK_RESOURCE_FILE_LICENSE");
-      if(!license_file.empty() &&
-         (license_file.find("CPack.GenericLicense.txt") == std::string::npos))
-        {
-        cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+      if (!license_file.empty() &&
+          (license_file.find("CPack.GenericLicense.txt") ==
+           std::string::npos)) {
+        cmCPackLogger(
+          cmCPackLog::LOG_OUTPUT,
           "Both CPACK_DMG_SLA_DIR and CPACK_RESOURCE_FILE_LICENSE specified, "
           "using CPACK_RESOURCE_FILE_LICENSE as a license for all languages."
-          << std::endl);
+            << std::endl);
         singleLicense = true;
-        }
       }
-    if(!this->IsSet("CPACK_DMG_SLA_LANGUAGES"))
-      {
+    }
+    if (!this->IsSet("CPACK_DMG_SLA_LANGUAGES")) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "CPACK_DMG_SLA_DIR set but no languages defined "
-        "(set CPACK_DMG_SLA_LANGUAGES)"
-        << std::endl);
+                    "CPACK_DMG_SLA_DIR set but no languages defined "
+                    "(set CPACK_DMG_SLA_LANGUAGES)"
+                      << std::endl);
       return 0;
-      }
-    if(!cmSystemTools::FileExists(slaDirectory, false))
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "CPACK_DMG_SLA_DIR does not exist"
-        << std::endl);
+    }
+    if (!cmSystemTools::FileExists(slaDirectory, false)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "CPACK_DMG_SLA_DIR does not exist"
+                      << std::endl);
       return 0;
-      }
+    }
 
     std::vector<std::string> languages;
     cmSystemTools::ExpandListArgument(
       this->GetOption("CPACK_DMG_SLA_LANGUAGES"), languages);
-    if(languages.empty())
-      {
+    if (languages.empty()) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "CPACK_DMG_SLA_LANGUAGES set but empty"
-        << std::endl);
+                    "CPACK_DMG_SLA_LANGUAGES set but empty" << std::endl);
       return 0;
-      }
-    for(size_t i = 0; i < languages.size(); ++i)
-      {
+    }
+    for (size_t i = 0; i < languages.size(); ++i) {
       std::string license = slaDirectory + "/" + languages[i] + ".license.txt";
-      if (!singleLicense && !cmSystemTools::FileExists(license))
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Missing license file " << languages[i] << ".license.txt"
-          << std::endl);
+      if (!singleLicense && !cmSystemTools::FileExists(license)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing license file "
+                        << languages[i] << ".license.txt" << std::endl);
         return 0;
-        }
+      }
       std::string menu = slaDirectory + "/" + languages[i] + ".menu.txt";
-      if (!cmSystemTools::FileExists(menu))
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Missing menu file " << languages[i] << ".menu.txt"
-          << std::endl);
+      if (!cmSystemTools::FileExists(menu)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Missing menu file "
+                        << languages[i] << ".menu.txt" << std::endl);
         return 0;
-        }
       }
     }
+  }
 
   return this->Superclass::InitializeInternal();
 }
@@ -191,40 +173,32 @@ int cmCPackDragNDropGenerator::PackageFiles()
   // multiple directories occur if packaging components or groups separately
 
   // monolith
-  if(this->Components.empty())
-    {
+  if (this->Components.empty()) {
     return this->CreateDMG(toplevel, packageFileNames[0]);
-    }
+  }
 
   // component install
   std::vector<std::string> package_files;
 
   std::map<std::string, cmCPackComponent>::iterator compIt;
-  for (compIt=this->Components.begin();
-       compIt!=this->Components.end(); ++compIt )
-    {
+  for (compIt = this->Components.begin(); compIt != this->Components.end();
+       ++compIt) {
     std::string name = GetComponentInstallDirNameSuffix(compIt->first);
     package_files.push_back(name);
-    }
+  }
   std::sort(package_files.begin(), package_files.end());
-  package_files.erase(std::unique(package_files.begin(),
-                      package_files.end()),
+  package_files.erase(std::unique(package_files.begin(), package_files.end()),
                       package_files.end());
 
-
   // loop to create dmg files
   packageFileNames.clear();
-  for(size_t i=0; i<package_files.size(); i++)
-    {
+  for (size_t i = 0; i < package_files.size(); i++) {
     std::string full_package_name = std::string(toplevel) + std::string("/");
-    if(package_files[i] == "ALL_IN_ONE")
-      {
+    if (package_files[i] == "ALL_IN_ONE") {
       full_package_name += this->GetOption("CPACK_PACKAGE_FILE_NAME");
-      }
-    else
-      {
+    } else {
       full_package_name += package_files[i];
-      }
+    }
     full_package_name += std::string(GetOutputExtension());
     packageFileNames.push_back(full_package_name);
 
@@ -232,30 +206,23 @@ int cmCPackDragNDropGenerator::PackageFiles()
     src_dir += "/";
     src_dir += package_files[i];
 
-    if(0 == this->CreateDMG(src_dir, full_package_name))
-      {
+    if (0 == this->CreateDMG(src_dir, full_package_name)) {
       return 0;
-      }
     }
+  }
   return 1;
 }
 
 bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
-  std::ostringstream& target)
+                                         std::ostringstream& target)
 {
-  if(!cmSystemTools::CopyFileIfDifferent(
-    source.str().c_str(),
-    target.str().c_str()))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Error copying "
-      << source.str()
-      << " to "
-      << target.str()
-      << std::endl);
+  if (!cmSystemTools::CopyFileIfDifferent(source.str().c_str(),
+                                          target.str().c_str())) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error copying "
+                    << source.str() << " to " << target.str() << std::endl);
 
     return false;
-    }
+  }
 
   return true;
 }
@@ -263,46 +230,35 @@ bool cmCPackDragNDropGenerator::CopyFile(std::ostringstream& source,
 bool cmCPackDragNDropGenerator::CreateEmptyFile(std::ostringstream& target,
                                                 size_t size)
 {
-  cmsys::ofstream fout(target.str().c_str(),
-                       std::ios::out | std::ios::binary);
-  if(!fout)
-    {
+  cmsys::ofstream fout(target.str().c_str(), std::ios::out | std::ios::binary);
+  if (!fout) {
     return false;
-    }
-  else
-    {
+  } else {
     // Seek to desired size - 1 byte
     fout.seekp(size - 1, std::ios_base::beg);
     char byte = 0;
     // Write one byte to ensure file grows
     fout.write(&byte, 1);
-    }
+  }
 
   return true;
 }
 
 bool cmCPackDragNDropGenerator::RunCommand(std::ostringstream& command,
-  std::string* output)
+                                           std::string* output)
 {
   int exit_code = 1;
 
-  bool result = cmSystemTools::RunSingleCommand(
-    command.str().c_str(),
-    output, output,
-    &exit_code,
-    0,
-    this->GeneratorVerbose,
-    0);
+  bool result =
+    cmSystemTools::RunSingleCommand(command.str().c_str(), output, output,
+                                    &exit_code, 0, this->GeneratorVerbose, 0);
 
-  if(!result || exit_code)
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Error executing: "
-      << command.str()
-      << std::endl);
+  if (!result || exit_code) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error executing: " << command.str()
+                                                             << std::endl);
 
     return false;
-    }
+  }
 
   return true;
 }
@@ -312,51 +268,54 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
 {
   // Get optional arguments ...
   const std::string cpack_package_icon = this->GetOption("CPACK_PACKAGE_ICON")
-    ? this->GetOption("CPACK_PACKAGE_ICON") : "";
+    ? this->GetOption("CPACK_PACKAGE_ICON")
+    : "";
 
   const std::string cpack_dmg_volume_name =
     this->GetOption("CPACK_DMG_VOLUME_NAME")
     ? this->GetOption("CPACK_DMG_VOLUME_NAME")
-        : this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    : this->GetOption("CPACK_PACKAGE_FILE_NAME");
 
-  const std::string cpack_dmg_format =
-    this->GetOption("CPACK_DMG_FORMAT")
-    ? this->GetOption("CPACK_DMG_FORMAT") : "UDZO";
+  const std::string cpack_dmg_format = this->GetOption("CPACK_DMG_FORMAT")
+    ? this->GetOption("CPACK_DMG_FORMAT")
+    : "UDZO";
 
   // Get optional arguments ...
   std::string cpack_license_file =
-    this->GetOption("CPACK_RESOURCE_FILE_LICENSE") ?
-    this->GetOption("CPACK_RESOURCE_FILE_LICENSE") : "";
+    this->GetOption("CPACK_RESOURCE_FILE_LICENSE")
+    ? this->GetOption("CPACK_RESOURCE_FILE_LICENSE")
+    : "";
 
   const std::string cpack_dmg_background_image =
     this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
-    ? this->GetOption("CPACK_DMG_BACKGROUND_IMAGE") : "";
+    ? this->GetOption("CPACK_DMG_BACKGROUND_IMAGE")
+    : "";
 
-  const std::string cpack_dmg_ds_store =
-    this->GetOption("CPACK_DMG_DS_STORE")
-    ? this->GetOption("CPACK_DMG_DS_STORE") : "";
+  const std::string cpack_dmg_ds_store = this->GetOption("CPACK_DMG_DS_STORE")
+    ? this->GetOption("CPACK_DMG_DS_STORE")
+    : "";
 
   const std::string cpack_dmg_languages =
     this->GetOption("CPACK_DMG_SLA_LANGUAGES")
-      ? this->GetOption("CPACK_DMG_SLA_LANGUAGES") : "";
+    ? this->GetOption("CPACK_DMG_SLA_LANGUAGES")
+    : "";
 
   const std::string cpack_dmg_ds_store_setup_script =
     this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
-    ? this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT") : "";
+    ? this->GetOption("CPACK_DMG_DS_STORE_SETUP_SCRIPT")
+    : "";
 
   // only put license on dmg if is user provided
-  if(!cpack_license_file.empty() &&
-      cpack_license_file.find("CPack.GenericLicense.txt") != std::string::npos)
-    {
+  if (!cpack_license_file.empty() &&
+      cpack_license_file.find("CPack.GenericLicense.txt") !=
+        std::string::npos) {
     cpack_license_file = "";
-    }
+  }
 
   // use sla_dir if both sla_dir and license_file are set
-  if(!cpack_license_file.empty() &&
-     !slaDirectory.empty() && !singleLicense)
-    {
+  if (!cpack_license_file.empty() && !slaDirectory.empty() && !singleLicense) {
     cpack_license_file = "";
-    }
+  }
 
   // The staging directory contains everything that will end-up inside the
   // final disk image ...
@@ -368,56 +327,52 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
   std::ostringstream application_link;
   application_link << staging.str() << "/Applications";
   cmSystemTools::CreateSymlink("/Applications",
-    application_link.str().c_str());
+                               application_link.str().c_str());
 
   // Optionally add a custom volume icon ...
-  if(!cpack_package_icon.empty())
-    {
+  if (!cpack_package_icon.empty()) {
     std::ostringstream package_icon_source;
     package_icon_source << cpack_package_icon;
 
     std::ostringstream package_icon_destination;
     package_icon_destination << staging.str() << "/.VolumeIcon.icns";
 
-    if(!this->CopyFile(package_icon_source, package_icon_destination))
-      {
+    if (!this->CopyFile(package_icon_source, package_icon_destination)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error copying disk volume icon.  "
+                    "Error copying disk volume icon.  "
                     "Check the value of CPACK_PACKAGE_ICON."
-        << std::endl);
+                      << std::endl);
 
       return 0;
-      }
     }
+  }
 
   // Optionally add a custom .DS_Store file
   // (e.g. for setting background/layout) ...
-  if(!cpack_dmg_ds_store.empty())
-    {
+  if (!cpack_dmg_ds_store.empty()) {
     std::ostringstream package_settings_source;
     package_settings_source << cpack_dmg_ds_store;
 
     std::ostringstream package_settings_destination;
     package_settings_destination << staging.str() << "/.DS_Store";
 
-    if(!this->CopyFile(package_settings_source, package_settings_destination))
-      {
+    if (!this->CopyFile(package_settings_source,
+                        package_settings_destination)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error copying disk volume settings file.  "
+                    "Error copying disk volume settings file.  "
                     "Check the value of CPACK_DMG_DS_STORE."
-        << std::endl);
+                      << std::endl);
 
       return 0;
-      }
     }
+  }
 
   // Optionally add a custom background image ...
   // Make sure the background file type is the same as the custom image
   // and that the file is hidden so it doesn't show up.
-  if(!cpack_dmg_background_image.empty())
-    {
+  if (!cpack_dmg_background_image.empty()) {
     const std::string extension =
-        cmSystemTools::GetFilenameLastExtension(cpack_dmg_background_image);
+      cmSystemTools::GetFilenameLastExtension(cpack_dmg_background_image);
     std::ostringstream package_background_source;
     package_background_source << cpack_dmg_background_image;
 
@@ -425,36 +380,32 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     package_background_destination << staging.str()
                                    << "/.background/background" << extension;
 
-    if(!this->CopyFile(package_background_source,
-        package_background_destination))
-      {
+    if (!this->CopyFile(package_background_source,
+                        package_background_destination)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error copying disk volume background image.  "
+                    "Error copying disk volume background image.  "
                     "Check the value of CPACK_DMG_BACKGROUND_IMAGE."
-        << std::endl);
+                      << std::endl);
 
       return 0;
-      }
     }
+  }
 
-  bool remount_image = !cpack_package_icon.empty() ||
-                       !cpack_dmg_ds_store_setup_script.empty();
+  bool remount_image =
+    !cpack_package_icon.empty() || !cpack_dmg_ds_store_setup_script.empty();
 
   // Create 1 MB dummy padding file in staging area when we need to remount
   // image, so we have enough space for storing changes ...
-  if(remount_image)
-    {
+  if (remount_image) {
     std::ostringstream dummy_padding;
     dummy_padding << staging.str() << "/.dummy-padding-file";
-    if(!this->CreateEmptyFile(dummy_padding, 1048576))
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error creating dummy padding file."
-        << std::endl);
+    if (!this->CreateEmptyFile(dummy_padding, 1048576)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error creating dummy padding file."
+                      << std::endl);
 
       return 0;
-      }
     }
+  }
 
   // Create a temporary read-write disk image ...
   std::string temp_image = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@@ -465,22 +416,18 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
   temp_image_command << " create";
   temp_image_command << " -ov";
   temp_image_command << " -srcfolder \"" << staging.str() << "\"";
-  temp_image_command << " -volname \""
-    << cpack_dmg_volume_name << "\"";
+  temp_image_command << " -volname \"" << cpack_dmg_volume_name << "\"";
   temp_image_command << " -format UDRW";
   temp_image_command << " \"" << temp_image << "\"";
 
-  if(!this->RunCommand(temp_image_command))
-    {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error generating temporary disk image."
-        << std::endl);
+  if (!this->RunCommand(temp_image_command)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Error generating temporary disk image." << std::endl);
 
     return 0;
-    }
+  }
 
-  if(remount_image)
-    {
+  if (remount_image) {
     // Store that we have a failure so that we always unmount the image
     // before we exit.
     bool had_error = false;
@@ -491,14 +438,12 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     attach_command << " \"" << temp_image << "\"";
 
     std::string attach_output;
-    if(!this->RunCommand(attach_command, &attach_output))
-      {
+    if (!this->RunCommand(attach_command, &attach_output)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error attaching temporary disk image."
-        << std::endl);
+                    "Error attaching temporary disk image." << std::endl);
 
       return 0;
-      }
+    }
 
     cmsys::RegularExpression mountpoint_regex(".*(/Volumes/[^\n]+)\n.*");
     mountpoint_regex.find(attach_output.c_str());
@@ -508,95 +453,81 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     // Remove dummy padding file so we have enough space on RW image ...
     std::ostringstream dummy_padding;
     dummy_padding << temp_mount.str() << "/.dummy-padding-file";
-    if(!cmSystemTools::RemoveFile(dummy_padding.str()))
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error removing dummy padding file."
-        << std::endl);
+    if (!cmSystemTools::RemoveFile(dummy_padding.str())) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error removing dummy padding file."
+                      << std::endl);
 
       had_error = true;
-      }
+    }
 
     // Optionally set the custom icon flag for the image ...
-    if(!had_error && !cpack_package_icon.empty())
-      {
+    if (!had_error && !cpack_package_icon.empty()) {
       std::ostringstream setfile_command;
       setfile_command << this->GetOption("CPACK_COMMAND_SETFILE");
       setfile_command << " -a C";
       setfile_command << " \"" << temp_mount.str() << "\"";
 
-      if(!this->RunCommand(setfile_command))
-        {
+      if (!this->RunCommand(setfile_command)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Error assigning custom icon to temporary disk image."
-          << std::endl);
+                      "Error assigning custom icon to temporary disk image."
+                        << std::endl);
 
         had_error = true;
-        }
       }
+    }
 
     // Optionally we can execute a custom apple script to generate
     // the .DS_Store for the volume folder ...
-    if(!had_error && !cpack_dmg_ds_store_setup_script.empty())
-      {
+    if (!had_error && !cpack_dmg_ds_store_setup_script.empty()) {
       std::ostringstream setup_script_command;
       setup_script_command << "osascript"
                            << " \"" << cpack_dmg_ds_store_setup_script << "\""
                            << " \"" << cpack_dmg_volume_name << "\"";
       std::string error;
-      if(!this->RunCommand(setup_script_command, &error))
-        {
+      if (!this->RunCommand(setup_script_command, &error)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Error executing custom script on disk image." << std::endl
-          << error
-          << std::endl);
+                      "Error executing custom script on disk image."
+                        << std::endl
+                        << error << std::endl);
 
         had_error = true;
-        }
       }
+    }
 
     std::ostringstream detach_command;
     detach_command << this->GetOption("CPACK_COMMAND_HDIUTIL");
     detach_command << " detach";
     detach_command << " \"" << temp_mount.str() << "\"";
 
-    if(!this->RunCommand(detach_command))
-      {
+    if (!this->RunCommand(detach_command)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error detaching temporary disk image."
-        << std::endl);
+                    "Error detaching temporary disk image." << std::endl);
 
       return 0;
-      }
+    }
 
-    if(had_error)
-      {
+    if (had_error) {
       return 0;
-      }
     }
+  }
 
-  if(!cpack_license_file.empty() || !slaDirectory.empty())
-    {
+  if (!cpack_license_file.empty() || !slaDirectory.empty()) {
     // Use old hardcoded style if sla_dir is not set
     bool oldStyle = slaDirectory.empty();
     std::string sla_r = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
     sla_r += "/sla.r";
 
     std::vector<std::string> languages;
-    if(!oldStyle)
-      {
+    if (!oldStyle) {
       cmSystemTools::ExpandListArgument(cpack_dmg_languages, languages);
-      }
+    }
 
     cmGeneratedFileStream ofs(sla_r.c_str());
     ofs << "#include <CoreServices/CoreServices.r>\n\n";
-    if(oldStyle)
-      {
+    if (oldStyle) {
       ofs << SLAHeader;
       ofs << "\n";
-      }
-    else
-      {
+    } else {
       /*
        * LPic Layout
        * (https://github.com/pypt/dmg-add-license/blob/master/main.c)
@@ -619,111 +550,92 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
       std::vector<uint16_t> header_data;
       header_data.push_back(0);
       header_data.push_back(languages.size());
-      for(size_t i = 0; i < languages.size(); ++i)
-        {
+      for (size_t i = 0; i < languages.size(); ++i) {
         CFStringRef language_cfstring = CFStringCreateWithCString(
           NULL, languages[i].c_str(), kCFStringEncodingUTF8);
         CFStringRef iso_language =
           CFLocaleCreateCanonicalLanguageIdentifierFromString(
             NULL, language_cfstring);
-        if (!iso_language)
-          {
-          cmCPackLogger(cmCPackLog::LOG_ERROR,
-            languages[i] << " is not a recognized language"
-            << std::endl);
-          }
-        char *iso_language_cstr = (char *) malloc(65);
+        if (!iso_language) {
+          cmCPackLogger(cmCPackLog::LOG_ERROR, languages[i]
+                          << " is not a recognized language" << std::endl);
+        }
+        char* iso_language_cstr = (char*)malloc(65);
         CFStringGetCString(iso_language, iso_language_cstr, 64,
                            kCFStringEncodingMacRoman);
         LangCode lang = 0;
         RegionCode region = 0;
 #ifdef HAVE_CoreServices
-        OSStatus err = LocaleStringToLangAndRegionCodes(iso_language_cstr,
-                                                        &lang, &region);
+        OSStatus err =
+          LocaleStringToLangAndRegionCodes(iso_language_cstr, &lang, &region);
         if (err != noErr)
 #endif
-          {
+        {
           cmCPackLogger(cmCPackLog::LOG_ERROR,
-            "No language/region code available for " << iso_language_cstr
-            << std::endl);
+                        "No language/region code available for "
+                          << iso_language_cstr << std::endl);
           free(iso_language_cstr);
           return 0;
-          }
+        }
 #ifdef HAVE_CoreServices
         free(iso_language_cstr);
         header_data.push_back(region);
         header_data.push_back(i);
         header_data.push_back(0);
 #endif
-        }
+      }
       ofs << "data 'LPic' (5000) {\n";
       ofs << std::hex << std::uppercase << std::setfill('0');
 
-      for(size_t i = 0; i < header_data.size(); ++i)
-        {
-        if(i % 8 == 0)
-          {
+      for (size_t i = 0; i < header_data.size(); ++i) {
+        if (i % 8 == 0) {
           ofs << "    $\"";
-          }
+        }
 
         ofs << std::setw(4) << header_data[i];
 
-        if(i % 8 == 7 || i == header_data.size() - 1)
-          {
+        if (i % 8 == 7 || i == header_data.size() - 1) {
           ofs << "\"\n";
-          }
-        else
-          {
+        } else {
           ofs << " ";
-          }
         }
+      }
       ofs << "};\n\n";
       // Reset ofs options
       ofs << std::dec << std::nouppercase << std::setfill(' ');
-      }
+    }
 
     bool have_write_license_error = false;
     std::string error;
 
-    if(oldStyle)
-      {
-      if(!this->WriteLicense(ofs, 0, "", cpack_license_file, &error))
-        {
+    if (oldStyle) {
+      if (!this->WriteLicense(ofs, 0, "", cpack_license_file, &error)) {
         have_write_license_error = true;
-        }
       }
-    else
-      {
-      for(size_t i = 0; i < languages.size() && !have_write_license_error; ++i)
-        {
-        if(singleLicense)
-          {
-          if(!this->WriteLicense(ofs, i + 5000, languages[i],
-                                 cpack_license_file, &error))
-            {
+    } else {
+      for (size_t i = 0; i < languages.size() && !have_write_license_error;
+           ++i) {
+        if (singleLicense) {
+          if (!this->WriteLicense(ofs, i + 5000, languages[i],
+                                  cpack_license_file, &error)) {
             have_write_license_error = true;
-            }
           }
-        else
-          {
-          if(!this->WriteLicense(ofs, i + 5000, languages[i], "", &error))
-            {
+        } else {
+          if (!this->WriteLicense(ofs, i + 5000, languages[i], "", &error)) {
             have_write_license_error = true;
-            }
           }
         }
       }
+    }
 
     ofs.Close();
 
-    if(have_write_license_error)
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error writing license file to SLA." << std::endl
-        << error
-        << std::endl);
+    if (have_write_license_error) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error writing license file to SLA."
+                      << std::endl
+                      << error << std::endl);
       return 0;
-      }
+    }
 
     // convert to UDCO
     std::string temp_udco = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@@ -735,14 +647,13 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     udco_image_command << " -format UDCO";
     udco_image_command << " -ov -o \"" << temp_udco << "\"";
 
-    if(!this->RunCommand(udco_image_command, &error))
-      {
+    if (!this->RunCommand(udco_image_command, &error)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error converting to UDCO dmg for adding SLA." << std::endl
-        << error
-        << std::endl);
+                    "Error converting to UDCO dmg for adding SLA."
+                      << std::endl
+                      << error << std::endl);
       return 0;
-      }
+    }
 
     // unflatten dmg
     std::ostringstream unflatten_command;
@@ -750,35 +661,31 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     unflatten_command << " unflatten ";
     unflatten_command << "\"" << temp_udco << "\"";
 
-    if(!this->RunCommand(unflatten_command, &error))
-      {
+    if (!this->RunCommand(unflatten_command, &error)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error unflattening dmg for adding SLA." << std::endl
-        << error
-        << std::endl);
+                    "Error unflattening dmg for adding SLA." << std::endl
+                                                             << error
+                                                             << std::endl);
       return 0;
-      }
+    }
 
     // Rez the SLA
     std::ostringstream embed_sla_command;
     embed_sla_command << this->GetOption("CPACK_COMMAND_REZ");
     const char* sysroot = this->GetOption("CPACK_OSX_SYSROOT");
-    if(sysroot && sysroot[0] != '\0')
-      {
+    if (sysroot && sysroot[0] != '\0') {
       embed_sla_command << " -isysroot \"" << sysroot << "\"";
-      }
+    }
     embed_sla_command << " \"" << sla_r << "\"";
     embed_sla_command << " -a -o ";
     embed_sla_command << "\"" << temp_udco << "\"";
 
-    if(!this->RunCommand(embed_sla_command, &error))
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error adding SLA." << std::endl
-        << error
-        << std::endl);
+    if (!this->RunCommand(embed_sla_command, &error)) {
+      cmCPackLogger(cmCPackLog::LOG_ERROR, "Error adding SLA." << std::endl
+                                                               << error
+                                                               << std::endl);
       return 0;
-      }
+    }
 
     // flatten dmg
     std::ostringstream flatten_command;
@@ -786,18 +693,16 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
     flatten_command << " flatten ";
     flatten_command << "\"" << temp_udco << "\"";
 
-    if(!this->RunCommand(flatten_command, &error))
-      {
+    if (!this->RunCommand(flatten_command, &error)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error flattening dmg for adding SLA." << std::endl
-        << error
-        << std::endl);
+                    "Error flattening dmg for adding SLA." << std::endl
+                                                           << error
+                                                           << std::endl);
       return 0;
-      }
-
-    temp_image = temp_udco;
     }
 
+    temp_image = temp_udco;
+  }
 
   // Create the final compressed read-only disk image ...
   std::ostringstream final_image_command;
@@ -809,14 +714,12 @@ int cmCPackDragNDropGenerator::CreateDMG(const std::string& src_dir,
   final_image_command << " zlib-level=9";
   final_image_command << " -o \"" << output_file << "\"";
 
-  if(!this->RunCommand(final_image_command))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Error compressing disk image."
-      << std::endl);
+  if (!this->RunCommand(final_image_command)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error compressing disk image."
+                    << std::endl);
 
     return 0;
-    }
+  }
 
   return 1;
 }
@@ -826,9 +729,8 @@ bool cmCPackDragNDropGenerator::SupportsComponentInstallation() const
   return true;
 }
 
-std::string
-cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
-                           const std::string& componentName)
+std::string cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
+  const std::string& componentName)
 {
   // we want to group components together that go in the same dmg package
   std::string package_file_name = this->GetOption("CPACK_PACKAGE_FILE_NAME");
@@ -840,179 +742,153 @@ cmCPackDragNDropGenerator::GetComponentInstallDirNameSuffix(
   // 3. ignore groups - if grouping is defined, it is ignored
   //    and each component goes in its own package
 
-  if(this->componentPackageMethod == ONE_PACKAGE)
-    {
+  if (this->componentPackageMethod == ONE_PACKAGE) {
     return "ALL_IN_ONE";
-    }
+  }
 
-  if(this->componentPackageMethod == ONE_PACKAGE_PER_GROUP)
-    {
+  if (this->componentPackageMethod == ONE_PACKAGE_PER_GROUP) {
     // We have to find the name of the COMPONENT GROUP
     // the current COMPONENT belongs to.
-    std::string groupVar = "CPACK_COMPONENT_" +
-                         cmSystemTools::UpperCase(componentName) + "_GROUP";
+    std::string groupVar =
+      "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
     const char* _groupName = GetOption(groupVar.c_str());
-    if (_groupName)
-      {
+    if (_groupName) {
       std::string groupName = _groupName;
 
-      groupName = GetComponentPackageFileName(package_file_name,
-                                              groupName, true);
+      groupName =
+        GetComponentPackageFileName(package_file_name, groupName, true);
       return groupName;
-      }
     }
+  }
 
   return GetComponentPackageFileName(package_file_name, componentName, false);
 }
 
-bool
-cmCPackDragNDropGenerator::WriteLicense(cmGeneratedFileStream& outputStream,
-  int licenseNumber, std::string licenseLanguage, std::string licenseFile,
-  std::string *error)
+bool cmCPackDragNDropGenerator::WriteLicense(
+  cmGeneratedFileStream& outputStream, int licenseNumber,
+  std::string licenseLanguage, std::string licenseFile, std::string* error)
 {
-  if(!licenseFile.empty() && !singleLicense)
-    {
+  if (!licenseFile.empty() && !singleLicense) {
     licenseNumber = 5002;
     licenseLanguage = "English";
-    }
+  }
 
   // License header
-  outputStream << "data 'TEXT' (" << licenseNumber << ", \""
-    << licenseLanguage << "\") {\n";
+  outputStream << "data 'TEXT' (" << licenseNumber << ", \"" << licenseLanguage
+               << "\") {\n";
   // License body
-  std::string actual_license = !licenseFile.empty() ? licenseFile :
-    (slaDirectory + "/" + licenseLanguage + ".license.txt");
+  std::string actual_license = !licenseFile.empty()
+    ? licenseFile
+    : (slaDirectory + "/" + licenseLanguage + ".license.txt");
   cmsys::ifstream license_ifs;
   license_ifs.open(actual_license.c_str());
-  if(license_ifs.is_open())
-    {
-    while(license_ifs.good())
-      {
+  if (license_ifs.is_open()) {
+    while (license_ifs.good()) {
       std::string line;
       std::getline(license_ifs, line);
-      if(!line.empty())
-        {
+      if (!line.empty()) {
         EscapeQuotesAndBackslashes(line);
         std::vector<std::string> lines;
-        if(!this->BreakLongLine(line, lines, error))
-          {
+        if (!this->BreakLongLine(line, lines, error)) {
           return false;
-          }
-        for(size_t i = 0; i < lines.size(); ++i)
-          {
+        }
+        for (size_t i = 0; i < lines.size(); ++i) {
           outputStream << "        \"" << lines[i] << "\"\n";
-          }
         }
-      outputStream << "        \"\\n\"\n";
       }
-    license_ifs.close();
+      outputStream << "        \"\\n\"\n";
     }
+    license_ifs.close();
+  }
 
   // End of License
   outputStream << "};\n\n";
-  if(!licenseFile.empty() && !singleLicense)
-    {
+  if (!licenseFile.empty() && !singleLicense) {
     outputStream << SLASTREnglish;
-    }
-  else
-    {
+  } else {
     // Menu header
     outputStream << "resource 'STR#' (" << licenseNumber << ", \""
-      << licenseLanguage << "\") {\n";
+                 << licenseLanguage << "\") {\n";
     outputStream << "    {\n";
 
     // Menu body
     cmsys::ifstream menu_ifs;
-    menu_ifs.open((slaDirectory+"/"+licenseLanguage+".menu.txt").c_str());
-    if(menu_ifs.is_open())
-      {
+    menu_ifs.open(
+      (slaDirectory + "/" + licenseLanguage + ".menu.txt").c_str());
+    if (menu_ifs.is_open()) {
       size_t lines_written = 0;
-      while(menu_ifs.good())
-        {
+      while (menu_ifs.good()) {
         // Lines written from original file, not from broken up lines
         std::string line;
         std::getline(menu_ifs, line);
-        if(!line.empty())
-          {
+        if (!line.empty()) {
           EscapeQuotesAndBackslashes(line);
           std::vector<std::string> lines;
-          if(!this->BreakLongLine(line, lines, error))
-            {
+          if (!this->BreakLongLine(line, lines, error)) {
             return false;
-            }
-          for(size_t i = 0; i < lines.size(); ++i)
-            {
+          }
+          for (size_t i = 0; i < lines.size(); ++i) {
             std::string comma;
             // We need a comma after every complete string,
             // but not on the very last line
-            if(lines_written != 8 && i == lines.size() - 1)
-              {
+            if (lines_written != 8 && i == lines.size() - 1) {
               comma = ",";
-              }
-            else
-              {
+            } else {
               comma = "";
-              }
-            outputStream << "        \"" << lines[i] << "\"" << comma << "\n";
             }
-          ++lines_written;
+            outputStream << "        \"" << lines[i] << "\"" << comma << "\n";
           }
+          ++lines_written;
         }
-      menu_ifs.close();
       }
+      menu_ifs.close();
+    }
 
-    //End of menu
+    // End of menu
     outputStream << "    }\n";
     outputStream << "};\n";
     outputStream << "\n";
-    }
+  }
 
   return true;
 }
 
-bool
-cmCPackDragNDropGenerator::BreakLongLine(const std::string& line,
-  std::vector<std::string>& lines, std::string *error)
+bool cmCPackDragNDropGenerator::BreakLongLine(const std::string& line,
+                                              std::vector<std::string>& lines,
+                                              std::string* error)
 {
   const size_t max_line_length = 512;
-  for(size_t i = 0; i < line.size(); i += max_line_length)
-    {
+  for (size_t i = 0; i < line.size(); i += max_line_length) {
     size_t line_length = max_line_length;
-    if(i + line_length > line.size())
-      {
+    if (i + line_length > line.size()) {
       line_length = line.size() - i;
-      }
-    else while(line_length > 0 && line[i + line_length - 1] != ' ')
-      {
-      line_length = line_length - 1;
+    } else
+      while (line_length > 0 && line[i + line_length - 1] != ' ') {
+        line_length = line_length - 1;
       }
 
-    if(line_length == 0)
-      {
+    if (line_length == 0) {
       *error = "Please make sure there are no words "
                "(or character sequences not broken up by spaces or newlines) "
                "in your license file which are more than 512 characters long.";
       return false;
-      }
-    lines.push_back(line.substr(i, line_length));
     }
+    lines.push_back(line.substr(i, line_length));
+  }
   return true;
 }
 
-void
-cmCPackDragNDropGenerator::EscapeQuotesAndBackslashes(std::string& line)
+void cmCPackDragNDropGenerator::EscapeQuotesAndBackslashes(std::string& line)
 {
   std::string::size_type backslash_pos = line.find('\\');
-  while(backslash_pos != std::string::npos)
-    {
+  while (backslash_pos != std::string::npos) {
     line.replace(backslash_pos, 1, "\\\\");
     backslash_pos = line.find('\\', backslash_pos + 2);
-    }
+  }
 
   std::string::size_type quote_pos = line.find('\"');
-  while(quote_pos != std::string::npos)
-    {
+  while (quote_pos != std::string::npos) {
     line.replace(quote_pos, 1, "\\\"");
     quote_pos = line.find('\"', quote_pos + 2);
-    }
+  }
 }
diff --git a/Source/CPack/cmCPackDragNDropGenerator.h b/Source/CPack/cmCPackDragNDropGenerator.h
index 604cdf5..1392b21 100644
--- a/Source/CPack/cmCPackDragNDropGenerator.h
+++ b/Source/CPack/cmCPackDragNDropGenerator.h
@@ -34,13 +34,12 @@ protected:
   int PackageFiles();
   bool SupportsComponentInstallation() const;
 
-
   bool CopyFile(std::ostringstream& source, std::ostringstream& target);
   bool CreateEmptyFile(std::ostringstream& target, size_t size);
   bool RunCommand(std::ostringstream& command, std::string* output = 0);
 
-  std::string
-  GetComponentInstallDirNameSuffix(const std::string& componentName);
+  std::string GetComponentInstallDirNameSuffix(
+    const std::string& componentName);
 
   int CreateDMG(const std::string& src_dir, const std::string& output_file);
 
@@ -51,11 +50,10 @@ private:
   bool singleLicense;
 
   bool WriteLicense(cmGeneratedFileStream& outputStream, int licenseNumber,
-    std::string licenseLanguage, std::string licenseFile,
-    std::string *error);
-  bool BreakLongLine(const std::string& line,
-    std::vector<std::string>& lines,
-    std::string *error);
+                    std::string licenseLanguage, std::string licenseFile,
+                    std::string* error);
+  bool BreakLongLine(const std::string& line, std::vector<std::string>& lines,
+                     std::string* error);
   void EscapeQuotesAndBackslashes(std::string& line);
 };
 
diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx
index 04ee21a..c8b075d 100644
--- a/Source/CPack/cmCPackGenerator.cxx
+++ b/Source/CPack/cmCPackGenerator.cxx
@@ -44,14 +44,13 @@ cmCPackGenerator::~cmCPackGenerator()
   this->MakefileMap = 0;
 }
 
-void cmCPackGeneratorProgress(const char *msg, float prog, void* ptr)
+void cmCPackGeneratorProgress(const char* msg, float prog, void* ptr)
 {
   cmCPackGenerator* self = static_cast<cmCPackGenerator*>(ptr);
   self->DisplayVerboseOutput(msg, prog);
 }
 
-void cmCPackGenerator::DisplayVerboseOutput(const char* msg,
-  float progress)
+void cmCPackGenerator::DisplayVerboseOutput(const char* msg, float progress)
 {
   (void)progress;
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "" << msg << std::endl);
@@ -59,63 +58,52 @@ void cmCPackGenerator::DisplayVerboseOutput(const char* msg,
 
 int cmCPackGenerator::PrepareNames()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG,
-    "Create temp directory." << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Create temp directory." << std::endl);
 
   // checks CPACK_SET_DESTDIR support
-  if (IsOn("CPACK_SET_DESTDIR"))
-    {
-      if (SETDESTDIR_UNSUPPORTED==SupportsSetDestdir())
-        {
-          cmCPackLogger(cmCPackLog::LOG_ERROR,
-                        "CPACK_SET_DESTDIR is set to ON but the '"
-                        << Name << "' generator does NOT support it."
-                        << std::endl);
-          return 0;
-        }
-      else if (SETDESTDIR_SHOULD_NOT_BE_USED==SupportsSetDestdir())
-        {
-          cmCPackLogger(cmCPackLog::LOG_WARNING,
-                        "CPACK_SET_DESTDIR is set to ON but it is "
-                        << "usually a bad idea to do that with '"
-                        << Name << "' generator. Use at your own risk."
-                        << std::endl);
-        }
+  if (IsOn("CPACK_SET_DESTDIR")) {
+    if (SETDESTDIR_UNSUPPORTED == SupportsSetDestdir()) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR, "CPACK_SET_DESTDIR is set to ON but the '"
+          << Name << "' generator does NOT support it." << std::endl);
+      return 0;
+    } else if (SETDESTDIR_SHOULD_NOT_BE_USED == SupportsSetDestdir()) {
+      cmCPackLogger(cmCPackLog::LOG_WARNING,
+                    "CPACK_SET_DESTDIR is set to ON but it is "
+                      << "usually a bad idea to do that with '" << Name
+                      << "' generator. Use at your own risk." << std::endl);
+    }
   }
 
   std::string tempDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
   tempDirectory += "/_CPack_Packages/";
   const char* toplevelTag = this->GetOption("CPACK_TOPLEVEL_TAG");
-  if ( toplevelTag )
-    {
+  if (toplevelTag) {
     tempDirectory += toplevelTag;
     tempDirectory += "/";
-    }
+  }
   tempDirectory += this->GetOption("CPACK_GENERATOR");
   std::string topDirectory = tempDirectory;
   const char* pfname = this->GetOption("CPACK_PACKAGE_FILE_NAME");
-  if(!pfname)
-    {
+  if (!pfname) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "CPACK_PACKAGE_FILE_NAME not specified" << std::endl);
     return 0;
-    }
+  }
   std::string outName = pfname;
   tempDirectory += "/" + outName;
-  if(!this->GetOutputExtension())
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-                  "No output extension specified" << std::endl);
+  if (!this->GetOutputExtension()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "No output extension specified"
+                    << std::endl);
     return 0;
-    }
+  }
   outName += this->GetOutputExtension();
   const char* pdir = this->GetOption("CPACK_PACKAGE_DIRECTORY");
-  if(!pdir)
-    {
+  if (!pdir) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
                   "CPACK_PACKAGE_DIRECTORY not specified" << std::endl);
     return 0;
-    }
+  }
 
   std::string destFile = pdir;
   this->SetOptionIfNotSet("CPACK_OUTPUT_FILE_PREFIX", destFile.c_str());
@@ -128,52 +116,49 @@ int cmCPackGenerator::PrepareNames()
   this->SetOptionIfNotSet("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
                           outFile.c_str());
   this->SetOptionIfNotSet("CPACK_INSTALL_DIRECTORY", this->GetInstallPath());
-  this->SetOptionIfNotSet("CPACK_NATIVE_INSTALL_DIRECTORY",
+  this->SetOptionIfNotSet(
+    "CPACK_NATIVE_INSTALL_DIRECTORY",
     cmsys::SystemTools::ConvertToOutputPath(this->GetInstallPath()).c_str());
   this->SetOptionIfNotSet("CPACK_TEMPORARY_INSTALL_DIRECTORY",
                           tempDirectory.c_str());
 
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
-    "Look for: CPACK_PACKAGE_DESCRIPTION_FILE" << std::endl);
-  const char* descFileName
-    = this->GetOption("CPACK_PACKAGE_DESCRIPTION_FILE");
-  if ( descFileName )
-    {
-    cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                  "Look for: " << descFileName << std::endl);
-    if ( !cmSystemTools::FileExists(descFileName) )
-      {
+                "Look for: CPACK_PACKAGE_DESCRIPTION_FILE" << std::endl);
+  const char* descFileName = this->GetOption("CPACK_PACKAGE_DESCRIPTION_FILE");
+  if (descFileName) {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for: " << descFileName
+                                                      << std::endl);
+    if (!cmSystemTools::FileExists(descFileName)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Cannot find description file name: ["
-                    << descFileName << "]" << std::endl);
+                      << descFileName << "]" << std::endl);
       return 0;
-      }
+    }
     cmsys::ifstream ifs(descFileName);
-    if ( !ifs )
-      {
+    if (!ifs) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Cannot open description file name: " << descFileName << std::endl);
+                    "Cannot open description file name: " << descFileName
+                                                          << std::endl);
       return 0;
-      }
+    }
     std::ostringstream ostr;
     std::string line;
 
     cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-      "Read description file: " << descFileName << std::endl);
-    while ( ifs && cmSystemTools::GetLineFromStream(ifs, line) )
-      {
+                  "Read description file: " << descFileName << std::endl);
+    while (ifs && cmSystemTools::GetLineFromStream(ifs, line)) {
       ostr << cmXMLSafe(line) << std::endl;
-      }
-    this->SetOptionIfNotSet("CPACK_PACKAGE_DESCRIPTION", ostr.str().c_str());
     }
-  if ( !this->GetOption("CPACK_PACKAGE_DESCRIPTION") )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
+    this->SetOptionIfNotSet("CPACK_PACKAGE_DESCRIPTION", ostr.str().c_str());
+  }
+  if (!this->GetOption("CPACK_PACKAGE_DESCRIPTION")) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
       "Project description not specified. Please specify "
       "CPACK_PACKAGE_DESCRIPTION or CPACK_PACKAGE_DESCRIPTION_FILE."
-      << std::endl);
+        << std::endl);
     return 0;
-    }
+  }
 
   this->SetOptionIfNotSet("CPACK_REMOVE_TOPLEVEL_DIRECTORY", "1");
 
@@ -185,78 +170,66 @@ int cmCPackGenerator::InstallProject()
   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Install projects" << std::endl);
   this->CleanTemporaryDirectory();
 
-  std::string bareTempInstallDirectory
-    = this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
+  std::string bareTempInstallDirectory =
+    this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
   std::string tempInstallDirectoryStr = bareTempInstallDirectory;
-  bool setDestDir = cmSystemTools::IsOn(this->GetOption("CPACK_SET_DESTDIR"))
-                  | cmSystemTools::IsInternallyOn(
-                    this->GetOption("CPACK_SET_DESTDIR"));
-  if (!setDestDir)
-    {
+  bool setDestDir = cmSystemTools::IsOn(this->GetOption("CPACK_SET_DESTDIR")) |
+    cmSystemTools::IsInternallyOn(this->GetOption("CPACK_SET_DESTDIR"));
+  if (!setDestDir) {
     tempInstallDirectoryStr += this->GetPackagingInstallPrefix();
-    }
+  }
 
   const char* tempInstallDirectory = tempInstallDirectoryStr.c_str();
   int res = 1;
-  if ( !cmsys::SystemTools::MakeDirectory(bareTempInstallDirectory.c_str()))
-    {
+  if (!cmsys::SystemTools::MakeDirectory(bareTempInstallDirectory.c_str())) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Problem creating temporary directory: "
-                  << (tempInstallDirectory ? tempInstallDirectory : "(NULL)")
-                  << std::endl);
+                  "Problem creating temporary directory: "
+                    << (tempInstallDirectory ? tempInstallDirectory : "(NULL)")
+                    << std::endl);
     return 0;
-    }
+  }
 
-  if ( setDestDir )
-    {
+  if (setDestDir) {
     std::string destDir = "DESTDIR=";
     destDir += tempInstallDirectory;
     cmSystemTools::PutEnv(destDir);
-    }
-  else
-    {
+  } else {
     // Make sure there is no destdir
     cmSystemTools::PutEnv("DESTDIR=");
-    }
+  }
 
   // If the CPackConfig file sets CPACK_INSTALL_COMMANDS then run them
   // as listed
-  if ( !this->InstallProjectViaInstallCommands(
-      setDestDir, tempInstallDirectory) )
-    {
+  if (!this->InstallProjectViaInstallCommands(setDestDir,
+                                              tempInstallDirectory)) {
     return 0;
-    }
+  }
 
   // If the CPackConfig file sets CPACK_INSTALL_SCRIPT then run them
   // as listed
-  if ( !this->InstallProjectViaInstallScript(
-      setDestDir, tempInstallDirectory) )
-    {
+  if (!this->InstallProjectViaInstallScript(setDestDir,
+                                            tempInstallDirectory)) {
     return 0;
-    }
+  }
 
   // If the CPackConfig file sets CPACK_INSTALLED_DIRECTORIES
   // then glob it and copy it to CPACK_TEMPORARY_DIRECTORY
   // This is used in Source packaging
-  if ( !this->InstallProjectViaInstalledDirectories(
-      setDestDir, tempInstallDirectory) )
-    {
+  if (!this->InstallProjectViaInstalledDirectories(setDestDir,
+                                                   tempInstallDirectory)) {
     return 0;
-    }
-
+  }
 
   // If the project is a CMAKE project then run pre-install
   // and then read the cmake_install script to run it
-  if ( !this->InstallProjectViaInstallCMakeProjects(
-         setDestDir, bareTempInstallDirectory) )
-    {
+  if (!this->InstallProjectViaInstallCMakeProjects(setDestDir,
+                                                   bareTempInstallDirectory)) {
     return 0;
-    }
+  }
 
-  if ( setDestDir )
-    {
+  if (setDestDir) {
     cmSystemTools::PutEnv("DESTDIR=");
-    }
+  }
 
   return res;
 }
@@ -264,43 +237,37 @@ int cmCPackGenerator::InstallProject()
 int cmCPackGenerator::InstallProjectViaInstallCommands(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
-  (void) setDestDir;
+  (void)setDestDir;
   const char* installCommands = this->GetOption("CPACK_INSTALL_COMMANDS");
-  if ( installCommands && *installCommands )
-    {
+  if (installCommands && *installCommands) {
     std::string tempInstallDirectoryEnv = "CMAKE_INSTALL_PREFIX=";
     tempInstallDirectoryEnv += tempInstallDirectory;
     cmSystemTools::PutEnv(tempInstallDirectoryEnv);
     std::vector<std::string> installCommandsVector;
-    cmSystemTools::ExpandListArgument(installCommands,installCommandsVector);
+    cmSystemTools::ExpandListArgument(installCommands, installCommandsVector);
     std::vector<std::string>::iterator it;
-    for ( it = installCommandsVector.begin();
-      it != installCommandsVector.end();
-      ++it )
-      {
-      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << *it
-        << std::endl);
+    for (it = installCommandsVector.begin(); it != installCommandsVector.end();
+         ++it) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << *it << std::endl);
       std::string output;
       int retVal = 1;
       bool resB = cmSystemTools::RunSingleCommand(
-        it->c_str(), &output, &output,
-        &retVal, 0, this->GeneratorVerbose, 0);
-      if ( !resB || retVal )
-        {
+        it->c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
+      if (!resB || retVal) {
         std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
         tmpFile += "/InstallOutput.log";
         cmGeneratedFileStream ofs(tmpFile.c_str());
         ofs << "# Run command: " << *it << std::endl
-          << "# Output:" << std::endl
-          << output << std::endl;
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Problem running install command: " << *it << std::endl
-          << "Please check " << tmpFile << " for errors"
-          << std::endl);
+            << "# Output:" << std::endl
+            << output << std::endl;
+        cmCPackLogger(
+          cmCPackLog::LOG_ERROR, "Problem running install command: "
+            << *it << std::endl
+            << "Please check " << tmpFile << " for errors" << std::endl);
         return 0;
-        }
       }
     }
+  }
   return 1;
 }
 
@@ -311,265 +278,230 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
   (void)tempInstallDirectory;
   std::vector<cmsys::RegularExpression> ignoreFilesRegex;
   const char* cpackIgnoreFiles = this->GetOption("CPACK_IGNORE_FILES");
-  if ( cpackIgnoreFiles )
-    {
+  if (cpackIgnoreFiles) {
     std::vector<std::string> ignoreFilesRegexString;
     cmSystemTools::ExpandListArgument(cpackIgnoreFiles,
                                       ignoreFilesRegexString);
     std::vector<std::string>::iterator it;
-    for ( it = ignoreFilesRegexString.begin();
-      it != ignoreFilesRegexString.end();
-      ++it )
-      {
+    for (it = ignoreFilesRegexString.begin();
+         it != ignoreFilesRegexString.end(); ++it) {
       cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-        "Create ignore files regex for: " << *it << std::endl);
+                    "Create ignore files regex for: " << *it << std::endl);
       ignoreFilesRegex.push_back(it->c_str());
-      }
     }
-  const char* installDirectories
-    = this->GetOption("CPACK_INSTALLED_DIRECTORIES");
-  if ( installDirectories && *installDirectories )
-    {
+  }
+  const char* installDirectories =
+    this->GetOption("CPACK_INSTALLED_DIRECTORIES");
+  if (installDirectories && *installDirectories) {
     std::vector<std::string> installDirectoriesVector;
     cmSystemTools::ExpandListArgument(installDirectories,
-      installDirectoriesVector);
-    if ( installDirectoriesVector.size() % 2 != 0 )
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                                      installDirectoriesVector);
+    if (installDirectoriesVector.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
         "CPACK_INSTALLED_DIRECTORIES should contain pairs of <directory> and "
         "<subdirectory>. The <subdirectory> can be '.' to be installed in "
-        "the toplevel directory of installation." << std::endl);
+        "the toplevel directory of installation."
+          << std::endl);
       return 0;
-      }
+    }
     std::vector<std::string>::iterator it;
     const std::string& tempDir = tempInstallDirectory;
-    for ( it = installDirectoriesVector.begin();
-      it != installDirectoriesVector.end();
-      ++it )
-      {
-      std::list<std::pair<std::string,std::string> > symlinkedFiles;
+    for (it = installDirectoriesVector.begin();
+         it != installDirectoriesVector.end(); ++it) {
+      std::list<std::pair<std::string, std::string> > symlinkedFiles;
       cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
       cmsys::Glob gl;
       std::string top = *it;
-      it ++;
+      it++;
       std::string subdir = *it;
       std::string findExpr = top;
       findExpr += "/*";
       cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-        "- Install directory: " << top << std::endl);
+                    "- Install directory: " << top << std::endl);
       gl.RecurseOn();
       gl.SetRecurseListDirs(true);
-      if ( !gl.FindFiles(findExpr) )
-        {
+      if (!gl.FindFiles(findExpr)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Cannot find any files in the installed directory" << std::endl);
+                      "Cannot find any files in the installed directory"
+                        << std::endl);
         return 0;
-        }
+      }
       files = gl.GetFiles();
       std::vector<std::string>::iterator gfit;
       std::vector<cmsys::RegularExpression>::iterator regIt;
-      for ( gfit = files.begin(); gfit != files.end(); ++ gfit )
-        {
+      for (gfit = files.begin(); gfit != files.end(); ++gfit) {
         bool skip = false;
         std::string inFile = *gfit;
-        if(cmSystemTools::FileIsDirectory(*gfit))
-          {
+        if (cmSystemTools::FileIsDirectory(*gfit)) {
           inFile += '/';
-          }
-        for ( regIt= ignoreFilesRegex.begin();
-          regIt!= ignoreFilesRegex.end();
-          ++ regIt)
-          {
-          if ( regIt->find(inFile.c_str()) )
-            {
-            cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Ignore file: "
-              << inFile << std::endl);
+        }
+        for (regIt = ignoreFilesRegex.begin(); regIt != ignoreFilesRegex.end();
+             ++regIt) {
+          if (regIt->find(inFile.c_str())) {
+            cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                          "Ignore file: " << inFile << std::endl);
             skip = true;
-            }
           }
-        if ( skip )
-          {
+        }
+        if (skip) {
           continue;
-          }
+        }
         std::string filePath = tempDir;
-        filePath += "/" + subdir + "/"
-          + cmSystemTools::RelativePath(top.c_str(), gfit->c_str());
+        filePath += "/" + subdir + "/" +
+          cmSystemTools::RelativePath(top.c_str(), gfit->c_str());
         cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy file: "
-          << inFile << " -> " << filePath << std::endl);
+                        << inFile << " -> " << filePath << std::endl);
         /* If the file is a symlink we will have to re-create it */
-        if ( cmSystemTools::FileIsSymlink(inFile))
-          {
+        if (cmSystemTools::FileIsSymlink(inFile)) {
           std::string targetFile;
           std::string inFileRelative =
-             cmSystemTools::RelativePath(top.c_str(),inFile.c_str());
-          cmSystemTools::ReadSymlink(inFile,targetFile);
-          symlinkedFiles.push_back(std::pair<std::string,
-                                   std::string>(targetFile,inFileRelative));
-          }
+            cmSystemTools::RelativePath(top.c_str(), inFile.c_str());
+          cmSystemTools::ReadSymlink(inFile, targetFile);
+          symlinkedFiles.push_back(
+            std::pair<std::string, std::string>(targetFile, inFileRelative));
+        }
         /* If it is not a symlink then do a plain copy */
-        else if (!(
-            cmSystemTools::CopyFileIfDifferent(inFile.c_str(),filePath.c_str())
-            &&
-            cmSystemTools::CopyFileTime(inFile.c_str(),filePath.c_str())
-                ) )
-          {
+        else if (!(cmSystemTools::CopyFileIfDifferent(inFile.c_str(),
+                                                      filePath.c_str()) &&
+                   cmSystemTools::CopyFileTime(inFile.c_str(),
+                                               filePath.c_str()))) {
           cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying file: "
-            << inFile << " -> " << filePath << std::endl);
+                          << inFile << " -> " << filePath << std::endl);
           return 0;
-          }
         }
+      }
       /* rebuild symlinks in the installed tree */
-      if (!symlinkedFiles.empty())
-        {
-        std::list< std::pair<std::string,std::string> >::iterator symlinkedIt;
+      if (!symlinkedFiles.empty()) {
+        std::list<std::pair<std::string, std::string> >::iterator symlinkedIt;
         std::string curDir = cmSystemTools::GetCurrentWorkingDirectory();
         std::string goToDir = tempDir;
-        goToDir  += "/"+subdir;
-        cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                      "Change dir to: " << goToDir <<std::endl);
+        goToDir += "/" + subdir;
+        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Change dir to: " << goToDir
+                                                               << std::endl);
         cmSystemTools::ChangeDirectory(goToDir);
-        for (symlinkedIt=symlinkedFiles.begin();
-             symlinkedIt != symlinkedFiles.end();
-             ++symlinkedIt)
-          {
+        for (symlinkedIt = symlinkedFiles.begin();
+             symlinkedIt != symlinkedFiles.end(); ++symlinkedIt) {
           cmCPackLogger(cmCPackLog::LOG_DEBUG, "Will create a symlink: "
-                         << symlinkedIt->second << "--> "
-                         << symlinkedIt->first << std::endl);
+                          << symlinkedIt->second << "--> "
+                          << symlinkedIt->first << std::endl);
           // make sure directory exists for symlink
           std::string destDir =
             cmSystemTools::GetFilenamePath(symlinkedIt->second);
-          if(!destDir.empty() && !cmSystemTools::MakeDirectory(destDir))
-            {
+          if (!destDir.empty() && !cmSystemTools::MakeDirectory(destDir)) {
             cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create dir: "
-                          << destDir
-                          << "\nTrying to create symlink: "
-                          << symlinkedIt->second << "--> "
-                          << symlinkedIt->first
-                          << std::endl);
-            }
+                            << destDir << "\nTrying to create symlink: "
+                            << symlinkedIt->second << "--> "
+                            << symlinkedIt->first << std::endl);
+          }
           if (!cmSystemTools::CreateSymlink(symlinkedIt->first,
-                                            symlinkedIt->second))
-            {
+                                            symlinkedIt->second)) {
             cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot create symlink: "
                             << symlinkedIt->second << "--> "
                             << symlinkedIt->first << std::endl);
             return 0;
-            }
           }
-        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Going back to: "
-                      << curDir <<std::endl);
-        cmSystemTools::ChangeDirectory(curDir);
         }
+        cmCPackLogger(cmCPackLog::LOG_DEBUG, "Going back to: " << curDir
+                                                               << std::endl);
+        cmSystemTools::ChangeDirectory(curDir);
       }
     }
+  }
   return 1;
 }
 
 int cmCPackGenerator::InstallProjectViaInstallScript(
   bool setDestDir, const std::string& tempInstallDirectory)
 {
-  const char* cmakeScripts
-    = this->GetOption("CPACK_INSTALL_SCRIPT");
-  if ( cmakeScripts && *cmakeScripts )
-    {
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                  "- Install scripts: " << cmakeScripts << std::endl);
+  const char* cmakeScripts = this->GetOption("CPACK_INSTALL_SCRIPT");
+  if (cmakeScripts && *cmakeScripts) {
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Install scripts: " << cmakeScripts
+                                                                << std::endl);
     std::vector<std::string> cmakeScriptsVector;
-    cmSystemTools::ExpandListArgument(cmakeScripts,
-      cmakeScriptsVector);
+    cmSystemTools::ExpandListArgument(cmakeScripts, cmakeScriptsVector);
     std::vector<std::string>::iterator it;
-    for ( it = cmakeScriptsVector.begin();
-      it != cmakeScriptsVector.end();
-      ++it )
-      {
+    for (it = cmakeScriptsVector.begin(); it != cmakeScriptsVector.end();
+         ++it) {
       std::string installScript = *it;
 
       cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-        "- Install script: " << installScript << std::endl);
+                    "- Install script: " << installScript << std::endl);
 
-      if ( setDestDir )
-        {
+      if (setDestDir) {
         // For DESTDIR based packaging, use the *project* CMAKE_INSTALL_PREFIX
         // underneath the tempInstallDirectory. The value of the project's
         // CMAKE_INSTALL_PREFIX is sent in here as the value of the
         // CPACK_INSTALL_PREFIX variable.
 
         std::string dir;
-        if (this->GetOption("CPACK_INSTALL_PREFIX"))
-          {
+        if (this->GetOption("CPACK_INSTALL_PREFIX")) {
           dir += this->GetOption("CPACK_INSTALL_PREFIX");
-          }
+        }
         this->SetOption("CMAKE_INSTALL_PREFIX", dir.c_str());
-        cmCPackLogger(cmCPackLog::LOG_DEBUG,
+        cmCPackLogger(
+          cmCPackLog::LOG_DEBUG,
           "- Using DESTDIR + CPACK_INSTALL_PREFIX... (this->SetOption)"
-          << std::endl);
+            << std::endl);
         cmCPackLogger(cmCPackLog::LOG_DEBUG,
-          "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'" << std::endl);
-        }
-      else
-        {
+                      "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'"
+                                                            << std::endl);
+      } else {
         this->SetOption("CMAKE_INSTALL_PREFIX", tempInstallDirectory.c_str());
 
         cmCPackLogger(cmCPackLog::LOG_DEBUG,
-          "- Using non-DESTDIR install... (this->SetOption)" << std::endl);
+                      "- Using non-DESTDIR install... (this->SetOption)"
+                        << std::endl);
         cmCPackLogger(cmCPackLog::LOG_DEBUG,
-          "- Setting CMAKE_INSTALL_PREFIX to '" << tempInstallDirectory
-          << "'" << std::endl);
-        }
+                      "- Setting CMAKE_INSTALL_PREFIX to '"
+                        << tempInstallDirectory << "'" << std::endl);
+      }
 
       this->SetOptionIfNotSet("CMAKE_CURRENT_BINARY_DIR",
-        tempInstallDirectory.c_str());
+                              tempInstallDirectory.c_str());
       this->SetOptionIfNotSet("CMAKE_CURRENT_SOURCE_DIR",
-        tempInstallDirectory.c_str());
+                              tempInstallDirectory.c_str());
       int res = this->MakefileMap->ReadListFile(installScript.c_str());
-      if ( cmSystemTools::GetErrorOccuredFlag() || !res )
-        {
+      if (cmSystemTools::GetErrorOccuredFlag() || !res) {
         return 0;
-        }
       }
     }
+  }
   return 1;
 }
 
 int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
   bool setDestDir, const std::string& baseTempInstallDirectory)
 {
-  const char* cmakeProjects
-    = this->GetOption("CPACK_INSTALL_CMAKE_PROJECTS");
-  const char* cmakeGenerator
-    = this->GetOption("CPACK_CMAKE_GENERATOR");
+  const char* cmakeProjects = this->GetOption("CPACK_INSTALL_CMAKE_PROJECTS");
+  const char* cmakeGenerator = this->GetOption("CPACK_CMAKE_GENERATOR");
   std::string absoluteDestFiles;
-  if ( cmakeProjects && *cmakeProjects )
-    {
-    if ( !cmakeGenerator )
-      {
+  if (cmakeProjects && *cmakeProjects) {
+    if (!cmakeGenerator) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "CPACK_INSTALL_CMAKE_PROJECTS is specified, but "
                     "CPACK_CMAKE_GENERATOR is not. CPACK_CMAKE_GENERATOR "
                     "is required to install the project."
-                    << std::endl);
+                      << std::endl);
       return 0;
-      }
+    }
     std::vector<std::string> cmakeProjectsVector;
-    cmSystemTools::ExpandListArgument(cmakeProjects,
-      cmakeProjectsVector);
+    cmSystemTools::ExpandListArgument(cmakeProjects, cmakeProjectsVector);
     std::vector<std::string>::iterator it;
-    for ( it = cmakeProjectsVector.begin();
-      it != cmakeProjectsVector.end();
-      ++it )
-      {
-      if ( it+1 == cmakeProjectsVector.end() ||
-        it+2 == cmakeProjectsVector.end() ||
-        it+3 == cmakeProjectsVector.end() )
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
+    for (it = cmakeProjectsVector.begin(); it != cmakeProjectsVector.end();
+         ++it) {
+      if (it + 1 == cmakeProjectsVector.end() ||
+          it + 2 == cmakeProjectsVector.end() ||
+          it + 3 == cmakeProjectsVector.end()) {
+        cmCPackLogger(
+          cmCPackLog::LOG_ERROR,
           "Not enough items on list: CPACK_INSTALL_CMAKE_PROJECTS. "
           "CPACK_INSTALL_CMAKE_PROJECTS should hold quadruplet of install "
           "directory, install project name, install component, and install "
           "subdirectory."
-          << std::endl);
+            << std::endl);
         return 0;
-        }
+      }
       std::string installDirectory = *it;
       ++it;
       std::string installProjectName = *it;
@@ -589,60 +521,50 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
        *      (this works at CPack time too)
        */
       if (this->SupportsComponentInstallation() &
-          !(this->IsOn("CPACK_MONOLITHIC_INSTALL")))
-        {
+          !(this->IsOn("CPACK_MONOLITHIC_INSTALL"))) {
         // Determine the installation types for this project (if provided).
-        std::string installTypesVar = "CPACK_"
-          + cmSystemTools::UpperCase(installComponent) + "_INSTALL_TYPES";
-        const char *installTypes = this->GetOption(installTypesVar);
-        if (installTypes && *installTypes)
-          {
+        std::string installTypesVar = "CPACK_" +
+          cmSystemTools::UpperCase(installComponent) + "_INSTALL_TYPES";
+        const char* installTypes = this->GetOption(installTypesVar);
+        if (installTypes && *installTypes) {
           std::vector<std::string> installTypesVector;
           cmSystemTools::ExpandListArgument(installTypes, installTypesVector);
           std::vector<std::string>::iterator installTypeIt;
           for (installTypeIt = installTypesVector.begin();
-               installTypeIt != installTypesVector.end();
-               ++installTypeIt)
-            {
-            this->GetInstallationType(installProjectName,
-                                      *installTypeIt);
-            }
+               installTypeIt != installTypesVector.end(); ++installTypeIt) {
+            this->GetInstallationType(installProjectName, *installTypeIt);
           }
+        }
 
         // Determine the set of components that will be used in this project
-        std::string componentsVar
-          = "CPACK_COMPONENTS_" + cmSystemTools::UpperCase(installComponent);
-        const char *components = this->GetOption(componentsVar);
-        if (components && *components)
-          {
+        std::string componentsVar =
+          "CPACK_COMPONENTS_" + cmSystemTools::UpperCase(installComponent);
+        const char* components = this->GetOption(componentsVar);
+        if (components && *components) {
           cmSystemTools::ExpandListArgument(components, componentsVector);
           std::vector<std::string>::iterator compIt;
           for (compIt = componentsVector.begin();
-               compIt != componentsVector.end();
-               ++compIt)
-            {
+               compIt != componentsVector.end(); ++compIt) {
             GetComponent(installProjectName, *compIt);
-            }
-          componentInstall = true;
           }
+          componentInstall = true;
         }
-      if (componentsVector.empty())
-        {
+      }
+      if (componentsVector.empty()) {
         componentsVector.push_back(installComponent);
-        }
+      }
 
       const char* buildConfigCstr = this->GetOption("CPACK_BUILD_CONFIG");
       std::string buildConfig = buildConfigCstr ? buildConfigCstr : "";
-      cmGlobalGenerator* globalGenerator
-        = this->MakefileMap->GetCMakeInstance()->CreateGlobalGenerator(
+      cmGlobalGenerator* globalGenerator =
+        this->MakefileMap->GetCMakeInstance()->CreateGlobalGenerator(
           cmakeGenerator);
-      if ( !globalGenerator )
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-                    "Specified package generator not found. "
-                    "CPACK_CMAKE_GENERATOR value is invalid."
-                    << std::endl);
-      return 0;
+      if (!globalGenerator) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+                      "Specified package generator not found. "
+                      "CPACK_CMAKE_GENERATOR value is invalid."
+                        << std::endl);
+        return 0;
       }
       // set the global flag for unix style paths on cmSystemTools as
       // soon as the generator is set.  This allows gmake to be used
@@ -650,59 +572,49 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
       cmSystemTools::SetForceUnixPaths(globalGenerator->GetForceUnixPaths());
 
       // Does this generator require pre-install?
-      if (const char* preinstall = globalGenerator->GetPreinstallTargetName())
-        {
-        std::string buildCommand =
-          globalGenerator->GenerateCMakeBuildCommand(
-            preinstall, buildConfig, "", false);
+      if (const char* preinstall =
+            globalGenerator->GetPreinstallTargetName()) {
+        std::string buildCommand = globalGenerator->GenerateCMakeBuildCommand(
+          preinstall, buildConfig, "", false);
         cmCPackLogger(cmCPackLog::LOG_DEBUG,
-          "- Install command: " << buildCommand << std::endl);
-        cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-          "- Run preinstall target for: " << installProjectName << std::endl);
+                      "- Install command: " << buildCommand << std::endl);
+        cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Run preinstall target for: "
+                        << installProjectName << std::endl);
         std::string output;
         int retVal = 1;
-        bool resB =
-          cmSystemTools::RunSingleCommand(buildCommand.c_str(),
-                                          &output, &output,
-                                          &retVal,
-                                          installDirectory.c_str(),
-                                          this->GeneratorVerbose, 0);
-        if ( !resB || retVal )
-          {
+        bool resB = cmSystemTools::RunSingleCommand(
+          buildCommand.c_str(), &output, &output, &retVal,
+          installDirectory.c_str(), this->GeneratorVerbose, 0);
+        if (!resB || retVal) {
           std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
           tmpFile += "/PreinstallOutput.log";
           cmGeneratedFileStream ofs(tmpFile.c_str());
           ofs << "# Run command: " << buildCommand << std::endl
-            << "# Directory: " << installDirectory << std::endl
-            << "# Output:" << std::endl
-            << output << std::endl;
-          cmCPackLogger(cmCPackLog::LOG_ERROR,
-            "Problem running install command: " << buildCommand
-            << std::endl
-            << "Please check " << tmpFile << " for errors"
-            << std::endl);
+              << "# Directory: " << installDirectory << std::endl
+              << "# Output:" << std::endl
+              << output << std::endl;
+          cmCPackLogger(
+            cmCPackLog::LOG_ERROR, "Problem running install command: "
+              << buildCommand << std::endl
+              << "Please check " << tmpFile << " for errors" << std::endl);
           return 0;
-          }
         }
+      }
       delete globalGenerator;
 
       cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-        "- Install project: " << installProjectName << std::endl);
+                    "- Install project: " << installProjectName << std::endl);
 
       // Run the installation for each component
       std::vector<std::string>::iterator componentIt;
       for (componentIt = componentsVector.begin();
-           componentIt != componentsVector.end();
-           ++componentIt)
-        {
+           componentIt != componentsVector.end(); ++componentIt) {
         std::string tempInstallDirectory = baseTempInstallDirectory;
         installComponent = *componentIt;
-        if (componentInstall)
-          {
-          cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                        "-   Install component: " << installComponent
-                        << std::endl);
-          }
+        if (componentInstall) {
+          cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Install component: "
+                          << installComponent << std::endl);
+        }
 
         cmake cm;
         cm.SetHomeDirectory("");
@@ -712,13 +624,11 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
         cm.SetProgressCallback(cmCPackGeneratorProgress, this);
         cmGlobalGenerator gg(&cm);
         cmsys::auto_ptr<cmMakefile> mf(
-              new cmMakefile(&gg, cm.GetCurrentSnapshot()));
-        if ( !installSubDirectory.empty() && installSubDirectory != "/" )
-          {
+          new cmMakefile(&gg, cm.GetCurrentSnapshot()));
+        if (!installSubDirectory.empty() && installSubDirectory != "/") {
           tempInstallDirectory += installSubDirectory;
-          }
-        if (componentInstall)
-          {
+        }
+        if (componentInstall) {
           tempInstallDirectory += "/";
           // Some CPack generators would rather chose
           // the local installation directory suffix.
@@ -728,20 +638,17 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
           //  one install directory for each component.
           tempInstallDirectory +=
             GetComponentInstallDirNameSuffix(installComponent);
-          if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY"))
-            {
+          if (this->IsOn("CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY")) {
             tempInstallDirectory += "/";
             tempInstallDirectory += this->GetOption("CPACK_PACKAGE_FILE_NAME");
-            }
           }
+        }
 
-        if (!setDestDir)
-          {
+        if (!setDestDir) {
           tempInstallDirectory += this->GetPackagingInstallPrefix();
-          }
+        }
 
-        if ( setDestDir )
-          {
+        if (setDestDir) {
           // For DESTDIR based packaging, use the *project*
           // CMAKE_INSTALL_PREFIX underneath the tempInstallDirectory. The
           // value of the project's CMAKE_INSTALL_PREFIX is sent in here as
@@ -754,37 +661,32 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
           // I know this is tricky and awkward but it's the price for
           // CPACK_SET_DESTDIR backward compatibility.
           if (cmSystemTools::IsInternallyOn(
-                this->GetOption("CPACK_SET_DESTDIR")))
-            {
+                this->GetOption("CPACK_SET_DESTDIR"))) {
             this->SetOption("CPACK_INSTALL_PREFIX",
                             this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX"));
-            }
+          }
           std::string dir;
-          if (this->GetOption("CPACK_INSTALL_PREFIX"))
-            {
+          if (this->GetOption("CPACK_INSTALL_PREFIX")) {
             dir += this->GetOption("CPACK_INSTALL_PREFIX");
-            }
+          }
           mf->AddDefinition("CMAKE_INSTALL_PREFIX", dir.c_str());
 
           cmCPackLogger(
             cmCPackLog::LOG_DEBUG,
             "- Using DESTDIR + CPACK_INSTALL_PREFIX... (mf->AddDefinition)"
-            << std::endl);
+              << std::endl);
           cmCPackLogger(cmCPackLog::LOG_DEBUG,
                         "- Setting CMAKE_INSTALL_PREFIX to '" << dir << "'"
-                        << std::endl);
+                                                              << std::endl);
 
           // Make sure that DESTDIR + CPACK_INSTALL_PREFIX directory
           // exists:
           //
-          if (cmSystemTools::StringStartsWith(dir.c_str(), "/"))
-            {
+          if (cmSystemTools::StringStartsWith(dir.c_str(), "/")) {
             dir = tempInstallDirectory + dir;
-            }
-          else
-            {
+          } else {
             dir = tempInstallDirectory + "/" + dir;
-            }
+          }
           /*
            *  We must re-set DESTDIR for each component
            *  We must not add the CPACK_INSTALL_PREFIX part because
@@ -796,178 +698,157 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
            *     - Because it was already used for component install
            *       in order to put things in subdirs...
            */
-          cmSystemTools::PutEnv(
-              std::string("DESTDIR=")+tempInstallDirectory
-                               );
-          cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                        "- Creating directory: '" << dir << "'" << std::endl);
-
-          if ( !cmsys::SystemTools::MakeDirectory(dir.c_str()))
-            {
-            cmCPackLogger(cmCPackLog::LOG_ERROR,
-                          "Problem creating temporary directory: "
-                          << dir << std::endl);
+          cmSystemTools::PutEnv(std::string("DESTDIR=") +
+                                tempInstallDirectory);
+          cmCPackLogger(cmCPackLog::LOG_DEBUG, "- Creating directory: '"
+                          << dir << "'" << std::endl);
+
+          if (!cmsys::SystemTools::MakeDirectory(dir.c_str())) {
+            cmCPackLogger(
+              cmCPackLog::LOG_ERROR,
+              "Problem creating temporary directory: " << dir << std::endl);
             return 0;
-            }
           }
-        else
-          {
+        } else {
           mf->AddDefinition("CMAKE_INSTALL_PREFIX",
                             tempInstallDirectory.c_str());
 
-          if ( !cmsys::SystemTools::MakeDirectory(
-                 tempInstallDirectory.c_str()))
-            {
+          if (!cmsys::SystemTools::MakeDirectory(
+                tempInstallDirectory.c_str())) {
             cmCPackLogger(cmCPackLog::LOG_ERROR,
                           "Problem creating temporary directory: "
-                          << tempInstallDirectory << std::endl);
+                            << tempInstallDirectory << std::endl);
             return 0;
-            }
+          }
 
           cmCPackLogger(cmCPackLog::LOG_DEBUG,
                         "- Using non-DESTDIR install... (mf->AddDefinition)"
-                        << std::endl);
+                          << std::endl);
           cmCPackLogger(cmCPackLog::LOG_DEBUG,
                         "- Setting CMAKE_INSTALL_PREFIX to '"
-                        << tempInstallDirectory
-                        << "'" << std::endl);
-          }
+                          << tempInstallDirectory << "'" << std::endl);
+        }
 
-        if (!buildConfig.empty())
-          {
+        if (!buildConfig.empty()) {
           mf->AddDefinition("BUILD_TYPE", buildConfig.c_str());
-          }
-        std::string installComponentLowerCase
-          = cmSystemTools::LowerCase(installComponent);
-        if ( installComponentLowerCase != "all" )
-          {
+        }
+        std::string installComponentLowerCase =
+          cmSystemTools::LowerCase(installComponent);
+        if (installComponentLowerCase != "all") {
           mf->AddDefinition("CMAKE_INSTALL_COMPONENT",
                             installComponent.c_str());
-          }
+        }
 
         // strip on TRUE, ON, 1, one or several file names, but not on
         // FALSE, OFF, 0 and an empty string
-        if (!cmSystemTools::IsOff(this->GetOption("CPACK_STRIP_FILES")))
-          {
+        if (!cmSystemTools::IsOff(this->GetOption("CPACK_STRIP_FILES"))) {
           mf->AddDefinition("CMAKE_INSTALL_DO_STRIP", "1");
-          }
+        }
         // Remember the list of files before installation
         // of the current component (if we are in component install)
         const char* InstallPrefix = tempInstallDirectory.c_str();
         std::vector<std::string> filesBefore;
         std::string findExpr(InstallPrefix);
-        if (componentInstall)
-          {
+        if (componentInstall) {
           cmsys::Glob glB;
           findExpr += "/*";
           glB.RecurseOn();
           glB.SetRecurseListDirs(true);
           glB.FindFiles(findExpr);
           filesBefore = glB.GetFiles();
-          std::sort(filesBefore.begin(),filesBefore.end());
-          }
+          std::sort(filesBefore.begin(), filesBefore.end());
+        }
 
         // If CPack was asked to warn on ABSOLUTE INSTALL DESTINATION
         // then forward request to cmake_install.cmake script
-        if (this->IsOn("CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION"))
-          {
-            mf->AddDefinition("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION",
-                              "1");
-          }
+        if (this->IsOn("CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION")) {
+          mf->AddDefinition("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", "1");
+        }
         // If current CPack generator does support
         // ABSOLUTE INSTALL DESTINATION or CPack has been asked for
         // then ask cmake_install.cmake script to error out
         // as soon as it occurs (before installing file)
         if (!SupportsAbsoluteDestination() ||
-            this->IsOn("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION"))
-          {
-            mf->AddDefinition("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION",
-                              "1");
-          }
+            this->IsOn("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION")) {
+          mf->AddDefinition("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION",
+                            "1");
+        }
         // do installation
         int res = mf->ReadListFile(installFile.c_str());
         // forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES
         // to CPack (may be used by generators like CPack RPM or DEB)
         // in order to transparently handle ABSOLUTE PATH
-        if (mf->GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"))
-          {
-            mf->AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES",
-                mf->GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"));
-          }
+        if (mf->GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
+          mf->AddDefinition(
+            "CPACK_ABSOLUTE_DESTINATION_FILES",
+            mf->GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"));
+        }
 
         // Now rebuild the list of files after installation
         // of the current component (if we are in component install)
-        if (componentInstall)
-          {
+        if (componentInstall) {
           cmsys::Glob glA;
           glA.RecurseOn();
           glA.SetRecurseListDirs(true);
           glA.FindFiles(findExpr);
           std::vector<std::string> filesAfter = glA.GetFiles();
-          std::sort(filesAfter.begin(),filesAfter.end());
+          std::sort(filesAfter.begin(), filesAfter.end());
           std::vector<std::string>::iterator diff;
           std::vector<std::string> result(filesAfter.size());
-          diff = std::set_difference (
-                  filesAfter.begin(),filesAfter.end(),
-                  filesBefore.begin(),filesBefore.end(),
-                  result.begin());
+          diff = std::set_difference(filesAfter.begin(), filesAfter.end(),
+                                     filesBefore.begin(), filesBefore.end(),
+                                     result.begin());
 
           std::vector<std::string>::iterator fit;
           std::string localFileName;
           // Populate the File field of each component
-          for (fit=result.begin();fit!=diff;++fit)
-            {
-            localFileName =
-                cmSystemTools::RelativePath(InstallPrefix, fit->c_str());
+          for (fit = result.begin(); fit != diff; ++fit) {
             localFileName =
-                localFileName.substr(localFileName.find_first_not_of('/'),
-                                     std::string::npos);
+              cmSystemTools::RelativePath(InstallPrefix, fit->c_str());
+            localFileName = localFileName.substr(
+              localFileName.find_first_not_of('/'), std::string::npos);
             Components[installComponent].Files.push_back(localFileName);
             cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file <"
-                                <<localFileName<<"> to component <"
-                                <<installComponent<<">"<<std::endl);
-            }
+                            << localFileName << "> to component <"
+                            << installComponent << ">" << std::endl);
           }
+        }
 
-        if (NULL !=mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) {
+        if (NULL != mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) {
           if (!absoluteDestFiles.empty()) {
-            absoluteDestFiles +=";";
+            absoluteDestFiles += ";";
           }
           absoluteDestFiles +=
             mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES");
           cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                                    "Got some ABSOLUTE DESTINATION FILES: "
-                                    << absoluteDestFiles << std::endl);
+                        "Got some ABSOLUTE DESTINATION FILES: "
+                          << absoluteDestFiles << std::endl);
           // define component specific var
-          if (componentInstall)
-            {
+          if (componentInstall) {
             std::string absoluteDestFileComponent =
-                std::string("CPACK_ABSOLUTE_DESTINATION_FILES")
-                + "_" + GetComponentInstallDirNameSuffix(installComponent);
-            if (NULL != this->GetOption(absoluteDestFileComponent))
-              {
-                std::string absoluteDestFilesListComponent =
-                    this->GetOption(absoluteDestFileComponent);
-                absoluteDestFilesListComponent +=";";
-                absoluteDestFilesListComponent +=
-                    mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES");
-                this->SetOption(absoluteDestFileComponent,
-                    absoluteDestFilesListComponent.c_str());
-              }
-            else
-              {
+              std::string("CPACK_ABSOLUTE_DESTINATION_FILES") + "_" +
+              GetComponentInstallDirNameSuffix(installComponent);
+            if (NULL != this->GetOption(absoluteDestFileComponent)) {
+              std::string absoluteDestFilesListComponent =
+                this->GetOption(absoluteDestFileComponent);
+              absoluteDestFilesListComponent += ";";
+              absoluteDestFilesListComponent +=
+                mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES");
               this->SetOption(absoluteDestFileComponent,
-                  mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES"));
-              }
+                              absoluteDestFilesListComponent.c_str());
+            } else {
+              this->SetOption(
+                absoluteDestFileComponent,
+                mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES"));
             }
+          }
         }
-        if ( cmSystemTools::GetErrorOccuredFlag() || !res )
-          {
+        if (cmSystemTools::GetErrorOccuredFlag() || !res) {
           return 0;
-          }
         }
       }
     }
+  }
   this->SetOption("CPACK_ABSOLUTE_DESTINATION_FILES",
                   absoluteDestFiles.c_str());
   return 1;
@@ -979,84 +860,73 @@ bool cmCPackGenerator::ReadListFile(const char* moduleName)
   std::string fullPath = this->MakefileMap->GetModulesFile(moduleName);
   retval = this->MakefileMap->ReadListFile(fullPath.c_str());
   // include FATAL_ERROR and ERROR in the return status
-  retval = retval && (! cmSystemTools::GetErrorOccuredFlag());
+  retval = retval && (!cmSystemTools::GetErrorOccuredFlag());
   return retval;
 }
 
 void cmCPackGenerator::SetOptionIfNotSet(const std::string& op,
-  const char* value)
+                                         const char* value)
 {
   const char* def = this->MakefileMap->GetDefinition(op);
-  if ( def && *def )
-    {
+  if (def && *def) {
     return;
-    }
+  }
   this->SetOption(op, value);
 }
 
 void cmCPackGenerator::SetOption(const std::string& op, const char* value)
 {
-  if ( !value )
-    {
+  if (!value) {
     this->MakefileMap->RemoveDefinition(op);
     return;
-    }
+  }
   cmCPackLogger(cmCPackLog::LOG_DEBUG, this->GetNameOfClass()
-    << "::SetOption(" << op << ", " << value << ")" << std::endl);
+                  << "::SetOption(" << op << ", " << value << ")"
+                  << std::endl);
   this->MakefileMap->AddDefinition(op, value);
 }
 
 int cmCPackGenerator::DoPackage()
 {
-  cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-    "Create package using " << this->Name << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Create package using " << this->Name
+                                                                << std::endl);
 
   // Prepare CPack internal name and check
   // values for many CPACK_xxx vars
-  if ( !this->PrepareNames() )
-    {
+  if (!this->PrepareNames()) {
     return 0;
-    }
+  }
 
   // Digest Component grouping specification
-  if ( !this->PrepareGroupingKind() )
-    {
+  if (!this->PrepareGroupingKind()) {
     return 0;
-    }
+  }
 
-  if ( cmSystemTools::IsOn(
-      this->GetOption("CPACK_REMOVE_TOPLEVEL_DIRECTORY")) )
-    {
-    const char* toplevelDirectory
-      = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
-    if ( cmSystemTools::FileExists(toplevelDirectory) )
-      {
-      cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-                    "Remove toplevel directory: "
-        << toplevelDirectory << std::endl);
-      if ( !cmSystemTools::RepeatedRemoveDirectory(toplevelDirectory) )
-        {
+  if (cmSystemTools::IsOn(
+        this->GetOption("CPACK_REMOVE_TOPLEVEL_DIRECTORY"))) {
+    const char* toplevelDirectory =
+      this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
+    if (cmSystemTools::FileExists(toplevelDirectory)) {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove toplevel directory: "
+                      << toplevelDirectory << std::endl);
+      if (!cmSystemTools::RepeatedRemoveDirectory(toplevelDirectory)) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Problem removing toplevel directory: "
-          << toplevelDirectory
-          << std::endl);
+                      "Problem removing toplevel directory: "
+                        << toplevelDirectory << std::endl);
         return 0;
-        }
       }
     }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                "About to install project " << std::endl);
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "About to install project "
+                  << std::endl);
 
-  if ( !this->InstallProject() )
-    {
+  if (!this->InstallProject()) {
     return 0;
-    }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                "Done install project " << std::endl);
-
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Done install project " << std::endl);
 
-  const char* tempPackageFileName = this->GetOption(
-    "CPACK_TEMPORARY_PACKAGE_FILE_NAME");
+  const char* tempPackageFileName =
+    this->GetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME");
   const char* tempDirectory = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
 
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Find files" << std::endl);
@@ -1066,27 +936,25 @@ int cmCPackGenerator::DoPackage()
   gl.RecurseOn();
   gl.SetRecurseListDirs(true);
   gl.SetRecurseThroughSymlinks(false);
-  if ( !gl.FindFiles(findExpr) )
-    {
+  if (!gl.FindFiles(findExpr)) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot find any files in the packaging tree" << std::endl);
+                  "Cannot find any files in the packaging tree" << std::endl);
     return 0;
-    }
+  }
 
   cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Create package" << std::endl);
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Package files to: "
-    << (tempPackageFileName ? tempPackageFileName : "(NULL)") << std::endl);
-  if ( cmSystemTools::FileExists(tempPackageFileName) )
-    {
+                  << (tempPackageFileName ? tempPackageFileName : "(NULL)")
+                  << std::endl);
+  if (cmSystemTools::FileExists(tempPackageFileName)) {
     cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Remove old package file"
-      << std::endl);
+                    << std::endl);
     cmSystemTools::RemoveFile(tempPackageFileName);
-    }
-  if ( cmSystemTools::IsOn(this->GetOption(
-        "CPACK_INCLUDE_TOPLEVEL_DIRECTORY")) )
-    {
+  }
+  if (cmSystemTools::IsOn(
+        this->GetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY"))) {
     tempDirectory = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
-    }
+  }
 
   // The files to be installed
   files = gl.GetFiles();
@@ -1099,12 +967,11 @@ int cmCPackGenerator::DoPackage()
    */
   packageFileNames.push_back(tempPackageFileName ? tempPackageFileName : "");
   toplevel = tempDirectory;
-  if ( !this->PackageFiles() || cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (!this->PackageFiles() || cmSystemTools::GetErrorOccuredFlag()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem compressing the directory"
-      << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
 
   /*
    * Copy the generated packages to final destination
@@ -1113,35 +980,29 @@ int cmCPackGenerator::DoPackage()
    *    (because the specific generator did 'normalize' it)
    */
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Copying final package(s) ["
-                   <<packageFileNames.size()
-                   <<"]:"<<std::endl);
+                  << packageFileNames.size() << "]:" << std::endl);
   std::vector<std::string>::iterator it;
   /* now copy package one by one */
-  for (it=packageFileNames.begin();it!=packageFileNames.end();++it)
-    {
+  for (it = packageFileNames.begin(); it != packageFileNames.end(); ++it) {
     std::string tmpPF(this->GetOption("CPACK_OUTPUT_FILE_PREFIX"));
     tempPackageFileName = it->c_str();
-    tmpPF += "/"+cmSystemTools::GetFilenameName(*it);
+    tmpPF += "/" + cmSystemTools::GetFilenameName(*it);
     const char* packageFileName = tmpPF.c_str();
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "Copy final package(s): "
-        << (tempPackageFileName ? tempPackageFileName : "(NULL)" )
-        << " to "
-        << (packageFileName ? packageFileName : "(NULL)")
-        << std::endl);
-    if ( !cmSystemTools::CopyFileIfDifferent(tempPackageFileName,
-        packageFileName) )
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the package: "
-          << (tempPackageFileName ? tempPackageFileName : "(NULL)" )
-          << " to "
-          << (packageFileName ? packageFileName : "(NULL)")
-          << std::endl);
+                    << (tempPackageFileName ? tempPackageFileName : "(NULL)")
+                    << " to " << (packageFileName ? packageFileName : "(NULL)")
+                    << std::endl);
+    if (!cmSystemTools::CopyFileIfDifferent(tempPackageFileName,
+                                            packageFileName)) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR, "Problem copying the package: "
+          << (tempPackageFileName ? tempPackageFileName : "(NULL)") << " to "
+          << (packageFileName ? packageFileName : "(NULL)") << std::endl);
       return 0;
-      }
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- package: "
-        << packageFileName
-        << " generated." << std::endl);
     }
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- package: "
+                    << packageFileName << " generated." << std::endl);
+  }
 
   return 1;
 }
@@ -1153,17 +1014,14 @@ int cmCPackGenerator::Initialize(const std::string& name, cmMakefile* mf)
   // set the running generator name
   this->SetOption("CPACK_GENERATOR", this->Name.c_str());
   // Load the project specific config file
-  const char* config =
-    this->GetOption("CPACK_PROJECT_CONFIG_FILE");
-  if(config)
-    {
+  const char* config = this->GetOption("CPACK_PROJECT_CONFIG_FILE");
+  if (config) {
     mf->ReadListFile(config);
-    }
+  }
   int result = this->InitializeInternal();
-  if (cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return 0;
-    }
+  }
 
   // If a generator subclass did not already set this option in its
   // InitializeInternal implementation, and the project did not already set
@@ -1191,13 +1049,10 @@ bool cmCPackGenerator::IsOn(const std::string& name) const
 const char* cmCPackGenerator::GetOption(const std::string& op) const
 {
   const char* ret = this->MakefileMap->GetDefinition(op);
-  if(!ret)
-    {
+  if (!ret) {
     cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                  "Warning, GetOption return NULL for: "
-                  << op
-                  << std::endl);
-    }
+                  "Warning, GetOption return NULL for: " << op << std::endl);
+  }
   return ret;
 }
 
@@ -1213,40 +1068,32 @@ int cmCPackGenerator::PackageFiles()
 
 const char* cmCPackGenerator::GetInstallPath()
 {
-  if ( !this->InstallPath.empty() )
-    {
+  if (!this->InstallPath.empty()) {
     return this->InstallPath.c_str();
-    }
+  }
 #if defined(_WIN32) && !defined(__CYGWIN__)
   const char* prgfiles = cmsys::SystemTools::GetEnv("ProgramFiles");
   const char* sysDrive = cmsys::SystemTools::GetEnv("SystemDrive");
-  if ( prgfiles )
-    {
+  if (prgfiles) {
     this->InstallPath = prgfiles;
-    }
-  else if ( sysDrive )
-    {
+  } else if (sysDrive) {
     this->InstallPath = sysDrive;
     this->InstallPath += "/Program Files";
-    }
-  else
-    {
+  } else {
     this->InstallPath = "c:/Program Files";
-    }
+  }
   this->InstallPath += "/";
   this->InstallPath += this->GetOption("CPACK_PACKAGE_NAME");
   this->InstallPath += "-";
   this->InstallPath += this->GetOption("CPACK_PACKAGE_VERSION");
 #elif defined(__HAIKU__)
   char dir[B_PATH_NAME_LENGTH];
-  if (find_directory(B_SYSTEM_DIRECTORY, -1, false, dir, sizeof(dir)) == B_OK)
-    {
+  if (find_directory(B_SYSTEM_DIRECTORY, -1, false, dir, sizeof(dir)) ==
+      B_OK) {
     this->InstallPath = dir;
-    }
-  else
-    {
+  } else {
     this->InstallPath = "/boot/system";
-    }
+  }
 #else
   this->InstallPath = "/usr/local/";
 #endif
@@ -1256,7 +1103,8 @@ const char* cmCPackGenerator::GetInstallPath()
 const char* cmCPackGenerator::GetPackagingInstallPrefix()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "GetPackagingInstallPrefix: '"
-    << this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX") << "'" << std::endl);
+                  << this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX") << "'"
+                  << std::endl);
 
   return this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
 }
@@ -1264,47 +1112,42 @@ const char* cmCPackGenerator::GetPackagingInstallPrefix()
 std::string cmCPackGenerator::FindTemplate(const char* name)
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Look for template: "
-    << (name ? name : "(NULL)") << std::endl);
+                  << (name ? name : "(NULL)") << std::endl);
   std::string ffile = this->MakefileMap->GetModulesFile(name);
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Found template: "
-    << ffile << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Found template: " << ffile
+                                                          << std::endl);
   return ffile;
 }
 
 bool cmCPackGenerator::ConfigureString(const std::string& inString,
-  std::string& outString)
+                                       std::string& outString)
 {
-  this->MakefileMap->ConfigureString(inString,
-    outString, true, false);
+  this->MakefileMap->ConfigureString(inString, outString, true, false);
   return true;
 }
 
-bool cmCPackGenerator::ConfigureFile(const char* inName,
-  const char* outName, bool copyOnly /* = false */)
+bool cmCPackGenerator::ConfigureFile(const char* inName, const char* outName,
+                                     bool copyOnly /* = false */)
 {
-  return this->MakefileMap->ConfigureFile(inName, outName,
-    copyOnly, true, false) == 1;
+  return this->MakefileMap->ConfigureFile(inName, outName, copyOnly, true,
+                                          false) == 1;
 }
 
 int cmCPackGenerator::CleanTemporaryDirectory()
 {
-  std::string tempInstallDirectoryWithPostfix
-    = this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
+  std::string tempInstallDirectoryWithPostfix =
+    this->GetOption("CPACK_TEMPORARY_INSTALL_DIRECTORY");
   const char* tempInstallDirectory = tempInstallDirectoryWithPostfix.c_str();
-  if(cmsys::SystemTools::FileExists(tempInstallDirectory))
-    {
+  if (cmsys::SystemTools::FileExists(tempInstallDirectory)) {
     cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                  "- Clean temporary : "
-                  << tempInstallDirectory << std::endl);
-    if(!cmSystemTools::RepeatedRemoveDirectory(tempInstallDirectory))
-      {
+                  "- Clean temporary : " << tempInstallDirectory << std::endl);
+    if (!cmSystemTools::RepeatedRemoveDirectory(tempInstallDirectory)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-                    "Problem removing temporary directory: " <<
-                    tempInstallDirectory
-                    << std::endl);
+                    "Problem removing temporary directory: "
+                      << tempInstallDirectory << std::endl);
       return 0;
-      }
     }
+  }
   return 1;
 }
 
@@ -1320,138 +1163,116 @@ int cmCPackGenerator::PrepareGroupingKind()
   // find a component package method specified by the user
   ComponentPackageMethod method = UNKNOWN_COMPONENT_PACKAGE_METHOD;
 
-  if(this->GetOption("CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE"))
-    {
+  if (this->GetOption("CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE")) {
     method = ONE_PACKAGE;
-    }
+  }
 
-  if(this->GetOption("CPACK_COMPONENTS_IGNORE_GROUPS"))
-    {
+  if (this->GetOption("CPACK_COMPONENTS_IGNORE_GROUPS")) {
     method = ONE_PACKAGE_PER_COMPONENT;
-    }
+  }
 
-  if(this->GetOption("CPACK_COMPONENTS_ONE_PACKAGE_PER_GROUP"))
-    {
+  if (this->GetOption("CPACK_COMPONENTS_ONE_PACKAGE_PER_GROUP")) {
     method = ONE_PACKAGE_PER_GROUP;
-    }
+  }
 
   std::string groupingType;
 
   // Second way to specify grouping
   if (NULL != this->GetOption("CPACK_COMPONENTS_GROUPING")) {
-     groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING");
+    groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING");
   }
 
-  if (!groupingType.empty())
-    {
-    cmCPackLogger(cmCPackLog::LOG_VERBOSE,  "["
-        << this->Name << "]"
-        << " requested component grouping = "<< groupingType <<std::endl);
-    if (groupingType == "ALL_COMPONENTS_IN_ONE")
-      {
+  if (!groupingType.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE, "["
+                    << this->Name << "]"
+                    << " requested component grouping = " << groupingType
+                    << std::endl);
+    if (groupingType == "ALL_COMPONENTS_IN_ONE") {
       method = ONE_PACKAGE;
-      }
-    else if (groupingType == "IGNORE")
-      {
+    } else if (groupingType == "IGNORE") {
       method = ONE_PACKAGE_PER_COMPONENT;
-      }
-    else if (groupingType == "ONE_PER_GROUP")
-      {
+    } else if (groupingType == "ONE_PER_GROUP") {
       method = ONE_PACKAGE_PER_GROUP;
-      }
-    else
-      {
-      cmCPackLogger(cmCPackLog::LOG_WARNING, "["
+    } else {
+      cmCPackLogger(
+        cmCPackLog::LOG_WARNING, "["
           << this->Name << "]"
-          << " requested component grouping type <"<< groupingType
+          << " requested component grouping type <" << groupingType
           << "> UNKNOWN not in (ALL_COMPONENTS_IN_ONE,IGNORE,ONE_PER_GROUP)"
           << std::endl);
-      }
     }
+  }
 
   // Some components were defined but NO group
   // fallback to default if not group based
-  if(method == ONE_PACKAGE_PER_GROUP &&
-     this->ComponentGroups.empty() && !this->Components.empty())
-    {
-    if(componentPackageMethod == ONE_PACKAGE)
-      {
+  if (method == ONE_PACKAGE_PER_GROUP && this->ComponentGroups.empty() &&
+      !this->Components.empty()) {
+    if (componentPackageMethod == ONE_PACKAGE) {
       method = ONE_PACKAGE;
-      }
-    else
-      {
+    } else {
       method = ONE_PACKAGE_PER_COMPONENT;
-      }
-    cmCPackLogger(cmCPackLog::LOG_WARNING, "["
-         << this->Name << "]"
-         << " One package per component group requested, "
-         << "but NO component groups exist: Ignoring component group."
-         << std::endl);
     }
+    cmCPackLogger(
+      cmCPackLog::LOG_WARNING, "["
+        << this->Name << "]"
+        << " One package per component group requested, "
+        << "but NO component groups exist: Ignoring component group."
+        << std::endl);
+  }
 
   // if user specified packaging method, override the default packaging method
-  if(method != UNKNOWN_COMPONENT_PACKAGE_METHOD)
-    {
+  if (method != UNKNOWN_COMPONENT_PACKAGE_METHOD) {
     componentPackageMethod = method;
-    }
+  }
 
-  const char* method_names[] =
-    {
-    "ALL_COMPONENTS_IN_ONE",
-    "IGNORE_GROUPS",
-    "ONE_PER_GROUP"
-    };
+  const char* method_names[] = { "ALL_COMPONENTS_IN_ONE", "IGNORE_GROUPS",
+                                 "ONE_PER_GROUP" };
 
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE,  "["
-        << this->Name << "]"
-        << " requested component grouping = "
-        << method_names[componentPackageMethod]
-        << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "["
+                  << this->Name << "]"
+                  << " requested component grouping = "
+                  << method_names[componentPackageMethod] << std::endl);
 
   return 1;
 }
 
 std::string cmCPackGenerator::GetComponentInstallDirNameSuffix(
-    const std::string& componentName) {
+  const std::string& componentName)
+{
   return componentName;
 }
 std::string cmCPackGenerator::GetComponentPackageFileName(
-    const std::string& initialPackageFileName,
-    const std::string& groupOrComponentName,
-    bool isGroupName) {
+  const std::string& initialPackageFileName,
+  const std::string& groupOrComponentName, bool isGroupName)
+{
 
   /*
    * the default behavior is to use the
    * component [group] name as a suffix
    */
-  std::string suffix="-"+groupOrComponentName;
+  std::string suffix = "-" + groupOrComponentName;
   /* check if we should use DISPLAY name */
-  std::string dispNameVar = "CPACK_"+Name+"_USE_DISPLAY_NAME_IN_FILENAME";
-  if (IsOn(dispNameVar))
-    {
+  std::string dispNameVar = "CPACK_" + Name + "_USE_DISPLAY_NAME_IN_FILENAME";
+  if (IsOn(dispNameVar)) {
     /* the component Group case */
-    if (isGroupName)
-      {
-      std::string groupDispVar = "CPACK_COMPONENT_GROUP_"
-          + cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
+    if (isGroupName) {
+      std::string groupDispVar = "CPACK_COMPONENT_GROUP_" +
+        cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
       const char* groupDispName = GetOption(groupDispVar);
-      if (groupDispName)
-        {
-        suffix = "-"+std::string(groupDispName);
-        }
+      if (groupDispName) {
+        suffix = "-" + std::string(groupDispName);
       }
+    }
     /* the [single] component case */
-    else
-      {
-      std::string dispVar = "CPACK_COMPONENT_"
-           + cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
-            const char* dispName = GetOption(dispVar);
-            if(dispName)
-              {
-              suffix = "-"+std::string(dispName);
-              }
-            }
+    else {
+      std::string dispVar = "CPACK_COMPONENT_" +
+        cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
+      const char* dispName = GetOption(dispVar);
+      if (dispName) {
+        suffix = "-" + std::string(dispName);
       }
+    }
+  }
   return initialPackageFileName + suffix;
 }
 
@@ -1473,183 +1294,137 @@ bool cmCPackGenerator::SupportsComponentInstallation() const
 
 bool cmCPackGenerator::WantsComponentInstallation() const
 {
-  return (!IsOn("CPACK_MONOLITHIC_INSTALL")
-        && SupportsComponentInstallation()
-        // check that we have at least one group or component
-        && (!this->ComponentGroups.empty() || !this->Components.empty()));
+  return (!IsOn("CPACK_MONOLITHIC_INSTALL") && SupportsComponentInstallation()
+          // check that we have at least one group or component
+          && (!this->ComponentGroups.empty() || !this->Components.empty()));
 }
 
-cmCPackInstallationType*
-cmCPackGenerator::GetInstallationType(const std::string& projectName,
-                                      const std::string& name)
+cmCPackInstallationType* cmCPackGenerator::GetInstallationType(
+  const std::string& projectName, const std::string& name)
 {
-  (void) projectName;
+  (void)projectName;
   bool hasInstallationType = this->InstallationTypes.count(name) != 0;
-  cmCPackInstallationType *installType = &this->InstallationTypes[name];
-  if (!hasInstallationType)
-    {
+  cmCPackInstallationType* installType = &this->InstallationTypes[name];
+  if (!hasInstallationType) {
     // Define the installation type
-    std::string macroPrefix = "CPACK_INSTALL_TYPE_"
-      + cmsys::SystemTools::UpperCase(name);
+    std::string macroPrefix =
+      "CPACK_INSTALL_TYPE_" + cmsys::SystemTools::UpperCase(name);
     installType->Name = name;
 
-    const char* displayName
-      = this->GetOption(macroPrefix + "_DISPLAY_NAME");
-    if (displayName && *displayName)
-      {
+    const char* displayName = this->GetOption(macroPrefix + "_DISPLAY_NAME");
+    if (displayName && *displayName) {
       installType->DisplayName = displayName;
-      }
-    else
-      {
+    } else {
       installType->DisplayName = installType->Name;
-      }
-
-    installType->Index = static_cast<unsigned>(
-      this->InstallationTypes.size());
     }
+
+    installType->Index = static_cast<unsigned>(this->InstallationTypes.size());
+  }
   return installType;
 }
 
-cmCPackComponent*
-cmCPackGenerator::GetComponent(const std::string& projectName,
-                               const std::string& name)
+cmCPackComponent* cmCPackGenerator::GetComponent(
+  const std::string& projectName, const std::string& name)
 {
   bool hasComponent = this->Components.count(name) != 0;
-  cmCPackComponent *component = &this->Components[name];
-  if (!hasComponent)
-    {
+  cmCPackComponent* component = &this->Components[name];
+  if (!hasComponent) {
     // Define the component
-    std::string macroPrefix = "CPACK_COMPONENT_"
-      + cmsys::SystemTools::UpperCase(name);
+    std::string macroPrefix =
+      "CPACK_COMPONENT_" + cmsys::SystemTools::UpperCase(name);
     component->Name = name;
-    const char* displayName
-      = this->GetOption(macroPrefix + "_DISPLAY_NAME");
-    if (displayName && *displayName)
-      {
+    const char* displayName = this->GetOption(macroPrefix + "_DISPLAY_NAME");
+    if (displayName && *displayName) {
       component->DisplayName = displayName;
-      }
-    else
-      {
+    } else {
       component->DisplayName = component->Name;
-      }
-    component->IsHidden
-      = this->IsOn(macroPrefix + "_HIDDEN");
-    component->IsRequired
-      = this->IsOn(macroPrefix + "_REQUIRED");
-    component->IsDisabledByDefault
-      = this->IsOn(macroPrefix + "_DISABLED");
-    component->IsDownloaded
-      = this->IsOn(macroPrefix + "_DOWNLOADED")
-        || cmSystemTools::IsOn(this->GetOption("CPACK_DOWNLOAD_ALL"));
-
-    const char* archiveFile = this->GetOption(macroPrefix +
-                                               "_ARCHIVE_FILE");
-    if (archiveFile && *archiveFile)
-      {
+    }
+    component->IsHidden = this->IsOn(macroPrefix + "_HIDDEN");
+    component->IsRequired = this->IsOn(macroPrefix + "_REQUIRED");
+    component->IsDisabledByDefault = this->IsOn(macroPrefix + "_DISABLED");
+    component->IsDownloaded = this->IsOn(macroPrefix + "_DOWNLOADED") ||
+      cmSystemTools::IsOn(this->GetOption("CPACK_DOWNLOAD_ALL"));
+
+    const char* archiveFile = this->GetOption(macroPrefix + "_ARCHIVE_FILE");
+    if (archiveFile && *archiveFile) {
       component->ArchiveFile = archiveFile;
-      }
+    }
 
     const char* groupName = this->GetOption(macroPrefix + "_GROUP");
-    if (groupName && *groupName)
-      {
+    if (groupName && *groupName) {
       component->Group = GetComponentGroup(projectName, groupName);
       component->Group->Components.push_back(component);
-      }
-    else
-      {
+    } else {
       component->Group = 0;
-      }
+    }
 
-    const char* description
-      = this->GetOption(macroPrefix + "_DESCRIPTION");
-    if (description && *description)
-      {
+    const char* description = this->GetOption(macroPrefix + "_DESCRIPTION");
+    if (description && *description) {
       component->Description = description;
-      }
+    }
 
     // Determine the installation types.
-    const char *installTypes
-      = this->GetOption(macroPrefix + "_INSTALL_TYPES");
-    if (installTypes && *installTypes)
-      {
+    const char* installTypes = this->GetOption(macroPrefix + "_INSTALL_TYPES");
+    if (installTypes && *installTypes) {
       std::vector<std::string> installTypesVector;
       cmSystemTools::ExpandListArgument(installTypes, installTypesVector);
       std::vector<std::string>::iterator installTypesIt;
       for (installTypesIt = installTypesVector.begin();
-           installTypesIt != installTypesVector.end();
-           ++installTypesIt)
-        {
+           installTypesIt != installTypesVector.end(); ++installTypesIt) {
         component->InstallationTypes.push_back(
           this->GetInstallationType(projectName, *installTypesIt));
-        }
       }
+    }
 
     // Determine the component dependencies.
-    const char *depends = this->GetOption(macroPrefix + "_DEPENDS");
-    if (depends && *depends)
-      {
+    const char* depends = this->GetOption(macroPrefix + "_DEPENDS");
+    if (depends && *depends) {
       std::vector<std::string> dependsVector;
       cmSystemTools::ExpandListArgument(depends, dependsVector);
       std::vector<std::string>::iterator dependIt;
-      for (dependIt = dependsVector.begin();
-           dependIt != dependsVector.end();
-           ++dependIt)
-        {
-        cmCPackComponent *child = GetComponent(projectName,
-                                               *dependIt);
+      for (dependIt = dependsVector.begin(); dependIt != dependsVector.end();
+           ++dependIt) {
+        cmCPackComponent* child = GetComponent(projectName, *dependIt);
         component->Dependencies.push_back(child);
         child->ReverseDependencies.push_back(component);
-        }
       }
     }
+  }
   return component;
 }
 
-cmCPackComponentGroup*
-cmCPackGenerator::GetComponentGroup(const std::string& projectName,
-                                    const std::string& name)
+cmCPackComponentGroup* cmCPackGenerator::GetComponentGroup(
+  const std::string& projectName, const std::string& name)
 {
-  (void) projectName;
-  std::string macroPrefix = "CPACK_COMPONENT_GROUP_"
-        + cmsys::SystemTools::UpperCase(name);
+  (void)projectName;
+  std::string macroPrefix =
+    "CPACK_COMPONENT_GROUP_" + cmsys::SystemTools::UpperCase(name);
   bool hasGroup = this->ComponentGroups.count(name) != 0;
-  cmCPackComponentGroup *group = &this->ComponentGroups[name];
-  if (!hasGroup)
-    {
+  cmCPackComponentGroup* group = &this->ComponentGroups[name];
+  if (!hasGroup) {
     // Define the group
     group->Name = name;
-    const char* displayName
-      = this->GetOption(macroPrefix + "_DISPLAY_NAME");
-    if (displayName && *displayName)
-      {
+    const char* displayName = this->GetOption(macroPrefix + "_DISPLAY_NAME");
+    if (displayName && *displayName) {
       group->DisplayName = displayName;
-      }
-    else
-      {
+    } else {
       group->DisplayName = group->Name;
-      }
+    }
 
-    const char* description
-      = this->GetOption(macroPrefix + "_DESCRIPTION");
-    if (description && *description)
-      {
+    const char* description = this->GetOption(macroPrefix + "_DESCRIPTION");
+    if (description && *description) {
       group->Description = description;
-      }
-    group->IsBold
-      = this->IsOn(macroPrefix + "_BOLD_TITLE");
-    group->IsExpandedByDefault
-      = this->IsOn(macroPrefix + "_EXPANDED");
-    const char* parentGroupName
-      = this->GetOption(macroPrefix + "_PARENT_GROUP");
-    if (parentGroupName && *parentGroupName)
-      {
+    }
+    group->IsBold = this->IsOn(macroPrefix + "_BOLD_TITLE");
+    group->IsExpandedByDefault = this->IsOn(macroPrefix + "_EXPANDED");
+    const char* parentGroupName =
+      this->GetOption(macroPrefix + "_PARENT_GROUP");
+    if (parentGroupName && *parentGroupName) {
       group->ParentGroup = GetComponentGroup(projectName, parentGroupName);
       group->ParentGroup->Subgroups.push_back(group);
-      }
-    else
-      {
+    } else {
       group->ParentGroup = 0;
-      }
     }
+  }
   return group;
 }
diff --git a/Source/CPack/cmCPackGenerator.h b/Source/CPack/cmCPackGenerator.h
index 3a53d05..ce93715 100644
--- a/Source/CPack/cmCPackGenerator.h
+++ b/Source/CPack/cmCPackGenerator.h
@@ -20,29 +20,29 @@
 #include <vector>
 
 #include "cmCPackComponentGroup.h" // cmCPackComponent and friends
-  // Forward declarations are insufficient since we use them in
-  // std::map data members below...
+// Forward declarations are insufficient since we use them in
+// std::map data members below...
 
-#define cmCPackTypeMacro(klass, superclass) \
-  cmTypeMacro(klass, superclass); \
-  static cmCPackGenerator* CreateGenerator() { return new klass; } \
+#define cmCPackTypeMacro(klass, superclass)                                   \
+  cmTypeMacro(klass, superclass);                                             \
+  static cmCPackGenerator* CreateGenerator() { return new klass; }            \
   class cmCPackTypeMacro_UseTrailingSemicolon
 
-#define cmCPackLogger(logType, msg) \
-  do { \
-    std::ostringstream cmCPackLog_msg; \
-    cmCPackLog_msg << msg; \
-    this->Logger->Log(logType, __FILE__, __LINE__,\
-                      cmCPackLog_msg.str().c_str());\
-  } while ( 0 )
+#define cmCPackLogger(logType, msg)                                           \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    this->Logger->Log(logType, __FILE__, __LINE__,                            \
+                      cmCPackLog_msg.str().c_str());                          \
+  } while (0)
 
 #ifdef cerr
-#  undef cerr
+#undef cerr
 #endif
 #define cerr no_cerr_use_cmCPack_Log
 
 #ifdef cout
-#  undef cout
+#undef cout
 #endif
 #define cout no_cout_use_cmCPack_Log
 
@@ -62,8 +62,10 @@ public:
    * If verbose then more information is printed out
    */
   void SetVerbose(bool val)
-    { this->GeneratorVerbose = val ?
-      cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE; }
+  {
+    this->GeneratorVerbose =
+      val ? cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE;
+  }
 
   /**
    * Returns true if the generator may work on this system.
@@ -157,7 +159,7 @@ protected:
    *         default is "componentName"
    */
   virtual std::string GetComponentInstallDirNameSuffix(
-      const std::string& componentName);
+    const std::string& componentName);
 
   /**
    * CPack specific generator may mangle CPACK_PACKAGE_FILE_NAME
@@ -169,9 +171,8 @@ protected:
    *            false otherwise
    */
   virtual std::string GetComponentPackageFileName(
-      const std::string& initialPackageFileName,
-      const std::string& groupOrComponentName,
-      bool isGroupName);
+    const std::string& initialPackageFileName,
+    const std::string& groupOrComponentName, bool isGroupName);
 
   /**
    * Package the list of files and/or components which
@@ -188,11 +189,10 @@ protected:
 
   virtual std::string FindTemplate(const char* name);
   virtual bool ConfigureFile(const char* inName, const char* outName,
-    bool copyOnly = false);
+                             bool copyOnly = false);
   virtual bool ConfigureString(const std::string& input, std::string& output);
   virtual int InitializeInternal();
 
-
   //! Run install commands if specified
   virtual int InstallProjectViaInstallCommands(
     bool setDestDir, const std::string& tempInstallDirectory);
@@ -207,7 +207,8 @@ protected:
    * The various level of support of
    * CPACK_SET_DESTDIR used by the generator.
    */
-  enum CPackSetDestdirSupport {
+  enum CPackSetDestdirSupport
+  {
     /* the generator works with or without it */
     SETDESTDIR_SUPPORTED,
     /* the generator works best if automatically handled */
@@ -251,13 +252,11 @@ protected:
    */
   virtual bool WantsComponentInstallation() const;
   virtual cmCPackInstallationType* GetInstallationType(
-                                                const std::string& projectName,
-                                                const std::string& name);
+    const std::string& projectName, const std::string& name);
   virtual cmCPackComponent* GetComponent(const std::string& projectName,
                                          const std::string& name);
   virtual cmCPackComponentGroup* GetComponentGroup(
-                                                const std::string& projectName,
-                                                const std::string& name);
+    const std::string& projectName, const std::string& name);
 
   cmSystemTools::OutputOption GeneratorVerbose;
   std::string Name;
@@ -324,6 +323,7 @@ protected:
   ComponentPackageMethod componentPackageMethod;
 
   cmCPackLog* Logger;
+
 private:
   cmMakefile* MakefileMap;
 };
diff --git a/Source/CPack/cmCPackGeneratorFactory.cxx b/Source/CPack/cmCPackGeneratorFactory.cxx
index 5a63dbc..b17f52e 100644
--- a/Source/CPack/cmCPackGeneratorFactory.cxx
+++ b/Source/CPack/cmCPackGeneratorFactory.cxx
@@ -24,134 +24,115 @@
 #include "cmCPackZIPGenerator.h"
 
 #ifdef __APPLE__
-#   include "cmCPackBundleGenerator.h"
-#   include "cmCPackDragNDropGenerator.h"
-#   include "cmCPackOSXX11Generator.h"
-#   include "cmCPackPackageMakerGenerator.h"
+#include "cmCPackBundleGenerator.h"
+#include "cmCPackDragNDropGenerator.h"
+#include "cmCPackOSXX11Generator.h"
+#include "cmCPackPackageMakerGenerator.h"
 #endif
 
 #ifdef __CYGWIN__
-#  include "cmCPackCygwinBinaryGenerator.h"
-#  include "cmCPackCygwinSourceGenerator.h"
+#include "cmCPackCygwinBinaryGenerator.h"
+#include "cmCPackCygwinSourceGenerator.h"
 #endif
 
-#if !defined(_WIN32) \
- && !defined(__QNXNTO__) && !defined(__BEOS__) && !defined(__HAIKU__)
-#  include "cmCPackDebGenerator.h"
-#  include "cmCPackRPMGenerator.h"
+#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) &&         \
+  !defined(__HAIKU__)
+#include "cmCPackDebGenerator.h"
+#include "cmCPackRPMGenerator.h"
 #endif
 
 #ifdef _WIN32
-#  include "WiX/cmCPackWIXGenerator.h"
+#include "WiX/cmCPackWIXGenerator.h"
 #endif
 
 #include "cmAlgorithms.h"
 #include "cmCPackLog.h"
 
-
 cmCPackGeneratorFactory::cmCPackGeneratorFactory()
 {
-  if (cmCPackTGZGenerator::CanGenerate())
-    {
+  if (cmCPackTGZGenerator::CanGenerate()) {
     this->RegisterGenerator("TGZ", "Tar GZip compression",
-      cmCPackTGZGenerator::CreateGenerator);
-    }
-  if (cmCPackTXZGenerator::CanGenerate())
-    {
+                            cmCPackTGZGenerator::CreateGenerator);
+  }
+  if (cmCPackTXZGenerator::CanGenerate()) {
     this->RegisterGenerator("TXZ", "Tar XZ compression",
-      cmCPackTXZGenerator::CreateGenerator);
-    }
-  if (cmCPackSTGZGenerator::CanGenerate())
-    {
+                            cmCPackTXZGenerator::CreateGenerator);
+  }
+  if (cmCPackSTGZGenerator::CanGenerate()) {
     this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
-      cmCPackSTGZGenerator::CreateGenerator);
-    }
-  if (cmCPackNSISGenerator::CanGenerate())
-    {
+                            cmCPackSTGZGenerator::CreateGenerator);
+  }
+  if (cmCPackNSISGenerator::CanGenerate()) {
     this->RegisterGenerator("NSIS", "Null Soft Installer",
-      cmCPackNSISGenerator::CreateGenerator);
+                            cmCPackNSISGenerator::CreateGenerator);
     this->RegisterGenerator("NSIS64", "Null Soft Installer (64-bit)",
-      cmCPackNSISGenerator::CreateGenerator64);
-    }
-  if (cmCPackIFWGenerator::CanGenerate())
-    {
+                            cmCPackNSISGenerator::CreateGenerator64);
+  }
+  if (cmCPackIFWGenerator::CanGenerate()) {
     this->RegisterGenerator("IFW", "Qt Installer Framework",
-      cmCPackIFWGenerator::CreateGenerator);
-    }
+                            cmCPackIFWGenerator::CreateGenerator);
+  }
 #ifdef __CYGWIN__
-  if (cmCPackCygwinBinaryGenerator::CanGenerate())
-    {
+  if (cmCPackCygwinBinaryGenerator::CanGenerate()) {
     this->RegisterGenerator("CygwinBinary", "Cygwin Binary Installer",
                             cmCPackCygwinBinaryGenerator::CreateGenerator);
-    }
-  if (cmCPackCygwinSourceGenerator::CanGenerate())
-    {
+  }
+  if (cmCPackCygwinSourceGenerator::CanGenerate()) {
     this->RegisterGenerator("CygwinSource", "Cygwin Source Installer",
                             cmCPackCygwinSourceGenerator::CreateGenerator);
-    }
+  }
 #endif
 
-  if (cmCPackZIPGenerator::CanGenerate())
-    {
+  if (cmCPackZIPGenerator::CanGenerate()) {
     this->RegisterGenerator("ZIP", "ZIP file format",
-      cmCPackZIPGenerator::CreateGenerator);
-    }
-  if (cmCPack7zGenerator::CanGenerate())
-    {
+                            cmCPackZIPGenerator::CreateGenerator);
+  }
+  if (cmCPack7zGenerator::CanGenerate()) {
     this->RegisterGenerator("7Z", "7-Zip file format",
-      cmCPack7zGenerator::CreateGenerator);
-    }
+                            cmCPack7zGenerator::CreateGenerator);
+  }
 #ifdef _WIN32
-  if (cmCPackWIXGenerator::CanGenerate())
-    {
+  if (cmCPackWIXGenerator::CanGenerate()) {
     this->RegisterGenerator("WIX", "MSI file format via WiX tools",
-      cmCPackWIXGenerator::CreateGenerator);
-    }
+                            cmCPackWIXGenerator::CreateGenerator);
+  }
 #endif
-  if (cmCPackTarBZip2Generator::CanGenerate())
-    {
+  if (cmCPackTarBZip2Generator::CanGenerate()) {
     this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
-      cmCPackTarBZip2Generator::CreateGenerator);
-    }
-  if (cmCPackTarCompressGenerator::CanGenerate())
-    {
+                            cmCPackTarBZip2Generator::CreateGenerator);
+  }
+  if (cmCPackTarCompressGenerator::CanGenerate()) {
     this->RegisterGenerator("TZ", "Tar Compress compression",
-      cmCPackTarCompressGenerator::CreateGenerator);
-    }
+                            cmCPackTarCompressGenerator::CreateGenerator);
+  }
 #ifdef __APPLE__
-  if (cmCPackDragNDropGenerator::CanGenerate())
-    {
+  if (cmCPackDragNDropGenerator::CanGenerate()) {
     this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
-      cmCPackDragNDropGenerator::CreateGenerator);
-    }
-  if (cmCPackBundleGenerator::CanGenerate())
-    {
+                            cmCPackDragNDropGenerator::CreateGenerator);
+  }
+  if (cmCPackBundleGenerator::CanGenerate()) {
     this->RegisterGenerator("Bundle", "Mac OSX bundle",
-      cmCPackBundleGenerator::CreateGenerator);
-    }
-  if (cmCPackPackageMakerGenerator::CanGenerate())
-    {
+                            cmCPackBundleGenerator::CreateGenerator);
+  }
+  if (cmCPackPackageMakerGenerator::CanGenerate()) {
     this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
-      cmCPackPackageMakerGenerator::CreateGenerator);
-    }
-  if (cmCPackOSXX11Generator::CanGenerate())
-    {
+                            cmCPackPackageMakerGenerator::CreateGenerator);
+  }
+  if (cmCPackOSXX11Generator::CanGenerate()) {
     this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
-      cmCPackOSXX11Generator::CreateGenerator);
-    }
+                            cmCPackOSXX11Generator::CreateGenerator);
+  }
 #endif
-#if !defined(_WIN32) \
-  && !defined(__QNXNTO__) && !defined(__BEOS__) && !defined(__HAIKU__)
-  if (cmCPackDebGenerator::CanGenerate())
-    {
+#if !defined(_WIN32) && !defined(__QNXNTO__) && !defined(__BEOS__) &&         \
+  !defined(__HAIKU__)
+  if (cmCPackDebGenerator::CanGenerate()) {
     this->RegisterGenerator("DEB", "Debian packages",
-      cmCPackDebGenerator::CreateGenerator);
-    }
-  if (cmCPackRPMGenerator::CanGenerate())
-    {
+                            cmCPackDebGenerator::CreateGenerator);
+  }
+  if (cmCPackRPMGenerator::CanGenerate()) {
     this->RegisterGenerator("RPM", "RPM packages",
-      cmCPackRPMGenerator::CreateGenerator);
-    }
+                            cmCPackRPMGenerator::CreateGenerator);
+  }
 #endif
 }
 
@@ -161,13 +142,12 @@ cmCPackGeneratorFactory::~cmCPackGeneratorFactory()
 }
 
 cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
-                                                const std::string& name)
+  const std::string& name)
 {
   cmCPackGenerator* gen = this->NewGeneratorInternal(name);
-  if ( !gen )
-    {
+  if (!gen) {
     return 0;
-    }
+  }
   this->Generators.push_back(gen);
   gen->SetLogger(this->Logger);
   return gen;
@@ -176,25 +156,23 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator(
 cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal(
   const std::string& name)
 {
-  cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it
-    = this->GeneratorCreators.find(name);
-  if ( it == this->GeneratorCreators.end() )
-    {
+  cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it =
+    this->GeneratorCreators.find(name);
+  if (it == this->GeneratorCreators.end()) {
     return 0;
-    }
+  }
   return (it->second)();
 }
 
-void cmCPackGeneratorFactory::RegisterGenerator(const std::string& name,
-  const char* generatorDescription,
+void cmCPackGeneratorFactory::RegisterGenerator(
+  const std::string& name, const char* generatorDescription,
   CreateGeneratorCall* createGenerator)
 {
-  if ( !createGenerator )
-    {
+  if (!createGenerator) {
     cmCPack_Log(this->Logger, cmCPackLog::LOG_ERROR,
-      "Cannot register generator" << std::endl);
+                "Cannot register generator" << std::endl);
     return;
-    }
+  }
   this->GeneratorCreators[name] = createGenerator;
   this->GeneratorDescriptions[name] = generatorDescription;
 }
diff --git a/Source/CPack/cmCPackGeneratorFactory.h b/Source/CPack/cmCPackGeneratorFactory.h
index 010777f..a55ec6e 100644
--- a/Source/CPack/cmCPackGeneratorFactory.h
+++ b/Source/CPack/cmCPackGeneratorFactory.h
@@ -37,14 +37,16 @@ public:
   typedef cmCPackGenerator* CreateGeneratorCall();
 
   void RegisterGenerator(const std::string& name,
-    const char* generatorDescription,
-    CreateGeneratorCall* createGenerator);
+                         const char* generatorDescription,
+                         CreateGeneratorCall* createGenerator);
 
   void SetLogger(cmCPackLog* logger) { this->Logger = logger; }
 
   typedef std::map<std::string, std::string> DescriptionsMap;
   const DescriptionsMap& GetGeneratorsList() const
-    { return this->GeneratorDescriptions; }
+  {
+    return this->GeneratorDescriptions;
+  }
 
 private:
   cmCPackGenerator* NewGeneratorInternal(const std::string& name);
diff --git a/Source/CPack/cmCPackLog.cxx b/Source/CPack/cmCPackLog.cxx
index 61d97c8..ff06eb8 100644
--- a/Source/CPack/cmCPackLog.cxx
+++ b/Source/CPack/cmCPackLog.cxx
@@ -39,37 +39,33 @@ cmCPackLog::~cmCPackLog()
 
 void cmCPackLog::SetLogOutputStream(std::ostream* os)
 {
-  if ( this->LogOutputCleanup && this->LogOutput )
-    {
+  if (this->LogOutputCleanup && this->LogOutput) {
     delete this->LogOutput;
-    }
+  }
   this->LogOutputCleanup = false;
   this->LogOutput = os;
 }
 
 bool cmCPackLog::SetLogOutputFile(const char* fname)
 {
-  cmGeneratedFileStream *cg = 0;
-  if ( fname )
-    {
+  cmGeneratedFileStream* cg = 0;
+  if (fname) {
     cg = new cmGeneratedFileStream(fname);
-    }
-  if ( cg && !*cg )
-    {
+  }
+  if (cg && !*cg) {
     delete cg;
     cg = 0;
-    }
+  }
   this->SetLogOutputStream(cg);
-  if ( !cg )
-    {
+  if (!cg) {
     return false;
-    }
+  }
   this->LogOutputCleanup = true;
   return true;
 }
 
-void cmCPackLog::Log(int tag, const char* file, int line,
-  const char* msg, size_t length)
+void cmCPackLog::Log(int tag, const char* file, int line, const char* msg,
+                     size_t length)
 {
   // By default no logging
   bool display = false;
@@ -77,144 +73,118 @@ void cmCPackLog::Log(int tag, const char* file, int line,
   // Display file and line number if debug
   bool useFileAndLine = this->Debug;
 
-  bool output  = false;
-  bool debug   = false;
+  bool output = false;
+  bool debug = false;
   bool warning = false;
-  bool error   = false;
+  bool error = false;
   bool verbose = false;
 
   // When writing in file, add list of tags whenever tag changes.
   std::string tagString;
   bool needTagString = false;
-  if ( this->LogOutput && this->LastTag != tag )
-    {
+  if (this->LogOutput && this->LastTag != tag) {
     needTagString = true;
-    }
+  }
 
-  if ( tag & LOG_OUTPUT )
-    {
+  if (tag & LOG_OUTPUT) {
     output = true;
     display = true;
-    if ( needTagString )
-      {
-      if (!tagString.empty()) { tagString += ","; }
-      tagString = "VERBOSE";
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
       }
+      tagString = "VERBOSE";
     }
-  if ( tag & LOG_WARNING )
-    {
+  }
+  if (tag & LOG_WARNING) {
     warning = true;
     display = true;
-    if ( needTagString )
-      {
-      if (!tagString.empty()) { tagString += ","; }
-      tagString = "WARNING";
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
       }
+      tagString = "WARNING";
     }
-  if ( tag & LOG_ERROR )
-    {
+  }
+  if (tag & LOG_ERROR) {
     error = true;
     display = true;
-    if ( needTagString )
-      {
-      if (!tagString.empty()) { tagString += ","; }
-      tagString = "ERROR";
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
       }
+      tagString = "ERROR";
     }
-  if ( tag & LOG_DEBUG && this->Debug )
-    {
+  }
+  if (tag & LOG_DEBUG && this->Debug) {
     debug = true;
     display = true;
-    if ( needTagString )
-      {
-      if (!tagString.empty()) { tagString += ","; }
-      tagString = "DEBUG";
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
       }
-    useFileAndLine = true;
+      tagString = "DEBUG";
     }
-  if ( tag & LOG_VERBOSE && this->Verbose )
-    {
+    useFileAndLine = true;
+  }
+  if (tag & LOG_VERBOSE && this->Verbose) {
     verbose = true;
     display = true;
-    if ( needTagString )
-      {
-      if (!tagString.empty()) { tagString += ","; }
-      tagString = "VERBOSE";
+    if (needTagString) {
+      if (!tagString.empty()) {
+        tagString += ",";
       }
+      tagString = "VERBOSE";
     }
-  if ( this->Quiet )
-    {
+  }
+  if (this->Quiet) {
     display = false;
+  }
+  if (this->LogOutput) {
+    if (needTagString) {
+      *this->LogOutput << "[" << file << ":" << line << " " << tagString
+                       << "] ";
     }
-  if ( this->LogOutput )
-    {
-    if ( needTagString )
-      {
-      *this->LogOutput << "[" << file << ":" << line << " "
-        << tagString << "] ";
-      }
     this->LogOutput->write(msg, length);
-    }
+  }
   this->LastTag = tag;
-  if ( !display )
-    {
+  if (!display) {
     return;
-    }
-  if ( this->NewLine )
-    {
-    if ( error && !this->ErrorPrefix.empty() )
-      {
+  }
+  if (this->NewLine) {
+    if (error && !this->ErrorPrefix.empty()) {
       *this->DefaultError << this->ErrorPrefix;
-      }
-    else if ( warning && !this->WarningPrefix.empty() )
-      {
+    } else if (warning && !this->WarningPrefix.empty()) {
       *this->DefaultError << this->WarningPrefix;
-      }
-    else if ( output && !this->OutputPrefix.empty() )
-      {
+    } else if (output && !this->OutputPrefix.empty()) {
       *this->DefaultOutput << this->OutputPrefix;
-      }
-    else if ( verbose && !this->VerbosePrefix.empty() )
-      {
+    } else if (verbose && !this->VerbosePrefix.empty()) {
       *this->DefaultOutput << this->VerbosePrefix;
-      }
-    else if ( debug && !this->DebugPrefix.empty() )
-      {
+    } else if (debug && !this->DebugPrefix.empty()) {
       *this->DefaultOutput << this->DebugPrefix;
-      }
-    else if ( !this->Prefix.empty() )
-      {
+    } else if (!this->Prefix.empty()) {
       *this->DefaultOutput << this->Prefix;
-      }
-    if ( useFileAndLine )
-      {
-      if ( error || warning )
-        {
+    }
+    if (useFileAndLine) {
+      if (error || warning) {
         *this->DefaultError << file << ":" << line << " ";
-        }
-      else
-        {
+      } else {
         *this->DefaultOutput << file << ":" << line << " ";
-        }
       }
     }
-  if ( error || warning )
-    {
+  }
+  if (error || warning) {
     this->DefaultError->write(msg, length);
     this->DefaultError->flush();
-    }
-  else
-    {
+  } else {
     this->DefaultOutput->write(msg, length);
     this->DefaultOutput->flush();
-    }
-  if ( msg[length-1] == '\n' || length > 2 )
-    {
+  }
+  if (msg[length - 1] == '\n' || length > 2) {
     this->NewLine = true;
-    }
+  }
 
-  if ( error )
-    {
+  if (error) {
     cmSystemTools::SetErrorOccured();
-    }
+  }
 }
diff --git a/Source/CPack/cmCPackLog.h b/Source/CPack/cmCPackLog.h
index 7a7ff58..41871cc 100644
--- a/Source/CPack/cmCPackLog.h
+++ b/Source/CPack/cmCPackLog.h
@@ -15,24 +15,23 @@
 
 #include "cmObject.h"
 
-#define cmCPack_Log(ctSelf, logType, msg) \
-  do { \
-  std::ostringstream cmCPackLog_msg; \
-  cmCPackLog_msg << msg; \
-  (ctSelf)->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str());\
-  } while ( 0 )
+#define cmCPack_Log(ctSelf, logType, msg)                                     \
+  do {                                                                        \
+    std::ostringstream cmCPackLog_msg;                                        \
+    cmCPackLog_msg << msg;                                                    \
+    (ctSelf)->Log(logType, __FILE__, __LINE__, cmCPackLog_msg.str().c_str()); \
+  } while (0)
 
 #ifdef cerr
-#  undef cerr
+#undef cerr
 #endif
 #define cerr no_cerr_use_cmCPack_Log
 
 #ifdef cout
-#  undef cout
+#undef cout
 #endif
 #define cout no_cout_use_cmCPack_Log
 
-
 /** \class cmCPackLog
  * \brief A container for CPack generators
  *
@@ -45,7 +44,8 @@ public:
   cmCPackLog();
   ~cmCPackLog();
 
-  enum __log_tags {
+  enum __log_tags
+  {
     NOTAG = 0,
     LOG_OUTPUT = 0x1,
     LOG_VERBOSE = 0x2,
@@ -56,19 +56,19 @@ public:
 
   //! Various signatures for logging.
   void Log(const char* file, int line, const char* msg)
-    {
+  {
     this->Log(LOG_OUTPUT, file, line, msg);
-    }
+  }
   void Log(const char* file, int line, const char* msg, size_t length)
-    {
+  {
     this->Log(LOG_OUTPUT, file, line, msg, length);
-    }
+  }
   void Log(int tag, const char* file, int line, const char* msg)
-    {
+  {
     this->Log(tag, file, line, msg, strlen(msg));
-    }
+  }
   void Log(int tag, const char* file, int line, const char* msg,
-    size_t length);
+           size_t length);
 
   //! Set Verbose
   void VerboseOn() { this->SetVerbose(true); }
@@ -126,11 +126,11 @@ private:
   std::string WarningPrefix;
   std::string ErrorPrefix;
 
-  std::ostream *DefaultOutput;
-  std::ostream *DefaultError;
+  std::ostream* DefaultOutput;
+  std::ostream* DefaultError;
 
   std::string LogOutputFileName;
-  std::ostream *LogOutput;
+  std::ostream* LogOutput;
   // Do we need to cleanup log output stream
   bool LogOutputCleanup;
 };
@@ -139,13 +139,16 @@ class cmCPackLogWrite
 {
 public:
   cmCPackLogWrite(const char* data, size_t length)
-    : Data(data), Length(length) {}
+    : Data(data)
+    , Length(length)
+  {
+  }
 
   const char* Data;
   size_t Length;
 };
 
-inline std::ostream& operator<< (std::ostream& os, const cmCPackLogWrite& c)
+inline std::ostream& operator<<(std::ostream& os, const cmCPackLogWrite& c)
 {
   os.write(c.Data, c.Length);
   os.flush();
diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx
index 9d6a457..4d48cb5 100644
--- a/Source/CPack/cmCPackNSISGenerator.cxx
+++ b/Source/CPack/cmCPackNSISGenerator.cxx
@@ -26,9 +26,9 @@
 
 /* NSIS uses different command line syntax on Windows and others */
 #ifdef _WIN32
-# define NSIS_OPT "/"
+#define NSIS_OPT "/"
 #else
-# define NSIS_OPT "-"
+#define NSIS_OPT "-"
 #endif
 
 cmCPackNSISGenerator::cmCPackNSISGenerator(bool nsis64)
@@ -45,22 +45,20 @@ int cmCPackNSISGenerator::PackageFiles()
   // TODO: Fix nsis to force out file name
 
   std::string nsisInFileName = this->FindTemplate("NSIS.template.in");
-  if (nsisInFileName.empty())
-    {
+  if (nsisInFileName.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "CPack error: Could not find NSIS installer template file."
-      << std::endl);
+                  "CPack error: Could not find NSIS installer template file."
+                    << std::endl);
     return false;
-    }
-  std::string nsisInInstallOptions
-    = this->FindTemplate("NSIS.InstallOptions.ini.in");
-  if (nsisInInstallOptions.empty())
-    {
+  }
+  std::string nsisInInstallOptions =
+    this->FindTemplate("NSIS.InstallOptions.ini.in");
+  if (nsisInInstallOptions.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "CPack error: Could not find NSIS installer options file."
-      << std::endl);
+                  "CPack error: Could not find NSIS installer options file."
+                    << std::endl);
     return false;
-    }
+  }
 
   std::string nsisFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   std::string tmpFile = nsisFileName;
@@ -69,93 +67,80 @@ int cmCPackNSISGenerator::PackageFiles()
   nsisFileName += "/project.nsi";
   std::ostringstream str;
   std::vector<std::string>::const_iterator it;
-  for ( it = files.begin(); it != files.end(); ++ it )
-    {
-    std::string fileN = cmSystemTools::RelativePath(toplevel.c_str(),
-                                                    it->c_str());
-    if (!this->Components.empty())
-      {
+  for (it = files.begin(); it != files.end(); ++it) {
+    std::string fileN =
+      cmSystemTools::RelativePath(toplevel.c_str(), it->c_str());
+    if (!this->Components.empty()) {
       // Strip off the component part of the path.
-      fileN = fileN.substr(fileN.find('/')+1, std::string::npos);
-      }
+      fileN = fileN.substr(fileN.find('/') + 1, std::string::npos);
+    }
     cmSystemTools::ReplaceString(fileN, "/", "\\");
     str << "  Delete \"$INSTDIR\\" << fileN << "\"" << std::endl;
-    }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Files: "
-    << str.str() << std::endl);
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Files: " << str.str()
+                                                           << std::endl);
   this->SetOptionIfNotSet("CPACK_NSIS_DELETE_FILES", str.str().c_str());
   std::vector<std::string> dirs;
   this->GetListOfSubdirectories(toplevel.c_str(), dirs);
   std::vector<std::string>::const_iterator sit;
   std::ostringstream dstr;
-  for ( sit = dirs.begin(); sit != dirs.end(); ++ sit )
-    {
+  for (sit = dirs.begin(); sit != dirs.end(); ++sit) {
     std::string componentName;
-    std::string fileN = cmSystemTools::RelativePath(toplevel.c_str(),
-                                                    sit->c_str());
-    if ( fileN.empty() )
-      {
+    std::string fileN =
+      cmSystemTools::RelativePath(toplevel.c_str(), sit->c_str());
+    if (fileN.empty()) {
       continue;
-      }
-    if (!Components.empty())
-      {
+    }
+    if (!Components.empty()) {
       // If this is a component installation, strip off the component
       // part of the path.
       std::string::size_type slash = fileN.find('/');
-      if (slash != std::string::npos)
-        {
+      if (slash != std::string::npos) {
         // If this is a component installation, determine which component it
         // is.
         componentName = fileN.substr(0, slash);
 
         // Strip off the component part of the path.
-        fileN = fileN.substr(slash+1, std::string::npos);
-        }
+        fileN = fileN.substr(slash + 1, std::string::npos);
       }
+    }
     cmSystemTools::ReplaceString(fileN, "/", "\\");
     dstr << "  RMDir \"$INSTDIR\\" << fileN << "\"" << std::endl;
-    if (!componentName.empty())
-      {
+    if (!componentName.empty()) {
       this->Components[componentName].Directories.push_back(fileN);
-      }
     }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Dirs: "
-    << dstr.str() << std::endl);
-  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_DIRECTORIES",
-                          dstr.str().c_str());
-
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: " << nsisInFileName
-    << " to " << nsisFileName << std::endl);
-  if(this->IsSet("CPACK_NSIS_MUI_ICON")
-     || this->IsSet("CPACK_NSIS_MUI_UNIICON"))
-    {
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Uninstall Dirs: " << dstr.str()
+                                                          << std::endl);
+  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_DIRECTORIES", dstr.str().c_str());
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
+                  << nsisInFileName << " to " << nsisFileName << std::endl);
+  if (this->IsSet("CPACK_NSIS_MUI_ICON") ||
+      this->IsSet("CPACK_NSIS_MUI_UNIICON")) {
     std::string installerIconCode;
-    if(this->IsSet("CPACK_NSIS_MUI_ICON"))
-      {
+    if (this->IsSet("CPACK_NSIS_MUI_ICON")) {
       installerIconCode += "!define MUI_ICON \"";
       installerIconCode += this->GetOption("CPACK_NSIS_MUI_ICON");
       installerIconCode += "\"\n";
-      }
-    if(this->IsSet("CPACK_NSIS_MUI_UNIICON"))
-      {
+    }
+    if (this->IsSet("CPACK_NSIS_MUI_UNIICON")) {
       installerIconCode += "!define MUI_UNICON \"";
       installerIconCode += this->GetOption("CPACK_NSIS_MUI_UNIICON");
       installerIconCode += "\"\n";
-      }
+    }
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_ICON_CODE",
                             installerIconCode.c_str());
-    }
-  if(this->IsSet("CPACK_PACKAGE_ICON"))
-    {
+  }
+  if (this->IsSet("CPACK_PACKAGE_ICON")) {
     std::string installerIconCode = "!define MUI_HEADERIMAGE_BITMAP \"";
     installerIconCode += this->GetOption("CPACK_PACKAGE_ICON");
     installerIconCode += "\"\n";
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_ICON_CODE",
                             installerIconCode.c_str());
-    }
+  }
 
-  if (this->IsSet("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP"))
-    {
+  if (this->IsSet("CPACK_NSIS_MUI_WELCOMEFINISHPAGE_BITMAP")) {
     std::string installerBitmapCode =
       "!define MUI_WELCOMEFINISHPAGE_BITMAP \"";
     installerBitmapCode +=
@@ -163,10 +148,9 @@ int cmCPackNSISGenerator::PackageFiles()
     installerBitmapCode += "\"\n";
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_WELCOMEFINISH_CODE",
                             installerBitmapCode.c_str());
-    }
+  }
 
-  if (this->IsSet("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP"))
-    {
+  if (this->IsSet("CPACK_NSIS_MUI_UNWELCOMEFINISHPAGE_BITMAP")) {
     std::string installerBitmapCode =
       "!define MUI_UNWELCOMEFINISHPAGE_BITMAP \"";
     installerBitmapCode +=
@@ -174,10 +158,9 @@ int cmCPackNSISGenerator::PackageFiles()
     installerBitmapCode += "\"\n";
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_UNWELCOMEFINISH_CODE",
                             installerBitmapCode.c_str());
-    }
+  }
 
-  if(this->IsSet("CPACK_NSIS_MUI_FINISHPAGE_RUN"))
-    {
+  if (this->IsSet("CPACK_NSIS_MUI_FINISHPAGE_RUN")) {
     std::string installerRunCode = "!define MUI_FINISHPAGE_RUN \"$INSTDIR\\";
     installerRunCode += this->GetOption("CPACK_NSIS_EXECUTABLES_DIRECTORY");
     installerRunCode += "\\";
@@ -185,11 +168,10 @@ int cmCPackNSISGenerator::PackageFiles()
     installerRunCode += "\"\n";
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_FINISHPAGE_RUN_CODE",
                             installerRunCode.c_str());
-    }
+  }
 
   // Setup all of the component sections
-  if (this->Components.empty())
-    {
+  if (this->Components.empty()) {
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLATION_TYPES", "");
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC", "");
     this->SetOptionIfNotSet("CPACK_NSIS_PAGE_COMPONENTS", "");
@@ -198,9 +180,7 @@ int cmCPackNSISGenerator::PackageFiles()
     this->SetOptionIfNotSet("CPACK_NSIS_COMPONENT_SECTIONS", "");
     this->SetOptionIfNotSet("CPACK_NSIS_COMPONENT_SECTION_LIST", "");
     this->SetOptionIfNotSet("CPACK_NSIS_SECTION_SELECTED_VARS", "");
-    }
-  else
-    {
+  } else {
     std::string componentCode;
     std::string sectionList;
     std::string selectedVarsList;
@@ -213,66 +193,54 @@ int cmCPackNSISGenerator::PackageFiles()
 
     // Create installation types. The order is significant, so we first fill
     // in a vector based on the indices, and print them in that order.
-    std::vector<cmCPackInstallationType *>
-      installTypes(this->InstallationTypes.size());
+    std::vector<cmCPackInstallationType*> installTypes(
+      this->InstallationTypes.size());
     std::map<std::string, cmCPackInstallationType>::iterator installTypeIt;
     for (installTypeIt = this->InstallationTypes.begin();
-         installTypeIt != this->InstallationTypes.end();
-         ++installTypeIt)
-      {
-      installTypes[installTypeIt->second.Index-1] = &installTypeIt->second;
-      }
-    std::vector<cmCPackInstallationType *>::iterator installTypeIt2;
+         installTypeIt != this->InstallationTypes.end(); ++installTypeIt) {
+      installTypes[installTypeIt->second.Index - 1] = &installTypeIt->second;
+    }
+    std::vector<cmCPackInstallationType*>::iterator installTypeIt2;
     for (installTypeIt2 = installTypes.begin();
-         installTypeIt2 != installTypes.end();
-         ++installTypeIt2)
-      {
+         installTypeIt2 != installTypes.end(); ++installTypeIt2) {
       installTypesCode += "InstType \"";
       installTypesCode += (*installTypeIt2)->DisplayName;
       installTypesCode += "\"\n";
-      }
+    }
 
     // Create installation groups first
     std::map<std::string, cmCPackComponentGroup>::iterator groupIt;
     for (groupIt = this->ComponentGroups.begin();
-         groupIt != this->ComponentGroups.end();
-         ++groupIt)
-      {
-      if (groupIt->second.ParentGroup == 0)
-        {
+         groupIt != this->ComponentGroups.end(); ++groupIt) {
+      if (groupIt->second.ParentGroup == 0) {
         componentCode +=
           this->CreateComponentGroupDescription(&groupIt->second, macrosOut);
-        }
+      }
 
       // Add the group description, if any.
-      if (!groupIt->second.Description.empty())
-        {
-        groupDescriptions += "  !insertmacro MUI_DESCRIPTION_TEXT ${"
-          + groupIt->first + "} \""
-          + this->TranslateNewlines(groupIt->second.Description) + "\"\n";
-        }
+      if (!groupIt->second.Description.empty()) {
+        groupDescriptions += "  !insertmacro MUI_DESCRIPTION_TEXT ${" +
+          groupIt->first + "} \"" +
+          this->TranslateNewlines(groupIt->second.Description) + "\"\n";
       }
+    }
 
     // Create the remaining components, which aren't associated with groups.
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt = this->Components.begin();
-         compIt != this->Components.end();
-         ++compIt)
-      {
-      if (compIt->second.Files.empty())
-        {
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
+      if (compIt->second.Files.empty()) {
         // NSIS cannot cope with components that have no files.
         continue;
-        }
+      }
 
       anyDownloadedComponents =
         anyDownloadedComponents || compIt->second.IsDownloaded;
 
-      if (!compIt->second.Group)
-        {
-        componentCode
-          += this->CreateComponentDescription(&compIt->second, macrosOut);
-        }
+      if (!compIt->second.Group) {
+        componentCode +=
+          this->CreateComponentDescription(&compIt->second, macrosOut);
+      }
 
       // Add this component to the various section lists.
       sectionList += "  !insertmacro \"${MacroName}\" \"";
@@ -282,41 +250,33 @@ int cmCPackNSISGenerator::PackageFiles()
       selectedVarsList += "Var " + compIt->first + "_was_installed\n";
 
       // Add the component description, if any.
-      if (!compIt->second.Description.empty())
-        {
-        componentDescriptions += "  !insertmacro MUI_DESCRIPTION_TEXT ${"
-          + compIt->first + "} \""
-          + this->TranslateNewlines(compIt->second.Description) + "\"\n";
-        }
+      if (!compIt->second.Description.empty()) {
+        componentDescriptions += "  !insertmacro MUI_DESCRIPTION_TEXT ${" +
+          compIt->first + "} \"" +
+          this->TranslateNewlines(compIt->second.Description) + "\"\n";
       }
+    }
 
     componentCode += macrosOut.str();
 
-    if (componentDescriptions.empty() && groupDescriptions.empty())
-      {
+    if (componentDescriptions.empty() && groupDescriptions.empty()) {
       // Turn off the "Description" box
       this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC",
                               "!define MUI_COMPONENTSPAGE_NODESC");
-      }
-    else
-      {
-      componentDescriptions =
-        "!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN\n"
-        + componentDescriptions
-        + groupDescriptions
-        + "!insertmacro MUI_FUNCTION_DESCRIPTION_END\n";
+    } else {
+      componentDescriptions = "!insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN\n" +
+        componentDescriptions + groupDescriptions +
+        "!insertmacro MUI_FUNCTION_DESCRIPTION_END\n";
       this->SetOptionIfNotSet("CPACK_NSIS_INSTALLER_MUI_COMPONENTS_DESC",
                               componentDescriptions.c_str());
-      }
+    }
 
-    if (anyDownloadedComponents)
-      {
+    if (anyDownloadedComponents) {
       defines += "!define CPACK_USES_DOWNLOAD\n";
-      if (cmSystemTools::IsOn(this->GetOption("CPACK_ADD_REMOVE")))
-        {
+      if (cmSystemTools::IsOn(this->GetOption("CPACK_ADD_REMOVE"))) {
         defines += "!define CPACK_NSIS_ADD_REMOVE\n";
-        }
       }
+    }
 
     this->SetOptionIfNotSet("CPACK_NSIS_INSTALLATION_TYPES",
                             installTypesCode.c_str());
@@ -330,7 +290,7 @@ int cmCPackNSISGenerator::PackageFiles()
     this->SetOptionIfNotSet("CPACK_NSIS_SECTION_SELECTED_VARS",
                             selectedVarsList.c_str());
     this->SetOption("CPACK_NSIS_DEFINES", defines.c_str());
-    }
+  }
 
   this->ConfigureFile(nsisInInstallOptions.c_str(),
                       nsisInstallOptions.c_str());
@@ -338,350 +298,308 @@ int cmCPackNSISGenerator::PackageFiles()
   std::string nsisCmd = "\"";
   nsisCmd += this->GetOption("CPACK_INSTALLER_PROGRAM");
   nsisCmd += "\" \"" + nsisFileName + "\"";
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << nsisCmd
-    << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << nsisCmd << std::endl);
   std::string output;
   int retVal = 1;
-  bool res = cmSystemTools::RunSingleCommand(nsisCmd.c_str(), &output, &output,
-    &retVal, 0, this->GeneratorVerbose, 0);
-  if ( !res || retVal )
-    {
+  bool res = cmSystemTools::RunSingleCommand(
+    nsisCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
+  if (!res || retVal) {
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Run command: " << nsisCmd << std::endl
-      << "# Output:" << std::endl
-      << output << std::endl;
+        << "# Output:" << std::endl
+        << output << std::endl;
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running NSIS command: "
-      << nsisCmd << std::endl
-      << "Please check " << tmpFile << " for errors" << std::endl);
+                    << nsisCmd << std::endl
+                    << "Please check " << tmpFile << " for errors"
+                    << std::endl);
     return 0;
-    }
+  }
   return 1;
 }
 
 int cmCPackNSISGenerator::InitializeInternal()
 {
-  if ( cmSystemTools::IsOn(this->GetOption(
-        "CPACK_INCLUDE_TOPLEVEL_DIRECTORY")) )
-    {
-    cmCPackLogger(cmCPackLog::LOG_WARNING,
+  if (cmSystemTools::IsOn(
+        this->GetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY"))) {
+    cmCPackLogger(
+      cmCPackLog::LOG_WARNING,
       "NSIS Generator cannot work with CPACK_INCLUDE_TOPLEVEL_DIRECTORY set. "
       "This option will be reset to 0 (for this generator only)."
-      << std::endl);
+        << std::endl);
     this->SetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", 0);
-    }
+  }
 
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackNSISGenerator::Initialize()"
-    << std::endl);
+                  << std::endl);
   std::vector<std::string> path;
   std::string nsisPath;
   bool gotRegValue = false;
 
 #ifdef _WIN32
-  if (Nsis64)
-    {
-    if ( !gotRegValue && cmsys::SystemTools::ReadRegistryValue(
-      "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode", nsisPath,
-      cmsys::SystemTools::KeyWOW64_64) )
-      {
+  if (Nsis64) {
+    if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                          "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode",
+                          nsisPath, cmsys::SystemTools::KeyWOW64_64)) {
       gotRegValue = true;
-      }
-    if ( !gotRegValue && cmsys::SystemTools::ReadRegistryValue(
-      "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath,
-      cmsys::SystemTools::KeyWOW64_64) )
-      {
+    }
+    if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                          "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath,
+                          cmsys::SystemTools::KeyWOW64_64)) {
       gotRegValue = true;
-      }
     }
-  if ( !gotRegValue && cmsys::SystemTools::ReadRegistryValue(
-      "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode", nsisPath,
-      cmsys::SystemTools::KeyWOW64_32) )
-    {
+  }
+  if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode",
+                        nsisPath, cmsys::SystemTools::KeyWOW64_32)) {
     gotRegValue = true;
-    }
-  if ( !gotRegValue && cmsys::SystemTools::ReadRegistryValue(
-      "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode", nsisPath) )
-    {
+  }
+  if (!gotRegValue &&
+      cmsys::SystemTools::ReadRegistryValue(
+        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS\\Unicode", nsisPath)) {
     gotRegValue = true;
-    }
-  if ( !gotRegValue && cmsys::SystemTools::ReadRegistryValue(
-      "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath,
-      cmsys::SystemTools::KeyWOW64_32) )
-    {
+  }
+  if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath,
+                        cmsys::SystemTools::KeyWOW64_32)) {
     gotRegValue = true;
-    }
-  if ( !gotRegValue && cmsys::SystemTools::ReadRegistryValue(
-      "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath) )
-    {
+  }
+  if (!gotRegValue && cmsys::SystemTools::ReadRegistryValue(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath)) {
     gotRegValue = true;
-    }
+  }
 
-  if (gotRegValue)
-    {
+  if (gotRegValue) {
     path.push_back(nsisPath);
-    }
+  }
 #endif
 
   nsisPath = cmSystemTools::FindProgram("makensis", path, false);
 
-  if ( nsisPath.empty() )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
+  if (nsisPath.empty()) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
       "Cannot find NSIS compiler makensis: likely it is not installed, "
       "or not in your PATH"
-      << std::endl);
-
-    if (!gotRegValue)
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-         "Could not read NSIS registry value. This is usually caused by "
-         "NSIS not being installed. Please install NSIS from "
-         "http://nsis.sourceforge.net"
-         << std::endl);
-      }
+        << std::endl);
+
+    if (!gotRegValue) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "Could not read NSIS registry value. This is usually caused by "
+        "NSIS not being installed. Please install NSIS from "
+        "http://nsis.sourceforge.net"
+          << std::endl);
+    }
 
     return 0;
-    }
+  }
 
   std::string nsisCmd = "\"" + nsisPath + "\" " NSIS_OPT "VERSION";
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Test NSIS version: "
-    << nsisCmd << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Test NSIS version: " << nsisCmd
+                                                               << std::endl);
   std::string output;
   int retVal = 1;
   bool resS = cmSystemTools::RunSingleCommand(
     nsisCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
   cmsys::RegularExpression versionRex("v([0-9]+.[0-9]+)");
   cmsys::RegularExpression versionRexCVS("v(.*)\\.cvs");
-  if ( !resS || retVal ||
-      (!versionRex.find(output) && !versionRexCVS.find(output))
-     )
-    {
+  if (!resS || retVal ||
+      (!versionRex.find(output) && !versionRexCVS.find(output))) {
     const char* topDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
     std::string tmpFile = topDir ? topDir : ".";
     tmpFile += "/NSISOutput.log";
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Run command: " << nsisCmd << std::endl
-      << "# Output:" << std::endl
-      << output << std::endl;
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Problem checking NSIS version with command: "
-      << nsisCmd << std::endl
-      << "Please check " << tmpFile << " for errors" << std::endl);
+        << "# Output:" << std::endl
+        << output << std::endl;
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "Problem checking NSIS version with command: "
+        << nsisCmd << std::endl
+        << "Please check " << tmpFile << " for errors" << std::endl);
     return 0;
-    }
-  if ( versionRex.find(output))
-    {
+  }
+  if (versionRex.find(output)) {
     double nsisVersion = atof(versionRex.match(1).c_str());
     double minNSISVersion = 2.09;
-    cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: "
-      << nsisVersion << std::endl);
-    if ( nsisVersion < minNSISVersion )
-      {
+    cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: " << nsisVersion
+                                                          << std::endl);
+    if (nsisVersion < minNSISVersion) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "CPack requires NSIS Version 2.09 or greater.  "
-        "NSIS found on the system was: "
-        << nsisVersion << std::endl);
+                    "CPack requires NSIS Version 2.09 or greater.  "
+                    "NSIS found on the system was: "
+                      << nsisVersion << std::endl);
       return 0;
-      }
     }
-  if ( versionRexCVS.find(output))
-    {
+  }
+  if (versionRexCVS.find(output)) {
     // No version check for NSIS cvs build
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "NSIS Version: CVS "
-      << versionRexCVS.match(1) << std::endl);
-    }
+                    << versionRexCVS.match(1) << std::endl);
+  }
   this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", nsisPath.c_str());
   this->SetOptionIfNotSet("CPACK_NSIS_EXECUTABLES_DIRECTORY", "bin");
-  const char* cpackPackageExecutables
-    = this->GetOption("CPACK_PACKAGE_EXECUTABLES");
-  const char* cpackPackageDeskTopLinks
-    = this->GetOption("CPACK_CREATE_DESKTOP_LINKS");
-  const char* cpackNsisExecutablesDirectory
-    = this->GetOption("CPACK_NSIS_EXECUTABLES_DIRECTORY");
+  const char* cpackPackageExecutables =
+    this->GetOption("CPACK_PACKAGE_EXECUTABLES");
+  const char* cpackPackageDeskTopLinks =
+    this->GetOption("CPACK_CREATE_DESKTOP_LINKS");
+  const char* cpackNsisExecutablesDirectory =
+    this->GetOption("CPACK_NSIS_EXECUTABLES_DIRECTORY");
   std::vector<std::string> cpackPackageDesktopLinksVector;
-  if(cpackPackageDeskTopLinks)
-    {
+  if (cpackPackageDeskTopLinks) {
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
-                << cpackPackageDeskTopLinks << std::endl);
-
-    cmSystemTools::
-      ExpandListArgument(cpackPackageDeskTopLinks,
-                         cpackPackageDesktopLinksVector);
-    for(std::vector<std::string>::iterator i =
-          cpackPackageDesktopLinksVector.begin(); i !=
-          cpackPackageDesktopLinksVector.end(); ++i)
-      {
-       cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
-                << *i << std::endl);
-      }
+                    << cpackPackageDeskTopLinks << std::endl);
+
+    cmSystemTools::ExpandListArgument(cpackPackageDeskTopLinks,
+                                      cpackPackageDesktopLinksVector);
+    for (std::vector<std::string>::iterator i =
+           cpackPackageDesktopLinksVector.begin();
+         i != cpackPackageDesktopLinksVector.end(); ++i) {
+      cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                    "CPACK_CREATE_DESKTOP_LINKS: " << *i << std::endl);
     }
-  else
-    {
+  } else {
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "CPACK_CREATE_DESKTOP_LINKS: "
-                  << "not set" << std::endl);
-    }
+                    << "not set" << std::endl);
+  }
 
   std::ostringstream str;
   std::ostringstream deleteStr;
 
-  if ( cpackPackageExecutables )
-    {
+  if (cpackPackageExecutables) {
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
-      << cpackPackageExecutables << "." << std::endl);
+                    << cpackPackageExecutables << "." << std::endl);
     std::vector<std::string> cpackPackageExecutablesVector;
     cmSystemTools::ExpandListArgument(cpackPackageExecutables,
-      cpackPackageExecutablesVector);
-    if ( cpackPackageExecutablesVector.size() % 2 != 0 )
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                                      cpackPackageExecutablesVector);
+    if (cpackPackageExecutablesVector.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
         "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
-        "<icon name>." << std::endl);
+        "<icon name>."
+          << std::endl);
       return 0;
-      }
+    }
     std::vector<std::string>::iterator it;
-    for ( it = cpackPackageExecutablesVector.begin();
-          it != cpackPackageExecutablesVector.end();
-          ++it )
-      {
+    for (it = cpackPackageExecutablesVector.begin();
+         it != cpackPackageExecutablesVector.end(); ++it) {
       std::string execName = *it;
-      ++ it;
+      ++it;
       std::string linkName = *it;
-      str << "  CreateShortCut \"$SMPROGRAMS\\$STARTMENU_FOLDER\\"
-        << linkName << ".lnk\" \"$INSTDIR\\"
-        << cpackNsisExecutablesDirectory << "\\" << execName << ".exe\""
-        << std::endl;
+      str << "  CreateShortCut \"$SMPROGRAMS\\$STARTMENU_FOLDER\\" << linkName
+          << ".lnk\" \"$INSTDIR\\" << cpackNsisExecutablesDirectory << "\\"
+          << execName << ".exe\"" << std::endl;
       deleteStr << "  Delete \"$SMPROGRAMS\\$MUI_TEMP\\" << linkName
-        << ".lnk\"" << std::endl;
+                << ".lnk\"" << std::endl;
       // see if CPACK_CREATE_DESKTOP_LINK_ExeName is on
       // if so add a desktop link
-      if(!cpackPackageDesktopLinksVector.empty() &&
-         std::find(cpackPackageDesktopLinksVector.begin(),
-                   cpackPackageDesktopLinksVector.end(),
-                   execName)
-         != cpackPackageDesktopLinksVector.end())
-        {
+      if (!cpackPackageDesktopLinksVector.empty() &&
+          std::find(cpackPackageDesktopLinksVector.begin(),
+                    cpackPackageDesktopLinksVector.end(),
+                    execName) != cpackPackageDesktopLinksVector.end()) {
         str << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
-        str << "    CreateShortCut \"$DESKTOP\\"
-            << linkName << ".lnk\" \"$INSTDIR\\"
-            << cpackNsisExecutablesDirectory << "\\" << execName << ".exe\""
-            << std::endl;
+        str << "    CreateShortCut \"$DESKTOP\\" << linkName
+            << ".lnk\" \"$INSTDIR\\" << cpackNsisExecutablesDirectory << "\\"
+            << execName << ".exe\"" << std::endl;
         deleteStr << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
-        deleteStr << "    Delete \"$DESKTOP\\" << linkName
-                  << ".lnk\"" << std::endl;
-        }
+        deleteStr << "    Delete \"$DESKTOP\\" << linkName << ".lnk\""
+                  << std::endl;
       }
     }
+  }
 
   this->CreateMenuLinks(str, deleteStr);
   this->SetOptionIfNotSet("CPACK_NSIS_CREATE_ICONS", str.str().c_str());
-  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_ICONS",
-                          deleteStr.str().c_str());
+  this->SetOptionIfNotSet("CPACK_NSIS_DELETE_ICONS", deleteStr.str().c_str());
 
   this->SetOptionIfNotSet("CPACK_NSIS_COMPRESSOR", "lzma");
 
   return this->Superclass::InitializeInternal();
 }
 
-void cmCPackNSISGenerator::CreateMenuLinks( std::ostringstream& str,
-                                            std::ostringstream& deleteStr)
+void cmCPackNSISGenerator::CreateMenuLinks(std::ostringstream& str,
+                                           std::ostringstream& deleteStr)
 {
-  const char* cpackMenuLinks
-    = this->GetOption("CPACK_NSIS_MENU_LINKS");
-  if(!cpackMenuLinks)
-    {
+  const char* cpackMenuLinks = this->GetOption("CPACK_NSIS_MENU_LINKS");
+  if (!cpackMenuLinks) {
     return;
-    }
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackMenuLinks: "
-                << cpackMenuLinks << "." << std::endl);
+  }
+  cmCPackLogger(cmCPackLog::LOG_DEBUG,
+                "The cpackMenuLinks: " << cpackMenuLinks << "." << std::endl);
   std::vector<std::string> cpackMenuLinksVector;
-  cmSystemTools::ExpandListArgument(cpackMenuLinks,
-                                    cpackMenuLinksVector);
-  if ( cpackMenuLinksVector.size() % 2 != 0 )
-    {
+  cmSystemTools::ExpandListArgument(cpackMenuLinks, cpackMenuLinksVector);
+  if (cpackMenuLinksVector.size() % 2 != 0) {
     cmCPackLogger(
       cmCPackLog::LOG_ERROR,
       "CPACK_NSIS_MENU_LINKS should contain pairs of <shortcut target> and "
-      "<shortcut label>." << std::endl);
+      "<shortcut label>."
+        << std::endl);
     return;
-    }
+  }
 
-  static cmsys::RegularExpression
-    urlRegex("^(mailto:|(ftps?|https?|news)://).*$");
+  static cmsys::RegularExpression urlRegex(
+    "^(mailto:|(ftps?|https?|news)://).*$");
 
   std::vector<std::string>::iterator it;
-  for ( it = cpackMenuLinksVector.begin();
-        it != cpackMenuLinksVector.end();
-        ++it )
-    {
+  for (it = cpackMenuLinksVector.begin(); it != cpackMenuLinksVector.end();
+       ++it) {
     std::string sourceName = *it;
     const bool url = urlRegex.find(sourceName);
 
     // Convert / to \ in filenames, but not in urls:
     //
-    if(!url)
-      {
+    if (!url) {
       cmSystemTools::ReplaceString(sourceName, "/", "\\");
-      }
+    }
 
-    ++ it;
+    ++it;
     std::string linkName = *it;
-    if(!url)
-      {
-      str << "  CreateShortCut \"$SMPROGRAMS\\$STARTMENU_FOLDER\\"
-          << linkName << ".lnk\" \"$INSTDIR\\" << sourceName << "\""
-          << std::endl;
+    if (!url) {
+      str << "  CreateShortCut \"$SMPROGRAMS\\$STARTMENU_FOLDER\\" << linkName
+          << ".lnk\" \"$INSTDIR\\" << sourceName << "\"" << std::endl;
       deleteStr << "  Delete \"$SMPROGRAMS\\$MUI_TEMP\\" << linkName
                 << ".lnk\"" << std::endl;
-      }
-    else
-      {
-      str << "  WriteINIStr \"$SMPROGRAMS\\$STARTMENU_FOLDER\\"
-          << linkName << ".url\" \"InternetShortcut\" \"URL\" \""
-          << sourceName << "\""
+    } else {
+      str << "  WriteINIStr \"$SMPROGRAMS\\$STARTMENU_FOLDER\\" << linkName
+          << ".url\" \"InternetShortcut\" \"URL\" \"" << sourceName << "\""
           << std::endl;
       deleteStr << "  Delete \"$SMPROGRAMS\\$MUI_TEMP\\" << linkName
                 << ".url\"" << std::endl;
-      }
+    }
     // see if CPACK_CREATE_DESKTOP_LINK_ExeName is on
     // if so add a desktop link
     std::string desktop = "CPACK_CREATE_DESKTOP_LINK_";
     desktop += linkName;
-    if(this->IsSet(desktop))
-      {
+    if (this->IsSet(desktop)) {
       str << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
-      str << "    CreateShortCut \"$DESKTOP\\"
-          << linkName << ".lnk\" \"$INSTDIR\\" << sourceName << "\""
-          << std::endl;
+      str << "    CreateShortCut \"$DESKTOP\\" << linkName
+          << ".lnk\" \"$INSTDIR\\" << sourceName << "\"" << std::endl;
       deleteStr << "  StrCmp \"$INSTALL_DESKTOP\" \"1\" 0 +2\n";
-      deleteStr << "    Delete \"$DESKTOP\\" << linkName
-                << ".lnk\"" << std::endl;
-      }
+      deleteStr << "    Delete \"$DESKTOP\\" << linkName << ".lnk\""
+                << std::endl;
     }
+  }
 }
 
-bool cmCPackNSISGenerator::GetListOfSubdirectories(const char* topdir,
-  std::vector<std::string>& dirs)
+bool cmCPackNSISGenerator::GetListOfSubdirectories(
+  const char* topdir, std::vector<std::string>& dirs)
 {
   cmsys::Directory dir;
   dir.Load(topdir);
   size_t fileNum;
-  for (fileNum = 0; fileNum <  dir.GetNumberOfFiles(); ++fileNum)
-    {
-    if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") &&
-        strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".."))
-      {
+  for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) {
+    if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), ".") &&
+        strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), "..")) {
       std::string fullPath = topdir;
       fullPath += "/";
       fullPath += dir.GetFile(static_cast<unsigned long>(fileNum));
-      if(cmsys::SystemTools::FileIsDirectory(fullPath) &&
-        !cmsys::SystemTools::FileIsSymlink(fullPath))
-        {
-        if (!this->GetListOfSubdirectories(fullPath.c_str(), dirs))
-          {
+      if (cmsys::SystemTools::FileIsDirectory(fullPath) &&
+          !cmsys::SystemTools::FileIsSymlink(fullPath)) {
+        if (!this->GetListOfSubdirectories(fullPath.c_str(), dirs)) {
           return false;
-          }
         }
       }
     }
+  }
   dirs.push_back(topdir);
   return true;
 }
@@ -694,116 +612,95 @@ cmCPackNSISGenerator::SupportsSetDestdir() const
 
 bool cmCPackNSISGenerator::SupportsAbsoluteDestination() const
 {
-        return false;
+  return false;
 }
 
 bool cmCPackNSISGenerator::SupportsComponentInstallation() const
 {
-        return true;
+  return true;
 }
 
-std::string
-cmCPackNSISGenerator::
-CreateComponentDescription(cmCPackComponent *component,
-                           std::ostringstream& macrosOut)
+std::string cmCPackNSISGenerator::CreateComponentDescription(
+  cmCPackComponent* component, std::ostringstream& macrosOut)
 {
   // Basic description of the component
   std::string componentCode = "Section ";
-  if (component->IsDisabledByDefault)
-    {
+  if (component->IsDisabledByDefault) {
     componentCode += "/o ";
-    }
+  }
   componentCode += "\"";
-  if (component->IsHidden)
-    {
+  if (component->IsHidden) {
     componentCode += "-";
-    }
+  }
   componentCode += component->DisplayName + "\" " + component->Name + "\n";
-  if (component->IsRequired)
-    {
+  if (component->IsRequired) {
     componentCode += "  SectionIn RO\n";
-    }
-  else if (!component->InstallationTypes.empty())
-    {
+  } else if (!component->InstallationTypes.empty()) {
     std::ostringstream out;
-    std::vector<cmCPackInstallationType *>::iterator installTypeIter;
+    std::vector<cmCPackInstallationType*>::iterator installTypeIter;
     for (installTypeIter = component->InstallationTypes.begin();
          installTypeIter != component->InstallationTypes.end();
-         ++installTypeIter)
-      {
+         ++installTypeIter) {
       out << " " << (*installTypeIter)->Index;
-      }
-    componentCode += "  SectionIn" + out.str() + "\n";
     }
+    componentCode += "  SectionIn" + out.str() + "\n";
+  }
   componentCode += "  SetOutPath \"$INSTDIR\"\n";
 
   // Create the actual installation commands
-  if (component->IsDownloaded)
-    {
-    if (component->ArchiveFile.empty())
-      {
+  if (component->IsDownloaded) {
+    if (component->ArchiveFile.empty()) {
       // Compute the name of the archive.
       std::string packagesDir = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
       packagesDir += ".dummy";
       std::ostringstream out;
-      out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir)
-        << "-" << component->Name << ".zip";
+      out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir) << "-"
+          << component->Name << ".zip";
       component->ArchiveFile = out.str();
-      }
+    }
 
     // Create the directory for the upload area
     const char* userUploadDirectory =
       this->GetOption("CPACK_UPLOAD_DIRECTORY");
     std::string uploadDirectory;
-    if (userUploadDirectory && *userUploadDirectory)
-      {
+    if (userUploadDirectory && *userUploadDirectory) {
       uploadDirectory = userUploadDirectory;
-      }
-    else
-      {
-      uploadDirectory= this->GetOption("CPACK_PACKAGE_DIRECTORY");
+    } else {
+      uploadDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
       uploadDirectory += "/CPackUploads";
-      }
-    if(!cmSystemTools::FileExists(uploadDirectory.c_str()))
-      {
-      if (!cmSystemTools::MakeDirectory(uploadDirectory.c_str()))
-        {
+    }
+    if (!cmSystemTools::FileExists(uploadDirectory.c_str())) {
+      if (!cmSystemTools::MakeDirectory(uploadDirectory.c_str())) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Unable to create NSIS upload directory " << uploadDirectory
-          << std::endl);
+                      "Unable to create NSIS upload directory "
+                        << uploadDirectory << std::endl);
         return "";
-        }
       }
+    }
 
     // Remove the old archive, if one exists
     std::string archiveFile = uploadDirectory + '/' + component->ArchiveFile;
     cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                  "-   Building downloaded component archive: "
-                  << archiveFile << std::endl);
-    if (cmSystemTools::FileExists(archiveFile.c_str(), true))
-      {
-        if (!cmSystemTools::RemoveFile(archiveFile))
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Unable to remove archive file " << archiveFile
-          << std::endl);
+                  "-   Building downloaded component archive: " << archiveFile
+                                                                << std::endl);
+    if (cmSystemTools::FileExists(archiveFile.c_str(), true)) {
+      if (!cmSystemTools::RemoveFile(archiveFile)) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Unable to remove archive file "
+                        << archiveFile << std::endl);
         return "";
-        }
       }
+    }
 
     // Find a ZIP program
-    if (!this->IsSet("ZIP_EXECUTABLE"))
-      {
+    if (!this->IsSet("ZIP_EXECUTABLE")) {
       this->ReadListFile("CPackZIP.cmake");
 
-      if (!this->IsSet("ZIP_EXECUTABLE"))
-        {
-        cmCPackLogger(cmCPackLog::LOG_ERROR,
-          "Unable to find ZIP program"
-          << std::endl);
+      if (!this->IsSet("ZIP_EXECUTABLE")) {
+        cmCPackLogger(cmCPackLog::LOG_ERROR, "Unable to find ZIP program"
+                        << std::endl);
         return "";
-        }
       }
+    }
 
     // The directory where this component's files reside
     std::string dirName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
@@ -815,29 +712,25 @@ CreateComponentDescription(cmCPackComponent *component,
     // size of the installed component.
     std::string zipListFileName = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
     zipListFileName += "/winZip.filelist";
-    bool needQuotesInFile
-      = cmSystemTools::IsOn(this->GetOption("CPACK_ZIP_NEED_QUOTES"));
+    bool needQuotesInFile =
+      cmSystemTools::IsOn(this->GetOption("CPACK_ZIP_NEED_QUOTES"));
     unsigned long totalSize = 0;
     { // the scope is needed for cmGeneratedFileStream
       cmGeneratedFileStream out(zipListFileName.c_str());
       std::vector<std::string>::iterator fileIt;
-      for (fileIt = component->Files.begin();
-           fileIt != component->Files.end();
-           ++fileIt)
-        {
-        if ( needQuotesInFile )
-          {
+      for (fileIt = component->Files.begin(); fileIt != component->Files.end();
+           ++fileIt) {
+        if (needQuotesInFile) {
           out << "\"";
-          }
+        }
         out << *fileIt;
-        if ( needQuotesInFile )
-          {
+        if (needQuotesInFile) {
           out << "\"";
-          }
+        }
         out << std::endl;
 
         totalSize += cmSystemTools::FileLength(dirName + *fileIt);
-        }
+      }
     }
 
     // Build the archive in the upload area
@@ -847,29 +740,28 @@ CreateComponentDescription(cmCPackComponent *component,
                                       zipListFileName.c_str());
     std::string output;
     int retVal = -1;
-    int res = cmSystemTools::RunSingleCommand(
-      cmd.c_str(), &output, &output,
-      &retVal, dirName.c_str(), cmSystemTools::OUTPUT_NONE, 0);
-    if ( !res || retVal )
-    {
+    int res = cmSystemTools::RunSingleCommand(cmd.c_str(), &output, &output,
+                                              &retVal, dirName.c_str(),
+                                              cmSystemTools::OUTPUT_NONE, 0);
+    if (!res || retVal) {
       std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
       tmpFile += "/CompressZip.log";
       cmGeneratedFileStream ofs(tmpFile.c_str());
       ofs << "# Run command: " << cmd << std::endl
-        << "# Output:" << std::endl
-        << output << std::endl;
+          << "# Output:" << std::endl
+          << output << std::endl;
       cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running zip command: "
-        << cmd << std::endl
-        << "Please check " << tmpFile << " for errors" << std::endl);
+                      << cmd << std::endl
+                      << "Please check " << tmpFile << " for errors"
+                      << std::endl);
       return "";
     }
 
     // Create the NSIS code to download this file on-the-fly.
     unsigned long totalSizeInKbytes = (totalSize + 512) / 1024;
-    if (totalSizeInKbytes == 0)
-      {
+    if (totalSizeInKbytes == 0) {
       totalSizeInKbytes = 1;
-      }
+    }
     std::ostringstream out;
     /* clang-format off */
     out << "  AddSize " << totalSizeInKbytes << "\n"
@@ -883,12 +775,10 @@ CreateComponentDescription(cmCPackComponent *component,
                      "  Delete $INSTDIR\\$0\n";
     /* clang-format on */
     componentCode += out.str();
-    }
-  else
-    {
-    componentCode += "  File /r \"${INST_DIR}\\" +
-      component->Name + "\\*.*\"\n";
-    }
+  } else {
+    componentCode +=
+      "  File /r \"${INST_DIR}\\" + component->Name + "\\*.*\"\n";
+  }
   componentCode += "SectionEnd\n";
 
   // Macro used to remove the component
@@ -897,32 +787,24 @@ CreateComponentDescription(cmCPackComponent *component,
             << component->Name << "\n";
   std::vector<std::string>::iterator pathIt;
   std::string path;
-  for (pathIt = component->Files.begin();
-       pathIt != component->Files.end();
-       ++pathIt)
-    {
+  for (pathIt = component->Files.begin(); pathIt != component->Files.end();
+       ++pathIt) {
     path = *pathIt;
     cmSystemTools::ReplaceString(path, "/", "\\");
-    macrosOut << "  Delete \"$INSTDIR\\"
-              << path
-              << "\"\n";
-    }
+    macrosOut << "  Delete \"$INSTDIR\\" << path << "\"\n";
+  }
   for (pathIt = component->Directories.begin();
-       pathIt != component->Directories.end();
-       ++pathIt)
-    {
+       pathIt != component->Directories.end(); ++pathIt) {
     path = *pathIt;
     cmSystemTools::ReplaceString(path, "/", "\\");
-    macrosOut << "  RMDir \"$INSTDIR\\"
-              << path
-              << "\"\n";
-    }
+    macrosOut << "  RMDir \"$INSTDIR\\" << path << "\"\n";
+  }
   macrosOut << "  noremove_" << component->Name << ":\n";
   macrosOut << "!macroend\n";
 
   // Macro used to select each of the components that this component
   // depends on.
-  std::set<cmCPackComponent *> visited;
+  std::set<cmCPackComponent*> visited;
   macrosOut << "!macro Select_" << component->Name << "_depends\n";
   macrosOut << CreateSelectionDependenciesDescription(component, visited);
   macrosOut << "!macroend\n";
@@ -936,23 +818,19 @@ CreateComponentDescription(cmCPackComponent *component,
   return componentCode;
 }
 
-std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription
-              (cmCPackComponent *component,
-               std::set<cmCPackComponent *>& visited)
+std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription(
+  cmCPackComponent* component, std::set<cmCPackComponent*>& visited)
 {
   // Don't visit a component twice
-  if (visited.count(component))
-    {
+  if (visited.count(component)) {
     return std::string();
-    }
+  }
   visited.insert(component);
 
   std::ostringstream out;
-  std::vector<cmCPackComponent *>::iterator dependIt;
+  std::vector<cmCPackComponent*>::iterator dependIt;
   for (dependIt = component->Dependencies.begin();
-       dependIt != component->Dependencies.end();
-       ++dependIt)
-    {
+       dependIt != component->Dependencies.end(); ++dependIt) {
     // Write NSIS code to select this dependency
     out << "  SectionGetFlags ${" << (*dependIt)->Name << "} $0\n";
     out << "  IntOp $0 $0 | ${SF_SELECTED}\n";
@@ -961,29 +839,24 @@ std::string cmCPackNSISGenerator::CreateSelectionDependenciesDescription
         << "_selected 0 + ${SF_SELECTED}\n";
     // Recurse
     out << CreateSelectionDependenciesDescription(*dependIt, visited).c_str();
-    }
+  }
 
   return out.str();
 }
 
-
-std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription
-              (cmCPackComponent *component,
-                   std::set<cmCPackComponent *>& visited)
+std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription(
+  cmCPackComponent* component, std::set<cmCPackComponent*>& visited)
 {
   // Don't visit a component twice
-  if (visited.count(component))
-    {
+  if (visited.count(component)) {
     return std::string();
-    }
+  }
   visited.insert(component);
 
   std::ostringstream out;
-  std::vector<cmCPackComponent *>::iterator dependIt;
+  std::vector<cmCPackComponent*>::iterator dependIt;
   for (dependIt = component->ReverseDependencies.begin();
-       dependIt != component->ReverseDependencies.end();
-       ++dependIt)
-    {
+       dependIt != component->ReverseDependencies.end(); ++dependIt) {
     // Write NSIS code to deselect this dependency
     out << "  SectionGetFlags ${" << (*dependIt)->Name << "} $0\n";
     out << "  IntOp $1 ${SF_SELECTED} ~\n";
@@ -992,57 +865,46 @@ std::string cmCPackNSISGenerator::CreateDeselectionDependenciesDescription
     out << "  IntOp $" << (*dependIt)->Name << "_selected 0 + 0\n";
 
     // Recurse
-    out <<
-      CreateDeselectionDependenciesDescription(*dependIt, visited).c_str();
-    }
+    out
+      << CreateDeselectionDependenciesDescription(*dependIt, visited).c_str();
+  }
 
   return out.str();
 }
 
-std::string
-cmCPackNSISGenerator::
-CreateComponentGroupDescription(cmCPackComponentGroup *group,
-                                std::ostringstream& macrosOut)
+std::string cmCPackNSISGenerator::CreateComponentGroupDescription(
+  cmCPackComponentGroup* group, std::ostringstream& macrosOut)
 {
-  if (group->Components.empty() && group->Subgroups.empty())
-    {
+  if (group->Components.empty() && group->Subgroups.empty()) {
     // Silently skip empty groups. NSIS doesn't support them.
     return std::string();
-    }
+  }
 
   std::string code = "SectionGroup ";
-  if (group->IsExpandedByDefault)
-    {
+  if (group->IsExpandedByDefault) {
     code += "/e ";
-    }
-  if (group->IsBold)
-    {
+  }
+  if (group->IsBold) {
     code += "\"!" + group->DisplayName + "\" " + group->Name + "\n";
-    }
-  else
-    {
+  } else {
     code += "\"" + group->DisplayName + "\" " + group->Name + "\n";
-    }
+  }
 
   std::vector<cmCPackComponentGroup*>::iterator groupIt;
   for (groupIt = group->Subgroups.begin(); groupIt != group->Subgroups.end();
-       ++groupIt)
-    {
+       ++groupIt) {
     code += this->CreateComponentGroupDescription(*groupIt, macrosOut);
-    }
+  }
 
   std::vector<cmCPackComponent*>::iterator comp;
-  for (comp = group->Components.begin();
-       comp != group->Components.end();
-       ++comp)
-    {
-    if ((*comp)->Files.empty())
-      {
+  for (comp = group->Components.begin(); comp != group->Components.end();
+       ++comp) {
+    if ((*comp)->Files.empty()) {
       continue;
-      }
+    }
 
     code += this->CreateComponentDescription(*comp, macrosOut);
-    }
+  }
   code += "SectionGroupEnd\n";
   return code;
 }
diff --git a/Source/CPack/cmCPackNSISGenerator.h b/Source/CPack/cmCPackNSISGenerator.h
index ab8ece4..fa52902 100644
--- a/Source/CPack/cmCPackNSISGenerator.h
+++ b/Source/CPack/cmCPackNSISGenerator.h
@@ -28,7 +28,9 @@ public:
   cmCPackTypeMacro(cmCPackNSISGenerator, cmCPackGenerator);
 
   static cmCPackGenerator* CreateGenerator64()
-    { return new cmCPackNSISGenerator(true); }
+  {
+    return new cmCPackNSISGenerator(true);
+  }
 
   /**
    * Construct generator
@@ -38,14 +40,13 @@ public:
 
 protected:
   virtual int InitializeInternal();
-  void CreateMenuLinks( std::ostringstream& str,
-                        std::ostringstream& deleteStr);
+  void CreateMenuLinks(std::ostringstream& str, std::ostringstream& deleteStr);
   int PackageFiles();
   virtual const char* GetOutputExtension() { return ".exe"; }
   virtual const char* GetOutputPostfix() { return "win32"; }
 
   bool GetListOfSubdirectories(const char* dir,
-    std::vector<std::string>& dirs);
+                               std::vector<std::string>& dirs);
 
   enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
   virtual bool SupportsAbsoluteDestination() const;
@@ -54,28 +55,24 @@ protected:
   /// Produce a string that contains the NSIS code to describe a
   /// particular component. Any added macros will be emitted via
   /// macrosOut.
-  std::string
-  CreateComponentDescription(cmCPackComponent *component,
-                             std::ostringstream& macrosOut);
+  std::string CreateComponentDescription(cmCPackComponent* component,
+                                         std::ostringstream& macrosOut);
 
   /// Produce NSIS code that selects all of the components that this component
   /// depends on, recursively.
-  std::string CreateSelectionDependenciesDescription
-                (cmCPackComponent *component,
-                 std::set<cmCPackComponent *>& visited);
+  std::string CreateSelectionDependenciesDescription(
+    cmCPackComponent* component, std::set<cmCPackComponent*>& visited);
 
   /// Produce NSIS code that de-selects all of the components that are
   /// dependent on this component, recursively.
-  std::string CreateDeselectionDependenciesDescription
-                (cmCPackComponent *component,
-                 std::set<cmCPackComponent *>& visited);
+  std::string CreateDeselectionDependenciesDescription(
+    cmCPackComponent* component, std::set<cmCPackComponent*>& visited);
 
   /// Produce a string that contains the NSIS code to describe a
   /// particular component group, including its components. Any
   /// added macros will be emitted via macrosOut.
-  std::string
-  CreateComponentGroupDescription(cmCPackComponentGroup *group,
-                                  std::ostringstream& macrosOut);
+  std::string CreateComponentGroupDescription(cmCPackComponentGroup* group,
+                                              std::ostringstream& macrosOut);
 
   /// Translations any newlines found in the string into \\r\\n, so that the
   /// resulting string can be used within NSIS.
diff --git a/Source/CPack/cmCPackOSXX11Generator.cxx b/Source/CPack/cmCPackOSXX11Generator.cxx
index 42b8c62..d5691be 100644
--- a/Source/CPack/cmCPackOSXX11Generator.cxx
+++ b/Source/CPack/cmCPackOSXX11Generator.cxx
@@ -36,41 +36,38 @@ int cmCPackOSXX11Generator::PackageFiles()
   // TODO: Use toplevel ?
   //       It is used! Is this an obsolete comment?
 
-  const char* cpackPackageExecutables
-    = this->GetOption("CPACK_PACKAGE_EXECUTABLES");
-  if ( cpackPackageExecutables )
-    {
+  const char* cpackPackageExecutables =
+    this->GetOption("CPACK_PACKAGE_EXECUTABLES");
+  if (cpackPackageExecutables) {
     cmCPackLogger(cmCPackLog::LOG_DEBUG, "The cpackPackageExecutables: "
-      << cpackPackageExecutables << "." << std::endl);
+                    << cpackPackageExecutables << "." << std::endl);
     std::ostringstream str;
     std::ostringstream deleteStr;
     std::vector<std::string> cpackPackageExecutablesVector;
     cmSystemTools::ExpandListArgument(cpackPackageExecutables,
-      cpackPackageExecutablesVector);
-    if ( cpackPackageExecutablesVector.size() % 2 != 0 )
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                                      cpackPackageExecutablesVector);
+    if (cpackPackageExecutablesVector.size() % 2 != 0) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
         "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
-        "<icon name>." << std::endl);
+        "<icon name>."
+          << std::endl);
       return 0;
-      }
+    }
     std::vector<std::string>::iterator it;
-    for ( it = cpackPackageExecutablesVector.begin();
-      it != cpackPackageExecutablesVector.end();
-      ++it )
-      {
+    for (it = cpackPackageExecutablesVector.begin();
+         it != cpackPackageExecutablesVector.end(); ++it) {
       std::string cpackExecutableName = *it;
-      ++ it;
+      ++it;
       this->SetOptionIfNotSet("CPACK_EXECUTABLE_NAME",
-        cpackExecutableName.c_str());
-      }
+                              cpackExecutableName.c_str());
     }
+  }
 
   // Disk image directories
   std::string diskImageDirectory = toplevel;
-  std::string diskImageBackgroundImageDir
-    = diskImageDirectory + "/.background";
-
+  std::string diskImageBackgroundImageDir =
+    diskImageDirectory + "/.background";
 
   // App bundle directories
   std::string packageDirFileName = toplevel;
@@ -90,48 +87,45 @@ int cmCPackOSXX11Generator::PackageFiles()
   const char* contDir = contentsDirectory.c_str();
   const char* rsrcFile = resourceFileName.c_str();
   const char* iconFile = this->GetOption("CPACK_PACKAGE_ICON");
-  if ( iconFile )
-    {
-    std::string iconFileName = cmsys::SystemTools::GetFilenameName(
-      iconFile);
-    if ( !cmSystemTools::FileExists(iconFile) )
-      {
+  if (iconFile) {
+    std::string iconFileName = cmsys::SystemTools::GetFilenameName(iconFile);
+    if (!cmSystemTools::FileExists(iconFile)) {
       cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find icon file: "
-        << iconFile << ". Please check CPACK_PACKAGE_ICON setting."
-        << std::endl);
+                      << iconFile
+                      << ". Please check CPACK_PACKAGE_ICON setting."
+                      << std::endl);
       return 0;
-      }
+    }
     std::string destFileName = resourcesDirectory + "/" + iconFileName;
     this->ConfigureFile(iconFile, destFileName.c_str(), true);
     this->SetOptionIfNotSet("CPACK_APPLE_GUI_ICON", iconFileName.c_str());
-    }
+  }
 
   std::string applicationsLinkName = diskImageDirectory + "/Applications";
   cmSystemTools::CreateSymlink("/Applications", applicationsLinkName.c_str());
 
-  if (
-    !this->CopyResourcePlistFile("VolumeIcon.icns",
-                                 diskImageDirectory.c_str(),
-                                 ".VolumeIcon.icns", true ) ||
-    !this->CopyResourcePlistFile("DS_Store", diskImageDirectory.c_str(),
-      ".DS_Store", true ) ||
-    !this->CopyResourcePlistFile("background.png",
-      diskImageBackgroundImageDir.c_str(), "background.png", true ) ||
-    !this->CopyResourcePlistFile("RuntimeScript", dir) ||
-    !this->CopyResourcePlistFile("OSXX11.Info.plist", contDir,
-      "Info.plist" ) ||
-    !this->CopyResourcePlistFile("OSXX11.main.scpt", scrDir,
-      "main.scpt", true ) ||
-    !this->CopyResourcePlistFile("OSXScriptLauncher.rsrc", dir,
-      rsrcFile, true) ||
-    !this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
-      this->GetOption("CPACK_PACKAGE_FILE_NAME"), true)
-  )
-    {
+  if (!this->CopyResourcePlistFile("VolumeIcon.icns",
+                                   diskImageDirectory.c_str(),
+                                   ".VolumeIcon.icns", true) ||
+      !this->CopyResourcePlistFile("DS_Store", diskImageDirectory.c_str(),
+                                   ".DS_Store", true) ||
+      !this->CopyResourcePlistFile("background.png",
+                                   diskImageBackgroundImageDir.c_str(),
+                                   "background.png", true) ||
+      !this->CopyResourcePlistFile("RuntimeScript", dir) ||
+      !this->CopyResourcePlistFile("OSXX11.Info.plist", contDir,
+                                   "Info.plist") ||
+      !this->CopyResourcePlistFile("OSXX11.main.scpt", scrDir, "main.scpt",
+                                   true) ||
+      !this->CopyResourcePlistFile("OSXScriptLauncher.rsrc", dir, rsrcFile,
+                                   true) ||
+      !this->CopyResourcePlistFile("OSXScriptLauncher", appdir,
+                                   this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                   true)) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
-      << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
 
   // Two of the files need to have execute permission, so ensure they do:
   std::string runTimeScript = dir;
@@ -143,21 +137,21 @@ int cmCPackOSXX11Generator::PackageFiles()
   appScriptName += this->GetOption("CPACK_PACKAGE_FILE_NAME");
 
   mode_t mode;
-  if (cmsys::SystemTools::GetPermissions(runTimeScript.c_str(), mode))
-    {
+  if (cmsys::SystemTools::GetPermissions(runTimeScript.c_str(), mode)) {
     mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
     cmsys::SystemTools::SetPermissions(runTimeScript.c_str(), mode);
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT, "Setting: " << runTimeScript
-      << " to permission: " << mode << std::endl);
-    }
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "Setting: " << runTimeScript << " to permission: " << mode
+                              << std::endl);
+  }
 
-  if (cmsys::SystemTools::GetPermissions(appScriptName.c_str(), mode))
-    {
+  if (cmsys::SystemTools::GetPermissions(appScriptName.c_str(), mode)) {
     mode |= (S_IXUSR | S_IXGRP | S_IXOTH);
     cmsys::SystemTools::SetPermissions(appScriptName.c_str(), mode);
-    cmCPackLogger(cmCPackLog::LOG_OUTPUT,  "Setting: " << appScriptName
-      << " to permission: " << mode << std::endl);
-    }
+    cmCPackLogger(cmCPackLog::LOG_OUTPUT,
+                  "Setting: " << appScriptName << " to permission: " << mode
+                              << std::endl);
+  }
 
   std::string output;
   std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@@ -165,56 +159,52 @@ int cmCPackOSXX11Generator::PackageFiles()
   std::ostringstream dmgCmd;
   dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
          << "\" create -ov -format UDZO -srcfolder \""
-         << diskImageDirectory.c_str()
-         << "\" \"" << packageFileNames[0] << "\"";
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-                "Compress disk image using command: "
-                << dmgCmd.str().c_str() << std::endl);
+         << diskImageDirectory.c_str() << "\" \"" << packageFileNames[0]
+         << "\"";
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Compress disk image using command: "
+                  << dmgCmd.str().c_str() << std::endl);
   // since we get random dashboard failures with this one
   // try running it more than once
   int retVal = 1;
   int numTries = 10;
   bool res = false;
-  while(numTries > 0)
-    {
-    res = cmSystemTools::RunSingleCommand(
-      dmgCmd.str().c_str(), &output, &output,
-      &retVal, 0, this->GeneratorVerbose, 0);
-    if ( res && !retVal )
-      {
+  while (numTries > 0) {
+    res =
+      cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output, &output,
+                                      &retVal, 0, this->GeneratorVerbose, 0);
+    if (res && !retVal) {
       numTries = -1;
       break;
-      }
+    }
     cmSystemTools::Delay(500);
     numTries--;
-    }
-  if ( !res || retVal )
-    {
+  }
+  if (!res || retVal) {
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Run command: " << dmgCmd.str().c_str() << std::endl
-      << "# Output:" << std::endl
-      << output.c_str() << std::endl;
+        << "# Output:" << std::endl
+        << output.c_str() << std::endl;
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
-      << dmgCmd.str().c_str() << std::endl
-      << "Please check " << tmpFile.c_str() << " for errors" << std::endl);
+                    << dmgCmd.str().c_str() << std::endl
+                    << "Please check " << tmpFile.c_str() << " for errors"
+                    << std::endl);
     return 0;
-    }
+  }
 
   return 1;
 }
 
 int cmCPackOSXX11Generator::InitializeInternal()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG,
-    "cmCPackOSXX11Generator::Initialize()" << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackOSXX11Generator::Initialize()"
+                  << std::endl);
   std::vector<std::string> path;
   std::string pkgPath = cmSystemTools::FindProgram("hdiutil", path, false);
-  if ( pkgPath.empty() )
-    {
+  if (pkgPath.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
-      << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
   this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
                           pkgPath.c_str());
 
@@ -265,32 +255,31 @@ bool cmCPackOSXX11Generator::CopyCreateResourceFile(const std::string& name)
 }
 */
 
-bool cmCPackOSXX11Generator::CopyResourcePlistFile(const std::string& name,
-  const std::string& dir, const char* outputFileName /* = 0 */,
-  bool copyOnly /* = false */)
+bool cmCPackOSXX11Generator::CopyResourcePlistFile(
+  const std::string& name, const std::string& dir,
+  const char* outputFileName /* = 0 */, bool copyOnly /* = false */)
 {
   std::string inFName = "CPack.";
   inFName += name;
   inFName += ".in";
   std::string inFileName = this->FindTemplate(inFName.c_str());
-  if ( inFileName.empty() )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find input file: "
-      << inFName << std::endl);
+  if (inFileName.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find input file: " << inFName << std::endl);
     return false;
-    }
+  }
 
-  if ( !outputFileName )
-    {
+  if (!outputFileName) {
     outputFileName = name.c_str();
-    }
+  }
 
   std::string destFileName = dir;
   destFileName += "/";
   destFileName += outputFileName;
 
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
-    << inFileName.c_str() << " to " << destFileName.c_str() << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Configure file: " << inFileName.c_str() << " to "
+                                   << destFileName.c_str() << std::endl);
   this->ConfigureFile(inFileName.c_str(), destFileName.c_str(), copyOnly);
   return true;
 }
diff --git a/Source/CPack/cmCPackOSXX11Generator.h b/Source/CPack/cmCPackOSXX11Generator.h
index 9d0a6d1..adc05d2 100644
--- a/Source/CPack/cmCPackOSXX11Generator.h
+++ b/Source/CPack/cmCPackOSXX11Generator.h
@@ -37,10 +37,11 @@ protected:
   virtual const char* GetPackagingInstallPrefix();
   virtual const char* GetOutputExtension() { return ".dmg"; }
 
-  //bool CopyCreateResourceFile(const std::string& name,
+  // bool CopyCreateResourceFile(const std::string& name,
   //                            const std::string& dir);
   bool CopyResourcePlistFile(const std::string& name, const std::string& dir,
-    const char* outputFileName = 0, bool copyOnly = false);
+                             const char* outputFileName = 0,
+                             bool copyOnly = false);
   std::string InstallPrefix;
 };
 
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx
index 71a5b12..5ca3ff7 100644
--- a/Source/CPack/cmCPackPackageMakerGenerator.cxx
+++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx
@@ -25,8 +25,7 @@
 
 #include <assert.h>
 
-static inline
-unsigned int getVersion(unsigned int major, unsigned int minor)
+static inline unsigned int getVersion(unsigned int major, unsigned int minor)
 {
   assert(major < 256 && minor < 256);
   return ((major & 0xFF) << 16 | minor);
@@ -55,10 +54,9 @@ int cmCPackPackageMakerGenerator::CopyInstallScript(const std::string& resdir,
   dst += "/";
   dst += name;
   cmSystemTools::CopyFileAlways(script.c_str(), dst.c_str());
-  cmSystemTools::SetPermissions(dst.c_str(),0777);
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-                "copy script : " << script << "\ninto " << dst.c_str() <<
-                std::endl);
+  cmSystemTools::SetPermissions(dst.c_str(), 0777);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "copy script : "
+                  << script << "\ninto " << dst.c_str() << std::endl);
 
   return 1;
 }
@@ -69,102 +67,80 @@ int cmCPackPackageMakerGenerator::PackageFiles()
   //       It is used! Is this an obsolete comment?
 
   std::string resDir; // Where this package's resources will go.
-  std::string packageDirFileName
-    = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
-  if (this->Components.empty())
-    {
+  std::string packageDirFileName =
+    this->GetOption("CPACK_TEMPORARY_DIRECTORY");
+  if (this->Components.empty()) {
     packageDirFileName += ".pkg";
     resDir = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
     resDir += "/Resources";
-    }
-  else
-    {
+  } else {
     packageDirFileName += ".mpkg";
-    if ( !cmsys::SystemTools::MakeDirectory(packageDirFileName.c_str()))
-      {
+    if (!cmsys::SystemTools::MakeDirectory(packageDirFileName.c_str())) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
-                    "unable to create package directory "
-                    << packageDirFileName << std::endl);
-        return 0;
-      }
+                    "unable to create package directory " << packageDirFileName
+                                                          << std::endl);
+      return 0;
+    }
 
     resDir = packageDirFileName;
     resDir += "/Contents";
-    if ( !cmsys::SystemTools::MakeDirectory(resDir.c_str()))
-      {
+    if (!cmsys::SystemTools::MakeDirectory(resDir.c_str())) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "unable to create package subdirectory " << resDir
-                    << std::endl);
-        return 0;
-      }
+                                                             << std::endl);
+      return 0;
+    }
 
     resDir += "/Resources";
-    if ( !cmsys::SystemTools::MakeDirectory(resDir.c_str()))
-      {
+    if (!cmsys::SystemTools::MakeDirectory(resDir.c_str())) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "unable to create package subdirectory " << resDir
-                    << std::endl);
-        return 0;
-      }
+                                                             << std::endl);
+      return 0;
+    }
 
     resDir += "/en.lproj";
-    }
+  }
 
   const char* preflight = this->GetOption("CPACK_PREFLIGHT_SCRIPT");
   const char* postflight = this->GetOption("CPACK_POSTFLIGHT_SCRIPT");
   const char* postupgrade = this->GetOption("CPACK_POSTUPGRADE_SCRIPT");
 
-  if(this->Components.empty())
-    {
+  if (this->Components.empty()) {
     // Create directory structure
     std::string preflightDirName = resDir + "/PreFlight";
     std::string postflightDirName = resDir + "/PostFlight";
     // if preflight or postflight scripts not there create directories
     // of the same name, I think this makes it work
-    if(!preflight)
-      {
-      if ( !cmsys::SystemTools::MakeDirectory(preflightDirName.c_str()))
-        {
+    if (!preflight) {
+      if (!cmsys::SystemTools::MakeDirectory(preflightDirName.c_str())) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
                       "Problem creating installer directory: "
-                      << preflightDirName.c_str() << std::endl);
+                        << preflightDirName.c_str() << std::endl);
         return 0;
-        }
       }
-    if(!postflight)
-      {
-      if ( !cmsys::SystemTools::MakeDirectory(postflightDirName.c_str()))
-        {
+    }
+    if (!postflight) {
+      if (!cmsys::SystemTools::MakeDirectory(postflightDirName.c_str())) {
         cmCPackLogger(cmCPackLog::LOG_ERROR,
                       "Problem creating installer directory: "
-                      << postflightDirName.c_str() << std::endl);
+                        << postflightDirName.c_str() << std::endl);
         return 0;
-        }
       }
+    }
     // if preflight, postflight, or postupgrade are set
     // then copy them into the resource directory and make
     // them executable
-    if(preflight)
-      {
-      this->CopyInstallScript(resDir.c_str(),
-                              preflight,
-                              "preflight");
-      }
-    if(postflight)
-      {
-      this->CopyInstallScript(resDir.c_str(),
-                              postflight,
-                              "postflight");
-      }
-    if(postupgrade)
-      {
-      this->CopyInstallScript(resDir.c_str(),
-                              postupgrade,
-                              "postupgrade");
-      }
+    if (preflight) {
+      this->CopyInstallScript(resDir.c_str(), preflight, "preflight");
     }
-  else if(postflight)
-    {
+    if (postflight) {
+      this->CopyInstallScript(resDir.c_str(), postflight, "postflight");
+    }
+    if (postupgrade) {
+      this->CopyInstallScript(resDir.c_str(), postupgrade, "postupgrade");
+    }
+  } else if (postflight) {
     // create a postflight component to house the script
     this->PostFlightComponent.Name = "PostFlight";
     this->PostFlightComponent.DisplayName = "PostFlight";
@@ -173,121 +149,101 @@ int cmCPackPackageMakerGenerator::PackageFiles()
 
     // empty directory for pkg contents
     std::string packageDir = toplevel + "/" + PostFlightComponent.Name;
-    if (!cmsys::SystemTools::MakeDirectory(packageDir.c_str()))
-      {
+    if (!cmsys::SystemTools::MakeDirectory(packageDir.c_str())) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Problem creating component packages directory: "
-                    << packageDir.c_str() << std::endl);
+                      << packageDir.c_str() << std::endl);
       return 0;
-      }
+    }
 
     // create package
     std::string packageFileDir = packageDirFileName + "/Contents/Packages/";
-    if (!cmsys::SystemTools::MakeDirectory(packageFileDir.c_str()))
-      {
-      cmCPackLogger(cmCPackLog::LOG_ERROR,
-                   "Problem creating component PostFlight Packages directory: "
-                    << packageFileDir.c_str() << std::endl);
+    if (!cmsys::SystemTools::MakeDirectory(packageFileDir.c_str())) {
+      cmCPackLogger(
+        cmCPackLog::LOG_ERROR,
+        "Problem creating component PostFlight Packages directory: "
+          << packageFileDir.c_str() << std::endl);
       return 0;
-      }
-    std::string packageFile = packageFileDir +
-      this->GetPackageName(PostFlightComponent);
-    if (!this->GenerateComponentPackage(packageFile.c_str(),
-                                        packageDir.c_str(),
-                                        PostFlightComponent))
-      {
+    }
+    std::string packageFile =
+      packageFileDir + this->GetPackageName(PostFlightComponent);
+    if (!this->GenerateComponentPackage(
+          packageFile.c_str(), packageDir.c_str(), PostFlightComponent)) {
       return 0;
-      }
+    }
 
     // copy postflight script into resource directory of .pkg
     std::string resourceDir = packageFile + "/Contents/Resources";
-    this->CopyInstallScript(resourceDir.c_str(),
-                            postflight,
-                            "postflight");
-    }
+    this->CopyInstallScript(resourceDir.c_str(), postflight, "postflight");
+  }
 
-  if (!this->Components.empty())
-    {
+  if (!this->Components.empty()) {
     // Create the directory where component packages will be built.
     std::string basePackageDir = packageDirFileName;
     basePackageDir += "/Contents/Packages";
-    if (!cmsys::SystemTools::MakeDirectory(basePackageDir.c_str()))
-      {
+    if (!cmsys::SystemTools::MakeDirectory(basePackageDir.c_str())) {
       cmCPackLogger(cmCPackLog::LOG_ERROR,
                     "Problem creating component packages directory: "
-                    << basePackageDir.c_str() << std::endl);
+                      << basePackageDir.c_str() << std::endl);
       return 0;
-      }
+    }
 
     // Create the directory where downloaded component packages will
     // be placed.
     const char* userUploadDirectory =
       this->GetOption("CPACK_UPLOAD_DIRECTORY");
     std::string uploadDirectory;
-    if (userUploadDirectory && *userUploadDirectory)
-      {
+    if (userUploadDirectory && *userUploadDirectory) {
       uploadDirectory = userUploadDirectory;
-      }
-    else
-      {
-      uploadDirectory= this->GetOption("CPACK_PACKAGE_DIRECTORY");
+    } else {
+      uploadDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
       uploadDirectory += "/CPackUploads";
-      }
+    }
 
     // Create packages for each component
     bool warnedAboutDownloadCompatibility = false;
 
     std::map<std::string, cmCPackComponent>::iterator compIt;
     for (compIt = this->Components.begin(); compIt != this->Components.end();
-         ++compIt)
-      {
+         ++compIt) {
       std::string packageFile;
-      if (compIt->second.IsDownloaded)
-        {
+      if (compIt->second.IsDownloaded) {
         if (this->PackageCompatibilityVersion >= getVersion(10, 5) &&
-            this->PackageMakerVersion >= 3.0)
-          {
+            this->PackageMakerVersion >= 3.0) {
           // Build this package within the upload directory.
           packageFile = uploadDirectory;
 
-          if(!cmSystemTools::FileExists(uploadDirectory.c_str()))
-            {
-            if (!cmSystemTools::MakeDirectory(uploadDirectory.c_str()))
-              {
+          if (!cmSystemTools::FileExists(uploadDirectory.c_str())) {
+            if (!cmSystemTools::MakeDirectory(uploadDirectory.c_str())) {
               cmCPackLogger(cmCPackLog::LOG_ERROR,
                             "Unable to create package upload directory "
-                            << uploadDirectory << std::endl);
+                              << uploadDirectory << std::endl);
               return 0;
-              }
             }
           }
-        else if (!warnedAboutDownloadCompatibility)
-          {
-            if (this->PackageCompatibilityVersion < getVersion(10, 5))
-            {
+        } else if (!warnedAboutDownloadCompatibility) {
+          if (this->PackageCompatibilityVersion < getVersion(10, 5)) {
             cmCPackLogger(
               cmCPackLog::LOG_WARNING,
               "CPack warning: please set CPACK_OSX_PACKAGE_VERSION to 10.5 "
               "or greater enable downloaded packages. CPack will build a "
               "non-downloaded package."
-              << std::endl);
-            }
+                << std::endl);
+          }
 
-          if (this->PackageMakerVersion < 3)
-            {
+          if (this->PackageMakerVersion < 3) {
             cmCPackLogger(cmCPackLog::LOG_WARNING,
-                        "CPack warning: unable to build downloaded "
+                          "CPack warning: unable to build downloaded "
                           "packages with PackageMaker versions prior "
                           "to 3.0. CPack will build a non-downloaded package."
-                          << std::endl);
-            }
+                            << std::endl);
+          }
 
           warnedAboutDownloadCompatibility = true;
-          }
         }
+      }
 
-      if (packageFile.empty())
-        {
+      if (packageFile.empty()) {
         // Build this package within the overall distribution
         // metapackage.
         packageFile = basePackageDir;
@@ -295,7 +251,7 @@ int cmCPackPackageMakerGenerator::PackageFiles()
         // We're not downloading this component, even if the user
         // requested it.
         compIt->second.IsDownloaded = false;
-        }
+      }
 
       packageFile += '/';
       packageFile += GetPackageName(compIt->second);
@@ -303,97 +259,85 @@ int cmCPackPackageMakerGenerator::PackageFiles()
       std::string packageDir = toplevel;
       packageDir += '/';
       packageDir += compIt->first;
-      if (!this->GenerateComponentPackage(packageFile.c_str(),
-                                          packageDir.c_str(),
-                                          compIt->second))
-        {
+      if (!this->GenerateComponentPackage(
+            packageFile.c_str(), packageDir.c_str(), compIt->second)) {
         return 0;
-        }
       }
     }
+  }
   this->SetOption("CPACK_MODULE_VERSION_SUFFIX", "");
 
   // Copy or create all of the resource files we need.
-  if ( !this->CopyCreateResourceFile("License", resDir.c_str())
-       || !this->CopyCreateResourceFile("ReadMe", resDir.c_str())
-       || !this->CopyCreateResourceFile("Welcome", resDir.c_str())
-       || !this->CopyResourcePlistFile("Info.plist")
-       || !this->CopyResourcePlistFile("Description.plist") )
-    {
+  if (!this->CopyCreateResourceFile("License", resDir.c_str()) ||
+      !this->CopyCreateResourceFile("ReadMe", resDir.c_str()) ||
+      !this->CopyCreateResourceFile("Welcome", resDir.c_str()) ||
+      !this->CopyResourcePlistFile("Info.plist") ||
+      !this->CopyResourcePlistFile("Description.plist")) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying the resource files"
-      << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
 
-  if (this->Components.empty())
-    {
+  if (this->Components.empty()) {
     // Use PackageMaker to build the package.
     std::ostringstream pkgCmd;
     pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
            << "\" -build -p \"" << packageDirFileName << "\"";
-    if (this->Components.empty())
-      {
+    if (this->Components.empty()) {
       pkgCmd << " -f \"" << this->GetOption("CPACK_TEMPORARY_DIRECTORY");
-      }
-    else
-      {
+    } else {
       pkgCmd << " -mi \"" << this->GetOption("CPACK_TEMPORARY_DIRECTORY")
              << "/packages/";
-      }
+    }
     pkgCmd << "\" -r \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
            << "/Resources\" -i \""
            << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
            << "/Info.plist\" -d \""
            << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
            << "/Description.plist\"";
-    if ( this->PackageMakerVersion > 2.0 )
-      {
+    if (this->PackageMakerVersion > 2.0) {
       pkgCmd << " -v";
-      }
+    }
     if (!RunPackageMaker(pkgCmd.str().c_str(), packageDirFileName.c_str()))
       return 0;
-    }
-  else
-    {
+  } else {
     // We have built the package in place. Generate the
     // distribution.dist file to describe it for the installer.
     WriteDistributionFile(packageDirFileName.c_str());
-    }
+  }
 
   std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   tmpFile += "/hdiutilOutput.log";
   std::ostringstream dmgCmd;
   dmgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM_DISK_IMAGE")
-    << "\" create -ov -format UDZO -srcfolder \"" << packageDirFileName
-    << "\" \"" << packageFileNames[0] << "\"";
+         << "\" create -ov -format UDZO -srcfolder \"" << packageDirFileName
+         << "\" \"" << packageFileNames[0] << "\"";
   std::string output;
   int retVal = 1;
   int numTries = 10;
   bool res = false;
-  while(numTries > 0)
-    {
-    res = cmSystemTools::RunSingleCommand(
-      dmgCmd.str().c_str(), &output, &output,
-      &retVal, 0, this->GeneratorVerbose, 0);
-    if ( res && !retVal )
-      {
+  while (numTries > 0) {
+    res =
+      cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output, &output,
+                                      &retVal, 0, this->GeneratorVerbose, 0);
+    if (res && !retVal) {
       numTries = -1;
       break;
-      }
+    }
     cmSystemTools::Delay(500);
     numTries--;
-    }
-  if ( !res || retVal )
-    {
+  }
+  if (!res || retVal) {
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Run command: " << dmgCmd.str().c_str() << std::endl
-      << "# Output:" << std::endl
-      << output.c_str() << std::endl;
+        << "# Output:" << std::endl
+        << output.c_str() << std::endl;
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem running hdiutil command: "
-      << dmgCmd.str().c_str() << std::endl
-      << "Please check " << tmpFile.c_str() << " for errors" << std::endl);
+                    << dmgCmd.str().c_str() << std::endl
+                    << "Please check " << tmpFile.c_str() << " for errors"
+                    << std::endl);
     return 0;
-    }
+  }
 
   return 1;
 }
@@ -401,7 +345,7 @@ int cmCPackPackageMakerGenerator::PackageFiles()
 int cmCPackPackageMakerGenerator::InitializeInternal()
 {
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
-    "cmCPackPackageMakerGenerator::Initialize()" << std::endl);
+                "cmCPackPackageMakerGenerator::Initialize()" << std::endl);
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
 
   // Starting with Xcode 4.3, PackageMaker is a separate app, and you
@@ -418,39 +362,30 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
   // If found, save result in the CPACK_INSTALLER_PROGRAM variable.
 
   std::vector<std::string> paths;
-  paths.push_back(
-    "/Applications/Xcode.app/Contents/Applications"
-    "/PackageMaker.app/Contents/MacOS");
-  paths.push_back(
-    "/Applications/Utilities"
-    "/PackageMaker.app/Contents/MacOS");
-  paths.push_back(
-    "/Applications"
-    "/PackageMaker.app/Contents/MacOS");
-  paths.push_back(
-    "/Developer/Applications/Utilities"
-    "/PackageMaker.app/Contents/MacOS");
-  paths.push_back(
-    "/Developer/Applications"
-    "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Applications/Xcode.app/Contents/Applications"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Applications/Utilities"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Applications"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Developer/Applications/Utilities"
+                  "/PackageMaker.app/Contents/MacOS");
+  paths.push_back("/Developer/Applications"
+                  "/PackageMaker.app/Contents/MacOS");
 
   std::string pkgPath;
-  const char *inst_program = this->GetOption("CPACK_INSTALLER_PROGRAM");
-  if (inst_program && *inst_program)
-    {
+  const char* inst_program = this->GetOption("CPACK_INSTALLER_PROGRAM");
+  if (inst_program && *inst_program) {
     pkgPath = inst_program;
-    }
-  else
-    {
+  } else {
     pkgPath = cmSystemTools::FindProgram("PackageMaker", paths, false);
-    if ( pkgPath.empty() )
-      {
+    if (pkgPath.empty()) {
       cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find PackageMaker compiler"
-        << std::endl);
+                      << std::endl);
       return 0;
-      }
-    this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", pkgPath.c_str());
     }
+    this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM", pkgPath.c_str());
+  }
 
   // Get path to the real PackageMaker, not a symlink:
   pkgPath = cmSystemTools::GetRealPath(pkgPath.c_str());
@@ -461,100 +396,85 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
 
   std::string versionFile = contents_dir + "/version.plist";
 
-  if ( !cmSystemTools::FileExists(versionFile.c_str()) )
-    {
+  if (!cmSystemTools::FileExists(versionFile.c_str())) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot find PackageMaker compiler version file: "
-      << versionFile.c_str()
-      << std::endl);
+                  "Cannot find PackageMaker compiler version file: "
+                    << versionFile.c_str() << std::endl);
     return 0;
-    }
+  }
 
   cmsys::ifstream ifs(versionFile.c_str());
-  if ( !ifs )
-    {
+  if (!ifs) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot open PackageMaker compiler version file" << std::endl);
+                  "Cannot open PackageMaker compiler version file"
+                    << std::endl);
     return 0;
-    }
+  }
 
   // Check the PackageMaker version
   cmsys::RegularExpression rexKey("<key>CFBundleShortVersionString</key>");
   cmsys::RegularExpression rexVersion("<string>([0-9]+.[0-9.]+)</string>");
   std::string line;
   bool foundKey = false;
-  while ( cmSystemTools::GetLineFromStream(ifs, line) )
-    {
-    if ( rexKey.find(line) )
-      {
+  while (cmSystemTools::GetLineFromStream(ifs, line)) {
+    if (rexKey.find(line)) {
       foundKey = true;
       break;
-      }
     }
-  if ( !foundKey )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
+  }
+  if (!foundKey) {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR,
       "Cannot find CFBundleShortVersionString in the PackageMaker compiler "
-      "version file" << std::endl);
+      "version file"
+        << std::endl);
     return 0;
-    }
-  if ( !cmSystemTools::GetLineFromStream(ifs, line) ||
-    !rexVersion.find(line) )
-    {
+  }
+  if (!cmSystemTools::GetLineFromStream(ifs, line) || !rexVersion.find(line)) {
     cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Problem reading the PackageMaker compiler version file: "
-      << versionFile.c_str() << std::endl);
+                  "Problem reading the PackageMaker compiler version file: "
+                    << versionFile.c_str() << std::endl);
     return 0;
-    }
+  }
   this->PackageMakerVersion = atof(rexVersion.match(1).c_str());
-  if ( this->PackageMakerVersion < 1.0 )
-    {
+  if (this->PackageMakerVersion < 1.0) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Require PackageMaker 1.0 or higher"
-      << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "PackageMaker version is: "
-    << this->PackageMakerVersion << std::endl);
+                  << this->PackageMakerVersion << std::endl);
 
   // Determine the package compatibility version. If it wasn't
   // specified by the user, we define it based on which features the
   // user requested.
-  const char *packageCompat = this->GetOption("CPACK_OSX_PACKAGE_VERSION");
-  if (packageCompat && *packageCompat)
-    {
+  const char* packageCompat = this->GetOption("CPACK_OSX_PACKAGE_VERSION");
+  if (packageCompat && *packageCompat) {
     unsigned int majorVersion = 10;
     unsigned int minorVersion = 5;
     int res = sscanf(packageCompat, "%u.%u", &majorVersion, &minorVersion);
-    if (res == 2)
-      {
+    if (res == 2) {
       this->PackageCompatibilityVersion =
         getVersion(majorVersion, minorVersion);
-      }
     }
-  else if (this->GetOption("CPACK_DOWNLOAD_SITE"))
-    {
+  } else if (this->GetOption("CPACK_DOWNLOAD_SITE")) {
     this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.5");
     this->PackageCompatibilityVersion = getVersion(10, 5);
-    }
-  else if (this->GetOption("CPACK_COMPONENTS_ALL"))
-    {
+  } else if (this->GetOption("CPACK_COMPONENTS_ALL")) {
     this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.4");
     this->PackageCompatibilityVersion = getVersion(10, 4);
-    }
-  else
-    {
+  } else {
     this->SetOption("CPACK_OSX_PACKAGE_VERSION", "10.3");
     this->PackageCompatibilityVersion = getVersion(10, 3);
-    }
+  }
 
   std::vector<std::string> no_paths;
   pkgPath = cmSystemTools::FindProgram("hdiutil", no_paths, false);
-  if ( pkgPath.empty() )
-    {
+  if (pkgPath.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find hdiutil compiler"
-      << std::endl);
+                    << std::endl);
     return 0;
-    }
+  }
   this->SetOptionIfNotSet("CPACK_INSTALLER_PROGRAM_DISK_IMAGE",
                           pkgPath.c_str());
 
@@ -562,36 +482,34 @@ int cmCPackPackageMakerGenerator::InitializeInternal()
 }
 
 bool cmCPackPackageMakerGenerator::CopyCreateResourceFile(
-                                            const std::string& name,
-                                            const std::string& dirName)
+  const std::string& name, const std::string& dirName)
 {
   std::string uname = cmSystemTools::UpperCase(name);
   std::string cpackVar = "CPACK_RESOURCE_FILE_" + uname;
   const char* inFileName = this->GetOption(cpackVar.c_str());
-  if ( !inFileName )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPack option: " << cpackVar.c_str()
-                  << " not specified. It should point to "
-                  << (!name.empty() ? name : "<empty>")
-                  << ".rtf, " << name
-                  << ".html, or " << name << ".txt file" << std::endl);
+  if (!inFileName) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "CPack option: "
+                    << cpackVar.c_str()
+                    << " not specified. It should point to "
+                    << (!name.empty() ? name : "<empty>") << ".rtf, " << name
+                    << ".html, or " << name << ".txt file" << std::endl);
     return false;
-    }
-  if ( !cmSystemTools::FileExists(inFileName) )
-    {
+  }
+  if (!cmSystemTools::FileExists(inFileName)) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find "
-                  << (!name.empty() ? name : "<empty>")
-                  << " resource file: " << inFileName << std::endl);
+                    << (!name.empty() ? name : "<empty>")
+                    << " resource file: " << inFileName << std::endl);
     return false;
-    }
+  }
   std::string ext = cmSystemTools::GetFilenameLastExtension(inFileName);
-  if ( ext != ".rtfd" && ext != ".rtf" && ext != ".html" && ext != ".txt" )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Bad file extension specified: "
-      << ext << ". Currently only .rtfd, .rtf, .html, and .txt files allowed."
-      << std::endl);
+  if (ext != ".rtfd" && ext != ".rtf" && ext != ".html" && ext != ".txt") {
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "Bad file extension specified: "
+        << ext
+        << ". Currently only .rtfd, .rtf, .html, and .txt files allowed."
+        << std::endl);
     return false;
-    }
+  }
 
   std::string destFileName = dirName;
   destFileName += '/';
@@ -603,44 +521,42 @@ bool cmCPackPackageMakerGenerator::CopyCreateResourceFile(
                   (name + ext).c_str());
 
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
-                << (inFileName ? inFileName : "(NULL)")
-                << " to " << destFileName.c_str() << std::endl);
+                  << (inFileName ? inFileName : "(NULL)") << " to "
+                  << destFileName.c_str() << std::endl);
   this->ConfigureFile(inFileName, destFileName.c_str());
   return true;
 }
 
 bool cmCPackPackageMakerGenerator::CopyResourcePlistFile(
-                                                const std::string& name,
-                                                const char* outName)
+  const std::string& name, const char* outName)
 {
-  if (!outName)
-    {
+  if (!outName) {
     outName = name.c_str();
-    }
+  }
 
   std::string inFName = "CPack.";
   inFName += name;
   inFName += ".in";
   std::string inFileName = this->FindTemplate(inFName.c_str());
-  if ( inFileName.empty() )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find input file: "
-      << inFName << std::endl);
+  if (inFileName.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find input file: " << inFName << std::endl);
     return false;
-    }
+  }
 
   std::string destFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   destFileName += "/";
   destFileName += outName;
 
-  cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Configure file: "
-    << inFileName.c_str() << " to " << destFileName.c_str() << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Configure file: " << inFileName.c_str() << " to "
+                                   << destFileName.c_str() << std::endl);
   this->ConfigureFile(inFileName.c_str(), destFileName.c_str());
   return true;
 }
 
-bool cmCPackPackageMakerGenerator::RunPackageMaker(const char *command,
-                                                   const char *packageFile)
+bool cmCPackPackageMakerGenerator::RunPackageMaker(const char* command,
+                                                   const char* packageFile)
 {
   std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   tmpFile += "/PackageMakerOutput.log";
@@ -649,78 +565,65 @@ bool cmCPackPackageMakerGenerator::RunPackageMaker(const char *command,
   std::string output;
   int retVal = 1;
   bool res = cmSystemTools::RunSingleCommand(
-    command, &output, &output,
-    &retVal, 0, this->GeneratorVerbose, 0);
+    command, &output, &output, &retVal, 0, this->GeneratorVerbose, 0);
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Done running package maker"
-    << std::endl);
-  if ( !res || retVal )
-    {
+                  << std::endl);
+  if (!res || retVal) {
     cmGeneratedFileStream ofs(tmpFile.c_str());
     ofs << "# Run command: " << command << std::endl
-      << "# Output:" << std::endl
-      << output.c_str() << std::endl;
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Problem running PackageMaker command: " << command
-      << std::endl << "Please check " << tmpFile.c_str() << " for errors"
-      << std::endl);
+        << "# Output:" << std::endl
+        << output.c_str() << std::endl;
+    cmCPackLogger(
+      cmCPackLog::LOG_ERROR, "Problem running PackageMaker command: "
+        << command << std::endl
+        << "Please check " << tmpFile.c_str() << " for errors" << std::endl);
     return false;
-    }
+  }
   // sometimes the command finishes but the directory is not yet
   // created, so try 10 times to see if it shows up
   int tries = 10;
-  while(tries > 0 &&
-        !cmSystemTools::FileExists(packageFile))
-    {
+  while (tries > 0 && !cmSystemTools::FileExists(packageFile)) {
     cmSystemTools::Delay(500);
     tries--;
-    }
-  if(!cmSystemTools::FileExists(packageFile))
-    {
-    cmCPackLogger(
-      cmCPackLog::LOG_ERROR,
-      "Problem running PackageMaker command: " << command
-      << std::endl << "Package not created: " << packageFile
-      << std::endl);
+  }
+  if (!cmSystemTools::FileExists(packageFile)) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Problem running PackageMaker command: "
+                    << command << std::endl
+                    << "Package not created: " << packageFile << std::endl);
     return false;
-    }
+  }
 
   return true;
 }
 
-std::string
-cmCPackPackageMakerGenerator::GetPackageName(const cmCPackComponent& component)
+std::string cmCPackPackageMakerGenerator::GetPackageName(
+  const cmCPackComponent& component)
 {
-  if (component.ArchiveFile.empty())
-    {
+  if (component.ArchiveFile.empty()) {
     std::string packagesDir = this->GetOption("CPACK_TEMPORARY_DIRECTORY");
     packagesDir += ".dummy";
     std::ostringstream out;
-    out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir)
-        << "-" << component.Name << ".pkg";
+    out << cmSystemTools::GetFilenameWithoutLastExtension(packagesDir) << "-"
+        << component.Name << ".pkg";
     return out.str();
-    }
-  else
-    {
+  } else {
     return component.ArchiveFile + ".pkg";
-    }
+  }
 }
 
-bool
-cmCPackPackageMakerGenerator::
-GenerateComponentPackage(const char *packageFile,
-                         const char *packageDir,
-                         const cmCPackComponent& component)
+bool cmCPackPackageMakerGenerator::GenerateComponentPackage(
+  const char* packageFile, const char* packageDir,
+  const cmCPackComponent& component)
 {
-  cmCPackLogger(cmCPackLog::LOG_OUTPUT,
-                "-   Building component package: " <<
-                packageFile << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_OUTPUT, "-   Building component package: "
+                  << packageFile << std::endl);
 
   // The command that will be used to run PackageMaker
   std::ostringstream pkgCmd;
 
   if (this->PackageCompatibilityVersion < getVersion(10, 5) ||
-      this->PackageMakerVersion < 3.0)
-    {
+      this->PackageMakerVersion < 3.0) {
     // Create Description.plist and Info.plist files for normal Mac OS
     // X packages, which work on Mac OS X 10.3 and newer.
     std::string descriptionFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
@@ -750,20 +653,17 @@ GenerateComponentPackage(const char *packageFile,
                     moduleVersionSuffix.c_str());
     std::string infoFileName = component.Name;
     infoFileName += "-Info.plist";
-    if (!this->CopyResourcePlistFile("Info.plist", infoFileName.c_str()))
-      {
+    if (!this->CopyResourcePlistFile("Info.plist", infoFileName.c_str())) {
       return false;
-      }
+    }
 
     pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
            << "\" -build -p \"" << packageFile << "\""
            << " -f \"" << packageDir << "\""
-           << " -i \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY")
-           << "/" << infoFileName << "\""
+           << " -i \"" << this->GetOption("CPACK_TOPLEVEL_DIRECTORY") << "/"
+           << infoFileName << "\""
            << " -d \"" << descriptionFile << "\"";
-    }
-  else
-    {
+  } else {
     // Create a "flat" package on Mac OS X 10.5 and newer. Flat
     // packages are stored in a single file, rather than a directory
     // like normal packages, and can be downloaded by the installer
@@ -778,27 +678,25 @@ GenerateComponentPackage(const char *packageFile,
 
     pkgCmd << "\"" << this->GetOption("CPACK_INSTALLER_PROGRAM")
            << "\" --root \"" << packageDir << "\""
-           << " --id " << pkgId
-           << " --target " << this->GetOption("CPACK_OSX_PACKAGE_VERSION")
-           << " --out \"" << packageFile << "\"";
-    }
+           << " --id " << pkgId << " --target "
+           << this->GetOption("CPACK_OSX_PACKAGE_VERSION") << " --out \""
+           << packageFile << "\"";
+  }
 
   // Run PackageMaker
   return RunPackageMaker(pkgCmd.str().c_str(), packageFile);
 }
 
-void
-cmCPackPackageMakerGenerator::
-WriteDistributionFile(const char* metapackageFile)
+void cmCPackPackageMakerGenerator::WriteDistributionFile(
+  const char* metapackageFile)
 {
-  std::string distributionTemplate
-    = this->FindTemplate("CPack.distribution.dist.in");
-  if ( distributionTemplate.empty() )
-    {
+  std::string distributionTemplate =
+    this->FindTemplate("CPack.distribution.dist.in");
+  if (distributionTemplate.empty()) {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find input file: "
-      << distributionTemplate << std::endl);
+                    << distributionTemplate << std::endl);
     return;
-    }
+  }
 
   std::string distributionFile = metapackageFile;
   distributionFile += "/Contents/distribution.dist";
@@ -811,102 +709,83 @@ WriteDistributionFile(const char* metapackageFile)
   // Emit the outline for the groups
   std::map<std::string, cmCPackComponentGroup>::iterator groupIt;
   for (groupIt = this->ComponentGroups.begin();
-       groupIt != this->ComponentGroups.end();
-       ++groupIt)
-    {
-    if (groupIt->second.ParentGroup == 0)
-      {
+       groupIt != this->ComponentGroups.end(); ++groupIt) {
+    if (groupIt->second.ParentGroup == 0) {
       CreateChoiceOutline(groupIt->second, choiceOut);
-      }
     }
+  }
 
   // Emit the outline for the non-grouped components
   std::map<std::string, cmCPackComponent>::iterator compIt;
   for (compIt = this->Components.begin(); compIt != this->Components.end();
-       ++compIt)
-    {
-    if (!compIt->second.Group)
-      {
+       ++compIt) {
+    if (!compIt->second.Group) {
       choiceOut << "<line choice=\"" << compIt->first << "Choice\"></line>"
                 << std::endl;
-      }
-    }
-  if(!this->PostFlightComponent.Name.empty())
-    {
-      choiceOut << "<line choice=\"" << PostFlightComponent.Name
-                << "Choice\"></line>" << std::endl;
     }
+  }
+  if (!this->PostFlightComponent.Name.empty()) {
+    choiceOut << "<line choice=\"" << PostFlightComponent.Name
+              << "Choice\"></line>" << std::endl;
+  }
   choiceOut << "</choices-outline>" << std::endl;
 
   // Create the actual choices
   for (groupIt = this->ComponentGroups.begin();
-       groupIt != this->ComponentGroups.end();
-       ++groupIt)
-    {
+       groupIt != this->ComponentGroups.end(); ++groupIt) {
     CreateChoice(groupIt->second, choiceOut);
-    }
+  }
   for (compIt = this->Components.begin(); compIt != this->Components.end();
-       ++compIt)
-    {
+       ++compIt) {
     CreateChoice(compIt->second, choiceOut);
-    }
+  }
 
-  if(!this->PostFlightComponent.Name.empty())
-    {
+  if (!this->PostFlightComponent.Name.empty()) {
     CreateChoice(PostFlightComponent, choiceOut);
-    }
+  }
 
   this->SetOption("CPACK_PACKAGEMAKER_CHOICES", choiceOut.str().c_str());
 
   // Create the distribution.dist file in the metapackage to turn it
   // into a distribution package.
-  this->ConfigureFile(distributionTemplate.c_str(),
-                      distributionFile.c_str());
+  this->ConfigureFile(distributionTemplate.c_str(), distributionFile.c_str());
 }
 
-void
-cmCPackPackageMakerGenerator::
-CreateChoiceOutline(const cmCPackComponentGroup& group,
-                    std::ostringstream& out)
+void cmCPackPackageMakerGenerator::CreateChoiceOutline(
+  const cmCPackComponentGroup& group, std::ostringstream& out)
 {
   out << "<line choice=\"" << group.Name << "Choice\">" << std::endl;
   std::vector<cmCPackComponentGroup*>::const_iterator groupIt;
   for (groupIt = group.Subgroups.begin(); groupIt != group.Subgroups.end();
-       ++groupIt)
-    {
+       ++groupIt) {
     CreateChoiceOutline(**groupIt, out);
-    }
+  }
 
   std::vector<cmCPackComponent*>::const_iterator compIt;
   for (compIt = group.Components.begin(); compIt != group.Components.end();
-       ++compIt)
-    {
+       ++compIt) {
     out << "  <line choice=\"" << (*compIt)->Name << "Choice\"></line>"
         << std::endl;
-    }
+  }
   out << "</line>" << std::endl;
 }
 
-void
-cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponentGroup& group,
-                                           std::ostringstream& out)
+void cmCPackPackageMakerGenerator::CreateChoice(
+  const cmCPackComponentGroup& group, std::ostringstream& out)
 {
   out << "<choice id=\"" << group.Name << "Choice\" "
       << "title=\"" << group.DisplayName << "\" "
       << "start_selected=\"true\" "
       << "start_enabled=\"true\" "
       << "start_visible=\"true\" ";
-  if (!group.Description.empty())
-    {
-    out << "description=\"" << EscapeForXML(group.Description)
-        << "\"";
-    }
+  if (!group.Description.empty()) {
+    out << "description=\"" << EscapeForXML(group.Description) << "\"";
+  }
   out << "></choice>" << std::endl;
 }
 
-void
-cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
-                                           std::ostringstream& out)
+void cmCPackPackageMakerGenerator::CreateChoice(
+  const cmCPackComponent& component, std::ostringstream& out)
 {
   std::string packageId = "com.";
   packageId += this->GetOption("CPACK_PACKAGE_VENDOR");
@@ -918,21 +797,18 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
   out << "<choice id=\"" << component.Name << "Choice\" "
       << "title=\"" << component.DisplayName << "\" "
       << "start_selected=\""
-      << (component.IsDisabledByDefault &&
-          !component.IsRequired? "false" : "true")
+      << (component.IsDisabledByDefault && !component.IsRequired ? "false"
+                                                                 : "true")
       << "\" "
-      << "start_enabled=\""
-      << (component.IsRequired? "false" : "true")
+      << "start_enabled=\"" << (component.IsRequired ? "false" : "true")
       << "\" "
-      << "start_visible=\"" << (component.IsHidden? "false" : "true") << "\" ";
-  if (!component.Description.empty())
-    {
-    out << "description=\"" << EscapeForXML(component.Description)
-        << "\" ";
-    }
+      << "start_visible=\"" << (component.IsHidden ? "false" : "true")
+      << "\" ";
+  if (!component.Description.empty()) {
+    out << "description=\"" << EscapeForXML(component.Description) << "\" ";
+  }
   if (!component.Dependencies.empty() ||
-      !component.ReverseDependencies.empty())
-    {
+      !component.ReverseDependencies.empty()) {
     // The "selected" expression is evaluated each time any choice is
     // selected, for all choices *except* the one that the user
     // selected. A component is marked selected if it has been
@@ -948,12 +824,12 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
     // on (B and A), while selecting something that depends on C--either D
     // or E--will automatically cause C to get selected.
     out << "selected=\"my.choice.selected";
-    std::set<const cmCPackComponent *> visited;
+    std::set<const cmCPackComponent*> visited;
     AddDependencyAttributes(component, visited, out);
     visited.clear();
     AddReverseDependencyAttributes(component, visited, out);
     out << "\"";
-    }
+  }
   out << ">" << std::endl;
   out << "  <pkg-ref id=\"" << packageId << "\"></pkg-ref>" << std::endl;
   out << "</choice>" << std::endl;
@@ -968,68 +844,54 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
   dirName += '/';
   dirName += component.Name;
   dirName += this->GetOption("CPACK_PACKAGING_INSTALL_PREFIX");
-  unsigned long installedSize
-    = component.GetInstalledSizeInKbytes(dirName.c_str());
+  unsigned long installedSize =
+    component.GetInstalledSizeInKbytes(dirName.c_str());
 
   out << "<pkg-ref id=\"" << packageId << "\" "
       << "version=\"" << this->GetOption("CPACK_PACKAGE_VERSION") << "\" "
       << "installKBytes=\"" << installedSize << "\" "
       << "auth=\"Admin\" onConclusion=\"None\">";
-  if (component.IsDownloaded)
-    {
+  if (component.IsDownloaded) {
     out << this->GetOption("CPACK_DOWNLOAD_SITE")
         << this->GetPackageName(component);
-    }
-  else
-    {
+  } else {
     out << "file:./" << relativePackageLocation;
-    }
+  }
   out << "</pkg-ref>" << std::endl;
 }
 
-void
-cmCPackPackageMakerGenerator::
-AddDependencyAttributes(const cmCPackComponent& component,
-                        std::set<const cmCPackComponent *>& visited,
-                        std::ostringstream& out)
+void cmCPackPackageMakerGenerator::AddDependencyAttributes(
+  const cmCPackComponent& component,
+  std::set<const cmCPackComponent*>& visited, std::ostringstream& out)
 {
-  if (visited.find(&component) != visited.end())
-    {
+  if (visited.find(&component) != visited.end()) {
     return;
-    }
+  }
   visited.insert(&component);
 
-  std::vector<cmCPackComponent *>::const_iterator dependIt;
+  std::vector<cmCPackComponent*>::const_iterator dependIt;
   for (dependIt = component.Dependencies.begin();
-       dependIt != component.Dependencies.end();
-       ++dependIt)
-    {
-    out << " &amp;&amp; choices['" <<
-      (*dependIt)->Name << "Choice'].selected";
+       dependIt != component.Dependencies.end(); ++dependIt) {
+    out << " &amp;&amp; choices['" << (*dependIt)->Name << "Choice'].selected";
     AddDependencyAttributes(**dependIt, visited, out);
-    }
+  }
 }
 
-void
-cmCPackPackageMakerGenerator::
-AddReverseDependencyAttributes(const cmCPackComponent& component,
-                               std::set<const cmCPackComponent *>& visited,
-                               std::ostringstream& out)
+void cmCPackPackageMakerGenerator::AddReverseDependencyAttributes(
+  const cmCPackComponent& component,
+  std::set<const cmCPackComponent*>& visited, std::ostringstream& out)
 {
-  if (visited.find(&component) != visited.end())
-    {
+  if (visited.find(&component) != visited.end()) {
     return;
-    }
+  }
   visited.insert(&component);
 
-  std::vector<cmCPackComponent *>::const_iterator dependIt;
+  std::vector<cmCPackComponent*>::const_iterator dependIt;
   for (dependIt = component.ReverseDependencies.begin();
-       dependIt != component.ReverseDependencies.end();
-       ++dependIt)
-    {
+       dependIt != component.ReverseDependencies.end(); ++dependIt) {
     out << " || choices['" << (*dependIt)->Name << "Choice'].selected";
     AddReverseDependencyAttributes(**dependIt, visited, out);
-    }
+  }
 }
 
 std::string cmCPackPackageMakerGenerator::EscapeForXML(std::string str)
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.h b/Source/CPack/cmCPackPackageMakerGenerator.h
index 4e8ff03..2b8d253 100644
--- a/Source/CPack/cmCPackPackageMakerGenerator.h
+++ b/Source/CPack/cmCPackPackageMakerGenerator.h
@@ -37,8 +37,7 @@ public:
   virtual bool SupportsComponentInstallation() const;
 
 protected:
-  int CopyInstallScript(const std::string& resdir,
-                        const std::string& script,
+  int CopyInstallScript(const std::string& resdir, const std::string& script,
                         const std::string& name);
   virtual int InitializeInternal();
   int PackageFiles();
@@ -57,7 +56,7 @@ protected:
   // Run PackageMaker with the given command line, which will (if
   // successful) produce the given package file. Returns true if
   // PackageMaker succeeds, false otherwise.
-  bool RunPackageMaker(const char *command, const char *packageFile);
+  bool RunPackageMaker(const char* command, const char* packageFile);
 
   // Retrieve the name of package file that will be generated for this
   // component. The name is just the file name with extension, and
@@ -68,8 +67,8 @@ protected:
   // component.  All of the files within this component are stored in
   // the directory packageDir. Returns true if successful, false
   // otherwise.
-  bool GenerateComponentPackage(const char *packageFile,
-                                const char *packageDir,
+  bool GenerateComponentPackage(const char* packageFile,
+                                const char* packageDir,
                                 const cmCPackComponent& component);
 
   // Writes a distribution.dist file, which turns a metapackage into a
@@ -82,15 +81,14 @@ protected:
   // Subroutine of WriteDistributionFile that writes out the
   // dependency attributes for inter-component dependencies.
   void AddDependencyAttributes(const cmCPackComponent& component,
-                               std::set<const cmCPackComponent *>& visited,
+                               std::set<const cmCPackComponent*>& visited,
                                std::ostringstream& out);
 
   // Subroutine of WriteDistributionFile that writes out the
   // reverse dependency attributes for inter-component dependencies.
-  void
-  AddReverseDependencyAttributes(const cmCPackComponent& component,
-                                 std::set<const cmCPackComponent *>& visited,
-                                 std::ostringstream& out);
+  void AddReverseDependencyAttributes(
+    const cmCPackComponent& component,
+    std::set<const cmCPackComponent*>& visited, std::ostringstream& out);
 
   // Generates XML that encodes the hierarchy of component groups and
   // their components in a form that can be used by distribution
diff --git a/Source/CPack/cmCPackRPMGenerator.cxx b/Source/CPack/cmCPackRPMGenerator.cxx
index 2640404..fc6603a 100644
--- a/Source/CPack/cmCPackRPMGenerator.cxx
+++ b/Source/CPack/cmCPackRPMGenerator.cxx
@@ -25,24 +25,23 @@ cmCPackRPMGenerator::~cmCPackRPMGenerator()
 int cmCPackRPMGenerator::InitializeInternal()
 {
   this->SetOptionIfNotSet("CPACK_PACKAGING_INSTALL_PREFIX", "/usr");
-  if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR")))
-    {
+  if (cmSystemTools::IsOff(this->GetOption("CPACK_SET_DESTDIR"))) {
     this->SetOption("CPACK_SET_DESTDIR", "I_ON");
-    }
+  }
   /* Replace space in CPACK_PACKAGE_NAME in order to avoid
    * rpmbuild scream on unwanted space in filename issue
    * Moreover RPM file do not usually embed space in filename
    */
   if (this->GetOption("CPACK_PACKAGE_NAME")) {
-    std::string packageName=this->GetOption("CPACK_PACKAGE_NAME");
-    cmSystemTools::ReplaceString(packageName," ","-");
-    this->SetOption("CPACK_PACKAGE_NAME",packageName.c_str());
+    std::string packageName = this->GetOption("CPACK_PACKAGE_NAME");
+    cmSystemTools::ReplaceString(packageName, " ", "-");
+    this->SetOption("CPACK_PACKAGE_NAME", packageName.c_str());
   }
   /* same for CPACK_PACKAGE_FILE_NAME */
   if (this->GetOption("CPACK_PACKAGE_FILE_NAME")) {
-    std::string packageName=this->GetOption("CPACK_PACKAGE_FILE_NAME");
-    cmSystemTools::ReplaceString(packageName," ","-");
-    this->SetOption("CPACK_PACKAGE_FILE_NAME",packageName.c_str());
+    std::string packageName = this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    cmSystemTools::ReplaceString(packageName, " ", "-");
+    this->SetOption("CPACK_PACKAGE_FILE_NAME", packageName.c_str());
   }
   return this->Superclass::InitializeInternal();
 }
@@ -53,14 +52,13 @@ void cmCPackRPMGenerator::AddGeneratedPackageNames()
   std::string fileNames(this->GetOption("GEN_CPACK_OUTPUT_FILES"));
   const char sep = ';';
   std::string::size_type pos1 = 0;
-  std::string::size_type pos2 = fileNames.find(sep, pos1+1);
-  while(pos2 != std::string::npos)
-    {
-    packageFileNames.push_back(fileNames.substr(pos1, pos2-pos1));
-    pos1 = pos2+1;
-    pos2 = fileNames.find(sep, pos1+1);
-    }
-  packageFileNames.push_back(fileNames.substr(pos1, pos2-pos1));
+  std::string::size_type pos2 = fileNames.find(sep, pos1 + 1);
+  while (pos2 != std::string::npos) {
+    packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
+    pos1 = pos2 + 1;
+    pos2 = fileNames.find(sep, pos1 + 1);
+  }
+  packageFileNames.push_back(fileNames.substr(pos1, pos2 - pos1));
 }
 
 int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
@@ -69,38 +67,33 @@ int cmCPackRPMGenerator::PackageOnePack(std::string initialToplevel,
   int retval = 1;
   // Begin the archive for this pack
   std::string localToplevel(initialToplevel);
-  std::string packageFileName(
-      cmSystemTools::GetParentDirectory(toplevel)
-                             );
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
   std::string outputFileName(
-   GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-                               packageName,
-                               true)
-                               + this->GetOutputExtension()
-                            );
+    GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                packageName, true) +
+    this->GetOutputExtension());
 
-  localToplevel += "/"+ packageName;
+  localToplevel += "/" + packageName;
   /* replace the TEMP DIRECTORY with the component one */
-  this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
-  packageFileName += "/"+ outputFileName;
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
   /* replace proposed CPACK_OUTPUT_FILE_NAME */
-  this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
   /* replace the TEMPORARY package file name */
   this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
                   packageFileName.c_str());
   // Tell CPackRPM.cmake the name of the component NAME.
-  this->SetOption("CPACK_RPM_PACKAGE_COMPONENT",packageName.c_str());
+  this->SetOption("CPACK_RPM_PACKAGE_COMPONENT", packageName.c_str());
   // Tell CPackRPM.cmake the path where the component is.
   std::string component_path = "/";
   component_path += packageName;
   this->SetOption("CPACK_RPM_PACKAGE_COMPONENT_PART_PATH",
                   component_path.c_str());
-  if (!this->ReadListFile("CPackRPM.cmake"))
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error while execution CPackRPM.cmake" << std::endl);
+  if (!this->ReadListFile("CPackRPM.cmake")) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
+                    << std::endl);
     retval = 0;
-    }
+  }
 
   return retval;
 }
@@ -115,56 +108,48 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
 
   // The default behavior is to have one package by component group
   // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
-  if (!ignoreGroup)
-    {
+  if (!ignoreGroup) {
     std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
-    for (compGIt=this->ComponentGroups.begin();
-        compGIt!=this->ComponentGroups.end(); ++compGIt)
-      {
+    for (compGIt = this->ComponentGroups.begin();
+         compGIt != this->ComponentGroups.end(); ++compGIt) {
       cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
-          << compGIt->first
-          << std::endl);
-      retval &= PackageOnePack(initialTopLevel,compGIt->first);
-      }
+                      << compGIt->first << std::endl);
+      retval &= PackageOnePack(initialTopLevel, compGIt->first);
+    }
     // Handle Orphan components (components not belonging to any groups)
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt=this->Components.begin();
-        compIt!=this->Components.end(); ++compIt )
-      {
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
       // Does the component belong to a group?
-      if (compIt->second.Group==NULL)
-        {
-        cmCPackLogger(cmCPackLog::LOG_VERBOSE,
-            "Component <"
+      if (compIt->second.Group == NULL) {
+        cmCPackLogger(
+          cmCPackLog::LOG_VERBOSE, "Component <"
             << compIt->second.Name
             << "> does not belong to any group, package it separately."
             << std::endl);
-        retval &= PackageOnePack(initialTopLevel,compIt->first);
-        }
+        retval &= PackageOnePack(initialTopLevel, compIt->first);
       }
     }
+  }
   // CPACK_COMPONENTS_IGNORE_GROUPS is set
   // We build 1 package per component
-  else
-    {
+  else {
     std::map<std::string, cmCPackComponent>::iterator compIt;
-    for (compIt=this->Components.begin();
-         compIt!=this->Components.end(); ++compIt )
-      {
-      retval &= PackageOnePack(initialTopLevel,compIt->first);
-      }
+    for (compIt = this->Components.begin(); compIt != this->Components.end();
+         ++compIt) {
+      retval &= PackageOnePack(initialTopLevel, compIt->first);
     }
+  }
 
-  if(retval)
-    {
+  if (retval) {
     AddGeneratedPackageNames();
-    }
+  }
 
   return retval;
 }
 
 int cmCPackRPMGenerator::PackageComponentsAllInOne(
-    const std::string& compInstDirName)
+  const std::string& compInstDirName)
 {
   int retval = 1;
   /* Reset package file name list it will be populated during the
@@ -175,98 +160,84 @@ int cmCPackRPMGenerator::PackageComponentsAllInOne(
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "Packaging all groups in one package..."
                 "(CPACK_COMPONENTS_ALL_[GROUPS_]IN_ONE_PACKAGE is set)"
-      << std::endl);
+                  << std::endl);
 
   // The ALL GROUPS in ONE package case
   std::string localToplevel(initialTopLevel);
-  std::string packageFileName(
-      cmSystemTools::GetParentDirectory(toplevel)
-                             );
+  std::string packageFileName(cmSystemTools::GetParentDirectory(toplevel));
   std::string outputFileName(
-            std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
-            + this->GetOutputExtension()
-                            );
+    std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")) +
+    this->GetOutputExtension());
   // all GROUP in one vs all COMPONENT in one
-  localToplevel += "/"+compInstDirName;
+  localToplevel += "/" + compInstDirName;
 
   /* replace the TEMP DIRECTORY with the component one */
-  this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
-  packageFileName += "/"+ outputFileName;
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY", localToplevel.c_str());
+  packageFileName += "/" + outputFileName;
   /* replace proposed CPACK_OUTPUT_FILE_NAME */
-  this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
+  this->SetOption("CPACK_OUTPUT_FILE_NAME", outputFileName.c_str());
   /* replace the TEMPORARY package file name */
   this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
-      packageFileName.c_str());
+                  packageFileName.c_str());
 
-  if(!compInstDirName.empty())
-    {
+  if (!compInstDirName.empty()) {
     // Tell CPackRPM.cmake the path where the component is.
     std::string component_path = "/";
     component_path += compInstDirName;
     this->SetOption("CPACK_RPM_PACKAGE_COMPONENT_PART_PATH",
                     component_path.c_str());
-    }
+  }
 
-  if (this->ReadListFile("CPackRPM.cmake"))
-    {
+  if (this->ReadListFile("CPackRPM.cmake")) {
     AddGeneratedPackageNames();
-    }
-    else
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-        "Error while execution CPackRPM.cmake" << std::endl);
+  } else {
+    cmCPackLogger(cmCPackLog::LOG_ERROR, "Error while execution CPackRPM.cmake"
+                    << std::endl);
     retval = 0;
-    }
+  }
 
   return retval;
 }
 
 int cmCPackRPMGenerator::PackageFiles()
 {
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
-                  << toplevel << std::endl);
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: " << toplevel << std::endl);
 
   /* Are we in the component packaging case */
   if (WantsComponentInstallation()) {
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL COMPONENTS in ONE package has been requested
     // then the package file is unique and should be open here.
-    if (componentPackageMethod == ONE_PACKAGE)
-      {
+    if (componentPackageMethod == ONE_PACKAGE) {
       return PackageComponentsAllInOne("ALL_COMPONENTS_IN_ONE");
-      }
+    }
     // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
     // There will be 1 package for each component group
     // however one may require to ignore component group and
     // in this case you'll get 1 package for each component.
-    else
-      {
+    else {
       return PackageComponents(componentPackageMethod ==
                                ONE_PACKAGE_PER_COMPONENT);
-      }
+    }
   }
   // CASE 3 : NON COMPONENT package.
-  else
-    {
+  else {
     return PackageComponentsAllInOne("");
-    }
+  }
 }
 
 bool cmCPackRPMGenerator::SupportsComponentInstallation() const
-  {
-  if (IsOn("CPACK_RPM_COMPONENT_INSTALL"))
-    {
-      return true;
-    }
-  else
-    {
-      return false;
-    }
+{
+  if (IsOn("CPACK_RPM_COMPONENT_INSTALL")) {
+    return true;
+  } else {
+    return false;
   }
+}
 
 std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
-    const std::string& componentName)
-  {
+  const std::string& componentName)
+{
   if (componentPackageMethod == ONE_PACKAGE_PER_COMPONENT) {
     return componentName;
   }
@@ -276,14 +247,11 @@ std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
   }
   // We have to find the name of the COMPONENT GROUP
   // the current COMPONENT belongs to.
-  std::string groupVar = "CPACK_COMPONENT_" +
-        cmSystemTools::UpperCase(componentName) + "_GROUP";
-    if (NULL != GetOption(groupVar))
-      {
-      return std::string(GetOption(groupVar));
-      }
-    else
-      {
-      return componentName;
-      }
+  std::string groupVar =
+    "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP";
+  if (NULL != GetOption(groupVar)) {
+    return std::string(GetOption(groupVar));
+  } else {
+    return componentName;
   }
+}
diff --git a/Source/CPack/cmCPackRPMGenerator.h b/Source/CPack/cmCPackRPMGenerator.h
index 9987cf4..40b9bb8 100644
--- a/Source/CPack/cmCPackRPMGenerator.h
+++ b/Source/CPack/cmCPackRPMGenerator.h
@@ -35,7 +35,7 @@ public:
   virtual ~cmCPackRPMGenerator();
 
   static bool CanGenerate()
-    {
+  {
 #ifdef __APPLE__
     // on MacOS enable CPackRPM iff rpmbuild is found
     std::vector<std::string> locations;
@@ -46,7 +46,7 @@ public:
     // legacy behavior on other systems
     return true;
 #endif
-    }
+  }
 
 protected:
   virtual int InitializeInternal();
@@ -69,7 +69,7 @@ protected:
   virtual const char* GetOutputExtension() { return ".rpm"; }
   virtual bool SupportsComponentInstallation() const;
   virtual std::string GetComponentInstallDirNameSuffix(
-      const std::string& componentName);
+    const std::string& componentName);
 
   void AddGeneratedPackageNames();
 };
diff --git a/Source/CPack/cmCPackSTGZGenerator.cxx b/Source/CPack/cmCPackSTGZGenerator.cxx
index 41e67c7..4d07a7e 100644
--- a/Source/CPack/cmCPackSTGZGenerator.cxx
+++ b/Source/CPack/cmCPackSTGZGenerator.cxx
@@ -37,12 +37,11 @@ int cmCPackSTGZGenerator::InitializeInternal()
   this->SetOptionIfNotSet("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", "0");
 
   std::string inFile = this->FindTemplate("CPack.STGZ_Header.sh.in");
-  if ( inFile.empty() )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find template file: "
-      << inFile << std::endl);
+  if (inFile.empty()) {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+                  "Cannot find template file: " << inFile << std::endl);
     return 0;
-    }
+  }
   this->SetOptionIfNotSet("CPACK_STGZ_HEADER_FILE", inFile.c_str());
   this->SetOptionIfNotSet("CPACK_AT_SIGN", "@");
 
@@ -51,28 +50,26 @@ int cmCPackSTGZGenerator::InitializeInternal()
 
 int cmCPackSTGZGenerator::PackageFiles()
 {
- bool retval = true;
-  if ( !this->Superclass::PackageFiles() )
-    {
+  bool retval = true;
+  if (!this->Superclass::PackageFiles()) {
     return 0;
-    }
+  }
 
   /* TGZ generator (our Superclass) may
    * have generated several packages (component packaging)
    * so we must iterate over generated packages.
    */
-  for (std::vector<std::string>::iterator it=packageFileNames.begin();
-       it != packageFileNames.end(); ++it)
-  {
+  for (std::vector<std::string>::iterator it = packageFileNames.begin();
+       it != packageFileNames.end(); ++it) {
     retval &= cmSystemTools::SetPermissions((*it).c_str(),
-#if defined( _MSC_VER ) || defined( __MINGW32__ )
-      S_IREAD | S_IWRITE | S_IEXEC
+#if defined(_MSC_VER) || defined(__MINGW32__)
+                                            S_IREAD | S_IWRITE | S_IEXEC
 #else
-      S_IRUSR | S_IWUSR | S_IXUSR |
-      S_IRGRP | S_IWGRP | S_IXGRP |
-      S_IROTH | S_IWOTH | S_IXOTH
+                                            S_IRUSR | S_IWUSR | S_IXUSR |
+                                              S_IRGRP | S_IWGRP | S_IXGRP |
+                                              S_IROTH | S_IWOTH | S_IXOTH
 #endif
-    );
+                                            );
   }
   return retval;
 }
@@ -87,10 +84,9 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
   std::string line;
   cmsys::ifstream ilfs(inLicFile.c_str());
   std::string licenseText;
-  while ( cmSystemTools::GetLineFromStream(ilfs, line) )
-    {
+  while (cmSystemTools::GetLineFromStream(ilfs, line)) {
     licenseText += line + "\n";
-    }
+  }
   this->SetOptionIfNotSet("CPACK_RESOURCE_FILE_LICENSE_CONTENT",
                           licenseText.c_str());
 
@@ -100,10 +96,9 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
   std::string inFile = this->GetOption("CPACK_STGZ_HEADER_FILE");
   cmsys::ifstream ifs(inFile.c_str());
   std::string packageHeaderText;
-  while ( cmSystemTools::GetLineFromStream(ifs, line) )
-    {
+  while (cmSystemTools::GetLineFromStream(ifs, line)) {
     packageHeaderText += line + "\n";
-    }
+  }
 
   // Configure in the values
   std::string res;
@@ -111,17 +106,15 @@ int cmCPackSTGZGenerator::GenerateHeader(std::ostream* os)
 
   // Count the lines
   const char* ptr = res.c_str();
-  while ( *ptr )
-    {
-    if ( *ptr == '\n' )
-      {
-      counter ++;
-      }
-    ++ptr;
+  while (*ptr) {
+    if (*ptr == '\n') {
+      counter++;
     }
-  counter ++;
-  cmCPackLogger(cmCPackLog::LOG_DEBUG,
-                "Number of lines: " << counter << std::endl);
+    ++ptr;
+  }
+  counter++;
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Number of lines: " << counter
+                                                           << std::endl);
   char buffer[1024];
   sprintf(buffer, "%d", counter);
   cmSystemTools::ReplaceString(res, headerLengthTag, buffer);
diff --git a/Source/CPack/cmCPackTGZGenerator.cxx b/Source/CPack/cmCPackTGZGenerator.cxx
index 90eb1a3..7c5c245 100644
--- a/Source/CPack/cmCPackTGZGenerator.cxx
+++ b/Source/CPack/cmCPackTGZGenerator.cxx
@@ -13,12 +13,10 @@
 #include "cmCPackTGZGenerator.h"
 
 cmCPackTGZGenerator::cmCPackTGZGenerator()
-  :cmCPackArchiveGenerator(cmArchiveWrite::CompressGZip,
-                           "paxr")
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressGZip, "paxr")
 {
 }
 
 cmCPackTGZGenerator::~cmCPackTGZGenerator()
 {
 }
-
diff --git a/Source/CPack/cmCPackTGZGenerator.h b/Source/CPack/cmCPackTGZGenerator.h
index 3a9fc6b..408422b 100644
--- a/Source/CPack/cmCPackTGZGenerator.h
+++ b/Source/CPack/cmCPackTGZGenerator.h
@@ -28,6 +28,7 @@ public:
    */
   cmCPackTGZGenerator();
   virtual ~cmCPackTGZGenerator();
+
 protected:
   virtual const char* GetOutputExtension() { return ".tar.gz"; }
 };
diff --git a/Source/CPack/cmCPackTXZGenerator.cxx b/Source/CPack/cmCPackTXZGenerator.cxx
index 454e062..d17a164 100644
--- a/Source/CPack/cmCPackTXZGenerator.cxx
+++ b/Source/CPack/cmCPackTXZGenerator.cxx
@@ -13,8 +13,7 @@
 #include "cmCPackTXZGenerator.h"
 
 cmCPackTXZGenerator::cmCPackTXZGenerator()
-  :cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ,
-                           "paxr")
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressXZ, "paxr")
 {
 }
 
diff --git a/Source/CPack/cmCPackTXZGenerator.h b/Source/CPack/cmCPackTXZGenerator.h
index bf8152f..05052a1 100644
--- a/Source/CPack/cmCPackTXZGenerator.h
+++ b/Source/CPack/cmCPackTXZGenerator.h
@@ -28,6 +28,7 @@ public:
    */
   cmCPackTXZGenerator();
   virtual ~cmCPackTXZGenerator();
+
 protected:
   virtual const char* GetOutputExtension() { return ".tar.xz"; }
 };
diff --git a/Source/CPack/cmCPackTarBZip2Generator.cxx b/Source/CPack/cmCPackTarBZip2Generator.cxx
index b05b399..694d392 100644
--- a/Source/CPack/cmCPackTarBZip2Generator.cxx
+++ b/Source/CPack/cmCPackTarBZip2Generator.cxx
@@ -13,12 +13,10 @@
 #include "cmCPackTarBZip2Generator.h"
 
 cmCPackTarBZip2Generator::cmCPackTarBZip2Generator()
- :cmCPackArchiveGenerator(cmArchiveWrite::CompressBZip2,
-                          "paxr")
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressBZip2, "paxr")
 {
 }
 
 cmCPackTarBZip2Generator::~cmCPackTarBZip2Generator()
 {
 }
-
diff --git a/Source/CPack/cmCPackTarBZip2Generator.h b/Source/CPack/cmCPackTarBZip2Generator.h
index 74c244e..4033197 100644
--- a/Source/CPack/cmCPackTarBZip2Generator.h
+++ b/Source/CPack/cmCPackTarBZip2Generator.h
@@ -27,6 +27,7 @@ public:
    */
   cmCPackTarBZip2Generator();
   virtual ~cmCPackTarBZip2Generator();
+
 protected:
   virtual const char* GetOutputExtension() { return ".tar.bz2"; }
 };
diff --git a/Source/CPack/cmCPackTarCompressGenerator.cxx b/Source/CPack/cmCPackTarCompressGenerator.cxx
index ddfe248..aec6893 100644
--- a/Source/CPack/cmCPackTarCompressGenerator.cxx
+++ b/Source/CPack/cmCPackTarCompressGenerator.cxx
@@ -13,12 +13,10 @@
 #include "cmCPackTarCompressGenerator.h"
 
 cmCPackTarCompressGenerator::cmCPackTarCompressGenerator()
-  :cmCPackArchiveGenerator(cmArchiveWrite::CompressCompress,
-                           "paxr")
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressCompress, "paxr")
 {
 }
 
 cmCPackTarCompressGenerator::~cmCPackTarCompressGenerator()
 {
 }
-
diff --git a/Source/CPack/cmCPackZIPGenerator.cxx b/Source/CPack/cmCPackZIPGenerator.cxx
index d316ab6..9b42e6d 100644
--- a/Source/CPack/cmCPackZIPGenerator.cxx
+++ b/Source/CPack/cmCPackZIPGenerator.cxx
@@ -13,12 +13,10 @@
 #include "cmCPackZIPGenerator.h"
 
 cmCPackZIPGenerator::cmCPackZIPGenerator()
-  :cmCPackArchiveGenerator(cmArchiveWrite::CompressNone,
-                           "zip")
+  : cmCPackArchiveGenerator(cmArchiveWrite::CompressNone, "zip")
 {
 }
 
 cmCPackZIPGenerator::~cmCPackZIPGenerator()
 {
 }
-
diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx
index 6b2323c..e54be2c 100644
--- a/Source/CPack/cpack.cxx
+++ b/Source/CPack/cpack.cxx
@@ -26,33 +26,28 @@
 #include <cmsys/Encoding.hxx>
 #include <cmsys/SystemTools.hxx>
 
-static const char * cmDocumentationName[][2] =
-{
-  {0,
-   "  cpack - Packaging driver provided by CMake."},
-  {0,0}
+static const char* cmDocumentationName[][2] = {
+  { 0, "  cpack - Packaging driver provided by CMake." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationUsage[][2] =
-{
-  {0,
-   "  cpack -G <generator> [options]"},
-  {0,0}
+static const char* cmDocumentationUsage[][2] = {
+  { 0, "  cpack -G <generator> [options]" },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationOptions[][2] =
-{
-    {"-G <generator>", "Use the specified generator to generate package."},
-    {"-C <Configuration>", "Specify the project configuration"},
-    {"-D <var>=<value>", "Set a CPack variable."},
-    {"--config <config file>", "Specify the config file."},
-    {"--verbose,-V","enable verbose output"},
-    {"--debug","enable debug output (for CPack developers)"},
-    {"-P <package name>","override/define CPACK_PACKAGE_NAME"},
-    {"-R <package version>","override/define CPACK_PACKAGE_VERSION"},
-    {"-B <package directory>","override/define CPACK_PACKAGE_DIRECTORY"},
-    {"--vendor <vendor name>","override/define CPACK_PACKAGE_VENDOR"},
-    {0,0}
+static const char* cmDocumentationOptions[][2] = {
+  { "-G <generator>", "Use the specified generator to generate package." },
+  { "-C <Configuration>", "Specify the project configuration" },
+  { "-D <var>=<value>", "Set a CPack variable." },
+  { "--config <config file>", "Specify the config file." },
+  { "--verbose,-V", "enable verbose output" },
+  { "--debug", "enable debug output (for CPack developers)" },
+  { "-P <package name>", "override/define CPACK_PACKAGE_NAME" },
+  { "-R <package version>", "override/define CPACK_PACKAGE_VERSION" },
+  { "-B <package directory>", "override/define CPACK_PACKAGE_DIRECTORY" },
+  { "--vendor <vendor name>", "override/define CPACK_PACKAGE_VENDOR" },
+  { 0, 0 }
 };
 
 int cpackUnknownArgument(const char*, void*)
@@ -64,33 +59,31 @@ struct cpackDefinitions
 {
   typedef std::map<std::string, std::string> MapType;
   MapType Map;
-  cmCPackLog *Log;
+  cmCPackLog* Log;
 };
 
 int cpackDefinitionArgument(const char* argument, const char* cValue,
-  void* call_data)
+                            void* call_data)
 {
   (void)argument;
   cpackDefinitions* def = static_cast<cpackDefinitions*>(call_data);
   std::string value = cValue;
   size_t pos = value.find_first_of("=");
-  if ( pos == std::string::npos )
-    {
+  if (pos == std::string::npos) {
     cmCPack_Log(def->Log, cmCPackLog::LOG_ERROR,
-      "Please specify CPack definitions as: KEY=VALUE" << std::endl);
+                "Please specify CPack definitions as: KEY=VALUE" << std::endl);
     return 0;
-    }
+  }
   std::string key = value.substr(0, pos);
   value = value.c_str() + pos + 1;
   def->Map[key] = value;
   cmCPack_Log(def->Log, cmCPackLog::LOG_DEBUG, "Set CPack variable: "
-    << key << " to \"" << value << "\"" << std::endl);
+                << key << " to \"" << value << "\"" << std::endl);
   return 1;
 }
 
-
 // this is CPack.
-int main (int argc, char const* const* argv)
+int main(int argc, char const* const* argv)
 {
   cmsys::Encoding::CommandLineArguments args =
     cmsys::Encoding::CommandLineArguments::Main(argc, argv);
@@ -107,12 +100,12 @@ int main (int argc, char const* const* argv)
 
   cmSystemTools::EnableMSVCDebugHook();
 
-  if (cmSystemTools::GetCurrentWorkingDirectory().empty())
-    {
+  if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
     cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-      "Current working directory cannot be established." << std::endl);
+                "Current working directory cannot be established."
+                  << std::endl);
     return 1;
-    }
+  }
 
   std::string generator;
   bool help = false;
@@ -142,9 +135,9 @@ int main (int argc, char const* const* argv)
   // Help arguments
   arg.AddArgument("--help", argT::NO_ARGUMENT, &help, "CPack help");
   arg.AddArgument("--help-full", argT::SPACE_ARGUMENT, &helpFull,
-    "CPack help");
+                  "CPack help");
   arg.AddArgument("--help-html", argT::SPACE_ARGUMENT, &helpHTML,
-    "CPack help");
+                  "CPack help");
   arg.AddArgument("--help-man", argT::SPACE_ARGUMENT, &helpMAN, "CPack help");
   arg.AddArgument("--version", argT::NO_ARGUMENT, &helpVersion, "CPack help");
 
@@ -152,42 +145,39 @@ int main (int argc, char const* const* argv)
   arg.AddArgument("--verbose", argT::NO_ARGUMENT, &verbose, "-V");
   arg.AddArgument("--debug", argT::NO_ARGUMENT, &debug, "-V");
   arg.AddArgument("--config", argT::SPACE_ARGUMENT, &cpackConfigFile,
-    "CPack configuration file");
+                  "CPack configuration file");
   arg.AddArgument("-C", argT::SPACE_ARGUMENT, &cpackBuildConfig,
-    "CPack build configuration");
-  arg.AddArgument("-G", argT::SPACE_ARGUMENT,
-    &generator, "CPack generator");
-  arg.AddArgument("-P", argT::SPACE_ARGUMENT,
-    &cpackProjectName, "CPack project name");
-  arg.AddArgument("-R", argT::SPACE_ARGUMENT,
-    &cpackProjectVersion, "CPack project version");
-  arg.AddArgument("-B", argT::SPACE_ARGUMENT,
-    &cpackProjectDirectory, "CPack project directory");
-  arg.AddArgument("--patch", argT::SPACE_ARGUMENT,
-    &cpackProjectPatch, "CPack project patch");
-  arg.AddArgument("--vendor", argT::SPACE_ARGUMENT,
-    &cpackProjectVendor, "CPack project vendor");
-  arg.AddCallback("-D", argT::SPACE_ARGUMENT,
-    cpackDefinitionArgument, &definitions, "CPack Definitions");
+                  "CPack build configuration");
+  arg.AddArgument("-G", argT::SPACE_ARGUMENT, &generator, "CPack generator");
+  arg.AddArgument("-P", argT::SPACE_ARGUMENT, &cpackProjectName,
+                  "CPack project name");
+  arg.AddArgument("-R", argT::SPACE_ARGUMENT, &cpackProjectVersion,
+                  "CPack project version");
+  arg.AddArgument("-B", argT::SPACE_ARGUMENT, &cpackProjectDirectory,
+                  "CPack project directory");
+  arg.AddArgument("--patch", argT::SPACE_ARGUMENT, &cpackProjectPatch,
+                  "CPack project patch");
+  arg.AddArgument("--vendor", argT::SPACE_ARGUMENT, &cpackProjectVendor,
+                  "CPack project vendor");
+  arg.AddCallback("-D", argT::SPACE_ARGUMENT, cpackDefinitionArgument,
+                  &definitions, "CPack Definitions");
   arg.SetUnknownArgumentCallback(cpackUnknownArgument);
 
   // Parse command line
   int parsed = arg.Parse();
 
   // Setup logging
-  if ( verbose )
-    {
+  if (verbose) {
     log.SetVerbose(verbose);
     cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Verbose" << std::endl);
-    }
-  if ( debug )
-    {
+  }
+  if (debug) {
     log.SetDebug(debug);
     cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Debug" << std::endl);
-    }
+  }
 
   cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
-    "Read CPack config file: " << cpackConfigFile << std::endl);
+              "Read CPack config file: " << cpackConfigFile << std::endl);
 
   cmake cminst;
   cminst.SetHomeDirectory("");
@@ -196,18 +186,17 @@ int main (int argc, char const* const* argv)
   cminst.GetState()->RemoveUnscriptableCommands();
   cmGlobalGenerator cmgg(&cminst);
   cmsys::auto_ptr<cmMakefile> globalMF(
-        new cmMakefile(&cmgg, cminst.GetCurrentSnapshot()));
+    new cmMakefile(&cmgg, cminst.GetCurrentSnapshot()));
 #if defined(__CYGWIN__)
   globalMF->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0");
 #endif
 
   bool cpackConfigFileSpecified = true;
-  if ( cpackConfigFile.empty() )
-    {
+  if (cpackConfigFile.empty()) {
     cpackConfigFile = cmSystemTools::GetCurrentWorkingDirectory();
     cpackConfigFile += "/CPackConfig.cmake";
     cpackConfigFileSpecified = false;
-    }
+  }
 
   cmCPackGeneratorFactory generators;
   generators.SetLogger(&log);
@@ -220,262 +209,225 @@ int main (int argc, char const* const* argv)
    * should launch cpack using "cpackConfigFile" if it exists
    * in the current directory.
    */
-  if((doc.CheckOptions(argc, argv,"-G")) && !(argc==1))
-    {
-      help = true;
-    }
-  else
-    {
-      help = false;
-    }
+  if ((doc.CheckOptions(argc, argv, "-G")) && !(argc == 1)) {
+    help = true;
+  } else {
+    help = false;
+  }
 
   // This part is used for cpack documentation lookup as well.
   cminst.AddCMakePaths();
 
-  if ( parsed && !help )
-    {
+  if (parsed && !help) {
     // find out which system cpack is running on, so it can setup the search
     // paths, so FIND_XXX() commands can be used in scripts
     std::string systemFile =
       globalMF->GetModulesFile("CMakeDetermineSystem.cmake");
-    if (!globalMF->ReadListFile(systemFile.c_str()))
-      {
+    if (!globalMF->ReadListFile(systemFile.c_str())) {
       cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-        "Error reading CMakeDetermineSystem.cmake" << std::endl);
+                  "Error reading CMakeDetermineSystem.cmake" << std::endl);
       return 1;
-      }
+    }
 
     systemFile =
       globalMF->GetModulesFile("CMakeSystemSpecificInformation.cmake");
-    if (!globalMF->ReadListFile(systemFile.c_str()))
-      {
+    if (!globalMF->ReadListFile(systemFile.c_str())) {
       cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-        "Error reading CMakeSystemSpecificInformation.cmake" << std::endl);
+                  "Error reading CMakeSystemSpecificInformation.cmake"
+                    << std::endl);
       return 1;
-      }
+    }
 
-    if ( !cpackBuildConfig.empty() )
-      {
+    if (!cpackBuildConfig.empty()) {
       globalMF->AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
-      }
+    }
 
-    if ( cmSystemTools::FileExists(cpackConfigFile.c_str()) )
-      {
-      cpackConfigFile =
-        cmSystemTools::CollapseFullPath(cpackConfigFile);
+    if (cmSystemTools::FileExists(cpackConfigFile.c_str())) {
+      cpackConfigFile = cmSystemTools::CollapseFullPath(cpackConfigFile);
       cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
-        "Read CPack configuration file: " << cpackConfigFile
-        << std::endl);
-      if ( !globalMF->ReadListFile(cpackConfigFile.c_str()) )
-        {
+                  "Read CPack configuration file: " << cpackConfigFile
+                                                    << std::endl);
+      if (!globalMF->ReadListFile(cpackConfigFile.c_str())) {
         cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-          "Problem reading CPack config file: \""
-          << cpackConfigFile << "\"" << std::endl);
+                    "Problem reading CPack config file: \""
+                      << cpackConfigFile << "\"" << std::endl);
         return 1;
-        }
       }
-    else if ( cpackConfigFileSpecified )
-      {
+    } else if (cpackConfigFileSpecified) {
       cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-        "Cannot find CPack config file: \"" <<
-         cpackConfigFile << "\"" << std::endl);
+                  "Cannot find CPack config file: \"" << cpackConfigFile
+                                                      << "\"" << std::endl);
       return 1;
-      }
+    }
 
-    if ( !generator.empty() )
-      {
+    if (!generator.empty()) {
       globalMF->AddDefinition("CPACK_GENERATOR", generator.c_str());
-      }
-    if ( !cpackProjectName.empty() )
-      {
+    }
+    if (!cpackProjectName.empty()) {
       globalMF->AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName.c_str());
-      }
-    if ( !cpackProjectVersion.empty() )
-      {
+    }
+    if (!cpackProjectVersion.empty()) {
       globalMF->AddDefinition("CPACK_PACKAGE_VERSION",
-        cpackProjectVersion.c_str());
-      }
-    if ( !cpackProjectVendor.empty() )
-      {
+                              cpackProjectVersion.c_str());
+    }
+    if (!cpackProjectVendor.empty()) {
       globalMF->AddDefinition("CPACK_PACKAGE_VENDOR",
-        cpackProjectVendor.c_str());
-      }
+                              cpackProjectVendor.c_str());
+    }
     // if this is not empty it has been set on the command line
     // go for it. Command line override values set in config file.
-    if ( !cpackProjectDirectory.empty() )
-      {
+    if (!cpackProjectDirectory.empty()) {
       globalMF->AddDefinition("CPACK_PACKAGE_DIRECTORY",
                               cpackProjectDirectory.c_str());
-      }
+    }
     // The value has not been set on the command line
-    else
-      {
+    else {
       // get a default value (current working directory)
       cpackProjectDirectory = cmsys::SystemTools::GetCurrentWorkingDirectory();
       // use default value iff no value has been provided by the config file
-      if (!globalMF->IsSet("CPACK_PACKAGE_DIRECTORY"))
-        {
+      if (!globalMF->IsSet("CPACK_PACKAGE_DIRECTORY")) {
         globalMF->AddDefinition("CPACK_PACKAGE_DIRECTORY",
                                 cpackProjectDirectory.c_str());
-        }
       }
+    }
     cpackDefinitions::MapType::iterator cdit;
-    for ( cdit = definitions.Map.begin();
-      cdit != definitions.Map.end();
-      ++cdit )
-      {
+    for (cdit = definitions.Map.begin(); cdit != definitions.Map.end();
+         ++cdit) {
       globalMF->AddDefinition(cdit->first, cdit->second.c_str());
-      }
+    }
 
     const char* cpackModulesPath =
       globalMF->GetDefinition("CPACK_MODULE_PATH");
-    if ( cpackModulesPath )
-      {
+    if (cpackModulesPath) {
       globalMF->AddDefinition("CMAKE_MODULE_PATH", cpackModulesPath);
-      }
+    }
     const char* genList = globalMF->GetDefinition("CPACK_GENERATOR");
-    if ( !genList )
-      {
-      cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-        "CPack generator not specified" << std::endl);
-      }
-    else
-      {
+    if (!genList) {
+      cmCPack_Log(&log, cmCPackLog::LOG_ERROR, "CPack generator not specified"
+                    << std::endl);
+    } else {
       std::vector<std::string> generatorsVector;
-      cmSystemTools::ExpandListArgument(genList,
-        generatorsVector);
+      cmSystemTools::ExpandListArgument(genList, generatorsVector);
       std::vector<std::string>::iterator it;
-      for ( it = generatorsVector.begin();
-        it != generatorsVector.end();
-        ++it )
-        {
+      for (it = generatorsVector.begin(); it != generatorsVector.end(); ++it) {
         const char* gen = it->c_str();
         cmMakefile::ScopePushPop raii(globalMF.get());
         cmMakefile* mf = globalMF.get();
         cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
-          "Specified generator: " << gen << std::endl);
-        if ( parsed && !mf->GetDefinition("CPACK_PACKAGE_NAME") )
-          {
+                    "Specified generator: " << gen << std::endl);
+        if (parsed && !mf->GetDefinition("CPACK_PACKAGE_NAME")) {
           cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-            "CPack project name not specified" << std::endl);
+                      "CPack project name not specified" << std::endl);
           parsed = 0;
-          }
+        }
         if (parsed &&
             !(mf->GetDefinition("CPACK_PACKAGE_VERSION") ||
               (mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR") &&
                mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR") &&
-               mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH"))))
-          {
+               mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH")))) {
           cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-            "CPack project version not specified" << std::endl
-            << "Specify CPACK_PACKAGE_VERSION, or "
-            "CPACK_PACKAGE_VERSION_MAJOR, "
-            "CPACK_PACKAGE_VERSION_MINOR, and CPACK_PACKAGE_VERSION_PATCH."
-            << std::endl);
+                      "CPack project version not specified"
+                        << std::endl
+                        << "Specify CPACK_PACKAGE_VERSION, or "
+                           "CPACK_PACKAGE_VERSION_MAJOR, "
+                           "CPACK_PACKAGE_VERSION_MINOR, and "
+                           "CPACK_PACKAGE_VERSION_PATCH."
+                        << std::endl);
           parsed = 0;
-          }
-        if ( parsed )
-          {
+        }
+        if (parsed) {
           cpackGenerator = generators.NewGenerator(gen);
-          if ( !cpackGenerator )
-            {
+          if (!cpackGenerator) {
             cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-              "Cannot initialize CPack generator: "
-              << gen << std::endl);
+                        "Cannot initialize CPack generator: " << gen
+                                                              << std::endl);
             parsed = 0;
-            }
-          if ( parsed && !cpackGenerator->Initialize(gen, mf) )
-            {
+          }
+          if (parsed && !cpackGenerator->Initialize(gen, mf)) {
             cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-              "Cannot initialize the generator " << gen << std::endl);
+                        "Cannot initialize the generator " << gen
+                                                           << std::endl);
             parsed = 0;
-            }
+          }
 
-          if ( !mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
-            !mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
-            !mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS") )
-            {
-            cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
+          if (!mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
+              !mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
+              !mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS")) {
+            cmCPack_Log(
+              &log, cmCPackLog::LOG_ERROR,
               "Please specify build tree of the project that uses CMake "
               "using CPACK_INSTALL_CMAKE_PROJECTS, specify "
               "CPACK_INSTALL_COMMANDS, or specify "
               "CPACK_INSTALLED_DIRECTORIES."
-              << std::endl);
+                << std::endl);
             parsed = 0;
-            }
-          if ( parsed )
-            {
+          }
+          if (parsed) {
             const char* projName = mf->GetDefinition("CPACK_PACKAGE_NAME");
             cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE, "Use generator: "
-              << cpackGenerator->GetNameOfClass() << std::endl);
-            cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE, "For project: "
-              << projName << std::endl);
+                          << cpackGenerator->GetNameOfClass() << std::endl);
+            cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
+                        "For project: " << projName << std::endl);
 
             const char* projVersion =
               mf->GetDefinition("CPACK_PACKAGE_VERSION");
-            if ( !projVersion )
-              {
-              const char* projVersionMajor
-                = mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
-              const char* projVersionMinor
-                = mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
-              const char* projVersionPatch
-                = mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
+            if (!projVersion) {
+              const char* projVersionMajor =
+                mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
+              const char* projVersionMinor =
+                mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
+              const char* projVersionPatch =
+                mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
               std::ostringstream ostr;
               ostr << projVersionMajor << "." << projVersionMinor << "."
-                << projVersionPatch;
-              mf->AddDefinition("CPACK_PACKAGE_VERSION",
-                                ostr.str().c_str());
-              }
+                   << projVersionPatch;
+              mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str().c_str());
+            }
 
             int res = cpackGenerator->DoPackage();
-            if ( !res )
-              {
+            if (!res) {
               cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
-                "Error when generating package: " << projName << std::endl);
+                          "Error when generating package: " << projName
+                                                            << std::endl);
               return 1;
-              }
             }
           }
         }
       }
     }
+  }
 
   /* In this case we are building the documentation object
    * instance in order to create appropriate structure
    * in order to satisfy the appropriate --help-xxx request
    */
-  if ( help )
-    {
+  if (help) {
     // Construct and print requested documentation.
 
     doc.SetName("cpack");
-    doc.SetSection("Name",cmDocumentationName);
-    doc.SetSection("Usage",cmDocumentationUsage);
-    doc.PrependSection("Options",cmDocumentationOptions);
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    doc.PrependSection("Options", cmDocumentationOptions);
 
     std::vector<cmDocumentationEntry> v;
     cmCPackGeneratorFactory::DescriptionsMap::const_iterator generatorIt;
-    for( generatorIt = generators.GetGeneratorsList().begin();
-      generatorIt != generators.GetGeneratorsList().end();
-      ++ generatorIt )
-      {
+    for (generatorIt = generators.GetGeneratorsList().begin();
+         generatorIt != generators.GetGeneratorsList().end(); ++generatorIt) {
       cmDocumentationEntry e;
       e.Name = generatorIt->first.c_str();
       e.Brief = generatorIt->second.c_str();
       v.push_back(e);
-      }
-    doc.SetSection("Generators",v);
+    }
+    doc.SetSection("Generators", v);
 
 #undef cout
-    return doc.PrintRequestedDocumentation(std::cout)? 0:1;
+    return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
 #define cout no_cout_use_cmCPack_Log
-    }
+  }
 
-  if (cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return 1;
-    }
+  }
 
   return 0;
 }
diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx
index 6dd17b0..dd53be8 100644
--- a/Source/CTest/cmCTestBZR.cxx
+++ b/Source/CTest/cmCTestBZR.cxx
@@ -19,63 +19,58 @@
 
 #include <cm_expat.h>
 
-extern "C"
-int cmBZRXMLParserUnknownEncodingHandler(void*,
-                                         const XML_Char *name,
-                                         XML_Encoding *info)
+extern "C" int cmBZRXMLParserUnknownEncodingHandler(void*,
+                                                    const XML_Char* name,
+                                                    XML_Encoding* info)
 {
-  static const int latin1[]=
-    {
-      0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
-      0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
-      0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
-      0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
-      0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
-      0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
-      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
-      0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
-      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
-      0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
-      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
-      0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
-      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
-      0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
-      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
-      0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
-      0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
-      0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
-      0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
-      0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
-      0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
-      0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
-      0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
-      0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
-      0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
-      0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
-      0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
-      0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
-      0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
-      0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
-      0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
-      0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
-    };
+  static const int latin1[] = {
+    0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
+    0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x0010, 0x0011,
+    0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A,
+    0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x0020, 0x0021, 0x0022, 0x0023,
+    0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C,
+    0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
+    0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E,
+    0x003F, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+    0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050,
+    0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059,
+    0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x0060, 0x0061, 0x0062,
+    0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B,
+    0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074,
+    0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D,
+    0x007E, 0x007F, 0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020,
+    0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
+    0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x02DC,
+    0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178, 0x00A0, 0x00A1,
+    0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA,
+    0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0, 0x00B1, 0x00B2, 0x00B3,
+    0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC,
+    0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5,
+    0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE,
+    0x00CF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
+    0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00E0,
+    0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9,
+    0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0, 0x00F1, 0x00F2,
+    0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB,
+    0x00FC, 0x00FD, 0x00FE, 0x00FF
+  };
 
   // The BZR xml output plugin can use some encodings that are not
   // recognized by expat.  This will lead to an error, e.g. "Error
   // parsing bzr log xml: unknown encoding", the following is a
   // workaround for these unknown encodings.
-  if(name == std::string("ascii") || name == std::string("cp1252") ||
-     name == std::string("ANSI_X3.4-1968"))
-    {
-    for(unsigned int i=0;i<256;++i) info->map[i] = latin1[i];
+  if (name == std::string("ascii") || name == std::string("cp1252") ||
+      name == std::string("ANSI_X3.4-1968")) {
+    for (unsigned int i = 0; i < 256; ++i)
+      info->map[i] = latin1[i];
     return 1;
-    }
+  }
 
   return 0;
 }
 
-cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
-  cmCTestGlobalVC(ct, log)
+cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
   // Even though it is specified in the documentation, with bzr 1.13
@@ -88,69 +83,68 @@ cmCTestBZR::~cmCTestBZR()
 {
 }
 
-class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
+class cmCTestBZR::InfoParser : public cmCTestVC::LineParser
 {
 public:
-  InfoParser(cmCTestBZR* bzr, const char* prefix):
-    BZR(bzr), CheckOutFound(false)
-    {
+  InfoParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+    , CheckOutFound(false)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
     this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
-    }
+  }
+
 private:
   cmCTestBZR* BZR;
   bool CheckOutFound;
   cmsys::RegularExpression RegexCheckOut;
   cmsys::RegularExpression RegexParent;
   virtual bool ProcessLine()
-    {
-    if(this->RegexCheckOut.find(this->Line))
-      {
+  {
+    if (this->RegexCheckOut.find(this->Line)) {
       this->BZR->URL = this->RegexCheckOut.match(1);
       CheckOutFound = true;
-      }
-    else if(!CheckOutFound && this->RegexParent.find(this->Line))
-      {
+    } else if (!CheckOutFound && this->RegexParent.find(this->Line)) {
       this->BZR->URL = this->RegexParent.match(1);
-      }
-    return true;
     }
+    return true;
+  }
 };
 
-class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
+class cmCTestBZR::RevnoParser : public cmCTestVC::LineParser
 {
 public:
-  RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev):
-    Rev(rev)
-    {
+  RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexRevno.compile("^([0-9]+)$");
-    }
+  }
+
 private:
   std::string& Rev;
   cmsys::RegularExpression RegexRevno;
   virtual bool ProcessLine()
-    {
-    if(this->RegexRevno.find(this->Line))
-      {
+  {
+    if (this->RegexRevno.find(this->Line)) {
       this->Rev = this->RegexRevno.match(1);
-      }
-    return true;
     }
+    return true;
+  }
 };
 
 std::string cmCTestBZR::LoadInfo()
 {
   // Run "bzr info" to get the repository info from the work tree.
   const char* bzr = this->CommandLineTool.c_str();
-  const char* bzr_info[] = {bzr, "info", 0};
+  const char* bzr_info[] = { bzr, "info", 0 };
   InfoParser iout(this, "info-out> ");
   OutputLogger ierr(this->Log, "info-err> ");
   this->RunChild(bzr_info, &iout, &ierr);
 
   // Run "bzr revno" to get the repository revision number from the work tree.
-  const char* bzr_revno[] = {bzr, "revno", 0};
+  const char* bzr_revno[] = { bzr, "revno", 0 };
   std::string rev;
   RevnoParser rout(this, "revno-out> ", rev);
   OutputLogger rerr(this->Log, "revno-err> ");
@@ -164,7 +158,7 @@ void cmCTestBZR::NoteOldRevision()
   this->OldRevision = this->LoadInfo();
   this->Log << "Revision before update: " << this->OldRevision << "\n";
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-             << this->OldRevision << "\n");
+               << this->OldRevision << "\n");
   this->PriorRev.Rev = this->OldRevision;
 }
 
@@ -173,35 +167,38 @@ void cmCTestBZR::NoteNewRevision()
   this->NewRevision = this->LoadInfo();
   this->Log << "Revision after update: " << this->NewRevision << "\n";
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-             << this->NewRevision << "\n");
+               << this->NewRevision << "\n");
   this->Log << "URL = " << this->URL << "\n";
 }
 
-class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
-                             private cmXMLParser
+class cmCTestBZR::LogParser : public cmCTestVC::OutputLogger,
+                              private cmXMLParser
 {
 public:
-  LogParser(cmCTestBZR* bzr, const char* prefix):
-    OutputLogger(bzr->Log, prefix), BZR(bzr),
-    EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
-    { this->InitializeParser(); }
+  LogParser(cmCTestBZR* bzr, const char* prefix)
+    : OutputLogger(bzr->Log, prefix)
+    , BZR(bzr)
+    , EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
+  {
+    this->InitializeParser();
+  }
   ~LogParser() { this->CleanupParser(); }
 
   virtual int InitializeParser()
-     {
-     int res = cmXMLParser::InitializeParser();
-     if (res)
-       {
-       XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
-                                     cmBZRXMLParserUnknownEncodingHandler, 0);
-       }
-     return res;
-     }
+  {
+    int res = cmXMLParser::InitializeParser();
+    if (res) {
+      XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
+                                    cmBZRXMLParserUnknownEncodingHandler, 0);
+    }
+    return res;
+  }
+
 private:
   cmCTestBZR* BZR;
 
   typedef cmCTestBZR::Revision Revision;
-  typedef cmCTestBZR::Change   Change;
+  typedef cmCTestBZR::Change Change;
   Revision Rev;
   std::vector<Change> Changes;
   Change CurChange;
@@ -210,194 +207,161 @@ private:
   cmsys::RegularExpression EmailRegex;
 
   virtual bool ProcessChunk(const char* data, int length)
-    {
+  {
     this->OutputLogger::ProcessChunk(data, length);
     this->ParseChunk(data, length);
     return true;
-    }
+  }
 
   virtual void StartElement(const std::string& name, const char**)
-    {
+  {
     this->CData.clear();
-    if(name == "log")
-      {
+    if (name == "log") {
       this->Rev = Revision();
       this->Changes.clear();
-      }
+    }
     // affected-files can contain blocks of
     // modified, unknown, renamed, kind-changed, removed, conflicts, added
-    else if(name == "modified"
-            || name == "renamed"
-            || name == "kind-changed")
-      {
+    else if (name == "modified" || name == "renamed" ||
+             name == "kind-changed") {
       this->CurChange = Change();
       this->CurChange.Action = 'M';
-      }
-    else if(name == "added")
-      {
+    } else if (name == "added") {
       this->CurChange = Change();
       this->CurChange = 'A';
-      }
-    else if(name == "removed")
-      {
+    } else if (name == "removed") {
       this->CurChange = Change();
       this->CurChange = 'D';
-      }
-    else if(name == "unknown"
-            || name == "conflicts")
-      {
+    } else if (name == "unknown" || name == "conflicts") {
       // Should not happen here
       this->CurChange = Change();
-      }
     }
+  }
 
   virtual void CharacterDataHandler(const char* data, int length)
-    {
-    this->CData.insert(this->CData.end(), data, data+length);
-    }
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
 
   virtual void EndElement(const std::string& name)
-    {
-    if(name == "log")
-      {
+  {
+    if (name == "log") {
       this->BZR->DoRevision(this->Rev, this->Changes);
-      }
-    else if(!this->CData.empty() &&
-            (name == "file" || name == "directory"))
-      {
+    } else if (!this->CData.empty() &&
+               (name == "file" || name == "directory")) {
       this->CurChange.Path.assign(&this->CData[0], this->CData.size());
       cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
       this->Changes.push_back(this->CurChange);
-      }
-    else if(!this->CData.empty() && name == "symlink")
-      {
+    } else if (!this->CData.empty() && name == "symlink") {
       // symlinks have an arobase at the end in the log
-      this->CurChange.Path.assign(&this->CData[0], this->CData.size()-1);
+      this->CurChange.Path.assign(&this->CData[0], this->CData.size() - 1);
       cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
       this->Changes.push_back(this->CurChange);
-      }
-    else if(!this->CData.empty() && name == "committer")
-      {
+    } else if (!this->CData.empty() && name == "committer") {
       this->Rev.Author.assign(&this->CData[0], this->CData.size());
-      if(this->EmailRegex.find(this->Rev.Author))
-        {
+      if (this->EmailRegex.find(this->Rev.Author)) {
         this->Rev.Author = this->EmailRegex.match(1);
         this->Rev.EMail = this->EmailRegex.match(2);
-        }
       }
-    else if(!this->CData.empty() && name == "timestamp")
-      {
+    } else if (!this->CData.empty() && name == "timestamp") {
       this->Rev.Date.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "message")
-      {
+    } else if (!this->CData.empty() && name == "message") {
       this->Rev.Log.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "revno")
-      {
+    } else if (!this->CData.empty() && name == "revno") {
       this->Rev.Rev.assign(&this->CData[0], this->CData.size());
-      }
-    this->CData.clear();
     }
+    this->CData.clear();
+  }
 
   virtual void ReportError(int, int, const char* msg)
-    {
+  {
     this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
-    }
+  }
 };
 
-class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
+class cmCTestBZR::UpdateParser : public cmCTestVC::LineParser
 {
 public:
-  UpdateParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
-    {
+  UpdateParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
-    }
+  }
+
 private:
   cmCTestBZR* BZR;
   cmsys::RegularExpression RegexUpdate;
 
   virtual bool ProcessChunk(const char* first, int length)
-    {
+  {
     bool last_is_new_line = (*first == '\r' || *first == '\n');
 
     const char* const last = first + length;
-    for(const char* c = first; c != last; ++c)
-      {
-      if(*c == '\r' || *c == '\n')
-        {
-        if(!last_is_new_line)
-          {
+    for (const char* c = first; c != last; ++c) {
+      if (*c == '\r' || *c == '\n') {
+        if (!last_is_new_line) {
           // Log this line.
-          if(this->Log && this->Prefix)
-            {
+          if (this->Log && this->Prefix) {
             *this->Log << this->Prefix << this->Line << "\n";
-            }
+          }
 
           // Hand this line to the subclass implementation.
-          if(!this->ProcessLine())
-            {
+          if (!this->ProcessLine()) {
             this->Line = "";
             return false;
-            }
+          }
 
           this->Line = "";
           last_is_new_line = true;
-          }
         }
-      else
-        {
+      } else {
         // Append this character to the line under construction.
         this->Line.append(1, *c);
         last_is_new_line = false;
-        }
       }
-    return true;
     }
+    return true;
+  }
 
   bool ProcessLine()
-    {
-    if(this->RegexUpdate.find(this->Line))
-      {
+  {
+    if (this->RegexUpdate.find(this->Line)) {
       this->DoPath(this->RegexUpdate.match(1)[0],
                    this->RegexUpdate.match(2)[0],
-                   this->RegexUpdate.match(3)[0],
-                   this->RegexUpdate.match(4));
-      }
-    return true;
+                   this->RegexUpdate.match(3)[0], this->RegexUpdate.match(4));
     }
+    return true;
+  }
 
   void DoPath(char c0, char c1, char c2, std::string path)
-    {
-    if(path.empty()) return;
+  {
+    if (path.empty())
+      return;
     cmSystemTools::ConvertToUnixSlashes(path);
 
     const std::string dir = cmSystemTools::GetFilenamePath(path);
     const std::string name = cmSystemTools::GetFilenameName(path);
 
-    if ( c0=='C' )
-      {
+    if (c0 == 'C') {
       this->BZR->Dirs[dir][name].Status = PathConflicting;
       return;
-      }
+    }
 
-    if ( c1=='M' || c1=='K' || c1=='N' || c1=='D' || c2 =='*' )
-      {
+    if (c1 == 'M' || c1 == 'K' || c1 == 'N' || c1 == 'D' || c2 == '*') {
       this->BZR->Dirs[dir][name].Status = PathUpdated;
       return;
-      }
     }
+  }
 };
 
 bool cmCTestBZR::UpdateImpl()
 {
   // Get user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
-    }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
@@ -407,11 +371,10 @@ bool cmCTestBZR::UpdateImpl()
   bzr_update.push_back(this->CommandLineTool.c_str());
   bzr_update.push_back("pull");
 
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     bzr_update.push_back(ai->c_str());
-    }
+  }
 
   bzr_update.push_back(this->URL.c_str());
 
@@ -427,82 +390,79 @@ void cmCTestBZR::LoadRevisions()
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              "   Gathering version information (one . per revision):\n"
-             "    " << std::flush);
+             "    "
+               << std::flush);
 
   // We are interested in every revision included in the update.
   this->Revisions.clear();
   std::string revs;
-  if(atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str()))
-    {
+  if (atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str())) {
     // DoRevision takes care of discarding the information about OldRevision
     revs = this->OldRevision + ".." + this->NewRevision;
-    }
-  else
-    {
+  } else {
     return;
-    }
+  }
 
   // Run "bzr log" to get all global revisions of interest.
   const char* bzr = this->CommandLineTool.c_str();
-  const char* bzr_log[] = {bzr, "log", "-v", "-r", revs.c_str(), "--xml",
-                           this->URL.c_str(), 0};
+  const char* bzr_log[] = {
+    bzr, "log", "-v", "-r", revs.c_str(), "--xml", this->URL.c_str(), 0
+  };
   {
-  LogParser out(this, "log-out> ");
-  OutputLogger err(this->Log, "log-err> ");
-  this->RunChild(bzr_log, &out, &err);
+    LogParser out(this, "log-out> ");
+    OutputLogger err(this->Log, "log-err> ");
+    this->RunChild(bzr_log, &out, &err);
   }
   cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
 }
 
-class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
+class cmCTestBZR::StatusParser : public cmCTestVC::LineParser
 {
 public:
-  StatusParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
-    {
+  StatusParser(cmCTestBZR* bzr, const char* prefix)
+    : BZR(bzr)
+  {
     this->SetLog(&bzr->Log, prefix);
     this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
-    }
+  }
+
 private:
   cmCTestBZR* BZR;
   cmsys::RegularExpression RegexStatus;
   bool ProcessLine()
-    {
-    if(this->RegexStatus.find(this->Line))
-      {
+  {
+    if (this->RegexStatus.find(this->Line)) {
       this->DoPath(this->RegexStatus.match(1)[0],
                    this->RegexStatus.match(2)[0],
-                   this->RegexStatus.match(3)[0],
-                   this->RegexStatus.match(4));
-      }
-    return true;
+                   this->RegexStatus.match(3)[0], this->RegexStatus.match(4));
     }
+    return true;
+  }
 
   void DoPath(char c0, char c1, char c2, std::string path)
-    {
-    if(path.empty()) return;
+  {
+    if (path.empty())
+      return;
     cmSystemTools::ConvertToUnixSlashes(path);
 
-    if ( c0=='C' )
-      {
+    if (c0 == 'C') {
       this->BZR->DoModification(PathConflicting, path);
       return;
-      }
+    }
 
-    if ( c0 == '+' || c0 == 'R' || c0 == 'P'
-         || c1=='M' || c1=='K' || c1=='N' || c1=='D'
-         || c2 =='*' )
-      {
+    if (c0 == '+' || c0 == 'R' || c0 == 'P' || c1 == 'M' || c1 == 'K' ||
+        c1 == 'N' || c1 == 'D' || c2 == '*') {
       this->BZR->DoModification(PathModified, path);
       return;
-      }
     }
+  }
 };
 
 void cmCTestBZR::LoadModifications()
 {
   // Run "bzr status" which reports local modifications.
   const char* bzr = this->CommandLineTool.c_str();
-  const char* bzr_status[] = {bzr, "status", "-SV", 0};
+  const char* bzr_status[] = { bzr, "status", "-SV", 0 };
   StatusParser out(this, "status-out> ");
   OutputLogger err(this->Log, "status-err> ");
   this->RunChild(bzr_status, &out, &err);
diff --git a/Source/CTest/cmCTestBZR.h b/Source/CTest/cmCTestBZR.h
index df688e1..4f44136 100644
--- a/Source/CTest/cmCTestBZR.h
+++ b/Source/CTest/cmCTestBZR.h
@@ -18,7 +18,7 @@
  * \brief Interaction with bzr command-line tool
  *
  */
-class cmCTestBZR: public cmCTestGlobalVC
+class cmCTestBZR : public cmCTestGlobalVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
diff --git a/Source/CTest/cmCTestBatchTestHandler.cxx b/Source/CTest/cmCTestBatchTestHandler.cxx
index 6127551..386c8d5 100644
--- a/Source/CTest/cmCTestBatchTestHandler.cxx
+++ b/Source/CTest/cmCTestBatchTestHandler.cxx
@@ -30,18 +30,17 @@ void cmCTestBatchTestHandler::RunTests()
 
 void cmCTestBatchTestHandler::WriteBatchScript()
 {
-  this->Script = this->CTest->GetBinaryDir()
-    + "/Testing/CTestBatch.txt";
+  this->Script = this->CTest->GetBinaryDir() + "/Testing/CTestBatch.txt";
   cmsys::ofstream fout;
   fout.open(this->Script.c_str());
   fout << "#!/bin/sh\n";
 
-  for(TestMap::iterator i = this->Tests.begin(); i != this->Tests.end(); ++i)
-    {
+  for (TestMap::iterator i = this->Tests.begin(); i != this->Tests.end();
+       ++i) {
     this->WriteSrunArgs(i->first, fout);
     this->WriteTestCommand(i->first, fout);
     fout << "\n";
-    }
+  }
   fout.flush();
   fout.close();
 }
@@ -49,13 +48,13 @@ void cmCTestBatchTestHandler::WriteBatchScript()
 void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
 {
   cmCTestTestHandler::cmCTestTestProperties* properties =
-      this->Properties[test];
+    this->Properties[test];
 
   fout << "srun ";
-  //fout << "--jobid=" << test << " ";
+  // fout << "--jobid=" << test << " ";
   fout << "-J=" << properties->Name << " ";
 
-  //Write dependency information
+  // Write dependency information
   /*if(!this->Tests[test].empty())
     {
       fout << "-P=afterany";
@@ -66,14 +65,12 @@ void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout)
         }
       fout << " ";
     }*/
-  if(properties->RunSerial)
-    {
+  if (properties->RunSerial) {
     fout << "--exclusive ";
-    }
-  if(properties->Processors > 1)
-    {
+  }
+  if (properties->Processors > 1) {
     fout << "-n" << properties->Processors << " ";
-    }
+  }
 }
 
 void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout)
@@ -85,36 +82,32 @@ void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout)
   command = this->TestHandler->FindTheExecutable(args[1].c_str());
   command = cmSystemTools::ConvertToOutputPath(command.c_str());
 
-  //Prepends memcheck args to our command string if this is a memcheck
+  // Prepends memcheck args to our command string if this is a memcheck
   this->TestHandler->GenerateTestCommand(processArgs, test);
   processArgs.push_back(command);
 
-  for(std::vector<std::string>::iterator arg = processArgs.begin();
-      arg != processArgs.end(); ++arg)
-    {
+  for (std::vector<std::string>::iterator arg = processArgs.begin();
+       arg != processArgs.end(); ++arg) {
     fout << *arg << " ";
-    }
+  }
 
   std::vector<std::string>::iterator i = args.begin();
-  ++i; //the test name
-  ++i; //the executable (command)
-  if(args.size() > 2)
-    {
+  ++i; // the test name
+  ++i; // the executable (command)
+  if (args.size() > 2) {
     fout << "'";
-    }
-  while(i != args.end())
-    {
-    fout << "\"" << *i << "\""; //args to the test executable
+  }
+  while (i != args.end()) {
+    fout << "\"" << *i << "\""; // args to the test executable
     ++i;
 
-    if(i == args.end() && args.size() > 2)
-      {
+    if (i == args.end() && args.size() > 2) {
       fout << "'";
-      }
-    fout << " ";
     }
-  //TODO ZACH build TestResult.FullCommandLine
-  //this->TestResult.FullCommandLine = this->TestCommand;
+    fout << " ";
+  }
+  // TODO ZACH build TestResult.FullCommandLine
+  // this->TestResult.FullCommandLine = this->TestCommand;
 }
 
 void cmCTestBatchTestHandler::SubmitBatchScript()
@@ -123,8 +116,7 @@ void cmCTestBatchTestHandler::SubmitBatchScript()
   std::vector<std::string> args;
   args.push_back(this->Script);
   args.push_back("-o");
-  args.push_back(this->CTest->GetBinaryDir()
-                 + "/Testing/CTestBatch.txt");
+  args.push_back(this->CTest->GetBinaryDir() + "/Testing/CTestBatch.txt");
 
   sbatch.SetCommand("sbatch");
   sbatch.SetCommandArguments(args);
diff --git a/Source/CTest/cmCTestBatchTestHandler.h b/Source/CTest/cmCTestBatchTestHandler.h
index b0fc8d5..7a2a4a2 100644
--- a/Source/CTest/cmCTestBatchTestHandler.h
+++ b/Source/CTest/cmCTestBatchTestHandler.h
@@ -30,6 +30,7 @@ class cmCTestBatchTestHandler : public cmCTestMultiProcessHandler
 public:
   ~cmCTestBatchTestHandler();
   virtual void RunTests();
+
 protected:
   void WriteBatchScript();
   void WriteSrunArgs(int test, cmsys::ofstream& fout);
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx
index 6ea9a89..0cba8b2 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.cxx
+++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx
@@ -21,9 +21,9 @@
 
 cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
 {
-  this->BuildTwoConfig         = false;
-  this->BuildNoClean           = false;
-  this->BuildNoCMake           = false;
+  this->BuildTwoConfig = false;
+  this->BuildNoClean = false;
+  this->BuildNoCMake = false;
   this->Timeout = 0;
 }
 
@@ -48,91 +48,75 @@ int cmCTestBuildAndTestHandler::ProcessHandler()
 }
 
 int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
-  std::ostringstream &out, std::string &cmakeOutString, std::string &cwd,
-  cmake *cm)
+                                         std::ostringstream& out,
+                                         std::string& cmakeOutString,
+                                         std::string& cwd, cmake* cm)
 {
   unsigned int k;
   std::vector<std::string> args;
   args.push_back(cmSystemTools::GetCMakeCommand());
   args.push_back(this->SourceDir);
-  if(!this->BuildGenerator.empty())
-    {
+  if (!this->BuildGenerator.empty()) {
     std::string generator = "-G";
     generator += this->BuildGenerator;
     args.push_back(generator);
-    }
-  if(!this->BuildGeneratorPlatform.empty())
-    {
+  }
+  if (!this->BuildGeneratorPlatform.empty()) {
     std::string platform = "-A";
     platform += this->BuildGeneratorPlatform;
     args.push_back(platform);
-    }
-  if(!this->BuildGeneratorToolset.empty())
-    {
+  }
+  if (!this->BuildGeneratorToolset.empty()) {
     std::string toolset = "-T";
     toolset += this->BuildGeneratorToolset;
     args.push_back(toolset);
-    }
+  }
 
   const char* config = 0;
-  if (!this->CTest->GetConfigType().empty())
-    {
+  if (!this->CTest->GetConfigType().empty()) {
     config = this->CTest->GetConfigType().c_str();
-    }
+  }
 #ifdef CMAKE_INTDIR
-  if(!config)
-    {
+  if (!config) {
     config = CMAKE_INTDIR;
-    }
+  }
 #endif
 
-  if ( config )
-    {
-    std::string btype
-      = "-DCMAKE_BUILD_TYPE:STRING=" + std::string(config);
+  if (config) {
+    std::string btype = "-DCMAKE_BUILD_TYPE:STRING=" + std::string(config);
     args.push_back(btype);
-    }
+  }
 
-  for(k=0; k < this->BuildOptions.size(); ++k)
-    {
+  for (k = 0; k < this->BuildOptions.size(); ++k) {
     args.push_back(this->BuildOptions[k]);
-    }
-  if (cm->Run(args) != 0)
-    {
+  }
+  if (cm->Run(args) != 0) {
     out << "Error: cmake execution failed\n";
     out << cmakeOutString << "\n";
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd);
-    if(outstring)
-      {
+    if (outstring) {
       *outstring = out.str();
-      }
-    else
-      {
+    } else {
       cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
-      }
-    return 1;
     }
+    return 1;
+  }
   // do another config?
-  if(this->BuildTwoConfig)
-    {
-    if (cm->Run(args) != 0)
-      {
+  if (this->BuildTwoConfig) {
+    if (cm->Run(args) != 0) {
       out << "Error: cmake execution failed\n";
       out << cmakeOutString << "\n";
       // return to the original directory
       cmSystemTools::ChangeDirectory(cwd);
-      if(outstring)
-        {
+      if (outstring) {
         *outstring = out.str();
-        }
-      else
-        {
+      } else {
         cmCTestLog(this->CTest, ERROR_MESSAGE, out.str() << std::endl);
-        }
-      return 1;
       }
+      return 1;
     }
+  }
   out << "======== CMake output     ======\n";
   out << cmakeOutString;
   out << "======== End CMake output ======\n";
@@ -146,7 +130,7 @@ void CMakeMessageCallback(const char* m, const char*, bool&, void* s)
   *out += "\n";
 }
 
-void CMakeProgressCallback(const char*msg, float , void * s)
+void CMakeProgressCallback(const char* msg, float, void* s)
 {
   std::string* out = (std::string*)s;
   *out += msg;
@@ -162,37 +146,36 @@ void CMakeOutputCallback(const char* m, size_t len, void* s)
 class cmCTestBuildAndTestCaptureRAII
 {
   cmake& CM;
+
 public:
-  cmCTestBuildAndTestCaptureRAII(cmake& cm, std::string& s): CM(cm)
-    {
+  cmCTestBuildAndTestCaptureRAII(cmake& cm, std::string& s)
+    : CM(cm)
+  {
     cmSystemTools::SetMessageCallback(CMakeMessageCallback, &s);
     cmSystemTools::SetStdoutCallback(CMakeOutputCallback, &s);
     cmSystemTools::SetStderrCallback(CMakeOutputCallback, &s);
     this->CM.SetProgressCallback(CMakeProgressCallback, &s);
-    }
+  }
   ~cmCTestBuildAndTestCaptureRAII()
-    {
+  {
     this->CM.SetProgressCallback(0, 0);
     cmSystemTools::SetStderrCallback(0, 0);
     cmSystemTools::SetStdoutCallback(0, 0);
     cmSystemTools::SetMessageCallback(0, 0);
-    }
+  }
 };
 
 int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 {
   // if the generator and make program are not specified then it is an error
-  if (this->BuildGenerator.empty())
-    {
-    if(outstring)
-      {
-      *outstring =
-        "--build-and-test requires that the generator "
-        "be provided using the --build-generator "
-        "command line option. ";
-      }
-    return 1;
+  if (this->BuildGenerator.empty()) {
+    if (outstring) {
+      *outstring = "--build-and-test requires that the generator "
+                   "be provided using the --build-generator "
+                   "command line option. ";
     }
+    return 1;
+  }
 
   cmake cm;
   cm.SetHomeDirectory("");
@@ -202,27 +185,21 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   static_cast<void>(captureRAII);
   std::ostringstream out;
 
-  if ( this->CTest->GetConfigType().empty() &&
-       !this->ConfigSample.empty())
-    {
+  if (this->CTest->GetConfigType().empty() && !this->ConfigSample.empty()) {
     // use the config sample to set the ConfigType
     std::string fullPath;
     std::string resultingConfig;
     std::vector<std::string> extraPaths;
     std::vector<std::string> failed;
-    fullPath =
-      cmCTestTestHandler::FindExecutable(this->CTest,
-                                         this->ConfigSample.c_str(),
-                                         resultingConfig,
-                                         extraPaths,
-                                         failed);
-    if (!fullPath.empty() && !resultingConfig.empty())
-      {
+    fullPath = cmCTestTestHandler::FindExecutable(
+      this->CTest, this->ConfigSample.c_str(), resultingConfig, extraPaths,
+      failed);
+    if (!fullPath.empty() && !resultingConfig.empty()) {
       this->CTest->SetConfigType(resultingConfig.c_str());
-      }
-    out << "Using config sample with results: "
-        << fullPath << " and " << resultingConfig << std::endl;
     }
+    out << "Using config sample with results: " << fullPath << " and "
+        << resultingConfig << std::endl;
+  }
 
   // we need to honor the timeout specified, the timeout include cmake, build
   // and test time
@@ -230,100 +207,79 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
 
   // make sure the binary dir is there
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
-  out << "Internal cmake changing into directory: "
-    << this->BinaryDir << std::endl;
-  if (!cmSystemTools::FileIsDirectory(this->BinaryDir))
-    {
+  out << "Internal cmake changing into directory: " << this->BinaryDir
+      << std::endl;
+  if (!cmSystemTools::FileIsDirectory(this->BinaryDir)) {
     cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
-    }
+  }
   cmSystemTools::ChangeDirectory(this->BinaryDir);
 
-  if(this->BuildNoCMake)
-    {
+  if (this->BuildNoCMake) {
     // Make the generator available for the Build call below.
-    cm.SetGlobalGenerator(cm.CreateGlobalGenerator(
-                            this->BuildGenerator));
+    cm.SetGlobalGenerator(cm.CreateGlobalGenerator(this->BuildGenerator));
     cm.SetGeneratorPlatform(this->BuildGeneratorPlatform);
     cm.SetGeneratorToolset(this->BuildGeneratorToolset);
 
     // Load the cache to make CMAKE_MAKE_PROGRAM available.
     cm.LoadCache(this->BinaryDir);
-    }
-  else
-    {
+  } else {
     // do the cmake step, no timeout here since it is not a sub process
-    if (this->RunCMake(outstring,out,cmakeOutString,cwd,&cm))
-      {
+    if (this->RunCMake(outstring, out, cmakeOutString, cwd, &cm)) {
       return 1;
-      }
     }
+  }
 
   // do the build
   std::vector<std::string>::iterator tarIt;
-  if (this->BuildTargets.empty())
-    {
+  if (this->BuildTargets.empty()) {
     this->BuildTargets.push_back("");
-    }
-  for ( tarIt = this->BuildTargets.begin();
-        tarIt != this->BuildTargets.end(); ++ tarIt )
-    {
+  }
+  for (tarIt = this->BuildTargets.begin(); tarIt != this->BuildTargets.end();
+       ++tarIt) {
     double remainingTime = 0;
-    if (this->Timeout > 0)
-      {
+    if (this->Timeout > 0) {
       remainingTime = this->Timeout - cmSystemTools::GetTime() + clock_start;
-      if (remainingTime <= 0)
-        {
-        if(outstring)
-          {
+      if (remainingTime <= 0) {
+        if (outstring) {
           *outstring = "--build-and-test timeout exceeded. ";
-          }
-        return 1;
         }
+        return 1;
       }
+    }
     std::string output;
     const char* config = 0;
-    if (!this->CTest->GetConfigType().empty())
-      {
+    if (!this->CTest->GetConfigType().empty()) {
       config = this->CTest->GetConfigType().c_str();
-      }
+    }
 #ifdef CMAKE_INTDIR
-    if(!config)
-      {
+    if (!config) {
       config = CMAKE_INTDIR;
-      }
+    }
 #endif
-    if(!config)
-      {
+    if (!config) {
       config = "Debug";
-      }
+    }
     int retVal = cm.GetGlobalGenerator()->Build(
-      this->SourceDir, this->BinaryDir,
-      this->BuildProject, *tarIt,
-      output, this->BuildMakeProgram,
-      config,
-      !this->BuildNoClean,
-      false, false, remainingTime);
+      this->SourceDir, this->BinaryDir, this->BuildProject, *tarIt, output,
+      this->BuildMakeProgram, config, !this->BuildNoClean, false, false,
+      remainingTime);
     out << output;
     // if the build failed then return
-    if (retVal)
-      {
-      if(outstring)
-        {
-        *outstring =  out.str();
-        }
-      return 1;
+    if (retVal) {
+      if (outstring) {
+        *outstring = out.str();
       }
+      return 1;
     }
-  if(outstring)
-    {
-    *outstring =  out.str();
-    }
+  }
+  if (outstring) {
+    *outstring = out.str();
+  }
 
   // if no test was specified then we are done
-  if (this->TestCommand.empty())
-    {
+  if (this->TestCommand.empty()) {
     return 0;
-    }
+  }
 
   // now run the compiled test if we can find it
   // store the final location in fullPath
@@ -331,99 +287,80 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
   std::string resultingConfig;
   std::vector<std::string> extraPaths;
   // if this->ExecutableDirectory is set try that as well
-  if (!this->ExecutableDirectory.empty())
-    {
+  if (!this->ExecutableDirectory.empty()) {
     std::string tempPath = this->ExecutableDirectory;
     tempPath += "/";
     tempPath += this->TestCommand;
     extraPaths.push_back(tempPath);
-    }
+  }
   std::vector<std::string> failed;
   fullPath =
-    cmCTestTestHandler::FindExecutable(this->CTest,
-                                       this->TestCommand.c_str(),
-                                       resultingConfig,
-                                       extraPaths,
-                                       failed);
-
-  if(!cmSystemTools::FileExists(fullPath.c_str()))
-    {
+    cmCTestTestHandler::FindExecutable(this->CTest, this->TestCommand.c_str(),
+                                       resultingConfig, extraPaths, failed);
+
+  if (!cmSystemTools::FileExists(fullPath.c_str())) {
     out << "Could not find path to executable, perhaps it was not built: "
-      << this->TestCommand << "\n";
+        << this->TestCommand << "\n";
     out << "tried to find it in these places:\n";
     out << fullPath.c_str() << "\n";
-    for(unsigned int i=0; i < failed.size(); ++i)
-      {
+    for (unsigned int i = 0; i < failed.size(); ++i) {
       out << failed[i] << "\n";
-      }
-    if(outstring)
-      {
-      *outstring =  out.str();
-      }
-    else
-      {
+    }
+    if (outstring) {
+      *outstring = out.str();
+    } else {
       cmCTestLog(this->CTest, ERROR_MESSAGE, out.str());
-      }
+    }
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd);
     return 1;
-    }
+  }
 
   std::vector<const char*> testCommand;
   testCommand.push_back(fullPath.c_str());
-  for(size_t k=0; k < this->TestCommandArgs.size(); ++k)
-    {
+  for (size_t k = 0; k < this->TestCommandArgs.size(); ++k) {
     testCommand.push_back(this->TestCommandArgs[k].c_str());
-    }
+  }
   testCommand.push_back(0);
   std::string outs;
   int retval = 0;
   // run the test from the this->BuildRunDir if set
-  if(!this->BuildRunDir.empty())
-    {
+  if (!this->BuildRunDir.empty()) {
     out << "Run test in directory: " << this->BuildRunDir << "\n";
     cmSystemTools::ChangeDirectory(this->BuildRunDir);
-    }
+  }
   out << "Running test command: \"" << fullPath << "\"";
-  for(size_t k=0; k < this->TestCommandArgs.size(); ++k)
-    {
+  for (size_t k = 0; k < this->TestCommandArgs.size(); ++k) {
     out << " \"" << this->TestCommandArgs[k] << "\"";
-    }
+  }
   out << "\n";
 
   // how much time is remaining
   double remainingTime = 0;
-  if (this->Timeout > 0)
-    {
+  if (this->Timeout > 0) {
     remainingTime = this->Timeout - cmSystemTools::GetTime() + clock_start;
-    if (remainingTime <= 0)
-      {
-      if(outstring)
-        {
+    if (remainingTime <= 0) {
+      if (outstring) {
         *outstring = "--build-and-test timeout exceeded. ";
-        }
-      return 1;
       }
+      return 1;
     }
+  }
 
-  int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, 0,
-                                        remainingTime, 0);
+  int runTestRes =
+    this->CTest->RunTest(testCommand, &outs, &retval, 0, remainingTime, 0);
 
-  if(runTestRes != cmsysProcess_State_Exited || retval != 0)
-    {
+  if (runTestRes != cmsysProcess_State_Exited || retval != 0) {
     out << "Test command failed: " << testCommand[0] << "\n";
     retval = 1;
-    }
+  }
 
   out << outs << "\n";
-  if(outstring)
-    {
+  if (outstring) {
     *outstring = out.str();
-    }
-  else
-    {
+  } else {
     cmCTestLog(this->CTest, OUTPUT, out.str() << std::endl);
-    }
+  }
   return retval;
 }
 
@@ -432,114 +369,89 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
   const std::vector<std::string>& allArgs)
 {
   // --build-and-test options
-  if(currentArg.find("--build-and-test",0) == 0 && idx < allArgs.size() - 1)
-    {
-    if(idx+2 < allArgs.size())
-      {
+  if (currentArg.find("--build-and-test", 0) == 0 &&
+      idx < allArgs.size() - 1) {
+    if (idx + 2 < allArgs.size()) {
       idx++;
       this->SourceDir = allArgs[idx];
       idx++;
       this->BinaryDir = allArgs[idx];
       // dir must exist before CollapseFullPath is called
       cmSystemTools::MakeDirectory(this->BinaryDir.c_str());
-      this->BinaryDir
-        = cmSystemTools::CollapseFullPath(this->BinaryDir);
-      this->SourceDir
-        = cmSystemTools::CollapseFullPath(this->SourceDir);
-      }
-    else
-      {
+      this->BinaryDir = cmSystemTools::CollapseFullPath(this->BinaryDir);
+      this->SourceDir = cmSystemTools::CollapseFullPath(this->SourceDir);
+    } else {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "--build-and-test must have source and binary dir" << std::endl);
+                 "--build-and-test must have source and binary dir"
+                   << std::endl);
       return 0;
-      }
     }
-  if(currentArg.find("--build-target",0) == 0 && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--build-target", 0) == 0 && idx < allArgs.size() - 1) {
     idx++;
     this->BuildTargets.push_back(allArgs[idx]);
-    }
-  if(currentArg.find("--build-nocmake",0) == 0)
-    {
+  }
+  if (currentArg.find("--build-nocmake", 0) == 0) {
     this->BuildNoCMake = true;
-    }
-  if(currentArg.find("--build-run-dir",0) == 0 && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--build-run-dir", 0) == 0 && idx < allArgs.size() - 1) {
     idx++;
     this->BuildRunDir = allArgs[idx];
-    }
-  if(currentArg.find("--build-two-config",0) == 0)
-    {
+  }
+  if (currentArg.find("--build-two-config", 0) == 0) {
     this->BuildTwoConfig = true;
-    }
-  if(currentArg.find("--build-exe-dir",0) == 0 && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--build-exe-dir", 0) == 0 && idx < allArgs.size() - 1) {
     idx++;
     this->ExecutableDirectory = allArgs[idx];
-    }
-  if(currentArg.find("--test-timeout",0) == 0 && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--test-timeout", 0) == 0 && idx < allArgs.size() - 1) {
     idx++;
     this->Timeout = atof(allArgs[idx].c_str());
-    }
-  if(currentArg == "--build-generator" && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg == "--build-generator" && idx < allArgs.size() - 1) {
     idx++;
     this->BuildGenerator = allArgs[idx];
-    }
-  if(currentArg == "--build-generator-platform" &&
-     idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg == "--build-generator-platform" && idx < allArgs.size() - 1) {
     idx++;
     this->BuildGeneratorPlatform = allArgs[idx];
-    }
-  if(currentArg == "--build-generator-toolset" &&
-     idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg == "--build-generator-toolset" && idx < allArgs.size() - 1) {
     idx++;
     this->BuildGeneratorToolset = allArgs[idx];
-    }
-  if(currentArg.find("--build-project",0) == 0 && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--build-project", 0) == 0 && idx < allArgs.size() - 1) {
     idx++;
     this->BuildProject = allArgs[idx];
-    }
-  if(currentArg.find("--build-makeprogram",0) == 0 &&
-    idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--build-makeprogram", 0) == 0 &&
+      idx < allArgs.size() - 1) {
     idx++;
     this->BuildMakeProgram = allArgs[idx];
-    }
-  if(currentArg.find("--build-config-sample",0) == 0 &&
-    idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--build-config-sample", 0) == 0 &&
+      idx < allArgs.size() - 1) {
     idx++;
     this->ConfigSample = allArgs[idx];
-    }
-  if(currentArg.find("--build-noclean",0) == 0)
-    {
+  }
+  if (currentArg.find("--build-noclean", 0) == 0) {
     this->BuildNoClean = true;
-    }
-  if(currentArg.find("--build-options",0) == 0)
-    {
-    while(idx+1 < allArgs.size() &&
-          allArgs[idx+1] != "--build-target" &&
-          allArgs[idx+1] != "--test-command")
-      {
+  }
+  if (currentArg.find("--build-options", 0) == 0) {
+    while (idx + 1 < allArgs.size() && allArgs[idx + 1] != "--build-target" &&
+           allArgs[idx + 1] != "--test-command") {
       ++idx;
       this->BuildOptions.push_back(allArgs[idx]);
-      }
     }
-  if(currentArg.find("--test-command",0) == 0 && idx < allArgs.size() - 1)
-    {
+  }
+  if (currentArg.find("--test-command", 0) == 0 && idx < allArgs.size() - 1) {
     ++idx;
     this->TestCommand = allArgs[idx];
-    while(idx+1 < allArgs.size())
-      {
+    while (idx + 1 < allArgs.size()) {
       ++idx;
       this->TestCommandArgs.push_back(allArgs[idx]);
-      }
     }
+  }
   return 1;
 }
-
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.h b/Source/CTest/cmCTestBuildAndTestHandler.h
index a75c631..d0443ae 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.h
+++ b/Source/CTest/cmCTestBuildAndTestHandler.h
@@ -13,7 +13,6 @@
 #ifndef cmCTestBuildAndTestHandler_h
 #define cmCTestBuildAndTestHandler_h
 
-
 #include "cmCTestGenericHandler.h"
 #include "cmListFileCache.h"
 
@@ -50,31 +49,29 @@ public:
 protected:
   ///! Run CMake and build a test and then run it as a single test.
   int RunCMakeAndTest(std::string* output);
-  int RunCMake(std::string* outstring, std::ostringstream &out,
-               std::string &cmakeOutString,
-               std::string &cwd, cmake *cm);
+  int RunCMake(std::string* outstring, std::ostringstream& out,
+               std::string& cmakeOutString, std::string& cwd, cmake* cm);
 
-  std::string  Output;
+  std::string Output;
 
-  std::string              BuildGenerator;
-  std::string              BuildGeneratorPlatform;
-  std::string              BuildGeneratorToolset;
+  std::string BuildGenerator;
+  std::string BuildGeneratorPlatform;
+  std::string BuildGeneratorToolset;
   std::vector<std::string> BuildOptions;
-  bool                     BuildTwoConfig;
-  std::string              BuildMakeProgram;
-  std::string              ConfigSample;
-  std::string              SourceDir;
-  std::string              BinaryDir;
-  std::string              BuildProject;
-  std::string              TestCommand;
-  bool                     BuildNoClean;
-  std::string              BuildRunDir;
-  std::string              ExecutableDirectory;
+  bool BuildTwoConfig;
+  std::string BuildMakeProgram;
+  std::string ConfigSample;
+  std::string SourceDir;
+  std::string BinaryDir;
+  std::string BuildProject;
+  std::string TestCommand;
+  bool BuildNoClean;
+  std::string BuildRunDir;
+  std::string ExecutableDirectory;
   std::vector<std::string> TestCommandArgs;
   std::vector<std::string> BuildTargets;
-  bool                     BuildNoCMake;
-  double                   Timeout;
+  bool BuildNoCMake;
+  double Timeout;
 };
 
 #endif
-
diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
index ca3960f..05cccbf 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -17,7 +17,6 @@
 #include "cmGlobalGenerator.h"
 #include "cmake.h"
 
-
 cmCTestBuildCommand::cmCTestBuildCommand()
 {
   this->GlobalGenerator = 0;
@@ -33,37 +32,31 @@ cmCTestBuildCommand::cmCTestBuildCommand()
 
 cmCTestBuildCommand::~cmCTestBuildCommand()
 {
-  if ( this->GlobalGenerator )
-    {
+  if (this->GlobalGenerator) {
     delete this->GlobalGenerator;
     this->GlobalGenerator = 0;
-    }
+  }
 }
 
 cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
 {
-  cmCTestGenericHandler* handler
-    = this->CTest->GetInitializedHandler("build");
-  if ( !handler )
-    {
+  cmCTestGenericHandler* handler = this->CTest->GetInitializedHandler("build");
+  if (!handler) {
     this->SetError("internal CTest error. Cannot instantiate build handler");
     return 0;
-    }
-  this->Handler =  (cmCTestBuildHandler*)handler;
+  }
+  this->Handler = (cmCTestBuildHandler*)handler;
 
-  const char* ctestBuildCommand
-    = this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
-  if ( ctestBuildCommand && *ctestBuildCommand )
-    {
+  const char* ctestBuildCommand =
+    this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
+  if (ctestBuildCommand && *ctestBuildCommand) {
     this->CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand,
-      this->Quiet);
-    }
-  else
-    {
-    const char* cmakeGeneratorName
-      = this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
-    const char* cmakeProjectName
-      = (this->Values[ctb_PROJECT_NAME] && *this->Values[ctb_PROJECT_NAME])
+                                       this->Quiet);
+  } else {
+    const char* cmakeGeneratorName =
+      this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
+    const char* cmakeProjectName =
+      (this->Values[ctb_PROJECT_NAME] && *this->Values[ctb_PROJECT_NAME])
       ? this->Values[ctb_PROJECT_NAME]
       : this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
 
@@ -72,81 +65,71 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
     // CTEST_CONFIGURATION_TYPE script variable, or ctest -C command
     // line argument... in that order.
     //
-    const char* ctestBuildConfiguration
-      = this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
-    const char* cmakeBuildConfiguration
-      = (this->Values[ctb_CONFIGURATION] && *this->Values[ctb_CONFIGURATION])
+    const char* ctestBuildConfiguration =
+      this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
+    const char* cmakeBuildConfiguration =
+      (this->Values[ctb_CONFIGURATION] && *this->Values[ctb_CONFIGURATION])
       ? this->Values[ctb_CONFIGURATION]
       : ((ctestBuildConfiguration && *ctestBuildConfiguration)
-        ? ctestBuildConfiguration
-        : this->CTest->GetConfigType().c_str());
+           ? ctestBuildConfiguration
+           : this->CTest->GetConfigType().c_str());
 
-    const char* cmakeBuildAdditionalFlags
-      = (this->Values[ctb_FLAGS] && *this->Values[ctb_FLAGS])
+    const char* cmakeBuildAdditionalFlags =
+      (this->Values[ctb_FLAGS] && *this->Values[ctb_FLAGS])
       ? this->Values[ctb_FLAGS]
       : this->Makefile->GetDefinition("CTEST_BUILD_FLAGS");
-    const char* cmakeBuildTarget
-      = (this->Values[ctb_TARGET] && *this->Values[ctb_TARGET])
+    const char* cmakeBuildTarget =
+      (this->Values[ctb_TARGET] && *this->Values[ctb_TARGET])
       ? this->Values[ctb_TARGET]
       : this->Makefile->GetDefinition("CTEST_BUILD_TARGET");
 
-    if ( cmakeGeneratorName && *cmakeGeneratorName &&
-      cmakeProjectName && *cmakeProjectName )
-      {
-      if ( !cmakeBuildConfiguration )
-        {
+    if (cmakeGeneratorName && *cmakeGeneratorName && cmakeProjectName &&
+        *cmakeProjectName) {
+      if (!cmakeBuildConfiguration) {
         cmakeBuildConfiguration = "Release";
-        }
-      if ( this->GlobalGenerator )
-        {
-        if ( this->GlobalGenerator->GetName() != cmakeGeneratorName )
-          {
+      }
+      if (this->GlobalGenerator) {
+        if (this->GlobalGenerator->GetName() != cmakeGeneratorName) {
           delete this->GlobalGenerator;
           this->GlobalGenerator = 0;
-          }
         }
-      if ( !this->GlobalGenerator )
-        {
+      }
+      if (!this->GlobalGenerator) {
         this->GlobalGenerator =
           this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
             cmakeGeneratorName);
-        if(!this->GlobalGenerator)
-          {
+        if (!this->GlobalGenerator) {
           std::string e = "could not create generator named \"";
           e += cmakeGeneratorName;
           e += "\"";
           this->Makefile->IssueMessage(cmake::FATAL_ERROR, e);
           cmSystemTools::SetFatalErrorOccured();
           return 0;
-          }
         }
-      if(strlen(cmakeBuildConfiguration) == 0)
-        {
+      }
+      if (strlen(cmakeBuildConfiguration) == 0) {
         const char* config = 0;
 #ifdef CMAKE_INTDIR
         config = CMAKE_INTDIR;
 #endif
-        if(!config)
-          {
+        if (!config) {
           config = "Debug";
-          }
-        cmakeBuildConfiguration = config;
         }
+        cmakeBuildConfiguration = config;
+      }
 
       std::string dir = this->CTest->GetCTestConfiguration("BuildDirectory");
-      std::string buildCommand
-        = this->GlobalGenerator->
-        GenerateCMakeBuildCommand(cmakeBuildTarget ? cmakeBuildTarget : "",
-          cmakeBuildConfiguration,
+      std::string buildCommand =
+        this->GlobalGenerator->GenerateCMakeBuildCommand(
+          cmakeBuildTarget ? cmakeBuildTarget : "", cmakeBuildConfiguration,
           cmakeBuildAdditionalFlags ? cmakeBuildAdditionalFlags : "",
           this->Makefile->IgnoreErrorsCMP0061());
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "SetMakeCommand:" << buildCommand << "\n", this->Quiet);
+                         "SetMakeCommand:" << buildCommand << "\n",
+                         this->Quiet);
       this->CTest->SetCTestConfiguration("MakeCommand", buildCommand.c_str(),
-        this->Quiet);
-      }
-    else
-      {
+                                         this->Quiet);
+    } else {
       std::ostringstream ostr;
       /* clang-format off */
       ostr << "has no project to build. If this is a "
@@ -163,39 +146,35 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
       /* clang-format on */
       this->SetError(ostr.str());
       return 0;
-      }
     }
+  }
 
-  if(const char* useLaunchers =
-     this->Makefile->GetDefinition("CTEST_USE_LAUNCHERS"))
-    {
+  if (const char* useLaunchers =
+        this->Makefile->GetDefinition("CTEST_USE_LAUNCHERS")) {
     this->CTest->SetCTestConfiguration("UseLaunchers", useLaunchers,
-      this->Quiet);
-    }
+                                       this->Quiet);
+  }
 
   handler->SetQuiet(this->Quiet);
   return handler;
 }
 
-
 bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
-                                      cmExecutionStatus &status)
+                                      cmExecutionStatus& status)
 {
-  bool ret =  cmCTestHandlerCommand::InitialPass(args, status);
-  if ( this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS])
-    {
+  bool ret = cmCTestHandlerCommand::InitialPass(args, status);
+  if (this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS]) {
     std::ostringstream str;
     str << this->Handler->GetTotalErrors();
-    this->Makefile->AddDefinition(
-      this->Values[ctb_NUMBER_ERRORS], str.str().c_str());
-    }
-  if ( this->Values[ctb_NUMBER_WARNINGS]
-       && *this->Values[ctb_NUMBER_WARNINGS])
-    {
+    this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS],
+                                  str.str().c_str());
+  }
+  if (this->Values[ctb_NUMBER_WARNINGS] &&
+      *this->Values[ctb_NUMBER_WARNINGS]) {
     std::ostringstream str;
     str << this->Handler->GetTotalWarnings();
-    this->Makefile->AddDefinition(
-      this->Values[ctb_NUMBER_WARNINGS], str.str().c_str());
-    }
+    this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS],
+                                  str.str().c_str());
+  }
   return ret;
 }
diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h
index 2632ebc..f420c2f 100644
--- a/Source/CTest/cmCTestBuildCommand.h
+++ b/Source/CTest/cmCTestBuildCommand.h
@@ -25,7 +25,6 @@ class cmCTestBuildHandler;
 class cmCTestBuildCommand : public cmCTestHandlerCommand
 {
 public:
-
   cmCTestBuildCommand();
   ~cmCTestBuildCommand();
 
@@ -33,20 +32,20 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestBuildCommand* ni = new cmCTestBuildCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_build";}
+  virtual std::string GetName() const { return "ctest_build"; }
 
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   cmTypeMacro(cmCTestBuildCommand, cmCTestHandlerCommand);
 
@@ -54,7 +53,8 @@ public:
 
 protected:
   cmCTestBuildHandler* Handler;
-  enum {
+  enum
+  {
     ctb_BUILD = ct_LAST,
     ctb_NUMBER_ERRORS,
     ctb_NUMBER_WARNINGS,
@@ -68,5 +68,4 @@ protected:
   cmCTestGenericHandler* InitializeHandler();
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
index ed0cad7..20b0e9c 100644
--- a/Source/CTest/cmCTestBuildHandler.cxx
+++ b/Source/CTest/cmCTestBuildHandler.cxx
@@ -36,7 +36,6 @@
 #include <stdlib.h>
 #include <time.h>
 
-
 static const char* cmCTestErrorMatches[] = {
   "^[Bb]us [Ee]rror",
   "^[Ss]egmentation [Vv]iolation",
@@ -163,16 +162,15 @@ struct cmCTestBuildCompileErrorWarningRex
   int LineIndex;
 };
 
-static cmCTestBuildCompileErrorWarningRex
-cmCTestWarningErrorFileLine[] = {
-    { "^Warning W[0-9]+ ([a-zA-Z.\\:/0-9_+ ~-]+) ([0-9]+):", 1, 2 },
-    { "^([a-zA-Z./0-9_+ ~-]+):([0-9]+):", 1, 2 },
-    { "^([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
-    { "^[0-9]+>([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
-    { "^([a-zA-Z./0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
-    { "\"([a-zA-Z./0-9_+ ~-]+)\", line ([0-9]+)", 1, 2 },
-    { "File = ([a-zA-Z./0-9_+ ~-]+), Line = ([0-9]+)", 1, 2 },
-    { 0, 0, 0 }
+static cmCTestBuildCompileErrorWarningRex cmCTestWarningErrorFileLine[] = {
+  { "^Warning W[0-9]+ ([a-zA-Z.\\:/0-9_+ ~-]+) ([0-9]+):", 1, 2 },
+  { "^([a-zA-Z./0-9_+ ~-]+):([0-9]+):", 1, 2 },
+  { "^([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
+  { "^[0-9]+>([a-zA-Z.\\:/0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
+  { "^([a-zA-Z./0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 },
+  { "\"([a-zA-Z./0-9_+ ~-]+)\", line ([0-9]+)", 1, 2 },
+  { "File = ([a-zA-Z./0-9_+ ~-]+), Line = ([0-9]+)", 1, 2 },
+  { 0, 0, 0 }
 };
 
 cmCTestBuildHandler::cmCTestBuildHandler()
@@ -233,131 +231,113 @@ void cmCTestBuildHandler::Initialize()
   this->UseCTestLaunch = false;
 }
 
-void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
+void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile* mf)
 {
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",
-                             this->CustomErrorMatches);
+                                    this->CustomErrorMatches);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION",
-                             this->CustomErrorExceptions);
+                                    this->CustomErrorExceptions);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH",
-                             this->CustomWarningMatches);
+                                    this->CustomWarningMatches);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION",
-                             this->CustomWarningExceptions);
-  this->CTest->PopulateCustomInteger(mf,
-                          "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS",
-                          this->MaxErrors);
-  this->CTest->PopulateCustomInteger(mf,
-                             "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS",
-                             this->MaxWarnings);
+                                    this->CustomWarningExceptions);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS", this->MaxErrors);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS", this->MaxWarnings);
 
   int n = -1;
   this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_PRE_CONTEXT", n);
-  if (n != -1)
-    {
+  if (n != -1) {
     this->MaxPreContext = static_cast<size_t>(n);
-    }
+  }
 
   n = -1;
   this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_POST_CONTEXT", n);
-  if (n != -1)
-    {
+  if (n != -1) {
     this->MaxPostContext = static_cast<size_t>(n);
-    }
+  }
 
   // Record the user-specified custom warning rules.
-  if(const char* customWarningMatchers =
-     mf->GetDefinition("CTEST_CUSTOM_WARNING_MATCH"))
-    {
+  if (const char* customWarningMatchers =
+        mf->GetDefinition("CTEST_CUSTOM_WARNING_MATCH")) {
     cmSystemTools::ExpandListArgument(customWarningMatchers,
                                       this->ReallyCustomWarningMatches);
-    }
-  if(const char* customWarningExceptions =
-     mf->GetDefinition("CTEST_CUSTOM_WARNING_EXCEPTION"))
-    {
+  }
+  if (const char* customWarningExceptions =
+        mf->GetDefinition("CTEST_CUSTOM_WARNING_EXCEPTION")) {
     cmSystemTools::ExpandListArgument(customWarningExceptions,
                                       this->ReallyCustomWarningExceptions);
-    }
+  }
 }
 
 std::string cmCTestBuildHandler::GetMakeCommand()
 {
-  std::string makeCommand
-    = this->CTest->GetCTestConfiguration("MakeCommand");
-  cmCTestOptionalLog(this->CTest,
-    HANDLER_VERBOSE_OUTPUT, "MakeCommand:" << makeCommand << "\n",
-    this->Quiet);
+  std::string makeCommand = this->CTest->GetCTestConfiguration("MakeCommand");
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "MakeCommand:" << makeCommand << "\n", this->Quiet);
 
   std::string configType = this->CTest->GetConfigType();
-  if (configType == "")
-    {
-    configType
-      = this->CTest->GetCTestConfiguration("DefaultCTestConfigurationType");
-    }
-  if (configType == "")
-    {
+  if (configType == "") {
+    configType =
+      this->CTest->GetCTestConfiguration("DefaultCTestConfigurationType");
+  }
+  if (configType == "") {
     configType = "Release";
-    }
+  }
 
-  cmSystemTools::ReplaceString(makeCommand,
-    "${CTEST_CONFIGURATION_TYPE}", configType.c_str());
+  cmSystemTools::ReplaceString(makeCommand, "${CTEST_CONFIGURATION_TYPE}",
+                               configType.c_str());
 
   return makeCommand;
 }
 
-//clearly it would be nice if this were broken up into a few smaller
-//functions and commented...
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
 int cmCTestBuildHandler::ProcessHandler()
 {
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Build project" << std::endl,
-    this->Quiet);
+                     this->Quiet);
 
   // do we have time for this
-  if (this->CTest->GetRemainingTimeAllowed() < 120)
-    {
+  if (this->CTest->GetRemainingTimeAllowed() < 120) {
     return 0;
-    }
+  }
 
   int entry;
-  for ( entry = 0;
-    cmCTestWarningErrorFileLine[entry].RegularExpressionString;
-    ++ entry )
-    {
+  for (entry = 0; cmCTestWarningErrorFileLine[entry].RegularExpressionString;
+       ++entry) {
     cmCTestBuildHandler::cmCTestCompileErrorWarningRex r;
-    if ( r.RegularExpression.compile(
-        cmCTestWarningErrorFileLine[entry].RegularExpressionString) )
-      {
+    if (r.RegularExpression.compile(
+          cmCTestWarningErrorFileLine[entry].RegularExpressionString)) {
       r.FileIndex = cmCTestWarningErrorFileLine[entry].FileIndex;
       r.LineIndex = cmCTestWarningErrorFileLine[entry].LineIndex;
       this->ErrorWarningFileLineRegex.push_back(r);
-      }
-    else
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Problem Compiling regular expression: "
-       << cmCTestWarningErrorFileLine[entry].RegularExpressionString
-       << std::endl);
-      }
+    } else {
+      cmCTestLog(
+        this->CTest, ERROR_MESSAGE, "Problem Compiling regular expression: "
+          << cmCTestWarningErrorFileLine[entry].RegularExpressionString
+          << std::endl);
     }
+  }
 
   // Determine build command and build directory
   std::string makeCommand = this->GetMakeCommand();
-  if (makeCommand.empty())
-    {
+  if (makeCommand.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot find MakeCommand key in the DartConfiguration.tcl"
-      << std::endl);
+               "Cannot find MakeCommand key in the DartConfiguration.tcl"
+                 << std::endl);
     return -1;
-    }
+  }
 
-  const std::string &buildDirectory
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
-  if (buildDirectory.empty())
-    {
+  const std::string& buildDirectory =
+    this->CTest->GetCTestConfiguration("BuildDirectory");
+  if (buildDirectory.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
-      << std::endl);
+               "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
     return -1;
-    }
+  }
 
   std::string const& useLaunchers =
     this->CTest->GetCTestConfiguration("UseLaunchers");
@@ -366,94 +346,81 @@ int cmCTestBuildHandler::ProcessHandler()
   // Create a last build log
   cmGeneratedFileStream ofs;
   double elapsed_time_start = cmSystemTools::GetTime();
-  if ( !this->StartLogFile("Build", ofs) )
-    {
+  if (!this->StartLogFile("Build", ofs)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build log file"
-      << std::endl);
-    }
+                 << std::endl);
+  }
 
   // Create lists of regular expression strings for errors, error exceptions,
   // warnings and warning exceptions.
   std::vector<std::string>::size_type cc;
-  for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
-    {
+  for (cc = 0; cmCTestErrorMatches[cc]; cc++) {
     this->CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
-    }
-  for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
-    {
+  }
+  for (cc = 0; cmCTestErrorExceptions[cc]; cc++) {
     this->CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
-    }
-  for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
-    {
+  }
+  for (cc = 0; cmCTestWarningMatches[cc]; cc++) {
     this->CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
-    }
+  }
 
-  for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
-    {
+  for (cc = 0; cmCTestWarningExceptions[cc]; cc++) {
     this->CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
-    }
+  }
 
   // Pre-compile regular expressions objects for all regular expressions
   std::vector<std::string>::iterator it;
 
-#define cmCTestBuildHandlerPopulateRegexVector(strings, regexes) \
-  regexes.clear(); \
-    cmCTestOptionalLog(this->CTest, DEBUG, this << "Add " #regexes \
-    << std::endl, this->Quiet); \
-  for ( it = strings.begin(); it != strings.end(); ++it ) \
-    { \
-    cmCTestOptionalLog(this->CTest, DEBUG, "Add " #strings ": " \
-    << *it << std::endl, this->Quiet); \
-    regexes.push_back(it->c_str()); \
-    }
-  cmCTestBuildHandlerPopulateRegexVector(
-    this->CustomErrorMatches, this->ErrorMatchRegex);
-  cmCTestBuildHandlerPopulateRegexVector(
-    this->CustomErrorExceptions, this->ErrorExceptionRegex);
-  cmCTestBuildHandlerPopulateRegexVector(
-    this->CustomWarningMatches, this->WarningMatchRegex);
-  cmCTestBuildHandlerPopulateRegexVector(
-    this->CustomWarningExceptions, this->WarningExceptionRegex);
-
+#define cmCTestBuildHandlerPopulateRegexVector(strings, regexes)              \
+  regexes.clear();                                                            \
+  cmCTestOptionalLog(this->CTest, DEBUG,                                      \
+                     this << "Add " #regexes << std::endl, this->Quiet);      \
+  for (it = strings.begin(); it != strings.end(); ++it) {                     \
+    cmCTestOptionalLog(this->CTest, DEBUG,                                    \
+                       "Add " #strings ": " << *it << std::endl,              \
+                       this->Quiet);                                          \
+    regexes.push_back(it->c_str());                                           \
+  }
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomErrorMatches,
+                                         this->ErrorMatchRegex);
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomErrorExceptions,
+                                         this->ErrorExceptionRegex);
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomWarningMatches,
+                                         this->WarningMatchRegex);
+  cmCTestBuildHandlerPopulateRegexVector(this->CustomWarningExceptions,
+                                         this->WarningExceptionRegex);
 
   // Determine source and binary tree substitutions to simplify the output.
   this->SimplifySourceDir = "";
   this->SimplifyBuildDir = "";
-  if ( this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20 )
-    {
-    std::string srcdir
-      = this->CTest->GetCTestConfiguration("SourceDirectory") + "/";
+  if (this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20) {
+    std::string srcdir =
+      this->CTest->GetCTestConfiguration("SourceDirectory") + "/";
     std::string srcdirrep;
-    for ( cc = srcdir.size()-2; cc > 0; cc -- )
-      {
-      if ( srcdir[cc] == '/' )
-        {
+    for (cc = srcdir.size() - 2; cc > 0; cc--) {
+      if (srcdir[cc] == '/') {
         srcdirrep = srcdir.c_str() + cc;
         srcdirrep = "/..." + srcdirrep;
-        srcdir = srcdir.substr(0, cc+1);
+        srcdir = srcdir.substr(0, cc + 1);
         break;
-        }
       }
-    this->SimplifySourceDir = srcdir;
     }
-  if ( this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20 )
-    {
-    std::string bindir
-      = this->CTest->GetCTestConfiguration("BuildDirectory") + "/";
+    this->SimplifySourceDir = srcdir;
+  }
+  if (this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20) {
+    std::string bindir =
+      this->CTest->GetCTestConfiguration("BuildDirectory") + "/";
     std::string bindirrep;
-    for ( cc = bindir.size()-2; cc > 0; cc -- )
-      {
-      if ( bindir[cc] == '/' )
-        {
+    for (cc = bindir.size() - 2; cc > 0; cc--) {
+      if (bindir[cc] == '/') {
         bindirrep = bindir.c_str() + cc;
         bindirrep = "/..." + bindirrep;
-        bindir = bindir.substr(0, cc+1);
+        bindir = bindir.substr(0, cc + 1);
         break;
-        }
       }
-    this->SimplifyBuildDir = bindir;
     }
-
+    this->SimplifyBuildDir = bindir;
+  }
 
   // Ok, let's do the build
 
@@ -462,16 +429,14 @@ int cmCTestBuildHandler::ProcessHandler()
   this->StartBuildTime = cmSystemTools::GetTime();
   int retVal = 0;
   int res = cmsysProcess_State_Exited;
-  if ( !this->CTest->GetShowOnly() )
-    {
+  if (!this->CTest->GetShowOnly()) {
     res = this->RunMakeCommand(makeCommand.c_str(), &retVal,
-      buildDirectory.c_str(), 0, ofs);
-    }
-  else
-    {
-    cmCTestOptionalLog(this->CTest, DEBUG, "Build with command: " <<
-      makeCommand << std::endl, this->Quiet);
-    }
+                               buildDirectory.c_str(), 0, ofs);
+  } else {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Build with command: " << makeCommand << std::endl,
+                       this->Quiet);
+  }
 
   // Remember end build time and calculate elapsed time
   this->EndBuild = this->CTest->CurrentTime();
@@ -480,69 +445,60 @@ int cmCTestBuildHandler::ProcessHandler()
 
   // Cleanups strings in the errors and warnings list.
   t_ErrorsAndWarningsVector::iterator evit;
-  if ( !this->SimplifySourceDir.empty() )
-    {
-    for ( evit = this->ErrorsAndWarnings.begin();
-      evit != this->ErrorsAndWarnings.end();
-      ++ evit )
-      {
-      cmSystemTools::ReplaceString(
-        evit->Text, this->SimplifySourceDir.c_str(), "/.../");
-      cmSystemTools::ReplaceString(
-        evit->PreContext, this->SimplifySourceDir.c_str(), "/.../");
-      cmSystemTools::ReplaceString(
-        evit->PostContext, this->SimplifySourceDir.c_str(), "/.../");
-      }
+  if (!this->SimplifySourceDir.empty()) {
+    for (evit = this->ErrorsAndWarnings.begin();
+         evit != this->ErrorsAndWarnings.end(); ++evit) {
+      cmSystemTools::ReplaceString(evit->Text, this->SimplifySourceDir.c_str(),
+                                   "/.../");
+      cmSystemTools::ReplaceString(evit->PreContext,
+                                   this->SimplifySourceDir.c_str(), "/.../");
+      cmSystemTools::ReplaceString(evit->PostContext,
+                                   this->SimplifySourceDir.c_str(), "/.../");
     }
-
-  if ( !this->SimplifyBuildDir.empty() )
-    {
-    for ( evit = this->ErrorsAndWarnings.begin();
-      evit != this->ErrorsAndWarnings.end();
-      ++ evit )
-      {
-      cmSystemTools::ReplaceString(
-        evit->Text, this->SimplifyBuildDir.c_str(), "/.../");
-      cmSystemTools::ReplaceString(
-        evit->PreContext, this->SimplifyBuildDir.c_str(), "/.../");
-      cmSystemTools::ReplaceString(
-        evit->PostContext, this->SimplifyBuildDir.c_str(), "/.../");
-      }
+  }
+
+  if (!this->SimplifyBuildDir.empty()) {
+    for (evit = this->ErrorsAndWarnings.begin();
+         evit != this->ErrorsAndWarnings.end(); ++evit) {
+      cmSystemTools::ReplaceString(evit->Text, this->SimplifyBuildDir.c_str(),
+                                   "/.../");
+      cmSystemTools::ReplaceString(evit->PreContext,
+                                   this->SimplifyBuildDir.c_str(), "/.../");
+      cmSystemTools::ReplaceString(evit->PostContext,
+                                   this->SimplifyBuildDir.c_str(), "/.../");
     }
+  }
 
   // Generate XML output
   cmGeneratedFileStream xofs;
-  if(!this->StartResultingXML(cmCTest::PartBuild, "Build", xofs))
-    {
+  if (!this->StartResultingXML(cmCTest::PartBuild, "Build", xofs)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create build XML file"
-      << std::endl);
+                 << std::endl);
     return -1;
-    }
+  }
   cmXMLWriter xml(xofs);
   this->GenerateXMLHeader(xml);
-  if(this->UseCTestLaunch)
-    {
+  if (this->UseCTestLaunch) {
     this->GenerateXMLLaunched(xml);
-    }
-  else
-    {
+  } else {
     this->GenerateXMLLogScraped(xml);
-    }
+  }
   this->GenerateXMLFooter(xml, elapsed_build_time);
 
-  if (res != cmsysProcess_State_Exited || retVal || this->TotalErrors > 0)
-    {
+  if (res != cmsysProcess_State_Exited || retVal || this->TotalErrors > 0) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Error(s) when building project"
-      << std::endl);
-    }
+                 << std::endl);
+  }
 
   // Display message about number of errors and warnings
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalErrors
-    << (this->TotalErrors >= this->MaxErrors ? " or more" : "")
-    << " Compiler errors" << std::endl);
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   " << this->TotalWarnings
-    << (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
-    << " Compiler warnings" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   "
+               << this->TotalErrors
+               << (this->TotalErrors >= this->MaxErrors ? " or more" : "")
+               << " Compiler errors" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, "   "
+               << this->TotalWarnings
+               << (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")
+               << " Compiler warnings" << std::endl);
 
   return retVal;
 }
@@ -553,40 +509,43 @@ void cmCTestBuildHandler::GenerateXMLHeader(cmXMLWriter& xml)
   xml.StartElement("Build");
   xml.Element("StartDateTime", this->StartBuild);
   xml.Element("StartBuildTime",
-    static_cast<unsigned int>(this->StartBuildTime));
+              static_cast<unsigned int>(this->StartBuildTime));
   xml.Element("BuildCommand", this->GetMakeCommand());
 }
 
 class cmCTestBuildHandler::FragmentCompare
 {
 public:
-  FragmentCompare(cmFileTimeComparison* ftc): FTC(ftc) {}
-  FragmentCompare(): FTC(0) {}
+  FragmentCompare(cmFileTimeComparison* ftc)
+    : FTC(ftc)
+  {
+  }
+  FragmentCompare()
+    : FTC(0)
+  {
+  }
   bool operator()(std::string const& l, std::string const& r)
-    {
+  {
     // Order files by modification time.  Use lexicographic order
     // among files with the same time.
     int result;
-    if(this->FTC->FileTimeCompare(l.c_str(), r.c_str(), &result) &&
-       result != 0)
-      {
+    if (this->FTC->FileTimeCompare(l.c_str(), r.c_str(), &result) &&
+        result != 0) {
       return result < 0;
-      }
-    else
-      {
+    } else {
       return l < r;
-      }
     }
+  }
+
 private:
   cmFileTimeComparison* FTC;
 };
 
 void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml)
 {
-  if(this->CTestLaunchDir.empty())
-    {
+  if (this->CTestLaunchDir.empty()) {
     return;
-    }
+  }
 
   // Sort XML fragments in chronological order.
   cmFileTimeComparison ftc;
@@ -601,29 +560,24 @@ void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml)
   cmsys::Directory launchDir;
   launchDir.Load(this->CTestLaunchDir);
   unsigned long n = launchDir.GetNumberOfFiles();
-  for(unsigned long i=0; i < n; ++i)
-    {
+  for (unsigned long i = 0; i < n; ++i) {
     const char* fname = launchDir.GetFile(i);
-    if(this->IsLaunchedErrorFile(fname) && numErrorsAllowed)
-      {
+    if (this->IsLaunchedErrorFile(fname) && numErrorsAllowed) {
       numErrorsAllowed--;
       fragments.insert(this->CTestLaunchDir + "/" + fname);
       ++this->TotalErrors;
-      }
-    else if(this->IsLaunchedWarningFile(fname) && numWarningsAllowed)
-      {
+    } else if (this->IsLaunchedWarningFile(fname) && numWarningsAllowed) {
       numWarningsAllowed--;
       fragments.insert(this->CTestLaunchDir + "/" + fname);
       ++this->TotalWarnings;
-      }
     }
+  }
 
   // Copy the fragments into the final XML file.
-  for(Fragments::const_iterator fi = fragments.begin();
-      fi != fragments.end(); ++fi)
-    {
+  for (Fragments::const_iterator fi = fragments.begin(); fi != fragments.end();
+       ++fi) {
     xml.FragmentFile(fi->c_str());
-    }
+  }
 }
 
 void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml)
@@ -639,87 +593,69 @@ void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml)
   // via a call to collapse full path.
   srcdir = cmSystemTools::CollapseFullPath(srcdir);
   srcdir += "/";
-  for ( it = ew.begin();
-        it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++ )
-    {
-    cmCTestBuildErrorWarning *cm = &(*it);
+  for (it = ew.begin();
+       it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++) {
+    cmCTestBuildErrorWarning* cm = &(*it);
     if ((cm->Error && numErrorsAllowed) ||
-        (!cm->Error && numWarningsAllowed))
-      {
-      if (cm->Error)
-        {
+        (!cm->Error && numWarningsAllowed)) {
+      if (cm->Error) {
         numErrorsAllowed--;
-        }
-      else
-        {
+      } else {
         numWarningsAllowed--;
-        }
+      }
       xml.StartElement(cm->Error ? "Error" : "Warning");
       xml.Element("BuildLogLine", cm->LogLine);
       xml.Element("Text", cm->Text);
       std::vector<cmCTestCompileErrorWarningRex>::iterator rit;
-      for ( rit = this->ErrorWarningFileLineRegex.begin();
-            rit != this->ErrorWarningFileLineRegex.end(); ++ rit )
-        {
+      for (rit = this->ErrorWarningFileLineRegex.begin();
+           rit != this->ErrorWarningFileLineRegex.end(); ++rit) {
         cmsys::RegularExpression* re = &rit->RegularExpression;
-        if ( re->find(cm->Text.c_str() ) )
-          {
+        if (re->find(cm->Text.c_str())) {
           cm->SourceFile = re->match(rit->FileIndex);
           // At this point we need to make this->SourceFile relative to
           // the source root of the project, so cvs links will work
           cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);
-          if(cm->SourceFile.find("/.../") != cm->SourceFile.npos)
-            {
+          if (cm->SourceFile.find("/.../") != cm->SourceFile.npos) {
             cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");
             std::string::size_type p = cm->SourceFile.find("/");
-            if(p != cm->SourceFile.npos)
-              {
-              cm->SourceFile = cm->SourceFile.substr(
-                p+1, cm->SourceFile.size()-p);
-              }
+            if (p != cm->SourceFile.npos) {
+              cm->SourceFile =
+                cm->SourceFile.substr(p + 1, cm->SourceFile.size() - p);
             }
-          else
-            {
+          } else {
             // make sure it is a full path with the correct case
-            cm->SourceFile = cmSystemTools::CollapseFullPath(
-              cm->SourceFile);
-            cmSystemTools::ReplaceString(
-              cm->SourceFile, srcdir.c_str(), "");
-            }
+            cm->SourceFile = cmSystemTools::CollapseFullPath(cm->SourceFile);
+            cmSystemTools::ReplaceString(cm->SourceFile, srcdir.c_str(), "");
+          }
           cm->LineNumber = atoi(re->match(rit->LineIndex).c_str());
           break;
-          }
         }
-      if ( !cm->SourceFile.empty() && cm->LineNumber >= 0 )
-        {
-        if (!cm->SourceFile.empty())
-          {
+      }
+      if (!cm->SourceFile.empty() && cm->LineNumber >= 0) {
+        if (!cm->SourceFile.empty()) {
           xml.Element("SourceFile", cm->SourceFile);
-          }
-        if (!cm->SourceFileTail.empty())
-          {
+        }
+        if (!cm->SourceFileTail.empty()) {
           xml.Element("SourceFileTail", cm->SourceFileTail);
-          }
-        if ( cm->LineNumber >= 0 )
-          {
+        }
+        if (cm->LineNumber >= 0) {
           xml.Element("SourceLineNumber", cm->LineNumber);
-          }
         }
+      }
       xml.Element("PreContext", cm->PreContext);
       xml.StartElement("PostContext");
       xml.Content(cm->PostContext);
       // is this the last warning or error, if so notify
       if ((cm->Error && !numErrorsAllowed) ||
-          (!cm->Error && !numWarningsAllowed))
-        {
+          (!cm->Error && !numWarningsAllowed)) {
         xml.Content("\nThe maximum number of reported warnings or errors "
-          "has been reached!!!\n");
-        }
+                    "has been reached!!!\n");
+      }
       xml.EndElement(); // PostContext
       xml.Element("RepeatCount", "0");
       xml.EndElement(); // "Error" / "Warning"
-      }
     }
+  }
 }
 
 void cmCTestBuildHandler::GenerateXMLFooter(cmXMLWriter& xml,
@@ -732,7 +668,8 @@ void cmCTestBuildHandler::GenerateXMLFooter(cmXMLWriter& xml,
 
   xml.Element("EndDateTime", this->EndBuild);
   xml.Element("EndBuildTime", static_cast<unsigned int>(this->EndBuildTime));
-  xml.Element("ElapsedMinutes", static_cast<int>(elapsed_build_time/6)/10.0);
+  xml.Element("ElapsedMinutes",
+              static_cast<int>(elapsed_build_time / 6) / 10.0);
   xml.EndElement(); // Build
   this->CTest->EndXML(xml);
 }
@@ -741,14 +678,14 @@ bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname)
 {
   // error-{hash}.xml
   return (cmHasLiteralPrefix(fname, "error-") &&
-          strcmp(fname+strlen(fname)-4, ".xml") == 0);
+          strcmp(fname + strlen(fname) - 4, ".xml") == 0);
 }
 
 bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname)
 {
   // warning-{hash}.xml
   return (cmHasLiteralPrefix(fname, "warning-") &&
-          strcmp(fname+strlen(fname)-4, ".xml") == 0);
+          strcmp(fname + strlen(fname) - 4, ".xml") == 0);
 }
 
 //######################################################################
@@ -761,6 +698,7 @@ class cmCTestBuildHandler::LaunchHelper
 public:
   LaunchHelper(cmCTestBuildHandler* handler);
   ~LaunchHelper();
+
 private:
   cmCTestBuildHandler* Handler;
   cmCTest* CTest;
@@ -770,18 +708,16 @@ private:
                            std::vector<std::string> const& matchers);
 };
 
-cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler):
-  Handler(handler), CTest(handler->CTest)
+cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler)
+  : Handler(handler)
+  , CTest(handler->CTest)
 {
   std::string tag = this->CTest->GetCurrentTag();
-  if(tag.empty())
-    {
+  if (tag.empty()) {
     // This is not for a dashboard submission, so there is no XML.
     // Skip enabling the launchers.
     this->Handler->UseCTestLaunch = false;
-    }
-  else
-    {
+  } else {
     // Compute a directory in which to store launcher fragments.
     std::string& launchDir = this->Handler->CTestLaunchDir;
     launchDir = this->CTest->GetBinaryDir();
@@ -792,30 +728,27 @@ cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler):
     // Clean out any existing launcher fragments.
     cmSystemTools::RemoveADirectory(launchDir);
 
-    if(this->Handler->UseCTestLaunch)
-      {
+    if (this->Handler->UseCTestLaunch) {
       // Enable launcher fragments.
       cmSystemTools::MakeDirectory(launchDir.c_str());
       this->WriteLauncherConfig();
       std::string launchEnv = "CTEST_LAUNCH_LOGS=";
       launchEnv += launchDir;
       cmSystemTools::PutEnv(launchEnv);
-      }
     }
+  }
 
   // If not using launchers, make sure they passthru.
-  if(!this->Handler->UseCTestLaunch)
-    {
+  if (!this->Handler->UseCTestLaunch) {
     cmSystemTools::UnsetEnv("CTEST_LAUNCH_LOGS");
-    }
+  }
 }
 
 cmCTestBuildHandler::LaunchHelper::~LaunchHelper()
 {
-  if(this->Handler->UseCTestLaunch)
-    {
+  if (this->Handler->UseCTestLaunch) {
     cmSystemTools::UnsetEnv("CTEST_LAUNCH_LOGS");
-    }
+  }
 }
 
 void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig()
@@ -833,56 +766,50 @@ void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig()
   fout << "set(CTEST_SOURCE_DIRECTORY \"" << srcdir << "\")\n";
 }
 
-void
-cmCTestBuildHandler::LaunchHelper
-::WriteScrapeMatchers(const char* purpose,
-                      std::vector<std::string> const& matchers)
+void cmCTestBuildHandler::LaunchHelper::WriteScrapeMatchers(
+  const char* purpose, std::vector<std::string> const& matchers)
 {
-  if(matchers.empty())
-    {
+  if (matchers.empty()) {
     return;
-    }
+  }
   std::string fname = this->Handler->CTestLaunchDir;
   fname += "/Custom";
   fname += purpose;
   fname += ".txt";
   cmGeneratedFileStream fout(fname.c_str());
-  for(std::vector<std::string>::const_iterator mi = matchers.begin();
-      mi != matchers.end(); ++mi)
-    {
+  for (std::vector<std::string>::const_iterator mi = matchers.begin();
+       mi != matchers.end(); ++mi) {
     fout << *mi << "\n";
-    }
+  }
 }
 
-int cmCTestBuildHandler::RunMakeCommand(const char* command,
-  int* retVal, const char* dir, int timeout, std::ostream& ofs)
+int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal,
+                                        const char* dir, int timeout,
+                                        std::ostream& ofs)
 {
   // First generate the command and arguments
   std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     return false;
-    }
+  }
 
   std::vector<const char*> argv;
-  for(std::vector<std::string>::const_iterator a = args.begin();
-    a != args.end(); ++a)
-    {
+  for (std::vector<std::string>::const_iterator a = args.begin();
+       a != args.end(); ++a) {
     argv.push_back(a->c_str());
-    }
+  }
   argv.push_back(0);
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:",
-    this->Quiet);
+                     this->Quiet);
   std::vector<const char*>::iterator ait;
-  for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " \"" << *ait <<
-      "\"", this->Quiet);
-    }
+  for (ait = argv.begin(); ait != argv.end() && *ait; ++ait) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       " \"" << *ait << "\"", this->Quiet);
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
-    this->Quiet);
+                     this->Quiet);
 
   // Optionally use make rule launchers to record errors and warnings.
   LaunchHelper launchHelper(this);
@@ -902,12 +829,14 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
 
   char* data;
   int length;
-  cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT,
-    "   Each symbol represents " << tick_len << " bytes of output."
-    << std::endl
-    << (this->UseCTestLaunch? "" :
-        "   '!' represents an error and '*' a warning.\n")
-    << "    " << std::flush, this->Quiet);
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_PROGRESS_OUTPUT, "   Each symbol represents "
+      << tick_len << " bytes of output." << std::endl
+      << (this->UseCTestLaunch
+            ? ""
+            : "   '!' represents an error and '*' a warning.\n")
+      << "    " << std::flush,
+    this->Quiet);
 
   // Initialize building structures
   this->BuildProcessingQueue.clear();
@@ -922,96 +851,84 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
 
   // For every chunk of data
   int res;
-  while((res = cmsysProcess_WaitForData(cp, &data, &length, 0)))
-    {
+  while ((res = cmsysProcess_WaitForData(cp, &data, &length, 0))) {
     // Replace '\0' with '\n', since '\0' does not really make sense. This is
     // for Visual Studio output
-    for(int cc =0; cc < length; ++cc)
-      {
-      if(data[cc] == 0)
-        {
+    for (int cc = 0; cc < length; ++cc) {
+      if (data[cc] == 0) {
         data[cc] = '\n';
-        }
       }
+    }
 
     // Process the chunk of data
-    if ( res == cmsysProcess_Pipe_STDERR )
-      {
+    if (res == cmsysProcess_Pipe_STDERR) {
       this->ProcessBuffer(data, length, tick, tick_len, ofs,
-        &this->BuildProcessingErrorQueue);
-      }
-    else
-      {
+                          &this->BuildProcessingErrorQueue);
+    } else {
       this->ProcessBuffer(data, length, tick, tick_len, ofs,
-        &this->BuildProcessingQueue);
-      }
+                          &this->BuildProcessingQueue);
     }
+  }
 
   this->ProcessBuffer(0, 0, tick, tick_len, ofs, &this->BuildProcessingQueue);
   this->ProcessBuffer(0, 0, tick, tick_len, ofs,
-    &this->BuildProcessingErrorQueue);
+                      &this->BuildProcessingErrorQueue);
   cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, " Size of output: "
-    << ((this->BuildOutputLogSize + 512) / 1024) << "K" << std::endl,
-    this->Quiet);
+                       << ((this->BuildOutputLogSize + 512) / 1024) << "K"
+                       << std::endl,
+                     this->Quiet);
 
   // Properly handle output of the build command
   cmsysProcess_WaitForExit(cp, 0);
   int result = cmsysProcess_GetState(cp);
 
-  if(result == cmsysProcess_State_Exited)
-    {
-    if (retVal)
-      {
+  if (result == cmsysProcess_State_Exited) {
+    if (retVal) {
       *retVal = cmsysProcess_GetExitValue(cp);
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Command exited with the value: " << *retVal << std::endl, this->Quiet);
+                         "Command exited with the value: " << *retVal
+                                                           << std::endl,
+                         this->Quiet);
       // if a non zero return value
-      if (*retVal)
-        {
+      if (*retVal) {
         // If there was an error running command, report that on the
         // dashboard.
         cmCTestBuildErrorWarning errorwarning;
-        errorwarning.LogLine     = 1;
-        errorwarning.Text
-          = "*** WARNING non-zero return value in ctest from: ";
-        errorwarning.Text        += argv[0];
-        errorwarning.PreContext  = "";
+        errorwarning.LogLine = 1;
+        errorwarning.Text =
+          "*** WARNING non-zero return value in ctest from: ";
+        errorwarning.Text += argv[0];
+        errorwarning.PreContext = "";
         errorwarning.PostContext = "";
-        errorwarning.Error       = false;
+        errorwarning.Error = false;
         this->ErrorsAndWarnings.push_back(errorwarning);
-        this->TotalWarnings ++;
-        }
+        this->TotalWarnings++;
       }
     }
-  else if(result == cmsysProcess_State_Exception)
-    {
-    if (retVal)
-      {
+  } else if (result == cmsysProcess_State_Exception) {
+    if (retVal) {
       *retVal = cmsysProcess_GetExitException(cp);
-      cmCTestOptionalLog(this->CTest, WARNING, "There was an exception: " <<
-        *retVal << std::endl, this->Quiet);
-      }
+      cmCTestOptionalLog(this->CTest, WARNING,
+                         "There was an exception: " << *retVal << std::endl,
+                         this->Quiet);
     }
-  else if(result == cmsysProcess_State_Expired)
-    {
-    cmCTestOptionalLog(this->CTest, WARNING, "There was a timeout" <<
-      std::endl, this->Quiet);
-    }
-  else if(result == cmsysProcess_State_Error)
-    {
+  } else if (result == cmsysProcess_State_Expired) {
+    cmCTestOptionalLog(this->CTest, WARNING,
+                       "There was a timeout" << std::endl, this->Quiet);
+  } else if (result == cmsysProcess_State_Error) {
     // If there was an error running command, report that on the dashboard.
     cmCTestBuildErrorWarning errorwarning;
-    errorwarning.LogLine     = 1;
-    errorwarning.Text        = "*** ERROR executing: ";
-    errorwarning.Text        += cmsysProcess_GetErrorString(cp);
-    errorwarning.PreContext  = "";
+    errorwarning.LogLine = 1;
+    errorwarning.Text = "*** ERROR executing: ";
+    errorwarning.Text += cmsysProcess_GetErrorString(cp);
+    errorwarning.PreContext = "";
     errorwarning.PostContext = "";
-    errorwarning.Error       = true;
+    errorwarning.Error = true;
     this->ErrorsAndWarnings.push_back(errorwarning);
-    this->TotalErrors ++;
+    this->TotalErrors++;
     cmCTestLog(this->CTest, ERROR_MESSAGE, "There was an error: "
-      << cmsysProcess_GetErrorString(cp) << std::endl);
-    }
+                 << cmsysProcess_GetErrorString(cp) << std::endl);
+  }
 
   cmsysProcess_Delete(cp);
   return result;
@@ -1023,46 +940,38 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command,
 //######################################################################
 
 void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
-  size_t& tick, size_t tick_len, std::ostream& ofs,
-  t_BuildProcessingQueueType* queue)
+                                        size_t& tick, size_t tick_len,
+                                        std::ostream& ofs,
+                                        t_BuildProcessingQueueType* queue)
 {
   const std::string::size_type tick_line_len = 50;
   const char* ptr;
-  for ( ptr = data; ptr < data+length; ptr ++ )
-    {
+  for (ptr = data; ptr < data + length; ptr++) {
     queue->push_back(*ptr);
-    }
+  }
   this->BuildOutputLogSize += length;
 
   // until there are any lines left in the buffer
-  while ( 1 )
-    {
+  while (1) {
     // Find the end of line
     t_BuildProcessingQueueType::iterator it;
-    for ( it = queue->begin();
-      it != queue->end();
-      ++ it )
-      {
-      if ( *it == '\n' )
-        {
+    for (it = queue->begin(); it != queue->end(); ++it) {
+      if (*it == '\n') {
         break;
-        }
       }
+    }
 
     // Once certain number of errors or warnings reached, ignore future errors
     // or warnings.
-    if ( this->TotalWarnings >= this->MaxWarnings )
-      {
+    if (this->TotalWarnings >= this->MaxWarnings) {
       this->WarningQuotaReached = true;
-      }
-    if ( this->TotalErrors >= this->MaxErrors )
-      {
+    }
+    if (this->TotalErrors >= this->MaxErrors) {
       this->ErrorQuotaReached = true;
-      }
+    }
 
     // If the end of line was found
-    if ( it != queue->end() )
-      {
+    if (it != queue->end()) {
       // Create a contiguous array for the line
       this->CurrentProcessingLine.clear();
       this->CurrentProcessingLine.insert(this->CurrentProcessingLine.end(),
@@ -1074,106 +983,93 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
       int lineType = this->ProcessSingleLine(line);
 
       // Erase the line from the queue
-      queue->erase(queue->begin(), it+1);
+      queue->erase(queue->begin(), it + 1);
 
       // Depending on the line type, produce error or warning, or nothing
       cmCTestBuildErrorWarning errorwarning;
       bool found = false;
-      switch ( lineType )
-        {
-      case b_WARNING_LINE:
-        this->LastTickChar = '*';
-        errorwarning.Error = false;
-        found = true;
-        this->TotalWarnings ++;
-        break;
-      case b_ERROR_LINE:
-        this->LastTickChar = '!';
-        errorwarning.Error = true;
-        found = true;
-        this->TotalErrors ++;
-        break;
-        }
-      if ( found )
-        {
+      switch (lineType) {
+        case b_WARNING_LINE:
+          this->LastTickChar = '*';
+          errorwarning.Error = false;
+          found = true;
+          this->TotalWarnings++;
+          break;
+        case b_ERROR_LINE:
+          this->LastTickChar = '!';
+          errorwarning.Error = true;
+          found = true;
+          this->TotalErrors++;
+          break;
+      }
+      if (found) {
         // This is an error or warning, so generate report
-        errorwarning.LogLine   = static_cast<int>(this->OutputLineCounter+1);
-        errorwarning.Text        = line;
-        errorwarning.PreContext  = "";
+        errorwarning.LogLine = static_cast<int>(this->OutputLineCounter + 1);
+        errorwarning.Text = line;
+        errorwarning.PreContext = "";
         errorwarning.PostContext = "";
 
         // Copy pre-context to report
         std::deque<std::string>::iterator pcit;
-        for ( pcit = this->PreContext.begin();
-          pcit != this->PreContext.end();
-          ++pcit )
-          {
+        for (pcit = this->PreContext.begin(); pcit != this->PreContext.end();
+             ++pcit) {
           errorwarning.PreContext += *pcit + "\n";
-          }
+        }
         this->PreContext.clear();
 
         // Store report
         this->ErrorsAndWarnings.push_back(errorwarning);
-        this->LastErrorOrWarning = this->ErrorsAndWarnings.end()-1;
+        this->LastErrorOrWarning = this->ErrorsAndWarnings.end() - 1;
         this->PostContextCount = 0;
-        }
-      else
-        {
+      } else {
         // This is not an error or warning.
         // So, figure out if this is a post-context line
-        if ( !this->ErrorsAndWarnings.empty() &&
-             this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
-             this->PostContextCount < this->MaxPostContext )
-          {
-          this->PostContextCount ++;
+        if (!this->ErrorsAndWarnings.empty() &&
+            this->LastErrorOrWarning != this->ErrorsAndWarnings.end() &&
+            this->PostContextCount < this->MaxPostContext) {
+          this->PostContextCount++;
           this->LastErrorOrWarning->PostContext += line;
-          if ( this->PostContextCount < this->MaxPostContext )
-            {
+          if (this->PostContextCount < this->MaxPostContext) {
             this->LastErrorOrWarning->PostContext += "\n";
-            }
           }
-        else
-          {
+        } else {
           // Otherwise store pre-context for the next error
           this->PreContext.push_back(line);
-          if ( this->PreContext.size() > this->MaxPreContext )
-            {
+          if (this->PreContext.size() > this->MaxPreContext) {
             this->PreContext.erase(this->PreContext.begin(),
-              this->PreContext.end()-this->MaxPreContext);
-            }
+                                   this->PreContext.end() -
+                                     this->MaxPreContext);
           }
         }
-      this->OutputLineCounter ++;
       }
-    else
-      {
+      this->OutputLineCounter++;
+    } else {
       break;
-      }
     }
+  }
 
   // Now that the buffer is processed, display missing ticks
   int tickDisplayed = false;
-  while ( this->BuildOutputLogSize > (tick * tick_len) )
-    {
-    tick ++;
+  while (this->BuildOutputLogSize > (tick * tick_len)) {
+    tick++;
     cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT,
-      this->LastTickChar, this->Quiet);
+                       this->LastTickChar, this->Quiet);
     tickDisplayed = true;
-    if ( tick % tick_line_len == 0 && tick > 0 )
-      {
+    if (tick % tick_line_len == 0 && tick > 0) {
       cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, "  Size: "
-        << ((this->BuildOutputLogSize + 512) / 1024) << "K" << std::endl
-        << "    ", this->Quiet);
-      }
+                           << ((this->BuildOutputLogSize + 512) / 1024) << "K"
+                           << std::endl
+                           << "    ",
+                         this->Quiet);
     }
-  if ( tickDisplayed )
-    {
+  }
+  if (tickDisplayed) {
     this->LastTickChar = '.';
-    }
+  }
 
   // And if this is verbose output, display the content of the chunk
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    cmCTestLogWrite(data, length));
+             cmCTestLogWrite(data, length));
 
   // Always store the chunk to the file
   ofs << cmCTestLogWrite(data, length);
@@ -1181,14 +1077,13 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length,
 
 int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 {
-  if(this->UseCTestLaunch)
-    {
+  if (this->UseCTestLaunch) {
     // No log scraping when using launchers.
     return b_REGULAR_LINE;
-    }
+  }
 
-  cmCTestOptionalLog(this->CTest, DEBUG, "Line: [" << data << "]" <<
-    std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG, "Line: [" << data << "]" << std::endl,
+                     this->Quiet);
 
   std::vector<cmsys::RegularExpression>::iterator it;
 
@@ -1197,86 +1092,76 @@ int cmCTestBuildHandler::ProcessSingleLine(const char* data)
 
   // Check for regular expressions
 
-  if ( !this->ErrorQuotaReached )
-    {
+  if (!this->ErrorQuotaReached) {
     // Errors
     int wrxCnt = 0;
-    for ( it = this->ErrorMatchRegex.begin();
-      it != this->ErrorMatchRegex.end();
-      ++ it )
-      {
-      if ( it->find(data) )
-        {
+    for (it = this->ErrorMatchRegex.begin(); it != this->ErrorMatchRegex.end();
+         ++it) {
+      if (it->find(data)) {
         errorLine = 1;
-        cmCTestOptionalLog(this->CTest, DEBUG, "  Error Line: " << data
-          << " (matches: " << this->CustomErrorMatches[wrxCnt] << ")"
-          << std::endl, this->Quiet);
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "  Error Line: " << data << " (matches: "
+                                            << this->CustomErrorMatches[wrxCnt]
+                                            << ")" << std::endl,
+                           this->Quiet);
         break;
-        }
-      wrxCnt ++;
       }
+      wrxCnt++;
+    }
     // Error exceptions
     wrxCnt = 0;
-    for ( it = this->ErrorExceptionRegex.begin();
-      it != this->ErrorExceptionRegex.end();
-      ++ it )
-      {
-      if ( it->find(data) )
-        {
+    for (it = this->ErrorExceptionRegex.begin();
+         it != this->ErrorExceptionRegex.end(); ++it) {
+      if (it->find(data)) {
         errorLine = 0;
-        cmCTestOptionalLog(this->CTest, DEBUG, "  Not an error Line: " << data
-          << " (matches: " << this->CustomErrorExceptions[wrxCnt] << ")"
-          << std::endl, this->Quiet);
+        cmCTestOptionalLog(this->CTest, DEBUG, "  Not an error Line: "
+                             << data << " (matches: "
+                             << this->CustomErrorExceptions[wrxCnt] << ")"
+                             << std::endl,
+                           this->Quiet);
         break;
-        }
-      wrxCnt ++;
       }
+      wrxCnt++;
     }
-  if ( !this->WarningQuotaReached )
-    {
+  }
+  if (!this->WarningQuotaReached) {
     // Warnings
     int wrxCnt = 0;
-    for ( it = this->WarningMatchRegex.begin();
-      it != this->WarningMatchRegex.end();
-      ++ it )
-      {
-      if ( it->find(data) )
-        {
+    for (it = this->WarningMatchRegex.begin();
+         it != this->WarningMatchRegex.end(); ++it) {
+      if (it->find(data)) {
         warningLine = 1;
-        cmCTestOptionalLog(this->CTest, DEBUG,
-          "  Warning Line: " << data
-          << " (matches: " << this->CustomWarningMatches[wrxCnt] << ")"
-          << std::endl, this->Quiet);
+        cmCTestOptionalLog(this->CTest, DEBUG, "  Warning Line: "
+                             << data << " (matches: "
+                             << this->CustomWarningMatches[wrxCnt] << ")"
+                             << std::endl,
+                           this->Quiet);
         break;
-        }
-      wrxCnt ++;
       }
+      wrxCnt++;
+    }
 
     wrxCnt = 0;
     // Warning exceptions
-    for ( it = this->WarningExceptionRegex.begin();
-      it != this->WarningExceptionRegex.end();
-      ++ it )
-      {
-      if ( it->find(data) )
-        {
+    for (it = this->WarningExceptionRegex.begin();
+         it != this->WarningExceptionRegex.end(); ++it) {
+      if (it->find(data)) {
         warningLine = 0;
-        cmCTestOptionalLog(this->CTest, DEBUG, "  Not a warning Line: " << data
-          << " (matches: " << this->CustomWarningExceptions[wrxCnt] << ")"
-          << std::endl, this->Quiet);
+        cmCTestOptionalLog(this->CTest, DEBUG, "  Not a warning Line: "
+                             << data << " (matches: "
+                             << this->CustomWarningExceptions[wrxCnt] << ")"
+                             << std::endl,
+                           this->Quiet);
         break;
-        }
-      wrxCnt ++;
       }
+      wrxCnt++;
     }
-  if ( errorLine )
-    {
+  }
+  if (errorLine) {
     return b_ERROR_LINE;
-    }
-  if ( warningLine )
-    {
+  }
+  if (warningLine) {
     return b_WARNING_LINE;
-    }
+  }
   return b_REGULAR_LINE;
 }
-
diff --git a/Source/CTest/cmCTestBuildHandler.h b/Source/CTest/cmCTestBuildHandler.h
index 9231170..48a37b7 100644
--- a/Source/CTest/cmCTestBuildHandler.h
+++ b/Source/CTest/cmCTestBuildHandler.h
@@ -40,48 +40,48 @@ public:
 
   cmCTestBuildHandler();
 
-  void PopulateCustomVectors(cmMakefile *mf);
+  void PopulateCustomVectors(cmMakefile* mf);
 
   /**
    * Initialize handler
    */
   virtual void Initialize();
 
-  int GetTotalErrors() { return this->TotalErrors;}
-  int GetTotalWarnings() { return this->TotalWarnings;}
+  int GetTotalErrors() { return this->TotalErrors; }
+  int GetTotalWarnings() { return this->TotalWarnings; }
 
 private:
   std::string GetMakeCommand();
 
   //! Run command specialized for make and configure. Returns process status
   // and retVal is return value or exception.
-  int RunMakeCommand(const char* command,
-    int* retVal, const char* dir, int timeout,
-    std::ostream& ofs);
+  int RunMakeCommand(const char* command, int* retVal, const char* dir,
+                     int timeout, std::ostream& ofs);
 
-  enum {
+  enum
+  {
     b_REGULAR_LINE,
     b_WARNING_LINE,
     b_ERROR_LINE
   };
 
   class cmCTestCompileErrorWarningRex
-    {
+  {
   public:
     cmCTestCompileErrorWarningRex() {}
     int FileIndex;
     int LineIndex;
     cmsys::RegularExpression RegularExpression;
-    };
+  };
 
   struct cmCTestBuildErrorWarning
   {
-    bool        Error;
-    int         LogLine;
+    bool Error;
+    int LogLine;
     std::string Text;
     std::string SourceFile;
     std::string SourceFileTail;
-    int         LineNumber;
+    int LineNumber;
     std::string PreContext;
     std::string PostContext;
   };
@@ -94,10 +94,10 @@ private:
   bool IsLaunchedErrorFile(const char* fname);
   bool IsLaunchedWarningFile(const char* fname);
 
-  std::string             StartBuild;
-  std::string             EndBuild;
-  double                  StartBuildTime;
-  double                  EndBuildTime;
+  std::string StartBuild;
+  std::string EndBuild;
+  double StartBuildTime;
+  double EndBuildTime;
 
   std::vector<std::string> CustomErrorMatches;
   std::vector<std::string> CustomErrorExceptions;
@@ -115,34 +115,35 @@ private:
   typedef std::deque<char> t_BuildProcessingQueueType;
 
   void ProcessBuffer(const char* data, int length, size_t& tick,
-    size_t tick_len, std::ostream& ofs, t_BuildProcessingQueueType* queue);
+                     size_t tick_len, std::ostream& ofs,
+                     t_BuildProcessingQueueType* queue);
   int ProcessSingleLine(const char* data);
 
-  t_BuildProcessingQueueType            BuildProcessingQueue;
-  t_BuildProcessingQueueType            BuildProcessingErrorQueue;
-  size_t                                BuildOutputLogSize;
-  std::vector<char>                     CurrentProcessingLine;
+  t_BuildProcessingQueueType BuildProcessingQueue;
+  t_BuildProcessingQueueType BuildProcessingErrorQueue;
+  size_t BuildOutputLogSize;
+  std::vector<char> CurrentProcessingLine;
 
-  std::string                           SimplifySourceDir;
-  std::string                           SimplifyBuildDir;
-  size_t                                OutputLineCounter;
+  std::string SimplifySourceDir;
+  std::string SimplifyBuildDir;
+  size_t OutputLineCounter;
   typedef std::vector<cmCTestBuildErrorWarning> t_ErrorsAndWarningsVector;
-  t_ErrorsAndWarningsVector             ErrorsAndWarnings;
-  t_ErrorsAndWarningsVector::iterator   LastErrorOrWarning;
-  size_t                                PostContextCount;
-  size_t                                MaxPreContext;
-  size_t                                MaxPostContext;
-  std::deque<std::string>               PreContext;
-
-  int                                   TotalErrors;
-  int                                   TotalWarnings;
-  char                                  LastTickChar;
-
-  bool                                  ErrorQuotaReached;
-  bool                                  WarningQuotaReached;
-
-  int                                   MaxErrors;
-  int                                   MaxWarnings;
+  t_ErrorsAndWarningsVector ErrorsAndWarnings;
+  t_ErrorsAndWarningsVector::iterator LastErrorOrWarning;
+  size_t PostContextCount;
+  size_t MaxPreContext;
+  size_t MaxPostContext;
+  std::deque<std::string> PreContext;
+
+  int TotalErrors;
+  int TotalWarnings;
+  char LastTickChar;
+
+  bool ErrorQuotaReached;
+  bool WarningQuotaReached;
+
+  int MaxErrors;
+  int MaxWarnings;
 
   bool UseCTestLaunch;
   std::string CTestLaunchDir;
diff --git a/Source/CTest/cmCTestCVS.cxx b/Source/CTest/cmCTestCVS.cxx
index 7ab87c2..5ddafbb 100644
--- a/Source/CTest/cmCTestCVS.cxx
+++ b/Source/CTest/cmCTestCVS.cxx
@@ -18,7 +18,8 @@
 #include <cmsys/FStream.hxx>
 #include <cmsys/RegularExpression.hxx>
 
-cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log): cmCTestVC(ct, log)
+cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log)
+  : cmCTestVC(ct, log)
 {
 }
 
@@ -26,11 +27,12 @@ cmCTestCVS::~cmCTestCVS()
 {
 }
 
-class cmCTestCVS::UpdateParser: public cmCTestVC::LineParser
+class cmCTestCVS::UpdateParser : public cmCTestVC::LineParser
 {
 public:
-  UpdateParser(cmCTestCVS* cvs, const char* prefix): CVS(cvs)
-    {
+  UpdateParser(cmCTestCVS* cvs, const char* prefix)
+    : CVS(cvs)
+  {
     this->SetLog(&cvs->Log, prefix);
     // See "man cvs", section "update output".
     this->RegexFileUpdated.compile("^([UP])  *(.*)");
@@ -41,7 +43,8 @@ public:
     this->RegexFileRemoved2.compile(
       "cvs[^ ]* update: "
       "warning: `?([^']*)'? is not \\(any longer\\) pertinent");
-    }
+  }
+
 private:
   cmCTestCVS* CVS;
   cmsys::RegularExpression RegexFileUpdated;
@@ -51,68 +54,55 @@ private:
   cmsys::RegularExpression RegexFileRemoved2;
 
   virtual bool ProcessLine()
-    {
-    if(this->RegexFileUpdated.find(this->Line))
-      {
+  {
+    if (this->RegexFileUpdated.find(this->Line)) {
       this->DoFile(PathUpdated, this->RegexFileUpdated.match(2));
-      }
-    else if(this->RegexFileModified.find(this->Line))
-      {
+    } else if (this->RegexFileModified.find(this->Line)) {
       this->DoFile(PathModified, this->RegexFileModified.match(2));
-      }
-    else if(this->RegexFileConflicting.find(this->Line))
-      {
+    } else if (this->RegexFileConflicting.find(this->Line)) {
       this->DoFile(PathConflicting, this->RegexFileConflicting.match(2));
-      }
-    else if(this->RegexFileRemoved1.find(this->Line))
-      {
+    } else if (this->RegexFileRemoved1.find(this->Line)) {
       this->DoFile(PathUpdated, this->RegexFileRemoved1.match(1));
-      }
-    else if(this->RegexFileRemoved2.find(this->Line))
-      {
+    } else if (this->RegexFileRemoved2.find(this->Line)) {
       this->DoFile(PathUpdated, this->RegexFileRemoved2.match(1));
-      }
-    return true;
     }
+    return true;
+  }
 
   void DoFile(PathStatus status, std::string const& file)
-    {
+  {
     std::string dir = cmSystemTools::GetFilenamePath(file);
     std::string name = cmSystemTools::GetFilenameName(file);
     this->CVS->Dirs[dir][name] = status;
-    }
+  }
 };
 
 bool cmCTestCVS::UpdateImpl()
 {
   // Get user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("CVSUpdateOptions");
-    if(opts.empty())
-      {
+    if (opts.empty()) {
       opts = "-dP";
-      }
     }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // Specify the start time for nightly testing.
-  if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
-    {
+  if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
     args.push_back("-D" + this->GetNightlyTime() + " UTC");
-    }
+  }
 
   // Run "cvs update" to update the work tree.
   std::vector<char const*> cvs_update;
   cvs_update.push_back(this->CommandLineTool.c_str());
   cvs_update.push_back("-z3");
   cvs_update.push_back("update");
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     cvs_update.push_back(ai->c_str());
-    }
+  }
   cvs_update.push_back(0);
 
   UpdateParser out(this, "up-out> ");
@@ -120,83 +110,76 @@ bool cmCTestCVS::UpdateImpl()
   return this->RunUpdateCommand(&cvs_update[0], &out, &err);
 }
 
-class cmCTestCVS::LogParser: public cmCTestVC::LineParser
+class cmCTestCVS::LogParser : public cmCTestVC::LineParser
 {
 public:
   typedef cmCTestCVS::Revision Revision;
-  LogParser(cmCTestCVS* cvs, const char* prefix, std::vector<Revision>& revs):
-    CVS(cvs), Revisions(revs), Section(SectionHeader)
-    {
+  LogParser(cmCTestCVS* cvs, const char* prefix, std::vector<Revision>& revs)
+    : CVS(cvs)
+    , Revisions(revs)
+    , Section(SectionHeader)
+  {
     this->SetLog(&cvs->Log, prefix),
-    this->RegexRevision.compile("^revision +([^ ]*) *$");
+      this->RegexRevision.compile("^revision +([^ ]*) *$");
     this->RegexBranches.compile("^branches: .*$");
     this->RegexPerson.compile("^date: +([^;]+); +author: +([^;]+);");
-    }
+  }
+
 private:
   cmCTestCVS* CVS;
   std::vector<Revision>& Revisions;
   cmsys::RegularExpression RegexRevision;
   cmsys::RegularExpression RegexBranches;
   cmsys::RegularExpression RegexPerson;
-  enum SectionType { SectionHeader, SectionRevisions, SectionEnd };
+  enum SectionType
+  {
+    SectionHeader,
+    SectionRevisions,
+    SectionEnd
+  };
   SectionType Section;
   Revision Rev;
 
   virtual bool ProcessLine()
-    {
-    if(this->Line == ("======================================="
-                      "======================================"))
-      {
+  {
+    if (this->Line == ("======================================="
+                       "======================================")) {
       // This line ends the revision list.
-      if(this->Section == SectionRevisions)
-        {
+      if (this->Section == SectionRevisions) {
         this->FinishRevision();
-        }
-      this->Section = SectionEnd;
       }
-    else if(this->Line == "----------------------------")
-      {
+      this->Section = SectionEnd;
+    } else if (this->Line == "----------------------------") {
       // This line divides revisions from the header and each other.
-      if(this->Section == SectionHeader)
-        {
+      if (this->Section == SectionHeader) {
         this->Section = SectionRevisions;
-        }
-      else if(this->Section == SectionRevisions)
-        {
+      } else if (this->Section == SectionRevisions) {
         this->FinishRevision();
-        }
       }
-    else if(this->Section == SectionRevisions)
-      {
-      if(!this->Rev.Log.empty())
-        {
+    } else if (this->Section == SectionRevisions) {
+      if (!this->Rev.Log.empty()) {
         // Continue the existing log.
         this->Rev.Log += this->Line;
         this->Rev.Log += "\n";
-        }
-      else if(this->Rev.Rev.empty() && this->RegexRevision.find(this->Line))
-        {
+      } else if (this->Rev.Rev.empty() &&
+                 this->RegexRevision.find(this->Line)) {
         this->Rev.Rev = this->RegexRevision.match(1);
-        }
-      else if(this->Rev.Date.empty() && this->RegexPerson.find(this->Line))
-        {
+      } else if (this->Rev.Date.empty() &&
+                 this->RegexPerson.find(this->Line)) {
         this->Rev.Date = this->RegexPerson.match(1);
         this->Rev.Author = this->RegexPerson.match(2);
-        }
-      else if(!this->RegexBranches.find(this->Line))
-        {
+      } else if (!this->RegexBranches.find(this->Line)) {
         // Start the log.
         this->Rev.Log += this->Line;
         this->Rev.Log += "\n";
-        }
       }
-    return this->Section != SectionEnd;
     }
+    return this->Section != SectionEnd;
+  }
 
   void FinishRevision()
-    {
-    if(!this->Rev.Rev.empty())
-      {
+  {
+    if (!this->Rev.Rev.empty()) {
       // Record this revision.
       /* clang-format off */
       this->CVS->Log << "Found revision " << this->Rev.Rev << "\n"
@@ -206,65 +189,57 @@ private:
       this->Revisions.push_back(this->Rev);
 
       // We only need two revisions.
-      if(this->Revisions.size() >= 2)
-        {
+      if (this->Revisions.size() >= 2) {
         this->Section = SectionEnd;
-        }
       }
-    this->Rev = Revision();
     }
+    this->Rev = Revision();
+  }
 };
 
 std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir)
 {
   // Compute the tag file location for this directory.
   std::string tagFile = this->SourceDirectory;
-  if(!dir.empty())
-    {
+  if (!dir.empty()) {
     tagFile += "/";
     tagFile += dir;
-    }
+  }
   tagFile += "/CVS/Tag";
 
   // Lookup the branch in the tag file, if any.
   std::string tagLine;
   cmsys::ifstream tagStream(tagFile.c_str());
-  if(tagStream && cmSystemTools::GetLineFromStream(tagStream, tagLine) &&
-     tagLine.size() > 1 && tagLine[0] == 'T')
-    {
+  if (tagStream && cmSystemTools::GetLineFromStream(tagStream, tagLine) &&
+      tagLine.size() > 1 && tagLine[0] == 'T') {
     // Use the branch specified in the tag file.
     std::string flag = "-r";
     flag += tagLine.substr(1);
     return flag;
-    }
-  else
-    {
+  } else {
     // Use the default branch.
     return "-b";
-    }
+  }
 }
 
-void cmCTestCVS::LoadRevisions(std::string const& file,
-                               const char* branchFlag,
+void cmCTestCVS::LoadRevisions(std::string const& file, const char* branchFlag,
                                std::vector<Revision>& revisions)
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
 
   // Run "cvs log" to get revisions of this file on this branch.
   const char* cvs = this->CommandLineTool.c_str();
-  const char* cvs_log[] =
-    {cvs, "log", "-N", branchFlag, file.c_str(), 0};
+  const char* cvs_log[] = { cvs, "log", "-N", branchFlag, file.c_str(), 0 };
 
   LogParser out(this, "log-out> ", revisions);
   OutputLogger err(this->Log, "log-err> ");
   this->RunChild(cvs_log, &out, &err);
 }
 
-void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml,
-                                   std::string const& path,
+void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml, std::string const& path,
                                    Directory const& dir)
 {
-  const char* slash = path.empty()? "":"/";
+  const char* slash = path.empty() ? "" : "/";
   xml.StartElement("Directory");
   xml.Element("Name", path);
 
@@ -273,25 +248,23 @@ void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml,
 
   // Load revisions and write an entry for each file in this directory.
   std::vector<Revision> revisions;
-  for(Directory::const_iterator fi = dir.begin(); fi != dir.end(); ++fi)
-    {
+  for (Directory::const_iterator fi = dir.begin(); fi != dir.end(); ++fi) {
     std::string full = path + slash + fi->first;
 
     // Load two real or unknown revisions.
     revisions.clear();
-    if(fi->second != PathUpdated)
-      {
+    if (fi->second != PathUpdated) {
       // For local modifications the current rev is unknown and the
       // prior rev is the latest from cvs.
       revisions.push_back(this->Unknown);
-      }
+    }
     this->LoadRevisions(full, branchFlag.c_str(), revisions);
     revisions.resize(2, this->Unknown);
 
     // Write the entry for this file with these revisions.
     File f(fi->second, &revisions[0], &revisions[1]);
     this->WriteXMLEntry(xml, path, fi->first, full, f);
-    }
+  }
   xml.EndElement(); // Directory
 }
 
@@ -299,13 +272,14 @@ bool cmCTestCVS::WriteXMLUpdates(cmXMLWriter& xml)
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              "   Gathering version information (one . per updated file):\n"
-             "    " << std::flush);
+             "    "
+               << std::flush);
 
-  for(std::map<std::string, Directory>::const_iterator
-        di = this->Dirs.begin(); di != this->Dirs.end(); ++di)
-    {
+  for (std::map<std::string, Directory>::const_iterator di =
+         this->Dirs.begin();
+       di != this->Dirs.end(); ++di) {
     this->WriteXMLDirectory(xml, di->first, di->second);
-    }
+  }
 
   cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
 
diff --git a/Source/CTest/cmCTestCVS.h b/Source/CTest/cmCTestCVS.h
index f2c0a73..62fe01b 100644
--- a/Source/CTest/cmCTestCVS.h
+++ b/Source/CTest/cmCTestCVS.h
@@ -18,7 +18,7 @@
  * \brief Interaction with cvs command-line tool
  *
  */
-class cmCTestCVS: public cmCTestVC
+class cmCTestCVS : public cmCTestVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
@@ -32,7 +32,9 @@ private:
   virtual bool WriteXMLUpdates(cmXMLWriter& xml);
 
   // Update status for files in each directory.
-  class Directory: public std::map<std::string, PathStatus> {};
+  class Directory : public std::map<std::string, PathStatus>
+  {
+  };
   std::map<std::string, Directory> Dirs;
 
   std::string ComputeBranchFlag(std::string const& dir);
diff --git a/Source/CTest/cmCTestCommand.h b/Source/CTest/cmCTestCommand.h
index e2ebba8..22a2c8e 100644
--- a/Source/CTest/cmCTestCommand.h
+++ b/Source/CTest/cmCTestCommand.h
@@ -27,14 +27,16 @@ class cmCTestScriptHandler;
 class cmCTestCommand : public cmCommand
 {
 public:
+  cmCTestCommand()
+  {
+    this->CTest = 0;
+    this->CTestScriptHandler = 0;
+  }
 
-  cmCTestCommand() {this->CTest = 0; this->CTestScriptHandler = 0;}
-
-  cmCTest *CTest;
-  cmCTestScriptHandler *CTestScriptHandler;
+  cmCTest* CTest;
+  cmCTestScriptHandler* CTestScriptHandler;
 
   cmTypeMacro(cmCTestCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx
index 8f15c6d..a90f27a 100644
--- a/Source/CTest/cmCTestConfigureCommand.cxx
+++ b/Source/CTest/cmCTestConfigureCommand.cxx
@@ -26,64 +26,56 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
 {
   std::vector<std::string> options;
 
-  if (this->Values[ctc_OPTIONS])
-    {
+  if (this->Values[ctc_OPTIONS]) {
     cmSystemTools::ExpandListArgument(this->Values[ctc_OPTIONS], options);
-    }
+  }
 
-  if ( this->CTest->GetCTestConfiguration("BuildDirectory").empty() )
-    {
-    this->SetError("Build directory not specified. Either use BUILD "
+  if (this->CTest->GetCTestConfiguration("BuildDirectory").empty()) {
+    this->SetError(
+      "Build directory not specified. Either use BUILD "
       "argument to CTEST_CONFIGURE command or set CTEST_BINARY_DIRECTORY "
       "variable");
     return 0;
-    }
+  }
 
-  const char* ctestConfigureCommand
-    = this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
+  const char* ctestConfigureCommand =
+    this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
 
-  if ( ctestConfigureCommand && *ctestConfigureCommand )
-    {
+  if (ctestConfigureCommand && *ctestConfigureCommand) {
     this->CTest->SetCTestConfiguration("ConfigureCommand",
-      ctestConfigureCommand, this->Quiet);
-    }
-  else
-    {
-    const char* cmakeGeneratorName
-      = this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
-    if ( cmakeGeneratorName && *cmakeGeneratorName )
-      {
-      const std::string& source_dir
-        = this->CTest->GetCTestConfiguration("SourceDirectory");
-      if ( source_dir.empty() )
-        {
-        this->SetError("Source directory not specified. Either use SOURCE "
+                                       ctestConfigureCommand, this->Quiet);
+  } else {
+    const char* cmakeGeneratorName =
+      this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
+    if (cmakeGeneratorName && *cmakeGeneratorName) {
+      const std::string& source_dir =
+        this->CTest->GetCTestConfiguration("SourceDirectory");
+      if (source_dir.empty()) {
+        this->SetError(
+          "Source directory not specified. Either use SOURCE "
           "argument to CTEST_CONFIGURE command or set CTEST_SOURCE_DIRECTORY "
           "variable");
         return 0;
-        }
+      }
 
       const std::string cmakelists_file = source_dir + "/CMakeLists.txt";
-      if ( !cmSystemTools::FileExists(cmakelists_file.c_str()) )
-        {
+      if (!cmSystemTools::FileExists(cmakelists_file.c_str())) {
         std::ostringstream e;
-        e << "CMakeLists.txt file does not exist ["
-          << cmakelists_file << "]";
+        e << "CMakeLists.txt file does not exist [" << cmakelists_file << "]";
         this->SetError(e.str());
         return 0;
-        }
+      }
 
       bool multiConfig = false;
       bool cmakeBuildTypeInOptions = false;
 
-      cmGlobalGenerator *gg =
+      cmGlobalGenerator* gg =
         this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
           cmakeGeneratorName);
-      if(gg)
-        {
+      if (gg) {
         multiConfig = gg->IsMultiConfig();
         delete gg;
-        }
+      }
 
       std::string cmakeConfigureCommand = "\"";
       cmakeConfigureCommand += cmSystemTools::GetCMakeCommand();
@@ -91,8 +83,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
 
       std::vector<std::string>::const_iterator it;
       std::string option;
-      for (it= options.begin(); it!=options.end(); ++it)
-        {
+      for (it = options.begin(); it != options.end(); ++it) {
         option = *it;
 
         cmakeConfigureCommand += " \"";
@@ -100,19 +91,17 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
         cmakeConfigureCommand += "\"";
 
         if ((0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE=")) ||
-           (0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING=")))
-          {
+            (0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING="))) {
           cmakeBuildTypeInOptions = true;
-          }
         }
+      }
 
       if (!multiConfig && !cmakeBuildTypeInOptions &&
-          !this->CTest->GetConfigType().empty())
-        {
+          !this->CTest->GetConfigType().empty()) {
         cmakeConfigureCommand += " \"-DCMAKE_BUILD_TYPE:STRING=";
         cmakeConfigureCommand += this->CTest->GetConfigType();
         cmakeConfigureCommand += "\"";
-        }
+      }
 
       cmakeConfigureCommand += " \"-G";
       cmakeConfigureCommand += cmakeGeneratorName;
@@ -120,46 +109,42 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
 
       const char* cmakeGeneratorPlatform =
         this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_PLATFORM");
-      if(cmakeGeneratorPlatform && *cmakeGeneratorPlatform)
-        {
+      if (cmakeGeneratorPlatform && *cmakeGeneratorPlatform) {
         cmakeConfigureCommand += " \"-A";
         cmakeConfigureCommand += cmakeGeneratorPlatform;
         cmakeConfigureCommand += "\"";
-        }
+      }
 
       const char* cmakeGeneratorToolset =
         this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_TOOLSET");
-      if(cmakeGeneratorToolset && *cmakeGeneratorToolset)
-        {
+      if (cmakeGeneratorToolset && *cmakeGeneratorToolset) {
         cmakeConfigureCommand += " \"-T";
         cmakeConfigureCommand += cmakeGeneratorToolset;
         cmakeConfigureCommand += "\"";
-        }
+      }
 
       cmakeConfigureCommand += " \"";
       cmakeConfigureCommand += source_dir;
       cmakeConfigureCommand += "\"";
 
-      this->CTest->SetCTestConfiguration("ConfigureCommand",
-        cmakeConfigureCommand.c_str(), this->Quiet);
-      }
-    else
-      {
-      this->SetError("Configure command is not specified. If this is a "
+      this->CTest->SetCTestConfiguration(
+        "ConfigureCommand", cmakeConfigureCommand.c_str(), this->Quiet);
+    } else {
+      this->SetError(
+        "Configure command is not specified. If this is a "
         "\"built with CMake\" project, set CTEST_CMAKE_GENERATOR. If not, "
         "set CTEST_CONFIGURE_COMMAND.");
       return 0;
-      }
     }
+  }
 
-  cmCTestGenericHandler* handler
-    = this->CTest->GetInitializedHandler("configure");
-  if ( !handler )
-    {
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("configure");
+  if (!handler) {
     this->SetError(
       "internal CTest error. Cannot instantiate configure handler");
     return 0;
-    }
+  }
   handler->SetQuiet(this->Quiet);
   return handler;
 }
diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h
index 7941d4e..9ff3d4a 100644
--- a/Source/CTest/cmCTestConfigureCommand.h
+++ b/Source/CTest/cmCTestConfigureCommand.h
@@ -28,29 +28,29 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestConfigureCommand* ni = new cmCTestConfigureCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_configure";}
+  virtual std::string GetName() const { return "ctest_configure"; }
 
   cmTypeMacro(cmCTestConfigureCommand, cmCTestHandlerCommand);
 
 protected:
   cmCTestGenericHandler* InitializeHandler();
 
-  enum {
+  enum
+  {
     ctc_FIRST = ct_LAST,
     ctc_OPTIONS,
     ctc_LAST
   };
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx
index ea4cf72..b99455f 100644
--- a/Source/CTest/cmCTestConfigureHandler.cxx
+++ b/Source/CTest/cmCTestConfigureHandler.cxx
@@ -18,7 +18,6 @@
 #include "cmake.h"
 #include <cmsys/Process.h>
 
-
 cmCTestConfigureHandler::cmCTestConfigureHandler()
 {
 }
@@ -28,64 +27,58 @@ void cmCTestConfigureHandler::Initialize()
   this->Superclass::Initialize();
 }
 
-//clearly it would be nice if this were broken up into a few smaller
-//functions and commented...
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
 int cmCTestConfigureHandler::ProcessHandler()
 {
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-    "Configure project" << std::endl, this->Quiet);
-  std::string cCommand
-    = this->CTest->GetCTestConfiguration("ConfigureCommand");
-  if (cCommand.empty())
-    {
+                     "Configure project" << std::endl, this->Quiet);
+  std::string cCommand =
+    this->CTest->GetCTestConfiguration("ConfigureCommand");
+  if (cCommand.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot find ConfigureCommand key in the DartConfiguration.tcl"
-      << std::endl);
+               "Cannot find ConfigureCommand key in the DartConfiguration.tcl"
+                 << std::endl);
     return -1;
-    }
+  }
 
-  std::string buildDirectory
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
-  if (buildDirectory.empty())
-    {
+  std::string buildDirectory =
+    this->CTest->GetCTestConfiguration("BuildDirectory");
+  if (buildDirectory.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
-      << std::endl);
+               "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
     return -1;
-    }
+  }
 
   double elapsed_time_start = cmSystemTools::GetTime();
   std::string output;
   int retVal = 0;
   int res = 0;
-  if ( !this->CTest->GetShowOnly() )
-    {
+  if (!this->CTest->GetShowOnly()) {
     cmGeneratedFileStream os;
-    if(!this->StartResultingXML(cmCTest::PartConfigure, "Configure", os))
-      {
+    if (!this->StartResultingXML(cmCTest::PartConfigure, "Configure", os)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open configure file"
-        << std::endl);
+                   << std::endl);
       return 1;
-      }
+    }
     std::string start_time = this->CTest->CurrentTime();
-    unsigned int start_time_time = static_cast<unsigned int>(
-      cmSystemTools::GetTime());
+    unsigned int start_time_time =
+      static_cast<unsigned int>(cmSystemTools::GetTime());
 
     cmGeneratedFileStream ofs;
     this->StartLogFile("Configure", ofs);
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Configure with command: " << cCommand << std::endl, this->Quiet);
-    res = this->CTest->RunMakeCommand(cCommand.c_str(), output,
-      &retVal, buildDirectory.c_str(),
-      0, ofs);
+                       "Configure with command: " << cCommand << std::endl,
+                       this->Quiet);
+    res = this->CTest->RunMakeCommand(cCommand.c_str(), output, &retVal,
+                                      buildDirectory.c_str(), 0, ofs);
 
-    if ( ofs )
-      {
+    if (ofs) {
       ofs.close();
-      }
+    }
 
-    if ( os )
-      {
+    if (os) {
       cmXMLWriter xml(os);
       this->CTest->StartXML(xml, this->AppendXML);
       xml.StartElement("Configure");
@@ -97,23 +90,23 @@ int cmCTestConfigureHandler::ProcessHandler()
       xml.Element("ConfigureStatus", retVal);
       xml.Element("EndDateTime", this->CTest->CurrentTime());
       xml.Element("EndConfigureTime",
-        static_cast<unsigned int>(cmSystemTools::GetTime()));
-      xml.Element("ElapsedMinutes", static_cast<int>(
-        (cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
+                  static_cast<unsigned int>(cmSystemTools::GetTime()));
+      xml.Element(
+        "ElapsedMinutes",
+        static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
+          10.0);
       xml.EndElement(); // Configure
       this->CTest->EndXML(xml);
-      }
     }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, DEBUG,
-      "Configure with command: " << cCommand << std::endl, this->Quiet);
-    }
-  if (! res || retVal )
-    {
+                       "Configure with command: " << cCommand << std::endl,
+                       this->Quiet);
+  }
+  if (!res || retVal) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Error(s) when configuring the project" << std::endl);
+               "Error(s) when configuring the project" << std::endl);
     return -1;
-    }
+  }
   return 0;
 }
diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx
index bf6a321..223d010 100644
--- a/Source/CTest/cmCTestCoverageCommand.cxx
+++ b/Source/CTest/cmCTestCoverageCommand.cxx
@@ -21,23 +21,22 @@ cmCTestCoverageCommand::cmCTestCoverageCommand()
 
 cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
 {
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "CoverageCommand", "CTEST_COVERAGE_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CoverageCommand", "CTEST_COVERAGE_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS",
+    this->Quiet);
   cmCTestCoverageHandler* handler = static_cast<cmCTestCoverageHandler*>(
     this->CTest->GetInitializedHandler("coverage"));
-  if ( !handler )
-    {
+  if (!handler) {
     this->SetError("internal CTest error. Cannot instantiate test handler");
     return 0;
-    }
+  }
 
   // If a LABELS option was given, select only files with the labels.
-  if(this->LabelsMentioned)
-    {
+  if (this->LabelsMentioned) {
     handler->SetLabelFilter(this->Labels);
-    }
+  }
 
   handler->SetQuiet(this->Quiet);
   return handler;
@@ -46,12 +45,11 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
 bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
 {
   // Look for arguments specific to this command.
-  if(arg == "LABELS")
-    {
+  if (arg == "LABELS") {
     this->ArgumentDoing = ArgumentDoingLabels;
     this->LabelsMentioned = true;
     return true;
-    }
+  }
 
   // Look for other arguments.
   return this->Superclass::CheckArgumentKeyword(arg);
@@ -60,11 +58,10 @@ bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg)
 bool cmCTestCoverageCommand::CheckArgumentValue(std::string const& arg)
 {
   // Handle states specific to this command.
-  if(this->ArgumentDoing == ArgumentDoingLabels)
-    {
+  if (this->ArgumentDoing == ArgumentDoingLabels) {
     this->Labels.insert(arg);
     return true;
-    }
+  }
 
   // Look for other arguments.
   return this->Superclass::CheckArgumentValue(arg);
diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h
index 5762e07..f60ffd5 100644
--- a/Source/CTest/cmCTestCoverageCommand.h
+++ b/Source/CTest/cmCTestCoverageCommand.h
@@ -22,24 +22,23 @@
 class cmCTestCoverageCommand : public cmCTestHandlerCommand
 {
 public:
-
   cmCTestCoverageCommand();
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestCoverageCommand* ni = new cmCTestCoverageCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_coverage";}
+  virtual std::string GetName() const { return "ctest_coverage"; }
 
   cmTypeMacro(cmCTestCoverageCommand, cmCTestHandlerCommand);
 
@@ -59,6 +58,4 @@ protected:
   std::set<std::string> Labels;
 };
 
-
 #endif
-
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index ed15834..550a774 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -34,95 +34,82 @@
 #include <math.h>
 #include <stdlib.h>
 
-#define SAFEDIV(x,y) (((y)!=0)?((x)/(y)):(0))
+#define SAFEDIV(x, y) (((y) != 0) ? ((x) / (y)) : (0))
 
 class cmCTestRunProcess
 {
 public:
   cmCTestRunProcess()
-    {
-      this->Process = cmsysProcess_New();
-      this->PipeState = -1;
-      this->TimeOut = -1;
-    }
+  {
+    this->Process = cmsysProcess_New();
+    this->PipeState = -1;
+    this->TimeOut = -1;
+  }
   ~cmCTestRunProcess()
-    {
-      if(!(this->PipeState == -1)
-         && !(this->PipeState == cmsysProcess_Pipe_None )
-         && !(this->PipeState == cmsysProcess_Pipe_Timeout))
-        {
-        this->WaitForExit();
-        }
-      cmsysProcess_Delete(this->Process);
+  {
+    if (!(this->PipeState == -1) &&
+        !(this->PipeState == cmsysProcess_Pipe_None) &&
+        !(this->PipeState == cmsysProcess_Pipe_Timeout)) {
+      this->WaitForExit();
     }
+    cmsysProcess_Delete(this->Process);
+  }
   void SetCommand(const char* command)
-    {
-      this->CommandLineStrings.clear();
-      this->CommandLineStrings.push_back(command);;
-    }
+  {
+    this->CommandLineStrings.clear();
+    this->CommandLineStrings.push_back(command);
+    ;
+  }
   void AddArgument(const char* arg)
-    {
-      if(arg)
-        {
-        this->CommandLineStrings.push_back(arg);
-        }
-    }
-  void SetWorkingDirectory(const char* dir)
-    {
-      this->WorkingDirectory = dir;
-    }
-  void SetTimeout(double t)
-    {
-      this->TimeOut = t;
+  {
+    if (arg) {
+      this->CommandLineStrings.push_back(arg);
     }
+  }
+  void SetWorkingDirectory(const char* dir) { this->WorkingDirectory = dir; }
+  void SetTimeout(double t) { this->TimeOut = t; }
   bool StartProcess()
-    {
-      std::vector<const char*> args;
-      for(std::vector<std::string>::iterator i =
-            this->CommandLineStrings.begin();
-          i != this->CommandLineStrings.end(); ++i)
-        {
-        args.push_back(i->c_str());
-        }
-      args.push_back(0); // null terminate
-      cmsysProcess_SetCommand(this->Process, &*args.begin());
-      if(!this->WorkingDirectory.empty())
-        {
-        cmsysProcess_SetWorkingDirectory(this->Process,
-                                         this->WorkingDirectory.c_str());
-        }
-
-      cmsysProcess_SetOption(this->Process,
-                             cmsysProcess_Option_HideWindow, 1);
-      if(this->TimeOut != -1)
-        {
-        cmsysProcess_SetTimeout(this->Process, this->TimeOut);
-        }
-      cmsysProcess_Execute(this->Process);
-      this->PipeState = cmsysProcess_GetState(this->Process);
-      // if the process is running or exited return true
-      if(this->PipeState == cmsysProcess_State_Executing
-         || this->PipeState == cmsysProcess_State_Exited)
-        {
-        return true;
-        }
-      return false;
+  {
+    std::vector<const char*> args;
+    for (std::vector<std::string>::iterator i =
+           this->CommandLineStrings.begin();
+         i != this->CommandLineStrings.end(); ++i) {
+      args.push_back(i->c_str());
+    }
+    args.push_back(0); // null terminate
+    cmsysProcess_SetCommand(this->Process, &*args.begin());
+    if (!this->WorkingDirectory.empty()) {
+      cmsysProcess_SetWorkingDirectory(this->Process,
+                                       this->WorkingDirectory.c_str());
+    }
+
+    cmsysProcess_SetOption(this->Process, cmsysProcess_Option_HideWindow, 1);
+    if (this->TimeOut != -1) {
+      cmsysProcess_SetTimeout(this->Process, this->TimeOut);
+    }
+    cmsysProcess_Execute(this->Process);
+    this->PipeState = cmsysProcess_GetState(this->Process);
+    // if the process is running or exited return true
+    if (this->PipeState == cmsysProcess_State_Executing ||
+        this->PipeState == cmsysProcess_State_Exited) {
+      return true;
     }
+    return false;
+  }
   void SetStdoutFile(const char* fname)
-    {
+  {
     cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDOUT, fname);
-    }
+  }
   void SetStderrFile(const char* fname)
-    {
+  {
     cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDERR, fname);
-    }
-  int WaitForExit(double* timeout =0)
-    {
-      this->PipeState = cmsysProcess_WaitForExit(this->Process,
-                                                 timeout);
-      return this->PipeState;
-    }
-  int GetProcessState() { return this->PipeState;}
+  }
+  int WaitForExit(double* timeout = 0)
+  {
+    this->PipeState = cmsysProcess_WaitForExit(this->Process, timeout);
+    return this->PipeState;
+  }
+  int GetProcessState() { return this->PipeState; }
 private:
   int PipeState;
   cmsysProcess* Process;
@@ -131,8 +118,6 @@ private:
   double TimeOut;
 };
 
-
-
 cmCTestCoverageHandler::cmCTestCoverageHandler()
 {
 }
@@ -157,12 +142,11 @@ void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log)
   cmsys::Glob gl;
   gl.FindFiles(logGlob);
   std::vector<std::string> const& files = gl.GetFiles();
-  for(std::vector<std::string>::const_iterator fi = files.begin();
-      fi != files.end(); ++fi)
-    {
+  for (std::vector<std::string>::const_iterator fi = files.begin();
+       fi != files.end(); ++fi) {
     log << "Removing old coverage log: " << *fi << "\n";
     cmSystemTools::RemoveFile(*fi);
-    }
+  }
 }
 
 bool cmCTestCoverageHandler::StartCoverageLogFile(
@@ -170,25 +154,26 @@ bool cmCTestCoverageHandler::StartCoverageLogFile(
 {
   char covLogFilename[1024];
   sprintf(covLogFilename, "CoverageLog-%d", logFileCount);
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Open file: "
-    << covLogFilename << std::endl, this->Quiet);
-  if(!this->StartResultingXML(cmCTest::PartCoverage,
-                              covLogFilename, covLogFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file: "
-      << covLogFilename << std::endl);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Open file: " << covLogFilename << std::endl,
+                     this->Quiet);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, covLogFilename,
+                               covLogFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open log file: " << covLogFilename << std::endl);
     return false;
-    }
+  }
   return true;
 }
 
 void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
-  int logFileCount)
+                                                int logFileCount)
 {
   char covLogFilename[1024];
   sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Close file: "
-    << covLogFilename << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Close file: " << covLogFilename << std::endl,
+                     this->Quiet);
   ostr.Close();
 }
 
@@ -198,7 +183,7 @@ void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml)
   xml.StartElement("CoverageLog");
   xml.Element("StartDateTime", this->CTest->CurrentTime());
   xml.Element("StartTime",
-    static_cast<unsigned int>(cmSystemTools::GetTime()));
+              static_cast<unsigned int>(cmSystemTools::GetTime()));
 }
 
 void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
@@ -210,138 +195,117 @@ void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
 }
 
 bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
-  const char* srcDir,
-  const char* binDir)
+                                               const char* srcDir,
+                                               const char* binDir)
 {
-  if(this->IsFilteredOut(file))
-    {
+  if (this->IsFilteredOut(file)) {
     return false;
-    }
+  }
 
   std::vector<cmsys::RegularExpression>::iterator sit;
-  for ( sit = this->CustomCoverageExcludeRegex.begin();
-    sit != this->CustomCoverageExcludeRegex.end(); ++ sit )
-    {
-    if ( sit->find(file) )
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File " << file
-        << " is excluded in CTestCustom.ctest" << std::endl;, this->Quiet);
+  for (sit = this->CustomCoverageExcludeRegex.begin();
+       sit != this->CustomCoverageExcludeRegex.end(); ++sit) {
+    if (sit->find(file)) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File "
+                           << file << " is excluded in CTestCustom.ctest"
+                           << std::endl;
+                         , this->Quiet);
       return false;
-      }
     }
+  }
 
   std::string fSrcDir = cmSystemTools::CollapseFullPath(srcDir);
   std::string fBinDir = cmSystemTools::CollapseFullPath(binDir);
   std::string fFile = cmSystemTools::CollapseFullPath(file);
-  bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile,
-    fSrcDir);
-  bool buildSubDir = cmSystemTools::IsSubDirectory(fFile,
-    fBinDir);
+  bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile, fSrcDir);
+  bool buildSubDir = cmSystemTools::IsSubDirectory(fFile, fBinDir);
   // Always check parent directory of the file.
   std::string fileDir = cmSystemTools::GetFilenamePath(fFile);
   std::string checkDir;
 
   // We also need to check the binary/source directory pair.
-  if ( sourceSubDir && buildSubDir )
-    {
-    if ( fSrcDir.size() > fBinDir.size() )
-      {
+  if (sourceSubDir && buildSubDir) {
+    if (fSrcDir.size() > fBinDir.size()) {
       checkDir = fSrcDir;
-      }
-    else
-      {
+    } else {
       checkDir = fBinDir;
-      }
     }
-  else if ( sourceSubDir )
-    {
+  } else if (sourceSubDir) {
     checkDir = fSrcDir;
-    }
-  else if ( buildSubDir )
-    {
+  } else if (buildSubDir) {
     checkDir = fBinDir;
-    }
-  std::string ndc
-    = cmSystemTools::FileExistsInParentDirectories(".NoDartCoverage",
-      fFile.c_str(), checkDir.c_str());
-  if (!ndc.empty())
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc
-      << " so skip coverage of " << file << std::endl, this->Quiet);
+  }
+  std::string ndc = cmSystemTools::FileExistsInParentDirectories(
+    ".NoDartCoverage", fFile.c_str(), checkDir.c_str());
+  if (!ndc.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found: " << ndc << " so skip coverage of " << file
+                                 << std::endl,
+                       this->Quiet);
     return false;
-    }
+  }
 
   // By now checkDir should be set to parent directory of the file.
   // Get the relative path to the file an apply it to the opposite directory.
   // If it is the same as fileDir, then ignore, otherwise check.
   std::string relPath;
-  if(!checkDir.empty())
-    {
-    relPath = cmSystemTools::RelativePath(checkDir.c_str(),
-                                          fFile.c_str());
-    }
-  else
-    {
+  if (!checkDir.empty()) {
+    relPath = cmSystemTools::RelativePath(checkDir.c_str(), fFile.c_str());
+  } else {
     relPath = fFile;
-    }
-  if ( checkDir == fSrcDir )
-    {
+  }
+  if (checkDir == fSrcDir) {
     checkDir = fBinDir;
-    }
-  else
-    {
+  } else {
     checkDir = fSrcDir;
-    }
+  }
   fFile = checkDir + "/" + relPath;
   fFile = cmSystemTools::GetFilenamePath(fFile);
 
-  if ( fileDir == fFile )
-    {
+  if (fileDir == fFile) {
     // This is in-source build, so we trust the previous check.
     return true;
-    }
+  }
 
-  ndc = cmSystemTools::FileExistsInParentDirectories(".NoDartCoverage",
-    fFile.c_str(), checkDir.c_str());
-  if (!ndc.empty())
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc
-      << " so skip coverage of: " << file << std::endl, this->Quiet);
+  ndc = cmSystemTools::FileExistsInParentDirectories(
+    ".NoDartCoverage", fFile.c_str(), checkDir.c_str());
+  if (!ndc.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found: " << ndc << " so skip coverage of: " << file
+                                 << std::endl,
+                       this->Quiet);
     return false;
-    }
+  }
   // Ok, nothing in source tree, nothing in binary tree
   return true;
 }
 
-//clearly it would be nice if this were broken up into a few smaller
-//functions and commented...
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
 int cmCTestCoverageHandler::ProcessHandler()
 {
   this->CTest->ClearSubmitFiles(cmCTest::PartCoverage);
   int error = 0;
   // do we have time for this
-  if (this->CTest->GetRemainingTimeAllowed() < 120)
-    {
+  if (this->CTest->GetRemainingTimeAllowed() < 120) {
     return error;
-    }
+  }
 
   std::string coverage_start_time = this->CTest->CurrentTime();
-  unsigned int coverage_start_time_time = static_cast<unsigned int>(
-    cmSystemTools::GetTime());
-  std::string sourceDir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
-  std::string binaryDir
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
+  unsigned int coverage_start_time_time =
+    static_cast<unsigned int>(cmSystemTools::GetTime());
+  std::string sourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string binaryDir = this->CTest->GetCTestConfiguration("BuildDirectory");
 
   this->LoadLabels();
 
   cmGeneratedFileStream ofs;
   double elapsed_time_start = cmSystemTools::GetTime();
-  if ( !this->StartLogFile("Coverage", ofs) )
-    {
+  if (!this->StartLogFile("Coverage", ofs)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot create LastCoverage.log file" << std::endl);
-    }
+               "Cannot create LastCoverage.log file" << std::endl);
+  }
 
   ofs << "Performing coverage: " << elapsed_time_start << std::endl;
   this->CleanCoverageLogFiles(ofs);
@@ -350,7 +314,7 @@ int cmCTestCoverageHandler::ProcessHandler()
   cmSystemTools::ConvertToUnixSlashes(binaryDir);
 
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-    "Performing coverage" << std::endl, this->Quiet);
+                     "Performing coverage" << std::endl, this->Quiet);
 
   cmCTestCoverageHandlerContainer cont;
   cont.Error = error;
@@ -362,97 +326,86 @@ int cmCTestCoverageHandler::ProcessHandler()
   // setup the regex exclude stuff
   this->CustomCoverageExcludeRegex.clear();
   std::vector<std::string>::iterator rexIt;
-  for ( rexIt = this->CustomCoverageExclude.begin();
-    rexIt != this->CustomCoverageExclude.end();
-    ++ rexIt )
-    {
+  for (rexIt = this->CustomCoverageExclude.begin();
+       rexIt != this->CustomCoverageExclude.end(); ++rexIt) {
     this->CustomCoverageExcludeRegex.push_back(
       cmsys::RegularExpression(rexIt->c_str()));
-    }
+  }
 
-  if(this->HandleBullseyeCoverage(&cont))
-    {
+  if (this->HandleBullseyeCoverage(&cont)) {
     return cont.Error;
-    }
+  }
   int file_count = 0;
   file_count += this->HandleGCovCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandleLCovCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandleTracePyCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandlePHPCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandleCoberturaCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
   file_count += this->HandleMumpsCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
   file_count += this->HandleJacocoCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
   file_count += this->HandleBlanketJSCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
-    file_count += this->HandleDelphiCoverage(&cont);
+  file_count += this->HandleDelphiCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   std::set<std::string> uncovered = this->FindUncoveredFiles(&cont);
 
-  if (file_count == 0 && this->ExtraCoverageGlobs.empty())
-    {
-    cmCTestOptionalLog(this->CTest, WARNING,
+  if (file_count == 0 && this->ExtraCoverageGlobs.empty()) {
+    cmCTestOptionalLog(
+      this->CTest, WARNING,
       " Cannot find any coverage files. Ignoring Coverage request."
-      << std::endl, this->Quiet);
+        << std::endl,
+      this->Quiet);
     return error;
-    }
+  }
   cmGeneratedFileStream covSumFile;
   cmGeneratedFileStream covLogFile;
   cmXMLWriter covSumXML(covSumFile);
   cmXMLWriter covLogXML(covLogFile);
 
-  if(!this->StartResultingXML(cmCTest::PartCoverage, "Coverage", covSumFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot open coverage summary file." << std::endl);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
+                               covSumFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+                 << std::endl);
     return -1;
-    }
+  }
   covSumFile.setf(std::ios::fixed, std::ios::floatfield);
   covSumFile.precision(2);
 
@@ -463,19 +416,19 @@ int cmCTestCoverageHandler::ProcessHandler()
   covSumXML.Element("StartDateTime", coverage_start_time);
   covSumXML.Element("StartTime", coverage_start_time_time);
   int logFileCount = 0;
-  if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-    {
+  if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
     return -1;
-    }
+  }
   this->StartCoverageLogXML(covLogXML);
   cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator fileIterator;
   int cnt = 0;
   long total_tested = 0;
   long total_untested = 0;
-  //std::string fullSourceDir = sourceDir + "/";
-  //std::string fullBinaryDir = binaryDir + "/";
+  // std::string fullSourceDir = sourceDir + "/";
+  // std::string fullBinaryDir = binaryDir + "/";
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet);
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
     "   Accumulating results (each . represents one file):" << std::endl,
     this->Quiet);
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
@@ -483,77 +436,68 @@ int cmCTestCoverageHandler::ProcessHandler()
   std::vector<std::string> errorsWhileAccumulating;
 
   file_count = 0;
-  for ( fileIterator = cont.TotalCoverage.begin();
-    fileIterator != cont.TotalCoverage.end();
-    ++fileIterator )
-    {
+  for (fileIterator = cont.TotalCoverage.begin();
+       fileIterator != cont.TotalCoverage.end(); ++fileIterator) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
-      this->Quiet);
-    file_count ++;
-    if ( file_count % 50 == 0 )
-      {
+                       this->Quiet);
+    file_count++;
+    if (file_count % 50 == 0) {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " processed: "
-        << file_count
-        << " out of "
-        << cont.TotalCoverage.size() << std::endl, this->Quiet);
+                           << file_count << " out of "
+                           << cont.TotalCoverage.size() << std::endl,
+                         this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
-      }
+    }
 
     const std::string fullFileName = fileIterator->first;
-    bool shouldIDoCoverage
-      = this->ShouldIDoCoverage(fullFileName.c_str(),
-        sourceDir.c_str(), binaryDir.c_str());
-    if ( !shouldIDoCoverage )
-      {
+    bool shouldIDoCoverage = this->ShouldIDoCoverage(
+      fullFileName.c_str(), sourceDir.c_str(), binaryDir.c_str());
+    if (!shouldIDoCoverage) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        ".NoDartCoverage found, so skip coverage check for: "
-        << fullFileName
-        << std::endl, this->Quiet);
+                         ".NoDartCoverage found, so skip coverage check for: "
+                           << fullFileName << std::endl,
+                         this->Quiet);
       continue;
-      }
+    }
 
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Process file: " << fullFileName << std::endl, this->Quiet);
+                       "Process file: " << fullFileName << std::endl,
+                       this->Quiet);
 
-    if ( !cmSystemTools::FileExists(fullFileName.c_str()) )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
-        << fullFileName << std::endl);
+    if (!cmSystemTools::FileExists(fullFileName.c_str())) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot find file: " << fullFileName << std::endl);
       continue;
-      }
+    }
 
-    if ( ++cnt % 100 == 0 )
-      {
+    if (++cnt % 100 == 0) {
       this->EndCoverageLogXML(covLogXML);
       this->EndCoverageLogFile(covLogFile, logFileCount);
-      logFileCount ++;
-      if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-        {
+      logFileCount++;
+      if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
         return -1;
-        }
-      this->StartCoverageLogXML(covLogXML);
       }
+      this->StartCoverageLogXML(covLogXML);
+    }
 
-    const std::string fileName
-      = cmSystemTools::GetFilenameName(fullFileName);
+    const std::string fileName = cmSystemTools::GetFilenameName(fullFileName);
     std::string shortFileName =
       this->CTest->GetShortPathToFile(fullFileName.c_str());
-    const cmCTestCoverageHandlerContainer::SingleFileCoverageVector& fcov
-      = fileIterator->second;
+    const cmCTestCoverageHandlerContainer::SingleFileCoverageVector& fcov =
+      fileIterator->second;
     covLogXML.StartElement("File");
     covLogXML.Attribute("Name", fileName);
     covLogXML.Attribute("FullPath", shortFileName);
     covLogXML.StartElement("Report");
 
     cmsys::ifstream ifs(fullFileName.c_str());
-    if ( !ifs)
-      {
+    if (!ifs) {
       std::ostringstream ostr;
-      ostr <<  "Cannot open source file: " << fullFileName;
+      ostr << "Cannot open source file: " << fullFileName;
       errorsWhileAccumulating.push_back(ostr.str());
-      error ++;
+      error++;
       continue;
-      }
+    }
 
     int tested = 0;
     int untested = 0;
@@ -561,49 +505,43 @@ int cmCTestCoverageHandler::ProcessHandler()
     cmCTestCoverageHandlerContainer::SingleFileCoverageVector::size_type cc;
     std::string line;
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Actually performing coverage for: " << fullFileName << std::endl,
-      this->Quiet);
-    for ( cc= 0; cc < fcov.size(); cc ++ )
-      {
-      if ( !cmSystemTools::GetLineFromStream(ifs, line) &&
-        cc != fcov.size() -1 )
-        {
+                       "Actually performing coverage for: " << fullFileName
+                                                            << std::endl,
+                       this->Quiet);
+    for (cc = 0; cc < fcov.size(); cc++) {
+      if (!cmSystemTools::GetLineFromStream(ifs, line) &&
+          cc != fcov.size() - 1) {
         std::ostringstream ostr;
         ostr << "Problem reading source file: " << fullFileName
-             << " line:" << cc << "  out total: " << fcov.size()-1;
+             << " line:" << cc << "  out total: " << fcov.size() - 1;
         errorsWhileAccumulating.push_back(ostr.str());
-        error ++;
+        error++;
         break;
-        }
+      }
       covLogXML.StartElement("Line");
       covLogXML.Attribute("Number", cc);
       covLogXML.Attribute("Count", fcov[cc]);
       covLogXML.Content(line);
       covLogXML.EndElement(); // Line
-      if ( fcov[cc] == 0 )
-        {
-        untested ++;
-        }
-      else if ( fcov[cc] > 0 )
-        {
-        tested ++;
-        }
+      if (fcov[cc] == 0) {
+        untested++;
+      } else if (fcov[cc] > 0) {
+        tested++;
       }
-    if ( cmSystemTools::GetLineFromStream(ifs, line) )
-      {
+    }
+    if (cmSystemTools::GetLineFromStream(ifs, line)) {
       std::ostringstream ostr;
-      ostr <<  "Looks like there are more lines in the file: " << fullFileName;
+      ostr << "Looks like there are more lines in the file: " << fullFileName;
       errorsWhileAccumulating.push_back(ostr.str());
-      }
+    }
     float cper = 0;
     float cmet = 0;
-    if ( tested + untested > 0 )
-      {
+    if (tested + untested > 0) {
       cper = (100 * SAFEDIV(static_cast<float>(tested),
-          static_cast<float>(tested + untested)));
-      cmet = ( SAFEDIV(static_cast<float>(tested + 10),
-          static_cast<float>(tested + untested + 10)));
-      }
+                            static_cast<float>(tested + untested)));
+      cmet = (SAFEDIV(static_cast<float>(tested + 10),
+                      static_cast<float>(tested + untested + 10)));
+    }
     total_tested += tested;
     total_untested += untested;
     covLogXML.EndElement(); // Report
@@ -611,7 +549,7 @@ int cmCTestCoverageHandler::ProcessHandler()
     covSumXML.StartElement("File");
     covSumXML.Attribute("Name", fileName);
     covSumXML.Attribute("FullPath",
-      this->CTest->GetShortPathToFile(fullFileName.c_str()));
+                        this->CTest->GetShortPathToFile(fullFileName.c_str()));
     covSumXML.Attribute("Covered", tested + untested > 0 ? "true" : "false");
     covSumXML.Element("LOCTested", tested);
     covSumXML.Element("LOCUnTested", untested);
@@ -619,12 +557,11 @@ int cmCTestCoverageHandler::ProcessHandler()
     covSumXML.Element("CoverageMetric", cmet);
     this->WriteXMLLabels(covSumXML, shortFileName);
     covSumXML.EndElement(); // File
-    }
+  }
 
-  //Handle all the files in the extra coverage globs that have no cov data
-  for(std::set<std::string>::iterator i = uncovered.begin();
-      i != uncovered.end(); ++i)
-    {
+  // Handle all the files in the extra coverage globs that have no cov data
+  for (std::set<std::string>::iterator i = uncovered.begin();
+       i != uncovered.end(); ++i) {
     std::string fileName = cmSystemTools::GetFilenameName(*i);
     std::string fullPath = cont.SourceDir + "/" + *i;
 
@@ -634,27 +571,26 @@ int cmCTestCoverageHandler::ProcessHandler()
     covLogXML.StartElement("Report");
 
     cmsys::ifstream ifs(fullPath.c_str());
-    if (!ifs)
-      {
+    if (!ifs) {
       std::ostringstream ostr;
-      ostr <<  "Cannot open source file: " << fullPath;
+      ostr << "Cannot open source file: " << fullPath;
       errorsWhileAccumulating.push_back(ostr.str());
-      error ++;
+      error++;
       continue;
-      }
+    }
     int untested = 0;
     std::string line;
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Actually performing coverage for: " << *i << std::endl, this->Quiet);
-    while (cmSystemTools::GetLineFromStream(ifs, line))
-      {
+                       "Actually performing coverage for: " << *i << std::endl,
+                       this->Quiet);
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
       covLogXML.StartElement("Line");
       covLogXML.Attribute("Number", untested);
       covLogXML.Attribute("Count", 0);
       covLogXML.Content(line);
       covLogXML.EndElement(); // Line
-      untested ++;
-      }
+      untested++;
+    }
     covLogXML.EndElement(); // Report
     covLogXML.EndElement(); // File
 
@@ -669,33 +605,28 @@ int cmCTestCoverageHandler::ProcessHandler()
     covSumXML.Element("CoverageMetric", 0);
     this->WriteXMLLabels(covSumXML, *i);
     covSumXML.EndElement(); // File
-    }
+  }
 
   this->EndCoverageLogXML(covLogXML);
   this->EndCoverageLogFile(covLogFile, logFileCount);
 
-  if (!errorsWhileAccumulating.empty())
-    {
+  if (!errorsWhileAccumulating.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, std::endl);
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Error(s) while accumulating results:" << std::endl);
+               "Error(s) while accumulating results:" << std::endl);
     std::vector<std::string>::iterator erIt;
-    for ( erIt = errorsWhileAccumulating.begin();
-      erIt != errorsWhileAccumulating.end();
-      ++ erIt )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "  " << *erIt << std::endl);
-      }
+    for (erIt = errorsWhileAccumulating.begin();
+         erIt != errorsWhileAccumulating.end(); ++erIt) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  " << *erIt << std::endl);
     }
+  }
 
   long total_lines = total_tested + total_untested;
-  float percent_coverage = 100 * SAFEDIV(static_cast<float>(total_tested),
-    static_cast<float>(total_lines));
-  if ( total_lines == 0 )
-    {
+  float percent_coverage = 100 *
+    SAFEDIV(static_cast<float>(total_tested), static_cast<float>(total_lines));
+  if (total_lines == 0) {
     percent_coverage = 0;
-    }
+  }
 
   std::string end_time = this->CTest->CurrentTime();
 
@@ -705,60 +636,57 @@ int cmCTestCoverageHandler::ProcessHandler()
   covSumXML.Element("PercentCoverage", percent_coverage);
   covSumXML.Element("EndDateTime", end_time);
   covSumXML.Element("EndTime",
-    static_cast<unsigned int>(cmSystemTools::GetTime()));
-  covSumXML.Element("ElapsedMinutes",
-    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
+                    static_cast<unsigned int>(cmSystemTools::GetTime()));
+  covSumXML.Element(
+    "ElapsedMinutes",
+    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
+      10.0);
   covSumXML.EndElement(); // Coverage
   this->CTest->EndXML(covSumXML);
 
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "" << std::endl
-    << "\tCovered LOC:         "
-    << total_tested << std::endl
-    << "\tNot covered LOC:     " << total_untested << std::endl
-    << "\tTotal LOC:           " << total_lines << std::endl
-    << "\tPercentage Coverage: "
-    << std::setiosflags(std::ios::fixed)
-    << std::setprecision(2)
-    << (percent_coverage) << "%" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, ""
+               << std::endl
+               << "\tCovered LOC:         " << total_tested << std::endl
+               << "\tNot covered LOC:     " << total_untested << std::endl
+               << "\tTotal LOC:           " << total_lines << std::endl
+               << "\tPercentage Coverage: "
+               << std::setiosflags(std::ios::fixed) << std::setprecision(2)
+               << (percent_coverage) << "%" << std::endl);
 
   ofs << "\tCovered LOC:         " << total_tested << std::endl
-    << "\tNot covered LOC:     " << total_untested << std::endl
-    << "\tTotal LOC:           " << total_lines << std::endl
-    << "\tPercentage Coverage: "
-    << std::setiosflags(std::ios::fixed)
-    << std::setprecision(2)
-    << (percent_coverage) << "%" << std::endl;
-
+      << "\tNot covered LOC:     " << total_untested << std::endl
+      << "\tTotal LOC:           " << total_lines << std::endl
+      << "\tPercentage Coverage: " << std::setiosflags(std::ios::fixed)
+      << std::setprecision(2) << (percent_coverage) << "%" << std::endl;
 
-  if ( error )
-    {
+  if (error) {
     return -1;
-    }
+  }
   return 0;
 }
 
-void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
+void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile* mf)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " Add coverage exclude regular expressions." << std::endl, this->Quiet);
+                     " Add coverage exclude regular expressions." << std::endl,
+                     this->Quiet);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_COVERAGE_EXCLUDE",
-                                this->CustomCoverageExclude);
+                                    this->CustomCoverageExclude);
   this->CTest->PopulateCustomVector(mf, "CTEST_EXTRA_COVERAGE_GLOB",
-                                this->ExtraCoverageGlobs);
+                                    this->ExtraCoverageGlobs);
   std::vector<std::string>::iterator it;
-  for ( it = this->CustomCoverageExclude.begin();
-    it != this->CustomCoverageExclude.end();
-    ++ it )
-    {
+  for (it = this->CustomCoverageExclude.begin();
+       it != this->CustomCoverageExclude.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Add coverage exclude: " << *it << std::endl, this->Quiet);
-    }
-  for ( it = this->ExtraCoverageGlobs.begin();
-    it != this->ExtraCoverageGlobs.end(); ++it)
-    {
+                       " Add coverage exclude: " << *it << std::endl,
+                       this->Quiet);
+  }
+  for (it = this->ExtraCoverageGlobs.begin();
+       it != this->ExtraCoverageGlobs.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Add coverage glob: " << *it << std::endl, this->Quiet);
-    }
+                       " Add coverage glob: " << *it << std::endl,
+                       this->Quiet);
+  }
 }
 
 // Fix for issue #4971 where the case of the drive letter component of
@@ -772,19 +700,16 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
 #define fnc(s) s
 #endif
 
-bool IsFileInDir(const std::string &infile, const std::string &indir)
+bool IsFileInDir(const std::string& infile, const std::string& indir)
 {
   std::string file = cmSystemTools::CollapseFullPath(infile);
   std::string dir = cmSystemTools::CollapseFullPath(indir);
 
-  if (
-    file.size() > dir.size() &&
-    (fnc(file.substr(0, dir.size())) == fnc(dir)) &&
-    file[dir.size()] == '/'
-    )
-    {
+  if (file.size() > dir.size() &&
+      (fnc(file.substr(0, dir.size())) == fnc(dir)) &&
+      file[dir.size()] == '/') {
     return true;
-    }
+  }
 
   return false;
 }
@@ -794,10 +719,9 @@ int cmCTestCoverageHandler::HandlePHPCoverage(
 {
   cmParsePHPCoverage cov(*cont, this->CTest);
   std::string coverageDir = this->CTest->GetBinaryDir() + "/xdebugCoverage";
-  if(cmSystemTools::FileIsDirectory(coverageDir))
-    {
+  if (cmSystemTools::FileIsDirectory(coverageDir)) {
     cov.ReadPHPCoverageDirectory(coverageDir.c_str());
-    }
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
@@ -812,31 +736,27 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage(
   // binary directory is used.
   std::string coverageXMLFile;
   const char* covDir = cmSystemTools::GetEnv("COBERTURADIR");
-  if(covDir && strlen(covDir) != 0)
-    {
-      coverageXMLFile = std::string(covDir);
-    }
-  else
-    {
-      coverageXMLFile = this->CTest->GetBinaryDir();
-    }
+  if (covDir && strlen(covDir) != 0) {
+    coverageXMLFile = std::string(covDir);
+  } else {
+    coverageXMLFile = this->CTest->GetBinaryDir();
+  }
   // build the find file string with the directory from above
   coverageXMLFile += "/coverage.xml";
 
-  if(cmSystemTools::FileExists(coverageXMLFile.c_str()))
-    {
+  if (cmSystemTools::FileExists(coverageXMLFile.c_str())) {
     // If file exists, parse it
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Parsing Cobertura XML file: " << coverageXMLFile
-               << std::endl, this->Quiet);
+                       "Parsing Cobertura XML file: " << coverageXMLFile
+                                                      << std::endl,
+                       this->Quiet);
     cov.ReadCoverageXML(coverageXMLFile.c_str());
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Cannot find Cobertura XML file: " << coverageXMLFile
-               << std::endl, this->Quiet);
-    }
+                       " Cannot find Cobertura XML file: " << coverageXMLFile
+                                                           << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
@@ -845,82 +765,71 @@ int cmCTestCoverageHandler::HandleMumpsCoverage(
 {
   // try gtm coverage
   cmParseGTMCoverage cov(*cont, this->CTest);
-  std::string coverageFile = this->CTest->GetBinaryDir() +
-    "/gtm_coverage.mcov";
-  if(cmSystemTools::FileExists(coverageFile.c_str()))
-    {
+  std::string coverageFile =
+    this->CTest->GetBinaryDir() + "/gtm_coverage.mcov";
+  if (cmSystemTools::FileExists(coverageFile.c_str())) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Parsing Cache Coverage: " << coverageFile
-               << std::endl, this->Quiet);
+                       "Parsing Cache Coverage: " << coverageFile << std::endl,
+                       this->Quiet);
     cov.ReadCoverageFile(coverageFile.c_str());
     return static_cast<int>(cont->TotalCoverage.size());
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Cannot find GTM coverage file: " << coverageFile
-               << std::endl, this->Quiet);
-    }
+                       " Cannot find GTM coverage file: " << coverageFile
+                                                          << std::endl,
+                       this->Quiet);
+  }
   cmParseCacheCoverage ccov(*cont, this->CTest);
-  coverageFile = this->CTest->GetBinaryDir() +
-    "/cache_coverage.cmcov";
-  if(cmSystemTools::FileExists(coverageFile.c_str()))
-    {
+  coverageFile = this->CTest->GetBinaryDir() + "/cache_coverage.cmcov";
+  if (cmSystemTools::FileExists(coverageFile.c_str())) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Parsing Cache Coverage: " << coverageFile
-               << std::endl, this->Quiet);
+                       "Parsing Cache Coverage: " << coverageFile << std::endl,
+                       this->Quiet);
     ccov.ReadCoverageFile(coverageFile.c_str());
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Cannot find Cache coverage file: " << coverageFile
-               << std::endl, this->Quiet);
-    }
+                       " Cannot find Cache coverage file: " << coverageFile
+                                                            << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
 struct cmCTestCoverageHandlerLocale
 {
   cmCTestCoverageHandlerLocale()
-    {
-    if(const char* l = cmSystemTools::GetEnv("LC_ALL"))
-      {
+  {
+    if (const char* l = cmSystemTools::GetEnv("LC_ALL")) {
       lc_all = l;
-      }
-    if(lc_all != "C")
-      {
+    }
+    if (lc_all != "C") {
       cmSystemTools::PutEnv("LC_ALL=C");
-      }
     }
+  }
   ~cmCTestCoverageHandlerLocale()
-    {
-    if(!lc_all.empty())
-      {
+  {
+    if (!lc_all.empty()) {
       cmSystemTools::PutEnv("LC_ALL=" + lc_all);
-      }
-    else
-      {
+    } else {
       cmSystemTools::UnsetEnv("LC_ALL");
-      }
     }
+  }
   std::string lc_all;
 };
 
 int cmCTestCoverageHandler::HandleJacocoCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  cmParseJacocoCoverage cov =
-   cmParseJacocoCoverage(*cont, this->CTest);
+  cmParseJacocoCoverage cov = cmParseJacocoCoverage(*cont, this->CTest);
 
   // Search in the source directory.
   cmsys::Glob g1;
   std::vector<std::string> files;
   g1.SetRecurse(true);
 
-  std::string SourceDir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
-  std::string coverageFile = SourceDir+ "/*jacoco.xml";
+  std::string SourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string coverageFile = SourceDir + "/*jacoco.xml";
 
   g1.FindFiles(coverageFile);
   files = g1.GetFiles();
@@ -929,147 +838,132 @@ int cmCTestCoverageHandler::HandleJacocoCoverage(
   cmsys::Glob g2;
   std::vector<std::string> binFiles;
   g2.SetRecurse(true);
-  std::string binaryDir
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
-  std::string binCoverageFile = binaryDir+ "/*jacoco.xml";
+  std::string binaryDir = this->CTest->GetCTestConfiguration("BuildDirectory");
+  std::string binCoverageFile = binaryDir + "/*jacoco.xml";
   g2.FindFiles(binCoverageFile);
   binFiles = g2.GetFiles();
-  if (!binFiles.empty())
-    {
+  if (!binFiles.empty()) {
     files.insert(files.end(), binFiles.begin(), binFiles.end());
-    }
+  }
 
-  if (!files.empty())
-    {
+  if (!files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Found Jacoco Files, Performing Coverage" << std::endl, this->Quiet);
+                       "Found Jacoco Files, Performing Coverage" << std::endl,
+                       this->Quiet);
     cov.LoadCoverageData(files);
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find Jacoco coverage files: " << coverageFile
-      << std::endl, this->Quiet);
-    }
+                       " Cannot find Jacoco coverage files: " << coverageFile
+                                                              << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
 int cmCTestCoverageHandler::HandleDelphiCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  cmParseDelphiCoverage cov =
-   cmParseDelphiCoverage(*cont, this->CTest);
+  cmParseDelphiCoverage cov = cmParseDelphiCoverage(*cont, this->CTest);
   cmsys::Glob g;
   std::vector<std::string> files;
   g.SetRecurse(true);
 
-
-  std::string BinDir
-    = this->CTest->GetBinaryDir();
-  std::string coverageFile = BinDir+ "/*(*.pas).html";
-
+  std::string BinDir = this->CTest->GetBinaryDir();
+  std::string coverageFile = BinDir + "/*(*.pas).html";
 
   g.FindFiles(coverageFile);
-  files=g.GetFiles();
-  if (!files.empty())
-    {
+  files = g.GetFiles();
+  if (!files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Found Delphi HTML Files, Performing Coverage" << std::endl,
-      this->Quiet);
+                       "Found Delphi HTML Files, Performing Coverage"
+                         << std::endl,
+                       this->Quiet);
     cov.LoadCoverageData(files);
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find Delphi coverage files: " << coverageFile
-      << std::endl, this->Quiet);
-    }
+                       " Cannot find Delphi coverage files: " << coverageFile
+                                                              << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
 int cmCTestCoverageHandler::HandleBlanketJSCoverage(
   cmCTestCoverageHandlerContainer* cont)
-  {
-  cmParseBlanketJSCoverage cov =
-   cmParseBlanketJSCoverage(*cont, this->CTest);
-  std::string SourceDir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
+{
+  cmParseBlanketJSCoverage cov = cmParseBlanketJSCoverage(*cont, this->CTest);
+  std::string SourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
 
-  //Look for something other than output.json, still JSON extension.
-  std::string coverageFile = SourceDir+ "/*.json";
+  // Look for something other than output.json, still JSON extension.
+  std::string coverageFile = SourceDir + "/*.json";
   cmsys::Glob g;
   std::vector<std::string> files;
   std::vector<std::string> blanketFiles;
   g.FindFiles(coverageFile);
-  files=g.GetFiles();
+  files = g.GetFiles();
   // Ensure that the JSON files found are the result of the
   // Blanket.js output. Check for the "node-jscoverage"
   // string on the second line
   std::string line;
-  for(unsigned int fileEntry=0;fileEntry<files.size();fileEntry++)
-    {
+  for (unsigned int fileEntry = 0; fileEntry < files.size(); fileEntry++) {
     cmsys::ifstream in(files[fileEntry].c_str());
     cmSystemTools::GetLineFromStream(in, line);
     cmSystemTools::GetLineFromStream(in, line);
-    if (line.find("node-jscoverage") != line.npos)
-      {
+    if (line.find("node-jscoverage") != line.npos) {
       blanketFiles.push_back(files[fileEntry]);
-      }
     }
+  }
   //  Take all files with the node-jscoverage string and parse those
-  if (!blanketFiles.empty())
-    {
+  if (!blanketFiles.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Found BlanketJS output JSON, Performing Coverage" << std::endl,
-      this->Quiet);
+                       "Found BlanketJS output JSON, Performing Coverage"
+                         << std::endl,
+                       this->Quiet);
     cov.LoadCoverageData(files);
-    }
-  else
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-       " Cannot find BlanketJS coverage files: " << coverageFile
-       << std::endl, this->Quiet);
-    }
-  return static_cast<int>(cont->TotalCoverage.size());
+  } else {
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
+      " Cannot find BlanketJS coverage files: " << coverageFile << std::endl,
+      this->Quiet);
   }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
 int cmCTestCoverageHandler::HandleGCovCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  std::string gcovCommand
-    = this->CTest->GetCTestConfiguration("CoverageCommand");
-  if (gcovCommand.empty())
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Could not find gcov." << std::endl);
+  std::string gcovCommand =
+    this->CTest->GetCTestConfiguration("CoverageCommand");
+  if (gcovCommand.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not find gcov."
+                 << std::endl);
     return 0;
-    }
-  std::string gcovExtraFlags
-    = this->CTest->GetCTestConfiguration("CoverageExtraFlags");
+  }
+  std::string gcovExtraFlags =
+    this->CTest->GetCTestConfiguration("CoverageExtraFlags");
 
   // Immediately skip to next coverage option since codecov is only for Intel
   // compiler
-  if ( gcovCommand == "codecov" )
-    {
+  if (gcovCommand == "codecov") {
     return 0;
-    }
+  }
 
   // Style 1
-  std::string st1gcovOutputRex1
-    = "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$";
+  std::string st1gcovOutputRex1 =
+    "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$";
   std::string st1gcovOutputRex2 = "^Creating (.*\\.gcov)\\.";
   cmsys::RegularExpression st1re1(st1gcovOutputRex1.c_str());
   cmsys::RegularExpression st1re2(st1gcovOutputRex2.c_str());
 
-
   // Style 2
   std::string st2gcovOutputRex1 = "^File *[`'](.*)'$";
-  std::string st2gcovOutputRex2
-    = "Lines executed: *[0-9]+\\.[0-9]+% of [0-9]+$";
+  std::string st2gcovOutputRex2 =
+    "Lines executed: *[0-9]+\\.[0-9]+% of [0-9]+$";
   std::string st2gcovOutputRex3 = "^(.*)reating [`'](.*\\.gcov)'";
   std::string st2gcovOutputRex4 = "^(.*):unexpected EOF *$";
   std::string st2gcovOutputRex5 = "^(.*):cannot open source file*$";
-  std::string st2gcovOutputRex6
-    = "^(.*):source file is newer than graph file `(.*)'$";
+  std::string st2gcovOutputRex6 =
+    "^(.*):source file is newer than graph file `(.*)'$";
   cmsys::RegularExpression st2re1(st2gcovOutputRex1.c_str());
   cmsys::RegularExpression st2re2(st2gcovOutputRex2.c_str());
   cmsys::RegularExpression st2re3(st2gcovOutputRex3.c_str());
@@ -1081,14 +975,13 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   this->FindGCovFiles(files);
   std::vector<std::string>::iterator it;
 
-  if (files.empty())
-    {
+  if (files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find any GCov coverage files."
-      << std::endl, this->Quiet);
+                       " Cannot find any GCov coverage files." << std::endl,
+                       this->Quiet);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
-    }
+  }
 
   std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
   std::string tempDir = testingDir + "/CoverageInfo";
@@ -1101,7 +994,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   std::set<std::string> missingFiles;
 
   std::string actualSourceFile = "";
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
     "   Processing coverage (each . represents one file):" << std::endl,
     this->Quiet);
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
@@ -1115,259 +1009,216 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   // These are binary files that you give as input to gcov so that it will
   // give us text output we can analyze to summarize coverage.
   //
-  for ( it = files.begin(); it != files.end(); ++ it )
-    {
+  for (it = files.begin(); it != files.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
-      this->Quiet);
+                       this->Quiet);
 
     // Call gcov to get coverage data for this *.gcda file:
     //
     std::string fileDir = cmSystemTools::GetFilenamePath(*it);
-    std::string command = "\"" + gcovCommand + "\" " +
-      gcovExtraFlags + " " +
-      "-o \"" + fileDir + "\" " +
-      "\"" + *it + "\"";
+    std::string command = "\"" + gcovCommand + "\" " + gcovExtraFlags + " " +
+      "-o \"" + fileDir + "\" " + "\"" + *it + "\"";
 
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, command.c_str()
-      << std::endl, this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       command.c_str() << std::endl, this->Quiet);
 
     std::string output = "";
     std::string errors = "";
     int retVal = 0;
     *cont->OFS << "* Run coverage for: " << fileDir << std::endl;
     *cont->OFS << "  Command: " << command << std::endl;
-    int res = this->CTest->RunCommand(command.c_str(), &output, &errors,
-      &retVal, tempDir.c_str(), 0 /*this->TimeOut*/);
+    int res =
+      this->CTest->RunCommand(command.c_str(), &output, &errors, &retVal,
+                              tempDir.c_str(), 0 /*this->TimeOut*/);
 
     *cont->OFS << "  Output: " << output << std::endl;
     *cont->OFS << "  Errors: " << errors << std::endl;
-    if ( ! res )
-      {
+    if (!res) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Problem running coverage on file: " << *it << std::endl);
+                 "Problem running coverage on file: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << errors << std::endl);
-      cont->Error ++;
+                 "Command produced error: " << errors << std::endl);
+      cont->Error++;
       continue;
-      }
-    if ( retVal != 0 )
-      {
+    }
+    if (retVal != 0) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
-        << retVal << " while processing: " << *it << std::endl);
+                   << retVal << " while processing: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << cont->Error << std::endl);
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Command produced error: " << cont->Error << std::endl);
+    }
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
       "--------------------------------------------------------------"
-      << std::endl
-      << output << std::endl
-      << "--------------------------------------------------------------"
-      << std::endl, this->Quiet);
+        << std::endl
+        << output << std::endl
+        << "--------------------------------------------------------------"
+        << std::endl,
+      this->Quiet);
 
     std::vector<std::string> lines;
     std::vector<std::string>::iterator line;
 
     cmSystemTools::Split(output.c_str(), lines);
 
-    for ( line = lines.begin(); line != lines.end(); ++line)
-      {
+    for (line = lines.begin(); line != lines.end(); ++line) {
       std::string sourceFile;
       std::string gcovFile;
 
-      cmCTestOptionalLog(this->CTest, DEBUG, "Line: [" << *line << "]"
-        << std::endl, this->Quiet);
+      cmCTestOptionalLog(this->CTest, DEBUG,
+                         "Line: [" << *line << "]" << std::endl, this->Quiet);
 
-      if (line->empty())
-        {
+      if (line->empty()) {
         // Ignore empty line; probably style 2
-        }
-      else if ( st1re1.find(line->c_str()) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st1re1.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 1;
-          }
-        if ( gcovStyle != 1 )
-          {
+        }
+        if (gcovStyle != 1) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e1"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         actualSourceFile = "";
         sourceFile = st1re1.match(2);
-        }
-      else if ( st1re2.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st1re2.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 1;
-          }
-        if ( gcovStyle != 1 )
-          {
+        }
+        if (gcovStyle != 1) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e2"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         gcovFile = st1re2.match(1);
-        }
-      else if ( st2re1.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re1.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e3"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         actualSourceFile = "";
         sourceFile = st2re1.match(1);
-        }
-      else if ( st2re2.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re2.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e4"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
         }
-      else if ( st2re3.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re3.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e5"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         gcovFile = st2re3.match(2);
-        }
-      else if ( st2re4.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re4.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e6"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
-
-        cmCTestOptionalLog(this->CTest, WARNING, "Warning: " << st2re4.match(1)
-          << " had unexpected EOF" << std::endl, this->Quiet);
         }
-      else if ( st2re5.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+
+        cmCTestOptionalLog(this->CTest, WARNING,
+                           "Warning: " << st2re4.match(1)
+                                       << " had unexpected EOF" << std::endl,
+                           this->Quiet);
+      } else if (st2re5.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e7"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         cmCTestOptionalLog(this->CTest, WARNING, "Warning: Cannot open file: "
-          << st2re5.match(1) << std::endl, this->Quiet);
-        }
-      else if ( st2re6.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+                             << st2re5.match(1) << std::endl,
+                           this->Quiet);
+      } else if (st2re6.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e8"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         cmCTestOptionalLog(this->CTest, WARNING, "Warning: File: "
-          << st2re6.match(1)
-          << " is newer than " << st2re6.match(2) << std::endl, this->Quiet);
-        }
-      else
-        {
+                             << st2re6.match(1) << " is newer than "
+                             << st2re6.match(2) << std::endl,
+                           this->Quiet);
+      } else {
         // gcov 4.7 can have output lines saying "No executable lines" and
         // "Removing 'filename.gcov'"... Don't log those as "errors."
-        if(*line != "No executable lines" &&
-           !cmSystemTools::StringStartsWith(line->c_str(), "Removing "))
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE,
-            "Unknown gcov output line: [" << *line << "]"
-            << std::endl);
-          cont->Error ++;
-          //abort();
-          }
+        if (*line != "No executable lines" &&
+            !cmSystemTools::StringStartsWith(line->c_str(), "Removing ")) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output line: ["
+                       << *line << "]" << std::endl);
+          cont->Error++;
+          // abort();
         }
-
+      }
 
       // If the last line of gcov output gave us a valid value for gcovFile,
       // and we have an actualSourceFile, then insert a (or add to existing)
       // SingleFileCoverageVector for actualSourceFile:
       //
-      if ( !gcovFile.empty() && !actualSourceFile.empty() )
-        {
-        cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec
-          = cont->TotalCoverage[actualSourceFile];
+      if (!gcovFile.empty() && !actualSourceFile.empty()) {
+        cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec =
+          cont->TotalCoverage[actualSourceFile];
 
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "   in gcovFile: " << gcovFile << std::endl, this->Quiet);
+                           "   in gcovFile: " << gcovFile << std::endl,
+                           this->Quiet);
 
         cmsys::ifstream ifile(gcovFile.c_str());
-        if ( ! ifile )
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-            << gcovFile << std::endl);
-          }
-        else
-          {
+        if (!ifile) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot open file: " << gcovFile << std::endl);
+        } else {
           long cnt = -1;
           std::string nl;
-          while ( cmSystemTools::GetLineFromStream(ifile, nl) )
-            {
-            cnt ++;
+          while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+            cnt++;
 
-            //TODO: Handle gcov 3.0 non-coverage lines
+            // TODO: Handle gcov 3.0 non-coverage lines
 
             // Skip empty lines
-            if (nl.empty())
-              {
+            if (nl.empty()) {
               continue;
-              }
+            }
 
             // Skip unused lines
-            if ( nl.size() < 12 )
-              {
+            if (nl.size() < 12) {
               continue;
-              }
+            }
 
             // Read the coverage count from the beginning of the gcov output
             // line
@@ -1378,96 +1229,86 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
             // output line
             std::string lineNumber = nl.substr(10, 5);
 
-            int lineIdx = atoi(lineNumber.c_str())-1;
-            if ( lineIdx >= 0 )
-              {
-              while ( vec.size() <= static_cast<size_t>(lineIdx) )
-                {
+            int lineIdx = atoi(lineNumber.c_str()) - 1;
+            if (lineIdx >= 0) {
+              while (vec.size() <= static_cast<size_t>(lineIdx)) {
                 vec.push_back(-1);
-                }
+              }
 
               // Initially all entries are -1 (not used). If we get coverage
               // information, increment it to 0 first.
-              if ( vec[lineIdx] < 0 )
-                {
-                if ( cov > 0 || prefix.find("#") != prefix.npos )
-                  {
+              if (vec[lineIdx] < 0) {
+                if (cov > 0 || prefix.find("#") != prefix.npos) {
                   vec[lineIdx] = 0;
-                  }
                 }
+              }
 
               vec[lineIdx] += cov;
-              }
             }
           }
-
-        actualSourceFile = "";
         }
 
+        actualSourceFile = "";
+      }
 
-      if ( !sourceFile.empty() && actualSourceFile.empty() )
-        {
+      if (!sourceFile.empty() && actualSourceFile.empty()) {
         gcovFile = "";
 
         // Is it in the source dir or the binary dir?
         //
-        if ( IsFileInDir(sourceFile, cont->SourceDir) )
-          {
+        if (IsFileInDir(sourceFile, cont->SourceDir)) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "   produced s: " << sourceFile << std::endl, this->Quiet);
+                             "   produced s: " << sourceFile << std::endl,
+                             this->Quiet);
           *cont->OFS << "  produced in source dir: " << sourceFile
-            << std::endl;
-          actualSourceFile
-            = cmSystemTools::CollapseFullPath(sourceFile);
-          }
-        else if ( IsFileInDir(sourceFile, cont->BinaryDir) )
-          {
+                     << std::endl;
+          actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile);
+        } else if (IsFileInDir(sourceFile, cont->BinaryDir)) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "   produced b: " << sourceFile << std::endl, this->Quiet);
+                             "   produced b: " << sourceFile << std::endl,
+                             this->Quiet);
           *cont->OFS << "  produced in binary dir: " << sourceFile
-            << std::endl;
-          actualSourceFile
-            = cmSystemTools::CollapseFullPath(sourceFile);
-          }
+                     << std::endl;
+          actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile);
+        }
 
-        if ( actualSourceFile.empty() )
-          {
-          if ( missingFiles.find(sourceFile) == missingFiles.end() )
-            {
+        if (actualSourceFile.empty()) {
+          if (missingFiles.find(sourceFile) == missingFiles.end()) {
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              "Something went wrong" << std::endl, this->Quiet);
+                               "Something went wrong" << std::endl,
+                               this->Quiet);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              "Cannot find file: ["
-              << sourceFile << "]" << std::endl, this->Quiet);
+                               "Cannot find file: [" << sourceFile << "]"
+                                                     << std::endl,
+                               this->Quiet);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              " in source dir: ["
-              << cont->SourceDir << "]"
-              << std::endl, this->Quiet);
+                               " in source dir: [" << cont->SourceDir << "]"
+                                                   << std::endl,
+                               this->Quiet);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              " or binary dir: ["
-              << cont->BinaryDir.size() << "]"
-              << std::endl, this->Quiet);
+                               " or binary dir: [" << cont->BinaryDir.size()
+                                                   << "]" << std::endl,
+                               this->Quiet);
             *cont->OFS << "  Something went wrong. Cannot find file: "
-              << sourceFile
-              << " in source dir: " << cont->SourceDir
-              << " or binary dir: " << cont->BinaryDir << std::endl;
+                       << sourceFile << " in source dir: " << cont->SourceDir
+                       << " or binary dir: " << cont->BinaryDir << std::endl;
 
             missingFiles.insert(sourceFile);
-            }
           }
         }
       }
+    }
 
     file_count++;
 
-    if ( file_count % 50 == 0 )
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " processed: "
-        << file_count
-        << " out of " << files.size() << std::endl, this->Quiet);
+    if (file_count % 50 == 0) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         " processed: " << file_count << " out of "
+                                        << files.size() << std::endl,
+                         this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
-      }
     }
+  }
 
   cmSystemTools::ChangeDirectory(currentDirectory);
   return file_count;
@@ -1476,46 +1317,44 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
 int cmCTestCoverageHandler::HandleLCovCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  std::string lcovCommand
-    = this->CTest->GetCTestConfiguration("CoverageCommand");
-  std::string lcovExtraFlags
-    = this->CTest->GetCTestConfiguration("CoverageExtraFlags");
-  if ( lcovCommand != "codecov" )
-    {
+  std::string lcovCommand =
+    this->CTest->GetCTestConfiguration("CoverageCommand");
+  std::string lcovExtraFlags =
+    this->CTest->GetCTestConfiguration("CoverageExtraFlags");
+  if (lcovCommand != "codecov") {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Not a valid Intel Coverage command."
-               << std::endl, this->Quiet);
+                       " Not a valid Intel Coverage command." << std::endl,
+                       this->Quiet);
     return 0;
-    }
+  }
   // There is only percentage completed output from LCOV
   std::string st2lcovOutputRex3 = "[0-9]+%";
   cmsys::RegularExpression st2re3(st2lcovOutputRex3.c_str());
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " This is coverage command: " << lcovCommand
-    << std::endl, this->Quiet);
+                     " This is coverage command: " << lcovCommand << std::endl,
+                     this->Quiet);
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " These are coverage command flags: " << lcovExtraFlags
-    << std::endl, this->Quiet);
+                     " These are coverage command flags: " << lcovExtraFlags
+                                                           << std::endl,
+                     this->Quiet);
 
   std::vector<std::string> files;
-  if (!this->FindLCovFiles(files))
-    {
+  if (!this->FindLCovFiles(files)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Error while finding LCov files.\n");
     return 0;
-    }
+  }
   std::vector<std::string>::iterator it;
 
-  if (files.empty())
-    {
+  if (files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find any LCov coverage files."
-      << std::endl, this->Quiet);
+                       " Cannot find any LCov coverage files." << std::endl,
+                       this->Quiet);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
-    }
+  }
   std::string testingDir = this->CTest->GetBinaryDir();
   std::string tempDir = testingDir;
   std::string currentDirectory = cmSystemTools::GetCurrentWorkingDirectory();
@@ -1523,7 +1362,8 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
   std::set<std::string> missingFiles;
 
   std::string actualSourceFile = "";
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
     "   Processing coverage (each . represents one file):" << std::endl,
     this->Quiet);
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
@@ -1535,67 +1375,65 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
 
   // In intel compiler we have to call codecov only once in each executable
   // directory. It collects all *.dyn files to generate .dpi file.
-  for ( it = files.begin(); it != files.end(); ++ it )
-    {
+  for (it = files.begin(); it != files.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
-      this->Quiet);
+                       this->Quiet);
     std::string fileDir = cmSystemTools::GetFilenamePath(*it);
     cmSystemTools::ChangeDirectory(fileDir);
-    std::string command = "\"" + lcovCommand + "\" " +
-      lcovExtraFlags + " ";
+    std::string command = "\"" + lcovCommand + "\" " + lcovExtraFlags + " ";
 
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Current coverage dir: " << fileDir << std::endl, this->Quiet);
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, command.c_str()
-      << std::endl, this->Quiet);
+                       "Current coverage dir: " << fileDir << std::endl,
+                       this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       command.c_str() << std::endl, this->Quiet);
 
     std::string output = "";
     std::string errors = "";
     int retVal = 0;
     *cont->OFS << "* Run coverage for: " << fileDir << std::endl;
     *cont->OFS << "  Command: " << command << std::endl;
-    int res = this->CTest->RunCommand(command.c_str(), &output, &errors,
-                &retVal, fileDir.c_str(), 0 /*this->TimeOut*/);
+    int res =
+      this->CTest->RunCommand(command.c_str(), &output, &errors, &retVal,
+                              fileDir.c_str(), 0 /*this->TimeOut*/);
 
     *cont->OFS << "  Output: " << output << std::endl;
     *cont->OFS << "  Errors: " << errors << std::endl;
-    if ( ! res )
-      {
+    if (!res) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Problem running coverage on file: " << *it << std::endl);
+                 "Problem running coverage on file: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << errors << std::endl);
-      cont->Error ++;
+                 "Command produced error: " << errors << std::endl);
+      cont->Error++;
       continue;
-      }
-    if ( retVal != 0 )
-      {
+    }
+    if (retVal != 0) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
-        << retVal << " while processing: " << *it << std::endl);
+                   << retVal << " while processing: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << cont->Error << std::endl);
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Command produced error: " << cont->Error << std::endl);
+    }
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
       "--------------------------------------------------------------"
-      << std::endl
-      << output << std::endl
-      << "--------------------------------------------------------------"
-      << std::endl, this->Quiet);
+        << std::endl
+        << output << std::endl
+        << "--------------------------------------------------------------"
+        << std::endl,
+      this->Quiet);
 
     std::vector<std::string> lines;
     std::vector<std::string>::iterator line;
 
     cmSystemTools::Split(output.c_str(), lines);
 
-    for ( line = lines.begin(); line != lines.end(); ++line)
-      {
+    for (line = lines.begin(); line != lines.end(); ++line) {
       std::string sourceFile;
       std::string lcovFile;
 
-      if (line->empty())
-        {
+      if (line->empty()) {
         // Ignore empty line
-        }
+      }
       // Look for LCOV files in binary directory
       // Intel Compiler creates a CodeCoverage dir for each subfolder and
       // each subfolder has LCOV files
@@ -1608,89 +1446,84 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
       std::string daGlob;
       daGlob = dir;
       daGlob += "/*.LCOV";
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_VERBOSE_OUTPUT,
         "   looking for LCOV files in: " << daGlob << std::endl, this->Quiet);
       gl.FindFiles(daGlob);
       // Keep a list of all LCOV files
       lcovFiles.insert(lcovFiles.end(), gl.GetFiles().begin(),
                        gl.GetFiles().end());
 
-      for(std::vector<std::string>::iterator a = lcovFiles.begin();
-          a != lcovFiles.end(); ++a)
-        {
+      for (std::vector<std::string>::iterator a = lcovFiles.begin();
+           a != lcovFiles.end(); ++a) {
         lcovFile = *a;
         cmsys::ifstream srcead(lcovFile.c_str());
-        if ( ! srcead )
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-                     << lcovFile << std::endl);
-          }
+        if (!srcead) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot open file: " << lcovFile << std::endl);
+        }
         std::string srcname;
 
         int success = cmSystemTools::GetLineFromStream(srcead, srcname);
-        if ( !success )
-          {
+        if (!success) {
           cmCTestLog(this->CTest, ERROR_MESSAGE,
-                     "Error while parsing lcov file '" << lcovFile << "':"
-                     << " No source file name found!" << std::endl);
+                     "Error while parsing lcov file '"
+                       << lcovFile << "':"
+                       << " No source file name found!" << std::endl);
           return 0;
-          }
+        }
         srcname = srcname.substr(18);
         // We can directly read found LCOV files to determine the source
         // files
         sourceFile = srcname;
         actualSourceFile = srcname;
 
-        for(std::vector<std::string>::iterator t = lcovFiles.begin();
-            t != lcovFiles.end(); ++t)
-          {
+        for (std::vector<std::string>::iterator t = lcovFiles.begin();
+             t != lcovFiles.end(); ++t) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "Found LCOV File: " << *t << std::endl, this->Quiet);
-          }
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "SourceFile: "
-          << sourceFile << std::endl, this->Quiet);
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "lCovFile: "
-        << lcovFile << std::endl, this->Quiet);
+                             "Found LCOV File: " << *t << std::endl,
+                             this->Quiet);
+        }
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "SourceFile: " << sourceFile << std::endl,
+                           this->Quiet);
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "lCovFile: " << lcovFile << std::endl, this->Quiet);
 
         // If we have some LCOV files to process
-        if ( !lcovFile.empty() && !actualSourceFile.empty() )
-          {
-          cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec
-            = cont->TotalCoverage[actualSourceFile];
+        if (!lcovFile.empty() && !actualSourceFile.empty()) {
+          cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec =
+            cont->TotalCoverage[actualSourceFile];
 
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "   in lcovFile: " << lcovFile << std::endl, this->Quiet);
+                             "   in lcovFile: " << lcovFile << std::endl,
+                             this->Quiet);
 
           cmsys::ifstream ifile(lcovFile.c_str());
-          if ( ! ifile )
-            {
-            cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-                       << lcovFile << std::endl);
-            }
-          else
-            {
+          if (!ifile) {
+            cmCTestLog(this->CTest, ERROR_MESSAGE,
+                       "Cannot open file: " << lcovFile << std::endl);
+          } else {
             long cnt = -1;
             std::string nl;
 
             // Skip the first line
             cmSystemTools::GetLineFromStream(ifile, nl);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              "File is ready, start reading." << std::endl, this->Quiet);
-            while ( cmSystemTools::GetLineFromStream(ifile, nl) )
-              {
-              cnt ++;
+                               "File is ready, start reading." << std::endl,
+                               this->Quiet);
+            while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+              cnt++;
 
               // Skip empty lines
-              if (nl.empty())
-                {
+              if (nl.empty()) {
                 continue;
-                }
+              }
 
               // Skip unused lines
-              if ( nl.size() < 12 )
-                {
+              if (nl.size() < 12) {
                 continue;
-                }
+              }
 
               // Read the coverage count from the beginning of the lcov
               // output line
@@ -1701,44 +1534,40 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
               // lcov output line
               std::string lineNumber = nl.substr(17, 7);
 
-              int lineIdx = atoi(lineNumber.c_str())-1;
-              if ( lineIdx >= 0 )
-                {
-                while ( vec.size() <= static_cast<size_t>(lineIdx) )
-                  {
+              int lineIdx = atoi(lineNumber.c_str()) - 1;
+              if (lineIdx >= 0) {
+                while (vec.size() <= static_cast<size_t>(lineIdx)) {
                   vec.push_back(-1);
-                  }
+                }
 
                 // Initially all entries are -1 (not used). If we get coverage
                 // information, increment it to 0 first.
-                if ( vec[lineIdx] < 0 )
-                  {
-                  if ( cov > 0 || prefix.find("#") != prefix.npos )
-                    {
+                if (vec[lineIdx] < 0) {
+                  if (cov > 0 || prefix.find("#") != prefix.npos) {
                     vec[lineIdx] = 0;
-                    }
                   }
+                }
 
                 vec[lineIdx] += cov;
-                }
               }
             }
+          }
 
           actualSourceFile = "";
-          }
         }
       }
+    }
 
     file_count++;
 
-    if ( file_count % 50 == 0 )
-      {
+    if (file_count % 50 == 0) {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        " processed: " << file_count << " out of " << files.size()
-        << std::endl, this->Quiet);
+                         " processed: " << file_count << " out of "
+                                        << files.size() << std::endl,
+                         this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
-      }
     }
+  }
 
   cmSystemTools::ChangeDirectory(currentDirectory);
   return file_count;
@@ -1750,18 +1579,17 @@ void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
   gl.RecurseOn();
   gl.RecurseThroughSymlinksOff();
 
-  for(LabelMapType::const_iterator lmi = this->TargetDirs.begin();
-      lmi != this->TargetDirs.end(); ++lmi)
-    {
+  for (LabelMapType::const_iterator lmi = this->TargetDirs.begin();
+       lmi != this->TargetDirs.end(); ++lmi) {
     // Skip targets containing no interesting labels.
-    if(!this->IntersectsFilter(lmi->second))
-      {
+    if (!this->IntersectsFilter(lmi->second)) {
       continue;
-      }
+    }
 
     // Coverage files appear next to their object files in the target
     // support directory.
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
       "   globbing for coverage in: " << lmi->first << std::endl, this->Quiet);
     std::string daGlob = lmi->first;
     daGlob += "/*.da";
@@ -1771,7 +1599,7 @@ void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
     daGlob += "/*.gcda";
     gl.FindFiles(daGlob);
     files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
-    }
+  }
 }
 
 bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
@@ -1782,20 +1610,17 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
   gl.RecurseThroughSymlinksOff();
   std::string prevBinaryDir;
   std::string buildDir = this->CTest->GetCTestConfiguration("BuildDirectory");
-  if (cmSystemTools::ChangeDirectory(buildDir))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Error changing directory to " << buildDir << std::endl);
+  if (cmSystemTools::ChangeDirectory(buildDir)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error changing directory to "
+                 << buildDir << std::endl);
     return false;
-    }
+  }
 
   // Run profmerge to merge all *.dyn files into dpi files
-  if (!cmSystemTools::RunSingleCommand("profmerge"))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Error while running profmerge.\n");
+  if (!cmSystemTools::RunSingleCommand("profmerge")) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error while running profmerge.\n");
     return false;
-    }
+  }
 
   prevBinaryDir = cmSystemTools::GetCurrentWorkingDirectory().c_str();
 
@@ -1804,16 +1629,16 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
   daGlob = prevBinaryDir;
   daGlob += "/*.dpi";
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "   looking for dpi files in: " << daGlob << std::endl, this->Quiet);
-  if (!gl.FindFiles(daGlob))
-    {
+                     "   looking for dpi files in: " << daGlob << std::endl,
+                     this->Quiet);
+  if (!gl.FindFiles(daGlob)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Error while finding files matching " << daGlob << std::endl);
     return false;
-    }
+  }
   files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Now searching in: " << daGlob << std::endl, this->Quiet);
+                     "Now searching in: " << daGlob << std::endl, this->Quiet);
   return true;
 }
 
@@ -1827,14 +1652,14 @@ int cmCTestCoverageHandler::HandleTracePyCoverage(
   gl.FindFiles(daGlob);
   std::vector<std::string> files = gl.GetFiles();
 
-  if (files.empty())
-    {
+  if (files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find any Python Trace.py coverage files."
-      << std::endl, this->Quiet);
+                       " Cannot find any Python Trace.py coverage files."
+                         << std::endl,
+                       this->Quiet);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
-    }
+  }
 
   std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
   std::string tempDir = testingDir + "/CoverageInfo";
@@ -1846,319 +1671,276 @@ int cmCTestCoverageHandler::HandleTracePyCoverage(
 
   std::vector<std::string>::iterator fileIt;
   int file_count = 0;
-  for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
-    {
+  for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
     std::string fileName = this->FindFile(cont, *fileIt);
-    if ( fileName.empty() )
-      {
+    if (fileName.empty()) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Cannot find source Python file corresponding to: "
-        << *fileIt << std::endl);
+                 "Cannot find source Python file corresponding to: "
+                   << *fileIt << std::endl);
       continue;
-      }
+    }
 
-    std::string actualSourceFile
-      = cmSystemTools::CollapseFullPath(fileName);
+    std::string actualSourceFile = cmSystemTools::CollapseFullPath(fileName);
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "   Check coverage for file: " << actualSourceFile
-      << std::endl, this->Quiet);
-    cmCTestCoverageHandlerContainer::SingleFileCoverageVector* vec
-      = &cont->TotalCoverage[actualSourceFile];
+                       "   Check coverage for file: " << actualSourceFile
+                                                      << std::endl,
+                       this->Quiet);
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector* vec =
+      &cont->TotalCoverage[actualSourceFile];
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "   in file: " << *fileIt << std::endl, this->Quiet);
+                       "   in file: " << *fileIt << std::endl, this->Quiet);
     cmsys::ifstream ifile(fileIt->c_str());
-    if ( ! ifile )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-        << *fileIt << std::endl);
-      }
-    else
-      {
+    if (!ifile) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot open file: " << *fileIt << std::endl);
+    } else {
       long cnt = -1;
       std::string nl;
-      while ( cmSystemTools::GetLineFromStream(ifile, nl) )
-        {
-        cnt ++;
+      while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+        cnt++;
 
         // Skip empty lines
-        if (nl.empty())
-          {
+        if (nl.empty()) {
           continue;
-          }
+        }
 
         // Skip unused lines
-        if ( nl.size() < 12 )
-          {
+        if (nl.size() < 12) {
           continue;
-          }
+        }
 
         // Read the coverage count from the beginning of the Trace.py output
         // line
         std::string prefix = nl.substr(0, 6);
-        if ( prefix[5] != ' ' && prefix[5] != ':' )
-          {
+        if (prefix[5] != ' ' && prefix[5] != ':') {
           // This is a hack. We should really do something more elaborate
           prefix = nl.substr(0, 7);
-          if ( prefix[6] != ' ' && prefix[6] != ':' )
-            {
+          if (prefix[6] != ' ' && prefix[6] != ':') {
             prefix = nl.substr(0, 8);
-            if ( prefix[7] != ' ' && prefix[7] != ':' )
-              {
+            if (prefix[7] != ' ' && prefix[7] != ':') {
               cmCTestLog(this->CTest, ERROR_MESSAGE,
-                "Currently the limit is maximum coverage of 999999"
-                << std::endl);
-              }
+                         "Currently the limit is maximum coverage of 999999"
+                           << std::endl);
             }
           }
+        }
         int cov = atoi(prefix.c_str());
-        if ( prefix[prefix.size()-1] != ':' )
-          {
+        if (prefix[prefix.size() - 1] != ':') {
           // This line does not have ':' so no coverage here. That said,
           // Trace.py does not handle not covered lines versus comments etc.
           // So, this will be set to 0.
           cov = 0;
-          }
-        cmCTestOptionalLog(this->CTest, DEBUG, "Prefix: " << prefix
-          << " cov: " << cov
-          << std::endl, this->Quiet);
+        }
+        cmCTestOptionalLog(
+          this->CTest, DEBUG,
+          "Prefix: " << prefix << " cov: " << cov << std::endl, this->Quiet);
         // Read the line number starting at the 10th character of the gcov
         // output line
         long lineIdx = cnt;
-        if ( lineIdx >= 0 )
-          {
-          while ( vec->size() <=
-            static_cast<size_t>(lineIdx) )
-            {
+        if (lineIdx >= 0) {
+          while (vec->size() <= static_cast<size_t>(lineIdx)) {
             vec->push_back(-1);
-            }
+          }
           // Initially all entries are -1 (not used). If we get coverage
           // information, increment it to 0 first.
-          if ( (*vec)[lineIdx] < 0 )
-            {
-            if ( cov >= 0 )
-              {
+          if ((*vec)[lineIdx] < 0) {
+            if (cov >= 0) {
               (*vec)[lineIdx] = 0;
-              }
             }
-          (*vec)[lineIdx] += cov;
           }
+          (*vec)[lineIdx] += cov;
         }
       }
-    ++ file_count;
     }
+    ++file_count;
+  }
   cmSystemTools::ChangeDirectory(currentDirectory);
   return file_count;
 }
 
 std::string cmCTestCoverageHandler::FindFile(
-  cmCTestCoverageHandlerContainer* cont,
-  std::string fileName)
+  cmCTestCoverageHandlerContainer* cont, std::string fileName)
 {
-  std::string fileNameNoE
-    = cmSystemTools::GetFilenameWithoutLastExtension(fileName);
+  std::string fileNameNoE =
+    cmSystemTools::GetFilenameWithoutLastExtension(fileName);
   // First check in source and binary directory
   std::string fullName = cont->SourceDir + "/" + fileNameNoE + ".py";
-  if ( cmSystemTools::FileExists(fullName.c_str()) )
-    {
+  if (cmSystemTools::FileExists(fullName.c_str())) {
     return fullName;
-    }
+  }
   fullName = cont->BinaryDir + "/" + fileNameNoE + ".py";
-  if ( cmSystemTools::FileExists(fullName.c_str()) )
-    {
+  if (cmSystemTools::FileExists(fullName.c_str())) {
     return fullName;
-    }
+  }
   return "";
 }
 
 // This is a header put on each marked up source file
-namespace
-{
-  const char* bullseyeHelp[] =
-  {"    Coverage produced by bullseye covbr tool: ",
-   "      www.bullseye.com/help/ref_covbr.html",
-   "    * An arrow --> indicates incomplete coverage.",
-   "    * An X indicates a function that was invoked, a switch label that ",
-   "      was exercised, a try-block that finished, or an exception handler ",
-   "      that was invoked.",
-   "    * A T or F indicates a boolean decision that evaluated true or false,",
-   "      respectively.",
-   "    * A t or f indicates a boolean condition within a decision if the ",
-   "      condition evaluated true or false, respectively.",
-   "    * A k indicates a constant decision or condition.",
-   "    * The slash / means this probe is excluded from summary results. ",
-   0};
+namespace {
+const char* bullseyeHelp[] = {
+  "    Coverage produced by bullseye covbr tool: ",
+  "      www.bullseye.com/help/ref_covbr.html",
+  "    * An arrow --> indicates incomplete coverage.",
+  "    * An X indicates a function that was invoked, a switch label that ",
+  "      was exercised, a try-block that finished, or an exception handler ",
+  "      that was invoked.",
+  "    * A T or F indicates a boolean decision that evaluated true or false,",
+  "      respectively.",
+  "    * A t or f indicates a boolean condition within a decision if the ",
+  "      condition evaluated true or false, respectively.",
+  "    * A k indicates a constant decision or condition.",
+  "    * The slash / means this probe is excluded from summary results. ",
+  0
+};
 }
 
 int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
   cmCTestCoverageHandlerContainer* cont,
-  std::set<std::string>& coveredFileNames,
-  std::vector<std::string>& files,
+  std::set<std::string>& coveredFileNames, std::vector<std::string>& files,
   std::vector<std::string>& filesFullPath)
 {
-  if(files.size() != filesFullPath.size())
-    {
+  if (files.size() != filesFullPath.size()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Files and full path files not the same size?:\n");
     return 0;
-    }
+  }
   // create the output stream for the CoverageLog-N.xml file
   cmGeneratedFileStream covLogFile;
   cmXMLWriter covLogXML(covLogFile);
   int logFileCount = 0;
-  if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-    {
+  if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
     return -1;
-    }
+  }
   this->StartCoverageLogXML(covLogXML);
   // for each file run covbr on that file to get the coverage
   // information for that file
   std::string outputFile;
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "run covbr: " << std::endl, this->Quiet);
+                     "run covbr: " << std::endl, this->Quiet);
 
-  if(!this->RunBullseyeCommand(cont, "covbr", 0, outputFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for." << "\n");
+  if (!this->RunBullseyeCommand(cont, "covbr", 0, outputFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for."
+                 << "\n");
     return -1;
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "covbr output in  " << outputFile << std::endl, this->Quiet);
+                     "covbr output in  " << outputFile << std::endl,
+                     this->Quiet);
   // open the output file
   cmsys::ifstream fin(outputFile.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Cannot open coverage file: " <<
-               outputFile << std::endl);
+               "Cannot open coverage file: " << outputFile << std::endl);
     return 0;
-    }
+  }
   std::map<std::string, std::string> fileMap;
   std::vector<std::string>::iterator fp = filesFullPath.begin();
-  for(std::vector<std::string>::iterator f =  files.begin();
-      f != files.end(); ++f, ++fp)
-    {
+  for (std::vector<std::string>::iterator f = files.begin(); f != files.end();
+       ++f, ++fp) {
     fileMap[*f] = *fp;
-    }
+  }
 
-  int count =0; // keep count of the number of files
+  int count = 0; // keep count of the number of files
   // Now parse each line from the bullseye cov log file
   std::string lineIn;
   bool valid = false; // are we in a valid output file
-  int line = 0; // line of the current file
+  int line = 0;       // line of the current file
   std::string file;
-  while(cmSystemTools::GetLineFromStream(fin, lineIn))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, lineIn)) {
     bool startFile = false;
-    if(lineIn.size() > 1 && lineIn[lineIn.size()-1] == ':')
-      {
-      file = lineIn.substr(0, lineIn.size()-1);
-      if(coveredFileNames.find(file) != coveredFileNames.end())
-        {
+    if (lineIn.size() > 1 && lineIn[lineIn.size() - 1] == ':') {
+      file = lineIn.substr(0, lineIn.size() - 1);
+      if (coveredFileNames.find(file) != coveredFileNames.end()) {
         startFile = true;
-        }
       }
-    if(startFile)
-      {
+    }
+    if (startFile) {
       // if we are in a valid file close it because a new one started
-      if(valid)
-        {
+      if (valid) {
         covLogXML.EndElement(); // Report
         covLogXML.EndElement(); // File
-        }
+      }
       // only allow 100 files in each log file
-      if ( count != 0 && count % 100 == 0 )
-        {
+      if (count != 0 && count % 100 == 0) {
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "start a new log file: " << count << std::endl, this->Quiet);
+                           "start a new log file: " << count << std::endl,
+                           this->Quiet);
         this->EndCoverageLogXML(covLogXML);
         this->EndCoverageLogFile(covLogFile, logFileCount);
-        logFileCount ++;
-        if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-          {
+        logFileCount++;
+        if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
           return -1;
-          }
+        }
         this->StartCoverageLogXML(covLogXML);
         count++; // move on one
-        }
-      std::map<std::string, std::string>::iterator
-        i = fileMap.find(file);
+      }
+      std::map<std::string, std::string>::iterator i = fileMap.find(file);
       // if the file should be covered write out the header for that file
-      if(i != fileMap.end())
-        {
+      if (i != fileMap.end()) {
         // we have a new file so count it in the output
         count++;
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "Produce coverage for file: " << file << " " << count
-          << std::endl, this->Quiet);
+                           "Produce coverage for file: " << file << " "
+                                                         << count << std::endl,
+                           this->Quiet);
         // start the file output
         covLogXML.StartElement("File");
         covLogXML.Attribute("Name", i->first);
-        covLogXML.Attribute("FullPath",
-          this->CTest->GetShortPathToFile(i->second.c_str()));
+        covLogXML.Attribute(
+          "FullPath", this->CTest->GetShortPathToFile(i->second.c_str()));
         covLogXML.StartElement("Report");
         // write the bullseye header
-        line =0;
-        for(int k =0; bullseyeHelp[k] != 0; ++k)
-          {
+        line = 0;
+        for (int k = 0; bullseyeHelp[k] != 0; ++k) {
           covLogXML.StartElement("Line");
           covLogXML.Attribute("Number", line);
           covLogXML.Attribute("Count", -1);
           covLogXML.Content(bullseyeHelp[k]);
           covLogXML.EndElement(); // Line
           line++;
-          }
-        valid = true; // we are in a valid file section
         }
-      else
-        {
+        valid = true; // we are in a valid file section
+      } else {
         // this is not a file that we want coverage for
         valid = false;
-        }
       }
+    }
     // we are not at a start file, and we are in a valid file output the line
-    else if(valid)
-      {
+    else if (valid) {
       covLogXML.StartElement("Line");
       covLogXML.Attribute("Number", line);
       covLogXML.Attribute("Count", -1);
       covLogXML.Content(lineIn);
       covLogXML.EndElement(); // Line
       line++;
-      }
     }
+  }
   // if we ran out of lines a valid file then close that file
-  if(valid)
-    {
+  if (valid) {
     covLogXML.EndElement(); // Report
     covLogXML.EndElement(); // File
-    }
+  }
   this->EndCoverageLogXML(covLogXML);
   this->EndCoverageLogFile(covLogFile, logFileCount);
   return 1;
 }
 
 int cmCTestCoverageHandler::RunBullseyeCommand(
-  cmCTestCoverageHandlerContainer* cont,
-  const char* cmd,
-  const char* arg,
+  cmCTestCoverageHandlerContainer* cont, const char* cmd, const char* arg,
   std::string& outputFile)
 {
   std::string program = cmSystemTools::FindProgram(cmd);
-  if(program.empty())
-    {
+  if (program.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find :" << cmd << "\n");
     return 0;
-    }
-  if(arg)
-    {
+  }
+  if (arg) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Run : " << program << " " << arg << "\n", this->Quiet);
-    }
-  else
-    {
+                       "Run : " << program << " " << arg << "\n", this->Quiet);
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Run : " << program << "\n", this->Quiet);
-    }
+                       "Run : " << program << "\n", this->Quiet);
+  }
   // create a process object and start it
   cmCTestRunProcess runCoverageSrc;
   runCoverageSrc.SetCommand(program.c_str());
@@ -2172,14 +1954,13 @@ int cmCTestCoverageHandler::RunBullseyeCommand(
   stderrFile += ".stderr";
   runCoverageSrc.SetStdoutFile(stdoutFile.c_str());
   runCoverageSrc.SetStderrFile(stderrFile.c_str());
-  if(!runCoverageSrc.StartProcess())
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not run : "
-               << program << " " << arg << "\n"
-               << "kwsys process state : "
-               << runCoverageSrc.GetProcessState());
+  if (!runCoverageSrc.StartProcess()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Could not run : " << program << " " << arg << "\n"
+                                  << "kwsys process state : "
+                                  << runCoverageSrc.GetProcessState());
     return 0;
-    }
+  }
   // since we set the output file names wait for it to end
   runCoverageSrc.WaitForExit();
   outputFile = stdoutFile;
@@ -2191,29 +1972,28 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
 {
   // Run the covsrc command and create a temp outputfile
   std::string outputFile;
-  if(!this->RunBullseyeCommand(cont, "covsrc", "-c", outputFile))
-    {
+  if (!this->RunBullseyeCommand(cont, "covsrc", "-c", outputFile)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covsrc:\n");
     return 0;
-    }
+  }
 
   std::ostream& tmpLog = *cont->OFS;
   // copen the Coverage.xml file in the Testing directory
   cmGeneratedFileStream covSumFile;
   cmXMLWriter xml(covSumFile);
-  if(!this->StartResultingXML(cmCTest::PartCoverage, "Coverage", covSumFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot open coverage summary file." << std::endl);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
+                               covSumFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+                 << std::endl);
     return 0;
-    }
+  }
   this->CTest->StartXML(xml, this->AppendXML);
   double elapsed_time_start = cmSystemTools::GetTime();
   std::string coverage_start_time = this->CTest->CurrentTime();
   xml.StartElement("Coverage");
   xml.Element("StartDateTime", coverage_start_time);
   xml.Element("StartTime",
-    static_cast<unsigned int>(cmSystemTools::GetTime()));
+              static_cast<unsigned int>(cmSystemTools::GetTime()));
   std::string stdline;
   std::string errline;
   // expected output:
@@ -2230,66 +2010,53 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
   double total_tested = 0;
   double total_untested = 0;
   double total_functions = 0;
-  double percent_coverage =0;
-  double number_files  = 0;
+  double percent_coverage = 0;
+  double number_files = 0;
   std::vector<std::string> coveredFiles;
   std::vector<std::string> coveredFilesFullPath;
   // Read and parse the summary output file
   cmsys::ifstream fin(outputFile.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Cannot open coverage summary file: " <<
-               outputFile << std::endl);
+               "Cannot open coverage summary file: " << outputFile
+                                                     << std::endl);
     return 0;
-    }
+  }
   std::set<std::string> coveredFileNames;
-  while(cmSystemTools::GetLineFromStream(fin, stdline))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, stdline)) {
     // if we have a line of output from stdout
-    if(!stdline.empty())
-      {
+    if (!stdline.empty()) {
       // parse the comma separated output
-      this->ParseBullsEyeCovsrcLine(stdline,
-                                    sourceFile,
-                                    functionsCalled,
-                                    totalFunctions,
-                                    percentFunction,
-                                    branchCovered,
-                                    totalBranches,
-                                    percentBranch);
+      this->ParseBullsEyeCovsrcLine(
+        stdline, sourceFile, functionsCalled, totalFunctions, percentFunction,
+        branchCovered, totalBranches, percentBranch);
       // The first line is the header
-      if(sourceFile == "Source" || sourceFile == "Total")
-        {
+      if (sourceFile == "Source" || sourceFile == "Total") {
         continue;
-        }
+      }
       std::string file = sourceFile;
       coveredFileNames.insert(file);
-      if(!cmSystemTools::FileIsFullPath(sourceFile.c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(sourceFile.c_str())) {
         // file will be relative to the binary dir
         file = cont->BinaryDir;
         file += "/";
         file += sourceFile;
-        }
+      }
       file = cmSystemTools::CollapseFullPath(file);
-      bool shouldIDoCoverage
-        = this->ShouldIDoCoverage(file.c_str(),
-                                  cont->SourceDir.c_str(),
-                                  cont->BinaryDir.c_str());
-      if ( !shouldIDoCoverage )
-        {
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          ".NoDartCoverage found, so skip coverage check for: "
-          << file
-          << std::endl, this->Quiet);
+      bool shouldIDoCoverage = this->ShouldIDoCoverage(
+        file.c_str(), cont->SourceDir.c_str(), cont->BinaryDir.c_str());
+      if (!shouldIDoCoverage) {
+        cmCTestOptionalLog(
+          this->CTest, HANDLER_VERBOSE_OUTPUT,
+          ".NoDartCoverage found, so skip coverage check for: " << file
+                                                                << std::endl,
+          this->Quiet);
         continue;
-        }
+      }
 
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "Doing coverage for: "
-        << file
-        << std::endl, this->Quiet);
+                         "Doing coverage for: " << file << std::endl,
+                         this->Quiet);
 
       coveredFiles.push_back(sourceFile);
       coveredFilesFullPath.push_back(file);
@@ -2304,21 +2071,19 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
         this->CTest->GetShortPathToFile(file.c_str());
 
       float cper = static_cast<float>(percentBranch + percentFunction);
-      if(totalBranches > 0)
-        {
+      if (totalBranches > 0) {
         cper /= 2.0f;
-        }
+      }
       percent_coverage += static_cast<double>(cper);
       float cmet = static_cast<float>(percentFunction + percentBranch);
-      if(totalBranches > 0)
-        {
+      if (totalBranches > 0) {
         cmet /= 2.0f;
-        }
+      }
       cmet /= 100.0f;
       tmpLog << stdline << "\n";
       tmpLog << fileName << "\n";
-      tmpLog << "functionsCalled: " << functionsCalled/100 << "\n";
-      tmpLog << "totalFunctions: " << totalFunctions/100 << "\n";
+      tmpLog << "functionsCalled: " << functionsCalled / 100 << "\n";
+      tmpLog << "totalFunctions: " << totalFunctions / 100 << "\n";
       tmpLog << "percentFunction: " << percentFunction << "\n";
       tmpLog << "branchCovered: " << branchCovered << "\n";
       tmpLog << "totalBranches: " << totalBranches << "\n";
@@ -2341,8 +2106,8 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
       xml.Element("CoverageMetric", cmet);
       this->WriteXMLLabels(xml, shortFileName);
       xml.EndElement(); // File
-      }
     }
+  }
   std::string end_time = this->CTest->CurrentTime();
   xml.Element("LOCTested", total_tested);
   xml.Element("LOCUntested", total_untested);
@@ -2350,15 +2115,15 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
   xml.Element("PercentCoverage", SAFEDIV(percent_coverage, number_files));
   xml.Element("EndDateTime", end_time);
   xml.Element("EndTime", static_cast<unsigned int>(cmSystemTools::GetTime()));
-  xml.Element("ElapsedMinutes",
-    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
+  xml.Element(
+    "ElapsedMinutes",
+    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
+      10.0);
   xml.EndElement(); // Coverage
   this->CTest->EndXML(xml);
 
   // Now create the coverage information for each file
-  return this->RunBullseyeCoverageBranch(cont,
-                                         coveredFileNames,
-                                         coveredFiles,
+  return this->RunBullseyeCoverageBranch(cont, coveredFileNames, coveredFiles,
                                          coveredFilesFullPath);
 }
 
@@ -2366,25 +2131,24 @@ int cmCTestCoverageHandler::HandleBullseyeCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
   const char* covfile = cmSystemTools::GetEnv("COVFILE");
-  if(!covfile || strlen(covfile) == 0)
-    {
+  if (!covfile || strlen(covfile) == 0) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " COVFILE environment variable not found, not running "
-      " bullseye\n", this->Quiet);
+                       " COVFILE environment variable not found, not running "
+                       " bullseye\n",
+                       this->Quiet);
     return 0;
-    }
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " run covsrc with COVFILE=["
-    << covfile
-    << "]" << std::endl, this->Quiet);
-  if(!this->RunBullseyeSourceSummary(cont))
-    {
+  }
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_VERBOSE_OUTPUT,
+    " run covsrc with COVFILE=[" << covfile << "]" << std::endl, this->Quiet);
+  if (!this->RunBullseyeSourceSummary(cont)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Error running bullseye summary.\n");
     return 0;
-    }
-  cmCTestOptionalLog(this->CTest, DEBUG, "HandleBullseyeCoverage return 1 "
-  << std::endl, this->Quiet);
+  }
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "HandleBullseyeCoverage return 1 " << std::endl,
+                     this->Quiet);
   return 1;
 }
 
@@ -2395,79 +2159,63 @@ bool cmCTestCoverageHandler::GetNextInt(std::string const& inputLine,
   std::string::size_type start = pos;
   pos = inputLine.find(',', start);
   value = atoi(inputLine.substr(start, pos).c_str());
-  if(pos == inputLine.npos)
-    {
+  if (pos == inputLine.npos) {
     return true;
-    }
+  }
   pos++;
   return true;
 }
 
 bool cmCTestCoverageHandler::ParseBullsEyeCovsrcLine(
-  std::string const& inputLine,
-  std::string& sourceFile,
-  int& functionsCalled,
-  int& totalFunctions,
-  int& percentFunction,
-  int& branchCovered,
-  int& totalBranches,
-  int& percentBranch)
+  std::string const& inputLine, std::string& sourceFile, int& functionsCalled,
+  int& totalFunctions, int& percentFunction, int& branchCovered,
+  int& totalBranches, int& percentBranch)
 {
   // find the first comma
   std::string::size_type pos = inputLine.find(',');
-  if(pos == inputLine.npos)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing string : "
-               << inputLine << "\n");
+  if (pos == inputLine.npos) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing string : " << inputLine << "\n");
     return false;
-    }
+  }
   // the source file has "" around it so extract out the file name
-  sourceFile = inputLine.substr(1,pos-2);
+  sourceFile = inputLine.substr(1, pos - 2);
   pos++;
-  if(!this->GetNextInt(inputLine, pos, functionsCalled))
-    {
+  if (!this->GetNextInt(inputLine, pos, functionsCalled)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, totalFunctions))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, totalFunctions)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, percentFunction))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, percentFunction)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, branchCovered))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, branchCovered)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, totalBranches))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, totalBranches)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, percentBranch))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, percentBranch)) {
     return false;
-    }
+  }
   // should be at the end now
-  if(pos != inputLine.npos)
-    {
+  if (pos != inputLine.npos) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing input : "
-               << inputLine << " last pos not npos =  " << pos <<
-               "\n");
-    }
+                 << inputLine << " last pos not npos =  " << pos << "\n");
+  }
   return true;
 }
 
 int cmCTestCoverageHandler::GetLabelId(std::string const& label)
 {
   LabelIdMapType::iterator i = this->LabelIdMap.find(label);
-  if(i == this->LabelIdMap.end())
-    {
+  if (i == this->LabelIdMap.end()) {
     int n = int(this->Labels.size());
     this->Labels.push_back(label);
     LabelIdMapType::value_type entry(label, n);
     i = this->LabelIdMap.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
@@ -2477,13 +2225,13 @@ void cmCTestCoverageHandler::LoadLabels()
   fileList += cmake::GetCMakeFilesDirectory();
   fileList += "/TargetDirectories.txt";
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " target directory list [" << fileList << "]\n", this->Quiet);
+                     " target directory list [" << fileList << "]\n",
+                     this->Quiet);
   cmsys::ifstream finList(fileList.c_str());
   std::string line;
-  while(cmSystemTools::GetLineFromStream(finList, line))
-    {
+  while (cmSystemTools::GetLineFromStream(finList, line)) {
     this->LoadLabels(line.c_str());
-    }
+  }
 }
 
 void cmCTestCoverageHandler::LoadLabels(const char* dir)
@@ -2492,41 +2240,31 @@ void cmCTestCoverageHandler::LoadLabels(const char* dir)
   std::string fname = dir;
   fname += "/Labels.txt";
   cmsys::ifstream fin(fname.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     return;
-    }
+  }
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " loading labels from [" << fname << "]\n", this->Quiet);
+                     " loading labels from [" << fname << "]\n", this->Quiet);
   bool inTarget = true;
   std::string source;
   std::string line;
   std::vector<int> targetLabels;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if(line.empty() || line[0] == '#')
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty() || line[0] == '#') {
       // Ignore blank and comment lines.
       continue;
-      }
-    else if(line[0] == ' ')
-      {
+    } else if (line[0] == ' ') {
       // Label lines appear indented by one space.
       std::string label = line.substr(1);
       int id = this->GetLabelId(label);
       dirLabels.insert(id);
-      if(inTarget)
-        {
+      if (inTarget) {
         targetLabels.push_back(id);
-        }
-      else
-        {
+      } else {
         this->SourceLabels[source].insert(id);
-        }
       }
-    else
-      {
+    } else {
       // Non-indented lines specify a source file name.  The first one
       // is the end of the target-wide labels.
       inTarget = false;
@@ -2536,69 +2274,62 @@ void cmCTestCoverageHandler::LoadLabels(const char* dir)
       // Label the source with the target labels.
       LabelSet& labelSet = this->SourceLabels[source];
       labelSet.insert(targetLabels.begin(), targetLabels.end());
-      }
     }
+  }
 }
 
 void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml,
                                             std::string const& source)
 {
   LabelMapType::const_iterator li = this->SourceLabels.find(source);
-  if(li != this->SourceLabels.end() && !li->second.empty())
-    {
+  if (li != this->SourceLabels.end() && !li->second.empty()) {
     xml.StartElement("Labels");
-    for(LabelSet::const_iterator lsi = li->second.begin();
-        lsi != li->second.end(); ++lsi)
-      {
+    for (LabelSet::const_iterator lsi = li->second.begin();
+         lsi != li->second.end(); ++lsi) {
       xml.Element("Label", this->Labels[*lsi]);
-      }
-    xml.EndElement(); // Labels
     }
+    xml.EndElement(); // Labels
+  }
 }
 
-void
-cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels)
+void cmCTestCoverageHandler::SetLabelFilter(
+  std::set<std::string> const& labels)
 {
   this->LabelFilter.clear();
-  for(std::set<std::string>::const_iterator li = labels.begin();
-      li != labels.end(); ++li)
-    {
+  for (std::set<std::string>::const_iterator li = labels.begin();
+       li != labels.end(); ++li) {
     this->LabelFilter.insert(this->GetLabelId(*li));
-    }
+  }
 }
 
 bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels)
 {
   // If there is no label filter then nothing is filtered out.
-  if(this->LabelFilter.empty())
-    {
+  if (this->LabelFilter.empty()) {
     return true;
-    }
+  }
 
   std::vector<int> ids;
-  std::set_intersection
-    (labels.begin(), labels.end(),
-     this->LabelFilter.begin(), this->LabelFilter.end(),
-     std::back_inserter(ids));
+  std::set_intersection(labels.begin(), labels.end(),
+                        this->LabelFilter.begin(), this->LabelFilter.end(),
+                        std::back_inserter(ids));
   return !ids.empty();
 }
 
 bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source)
 {
   // If there is no label filter then nothing is filtered out.
-  if(this->LabelFilter.empty())
-    {
+  if (this->LabelFilter.empty()) {
     return false;
-    }
+  }
 
   // The source is filtered out if it does not have any labels in
   // common with the filter set.
   std::string shortSrc = this->CTest->GetShortPathToFile(source.c_str());
   LabelMapType::const_iterator li = this->SourceLabels.find(shortSrc);
-  if(li != this->SourceLabels.end())
-    {
+  if (li != this->SourceLabels.end()) {
     return !this->IntersectsFilter(li->second);
-    }
+  }
   return true;
 }
 
@@ -2607,36 +2338,31 @@ std::set<std::string> cmCTestCoverageHandler::FindUncoveredFiles(
 {
   std::set<std::string> extraMatches;
 
-  for(std::vector<std::string>::iterator i = this->ExtraCoverageGlobs.begin();
-      i != this->ExtraCoverageGlobs.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->ExtraCoverageGlobs.begin();
+       i != this->ExtraCoverageGlobs.end(); ++i) {
     cmsys::Glob gl;
     gl.RecurseOn();
     gl.RecurseThroughSymlinksOff();
     std::string glob = cont->SourceDir + "/" + *i;
     gl.FindFiles(glob);
     std::vector<std::string> files = gl.GetFiles();
-    for(std::vector<std::string>::iterator f = files.begin();
-        f != files.end(); ++f)
-      {
-      if(this->ShouldIDoCoverage(f->c_str(),
-         cont->SourceDir.c_str(), cont->BinaryDir.c_str()))
-        {
-        extraMatches.insert(this->CTest->GetShortPathToFile(
-          f->c_str()));
-        }
+    for (std::vector<std::string>::iterator f = files.begin();
+         f != files.end(); ++f) {
+      if (this->ShouldIDoCoverage(f->c_str(), cont->SourceDir.c_str(),
+                                  cont->BinaryDir.c_str())) {
+        extraMatches.insert(this->CTest->GetShortPathToFile(f->c_str()));
       }
     }
+  }
 
-  if(!extraMatches.empty())
-    {
-    for(cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator i =
-        cont->TotalCoverage.begin(); i != cont->TotalCoverage.end(); ++i)
-      {
-      std::string shortPath = this->CTest->GetShortPathToFile(
-        i->first.c_str());
+  if (!extraMatches.empty()) {
+    for (cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator i =
+           cont->TotalCoverage.begin();
+         i != cont->TotalCoverage.end(); ++i) {
+      std::string shortPath =
+        this->CTest->GetShortPathToFile(i->first.c_str());
       extraMatches.erase(shortPath);
-      }
     }
+  }
   return extraMatches;
 }
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
index c91a2d7..4a2a602 100644
--- a/Source/CTest/cmCTestCoverageHandler.h
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -54,14 +54,14 @@ public:
   /**
    * This method is called when reading CTest custom file
    */
-  void PopulateCustomVectors(cmMakefile *mf);
+  void PopulateCustomVectors(cmMakefile* mf);
 
   /** Report coverage only for sources with these labels.  */
   void SetLabelFilter(std::set<std::string> const& labels);
 
 private:
   bool ShouldIDoCoverage(const char* file, const char* srcDir,
-    const char* binDir);
+                         const char* binDir);
   void CleanCoverageLogFiles(std::ostream& log);
   bool StartCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
   void EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
@@ -95,7 +95,7 @@ private:
   //! Handle coverage for Jacoco
   int HandleBlanketJSCoverage(cmCTestCoverageHandlerContainer* cont);
 
-//! Handle coverage using Bullseye
+  //! Handle coverage using Bullseye
   int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
   int RunBullseyeSourceSummary(cmCTestCoverageHandlerContainer* cont);
   int RunBullseyeCoverageBranch(cmCTestCoverageHandlerContainer* cont,
@@ -103,22 +103,15 @@ private:
                                 std::vector<std::string>& files,
                                 std::vector<std::string>& filesFullPath);
 
-  int RunBullseyeCommand(
-    cmCTestCoverageHandlerContainer* cont,
-    const char* cmd,
-    const char* arg,
-    std::string& outputFile);
-  bool ParseBullsEyeCovsrcLine(
-    std::string const& inputLine,
-    std::string& sourceFile,
-    int& functionsCalled,
-    int& totalFunctions,
-    int& percentFunction,
-    int& branchCovered,
-    int& totalBranches,
-    int& percentBranch);
-  bool GetNextInt(std::string const& inputLine,
-                  std::string::size_type& pos,
+  int RunBullseyeCommand(cmCTestCoverageHandlerContainer* cont,
+                         const char* cmd, const char* arg,
+                         std::string& outputFile);
+  bool ParseBullsEyeCovsrcLine(std::string const& inputLine,
+                               std::string& sourceFile, int& functionsCalled,
+                               int& totalFunctions, int& percentFunction,
+                               int& branchCovered, int& totalBranches,
+                               int& percentBranch);
+  bool GetNextInt(std::string const& inputLine, std::string::size_type& pos,
                   int& value);
   //! Handle Python coverage using Python's Trace.py
   int HandleTracePyCoverage(cmCTestCoverageHandlerContainer* cont);
@@ -126,7 +119,7 @@ private:
   // Find the source file based on the source and build tree. This is used for
   // Trace.py mode, since that one does not tell us where the source file is.
   std::string FindFile(cmCTestCoverageHandlerContainer* cont,
-    std::string fileName);
+                       std::string fileName);
 
   std::set<std::string> FindUncoveredFiles(
     cmCTestCoverageHandlerContainer* cont);
@@ -134,9 +127,10 @@ private:
   std::vector<cmsys::RegularExpression> CustomCoverageExcludeRegex;
   std::vector<std::string> ExtraCoverageGlobs;
 
-
   // Map from source file to label ids.
-  class LabelSet: public std::set<int> {};
+  class LabelSet : public std::set<int>
+  {
+  };
   typedef std::map<std::string, LabelSet> LabelMapType;
   LabelMapType SourceLabels;
   LabelMapType TargetDirs;
diff --git a/Source/CTest/cmCTestCurl.cxx b/Source/CTest/cmCTestCurl.cxx
index 0367d7d..59675dd 100644
--- a/Source/CTest/cmCTestCurl.cxx
+++ b/Source/CTest/cmCTestCurl.cxx
@@ -42,115 +42,95 @@ std::string cmCTestCurl::Escape(std::string const& source)
   return ret;
 }
 
-namespace
-{
-static size_t
-curlWriteMemoryCallback(void *ptr, size_t size, size_t nmemb,
-  void *data)
+namespace {
+static size_t curlWriteMemoryCallback(void* ptr, size_t size, size_t nmemb,
+                                      void* data)
 {
   int realsize = (int)(size * nmemb);
 
-  std::vector<char> *vec
-    = static_cast<std::vector<char>* >(data);
+  std::vector<char>* vec = static_cast<std::vector<char>*>(data);
   const char* chPtr = static_cast<char*>(ptr);
   vec->insert(vec->end(), chPtr, chPtr + realsize);
   return realsize;
 }
 
-static size_t
-curlDebugCallback(CURL *, curl_infotype, char *chPtr,
-  size_t size, void *data)
+static size_t curlDebugCallback(CURL*, curl_infotype, char* chPtr, size_t size,
+                                void* data)
 {
-  std::vector<char> *vec
-    = static_cast<std::vector<char>* >(data);
+  std::vector<char>* vec = static_cast<std::vector<char>*>(data);
   vec->insert(vec->end(), chPtr, chPtr + size);
 
   return size;
 }
-
 }
 
 void cmCTestCurl::SetCurlOptions(std::vector<std::string> const& args)
 {
-  for( std::vector<std::string>::const_iterator i = args.begin();
-       i != args.end(); ++i)
-    {
-    if(*i == "CURLOPT_SSL_VERIFYPEER_OFF")
-      {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
+    if (*i == "CURLOPT_SSL_VERIFYPEER_OFF") {
       this->VerifyPeerOff = true;
-      }
-    if(*i == "CURLOPT_SSL_VERIFYHOST_OFF")
-      {
+    }
+    if (*i == "CURLOPT_SSL_VERIFYHOST_OFF") {
       this->VerifyHostOff = true;
-      }
     }
+  }
 }
 
 bool cmCTestCurl::InitCurl()
 {
-  if(!this->Curl)
-    {
+  if (!this->Curl) {
     return false;
-    }
-  if(this->VerifyPeerOff)
-    {
+  }
+  if (this->VerifyPeerOff) {
     curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYPEER, 0);
-    }
-  if(this->VerifyHostOff)
-    {
+  }
+  if (this->VerifyHostOff) {
     curl_easy_setopt(this->Curl, CURLOPT_SSL_VERIFYHOST, 0);
-    }
-  if(this->HTTPProxy.size())
-    {
+  }
+  if (this->HTTPProxy.size()) {
     curl_easy_setopt(this->Curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
     curl_easy_setopt(this->Curl, CURLOPT_PROXYTYPE, this->HTTPProxyType);
-    if (this->HTTPProxyAuth.size() > 0)
-      {
+    if (this->HTTPProxyAuth.size() > 0) {
       curl_easy_setopt(this->Curl, CURLOPT_PROXYUSERPWD,
                        this->HTTPProxyAuth.c_str());
-      }
     }
-  if(this->UseHttp10)
-    {
+  }
+  if (this->UseHttp10) {
     curl_easy_setopt(this->Curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-    }
+  }
   // enable HTTP ERROR parsing
   curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
   return true;
 }
 
-
 bool cmCTestCurl::UploadFile(std::string const& local_file,
-                             std::string const& url,
-                             std::string const& fields,
+                             std::string const& url, std::string const& fields,
                              std::string& response)
 {
   response = "";
-  if(!this->InitCurl())
-    {
+  if (!this->InitCurl()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
     return false;
-    }
+  }
   /* enable uploading */
   curl_easy_setopt(this->Curl, CURLOPT_UPLOAD, 1);
   // if there is little to no activity for too long stop submitting
-  if(this->TimeOutSeconds)
-    {
+  if (this->TimeOutSeconds) {
     ::curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_LIMIT, 1);
     ::curl_easy_setopt(this->Curl, CURLOPT_LOW_SPEED_TIME,
                        this->TimeOutSeconds);
-    }
+  }
   /* HTTP PUT please */
   ::curl_easy_setopt(this->Curl, CURLOPT_PUT, 1);
   ::curl_easy_setopt(this->Curl, CURLOPT_VERBOSE, 1);
 
   FILE* ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
-  if(!ftpfile)
-    {
+  if (!ftpfile) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Could not open file for upload: " << local_file << "\n");
     return false;
-    }
+  }
   // set the url
   std::string upload_url = url;
   upload_url += "?";
@@ -164,16 +144,15 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
                      static_cast<long>(filelen));
   ::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
                      curlWriteMemoryCallback);
-  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION,
-                     curlDebugCallback);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
   // Be sure to set Content-Type to satisfy fussy modsecurity rules
-  struct curl_slist *headers = ::curl_slist_append(NULL,
-                                                   "Content-Type: text/xml");
+  struct curl_slist* headers =
+    ::curl_slist_append(NULL, "Content-Type: text/xml");
   ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers);
   std::vector<char> responseData;
   std::vector<char> debugData;
-  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void *)&responseData);
-  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void *)&debugData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void*)&responseData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void*)&debugData);
   ::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
   // Now run off and do what you've been told!
   ::curl_easy_perform(this->Curl);
@@ -181,108 +160,90 @@ bool cmCTestCurl::UploadFile(std::string const& local_file,
   ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, NULL);
   ::curl_slist_free_all(headers);
 
-  if ( responseData.size() > 0 )
-    {
+  if (responseData.size() > 0) {
     response = std::string(responseData.begin(), responseData.end());
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Curl response: [" << response << "]\n");
-    }
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Curl response: ["
+                 << response << "]\n");
+  }
   std::string curlDebug;
-  if ( debugData.size() > 0 )
-    {
+  if (debugData.size() > 0) {
     curlDebug = std::string(debugData.begin(), debugData.end());
     cmCTestLog(this->CTest, DEBUG, "Curl debug: [" << curlDebug << "]\n");
-    }
-  if(response.size() == 0)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n" <<
-      curlDebug);
+  }
+  if (response.size() == 0) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "No response from server.\n"
+                 << curlDebug);
     return false;
-    }
+  }
   return true;
 }
 
 bool cmCTestCurl::HttpRequest(std::string const& url,
-                              std::string const& fields,
-                              std::string& response)
+                              std::string const& fields, std::string& response)
 {
   response = "";
   cmCTestLog(this->CTest, DEBUG, "HttpRequest\n"
-             << "url: " << url << "\n"
-             << "fields " << fields << "\n");
-  if(!this->InitCurl())
-    {
+               << "url: " << url << "\n"
+               << "fields " << fields << "\n");
+  if (!this->InitCurl()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Initialization of curl failed");
     return false;
-    }
+  }
   curl_easy_setopt(this->Curl, CURLOPT_POST, 1);
   curl_easy_setopt(this->Curl, CURLOPT_POSTFIELDS, fields.c_str());
   ::curl_easy_setopt(this->Curl, CURLOPT_URL, url.c_str());
   ::curl_easy_setopt(this->Curl, CURLOPT_FOLLOWLOCATION, 1);
-  //set response options
+  // set response options
   ::curl_easy_setopt(this->Curl, CURLOPT_WRITEFUNCTION,
                      curlWriteMemoryCallback);
-  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION,
-        curlDebugCallback);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback);
   std::vector<char> responseData;
   std::vector<char> debugData;
-  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void *)&responseData);
-  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void *)&debugData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_FILE, (void*)&responseData);
+  ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGDATA, (void*)&debugData);
   ::curl_easy_setopt(this->Curl, CURLOPT_FAILONERROR, 1);
 
   CURLcode res = ::curl_easy_perform(this->Curl);
 
-  if ( responseData.size() > 0 )
-    {
+  if (responseData.size() > 0) {
     response = std::string(responseData.begin(), responseData.end());
     cmCTestLog(this->CTest, DEBUG, "Curl response: [" << response << "]\n");
-    }
-  if ( debugData.size() > 0 )
-    {
+  }
+  if (debugData.size() > 0) {
     std::string curlDebug = std::string(debugData.begin(), debugData.end());
     cmCTestLog(this->CTest, DEBUG, "Curl debug: [" << curlDebug << "]\n");
-    }
+  }
   cmCTestLog(this->CTest, DEBUG, "Curl res: " << res << "\n");
   return (res == 0);
 }
 
 void cmCTestCurl::SetProxyType()
 {
-  if ( cmSystemTools::GetEnv("HTTP_PROXY") )
-    {
+  if (cmSystemTools::GetEnv("HTTP_PROXY")) {
     this->HTTPProxy = cmSystemTools::GetEnv("HTTP_PROXY");
-    if ( cmSystemTools::GetEnv("HTTP_PROXY_PORT") )
-      {
+    if (cmSystemTools::GetEnv("HTTP_PROXY_PORT")) {
       this->HTTPProxy += ":";
       this->HTTPProxy += cmSystemTools::GetEnv("HTTP_PROXY_PORT");
-      }
-    if ( cmSystemTools::GetEnv("HTTP_PROXY_TYPE") )
-      {
+    }
+    if (cmSystemTools::GetEnv("HTTP_PROXY_TYPE")) {
       // this is the default
       this->HTTPProxyType = CURLPROXY_HTTP;
       std::string type = cmSystemTools::GetEnv("HTTP_PROXY_TYPE");
       // HTTP/SOCKS4/SOCKS5
-      if ( type == "HTTP" )
-        {
+      if (type == "HTTP") {
         this->HTTPProxyType = CURLPROXY_HTTP;
-        }
-      else if ( type == "SOCKS4" )
-        {
+      } else if (type == "SOCKS4") {
         this->HTTPProxyType = CURLPROXY_SOCKS4;
-        }
-      else if ( type == "SOCKS5" )
-        {
+      } else if (type == "SOCKS5") {
         this->HTTPProxyType = CURLPROXY_SOCKS5;
-        }
       }
-    if ( cmSystemTools::GetEnv("HTTP_PROXY_USER") )
-      {
+    }
+    if (cmSystemTools::GetEnv("HTTP_PROXY_USER")) {
       this->HTTPProxyAuth = cmSystemTools::GetEnv("HTTP_PROXY_USER");
-      }
-    if ( cmSystemTools::GetEnv("HTTP_PROXY_PASSWD") )
-      {
+    }
+    if (cmSystemTools::GetEnv("HTTP_PROXY_PASSWD")) {
       this->HTTPProxyAuth += ":";
       this->HTTPProxyAuth += cmSystemTools::GetEnv("HTTP_PROXY_PASSWD");
-      }
     }
+  }
 }
diff --git a/Source/CTest/cmCTestCurl.h b/Source/CTest/cmCTestCurl.h
index 0737bb6..82601e3 100644
--- a/Source/CTest/cmCTestCurl.h
+++ b/Source/CTest/cmCTestCurl.h
@@ -23,22 +23,21 @@ class cmCTestCurl
 public:
   cmCTestCurl(cmCTest*);
   ~cmCTestCurl();
-  bool UploadFile(std::string const& url,
-                  std::string const& file,
-                  std::string const& fields,
-                  std::string& response);
-  bool HttpRequest(std::string const& url,
-                   std::string const& fields,
+  bool UploadFile(std::string const& url, std::string const& file,
+                  std::string const& fields, std::string& response);
+  bool HttpRequest(std::string const& url, std::string const& fields,
                    std::string& response);
   // currently only supports CURLOPT_SSL_VERIFYPEER_OFF
   // and CURLOPT_SSL_VERIFYHOST_OFF
   void SetCurlOptions(std::vector<std::string> const& args);
-  void SetUseHttp10On() { this->UseHttp10 = true;}
-  void SetTimeOutSeconds(int s) { this->TimeOutSeconds = s;}
+  void SetUseHttp10On() { this->UseHttp10 = true; }
+  void SetTimeOutSeconds(int s) { this->TimeOutSeconds = s; }
   std::string Escape(std::string const& source);
+
 protected:
   void SetProxyType();
   bool InitCurl();
+
 private:
   cmCTest* CTest;
   CURL* Curl;
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
index e175592..1bda9be 100644
--- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
@@ -13,24 +13,20 @@
 
 #include "cmCTestScriptHandler.h"
 
-bool cmCTestEmptyBinaryDirectoryCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestEmptyBinaryDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() != 1 )
-    {
+  if (args.size() != 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
-  if ( !cmCTestScriptHandler::EmptyBinaryDirectory(args[0].c_str()) )
-    {
+  if (!cmCTestScriptHandler::EmptyBinaryDirectory(args[0].c_str())) {
     std::ostringstream ostr;
     ostr << "problem removing the binary directory: " << args[0];
     this->SetError(ostr.str());
     return false;
-    }
+  }
 
   return true;
 }
-
-
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
index d182d17..e904d19 100644
--- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
@@ -23,36 +23,36 @@
 class cmCTestEmptyBinaryDirectoryCommand : public cmCTestCommand
 {
 public:
-
   cmCTestEmptyBinaryDirectoryCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
-    cmCTestEmptyBinaryDirectoryCommand* ni
-      = new cmCTestEmptyBinaryDirectoryCommand;
+  {
+    cmCTestEmptyBinaryDirectoryCommand* ni =
+      new cmCTestEmptyBinaryDirectoryCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_empty_binary_directory";}
+  virtual std::string GetName() const
+  {
+    return "ctest_empty_binary_directory";
+  }
 
   cmTypeMacro(cmCTestEmptyBinaryDirectoryCommand, cmCTestCommand);
-
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestGIT.cxx b/Source/CTest/cmCTestGIT.cxx
index 6d70be9..8b392f2 100644
--- a/Source/CTest/cmCTestGIT.cxx
+++ b/Source/CTest/cmCTestGIT.cxx
@@ -27,11 +27,11 @@ static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major,
                                       unsigned int minor, unsigned int fix)
 {
   // 1.6.5.0 maps to 10605000
-  return fix + minor*1000 + major*100000 + epic*10000000;
+  return fix + minor * 1000 + major * 100000 + epic * 10000000;
 }
 
-cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log):
-  cmCTestGlobalVC(ct, log)
+cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
   this->CurrentGitVersion = 0;
@@ -41,29 +41,30 @@ cmCTestGIT::~cmCTestGIT()
 {
 }
 
-class cmCTestGIT::OneLineParser: public cmCTestVC::LineParser
+class cmCTestGIT::OneLineParser : public cmCTestVC::LineParser
 {
 public:
-  OneLineParser(cmCTestGIT* git, const char* prefix,
-                std::string& l): Line1(l)
-    {
+  OneLineParser(cmCTestGIT* git, const char* prefix, std::string& l)
+    : Line1(l)
+  {
     this->SetLog(&git->Log, prefix);
-    }
+  }
+
 private:
   std::string& Line1;
   virtual bool ProcessLine()
-    {
+  {
     // Only the first line is of interest.
     this->Line1 = this->Line;
     return false;
-    }
+  }
 };
 
 std::string cmCTestGIT::GetWorkingRevision()
 {
   // Run plumbing "git rev-list" to get work tree revision.
   const char* git = this->CommandLineTool.c_str();
-  const char* git_rev_list[] = {git, "rev-list", "-n", "1", "HEAD", "--", 0};
+  const char* git_rev_list[] = { git, "rev-list", "-n", "1", "HEAD", "--", 0 };
   std::string rev;
   OneLineParser out(this, "rl-out> ", rev);
   OutputLogger err(this->Log, "rl-err> ");
@@ -75,7 +76,7 @@ void cmCTestGIT::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-             << this->OldRevision << "\n");
+               << this->OldRevision << "\n");
   this->PriorRev.Rev = this->OldRevision;
 }
 
@@ -83,7 +84,7 @@ void cmCTestGIT::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-             << this->NewRevision << "\n");
+               << this->NewRevision << "\n");
 }
 
 std::string cmCTestGIT::FindGitDir()
@@ -92,43 +93,38 @@ std::string cmCTestGIT::FindGitDir()
 
   // Run "git rev-parse --git-dir" to locate the real .git directory.
   const char* git = this->CommandLineTool.c_str();
-  char const* git_rev_parse[] = {git, "rev-parse", "--git-dir", 0};
+  char const* git_rev_parse[] = { git, "rev-parse", "--git-dir", 0 };
   std::string git_dir_line;
   OneLineParser rev_parse_out(this, "rev-parse-out> ", git_dir_line);
   OutputLogger rev_parse_err(this->Log, "rev-parse-err> ");
-  if(this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err))
-    {
+  if (this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err)) {
     git_dir = git_dir_line;
-    }
-  if(git_dir.empty())
-    {
+  }
+  if (git_dir.empty()) {
     git_dir = ".git";
-    }
+  }
 
   // Git reports a relative path only when the .git directory is in
   // the current directory.
-  if(git_dir[0] == '.')
-    {
+  if (git_dir[0] == '.') {
     git_dir = this->SourceDirectory + "/" + git_dir;
-    }
+  }
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  else if(git_dir[0] == '/')
-    {
+  else if (git_dir[0] == '/') {
     // Cygwin Git reports a full path that Cygwin understands, but we
     // are a Windows application.  Run "cygpath" to get Windows path.
     std::string cygpath_exe = cmSystemTools::GetFilenamePath(git);
     cygpath_exe += "/cygpath.exe";
-    if(cmSystemTools::FileExists(cygpath_exe.c_str()))
-      {
-      char const* cygpath[] = {cygpath_exe.c_str(), "-w", git_dir.c_str(), 0};
+    if (cmSystemTools::FileExists(cygpath_exe.c_str())) {
+      char const* cygpath[] = { cygpath_exe.c_str(), "-w", git_dir.c_str(),
+                                0 };
       OneLineParser cygpath_out(this, "cygpath-out> ", git_dir_line);
       OutputLogger cygpath_err(this->Log, "cygpath-err> ");
-      if(this->RunChild(cygpath, &cygpath_out, &cygpath_err))
-        {
+      if (this->RunChild(cygpath, &cygpath_out, &cygpath_err)) {
         git_dir = git_dir_line;
-        }
       }
     }
+  }
 #endif
   return git_dir;
 }
@@ -139,17 +135,16 @@ std::string cmCTestGIT::FindTopDir()
 
   // Run "git rev-parse --show-cdup" to locate the top of the tree.
   const char* git = this->CommandLineTool.c_str();
-  char const* git_rev_parse[] = {git, "rev-parse", "--show-cdup", 0};
+  char const* git_rev_parse[] = { git, "rev-parse", "--show-cdup", 0 };
   std::string cdup;
   OneLineParser rev_parse_out(this, "rev-parse-out> ", cdup);
   OutputLogger rev_parse_err(this->Log, "rev-parse-err> ");
-  if(this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err) &&
-     !cdup.empty())
-    {
+  if (this->RunChild(git_rev_parse, &rev_parse_out, &rev_parse_err) &&
+      !cdup.empty()) {
     top_dir += "/";
     top_dir += cdup;
     top_dir = cmSystemTools::CollapseFullPath(top_dir);
-    }
+  }
   return top_dir;
 }
 
@@ -164,16 +159,14 @@ bool cmCTestGIT::UpdateByFetchAndReset()
 
   // Add user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("GITUpdateOptions");
-    }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     git_fetch.push_back(ai->c_str());
-    }
+  }
 
   // Sentinel argument.
   git_fetch.push_back(0);
@@ -181,43 +174,37 @@ bool cmCTestGIT::UpdateByFetchAndReset()
   // Fetch upstream refs.
   OutputLogger fetch_out(this->Log, "fetch-out> ");
   OutputLogger fetch_err(this->Log, "fetch-err> ");
-  if(!this->RunUpdateCommand(&git_fetch[0], &fetch_out, &fetch_err))
-    {
+  if (!this->RunUpdateCommand(&git_fetch[0], &fetch_out, &fetch_err)) {
     return false;
-    }
+  }
 
   // Identify the merge head that would be used by "git pull".
   std::string sha1;
   {
-  std::string fetch_head = this->FindGitDir() + "/FETCH_HEAD";
-  cmsys::ifstream fin(fetch_head.c_str(), std::ios::in | std::ios::binary);
-  if(!fin)
-    {
-    this->Log << "Unable to open " << fetch_head << "\n";
-    return false;
+    std::string fetch_head = this->FindGitDir() + "/FETCH_HEAD";
+    cmsys::ifstream fin(fetch_head.c_str(), std::ios::in | std::ios::binary);
+    if (!fin) {
+      this->Log << "Unable to open " << fetch_head << "\n";
+      return false;
     }
-  std::string line;
-  while(sha1.empty() && cmSystemTools::GetLineFromStream(fin, line))
-    {
-    this->Log << "FETCH_HEAD> " << line << "\n";
-    if(line.find("\tnot-for-merge\t") == line.npos)
-      {
-      std::string::size_type pos = line.find('\t');
-      if(pos != line.npos)
-        {
-        sha1 = line.substr(0, pos);
+    std::string line;
+    while (sha1.empty() && cmSystemTools::GetLineFromStream(fin, line)) {
+      this->Log << "FETCH_HEAD> " << line << "\n";
+      if (line.find("\tnot-for-merge\t") == line.npos) {
+        std::string::size_type pos = line.find('\t');
+        if (pos != line.npos) {
+          sha1 = line.substr(0, pos);
         }
       }
     }
-  if(sha1.empty())
-    {
-    this->Log << "FETCH_HEAD has no upstream branch candidate!\n";
-    return false;
+    if (sha1.empty()) {
+      this->Log << "FETCH_HEAD has no upstream branch candidate!\n";
+      return false;
     }
   }
 
   // Reset the local branch to point at that tracked from upstream.
-  char const* git_reset[] = {git, "reset", "--hard", sha1.c_str(), 0};
+  char const* git_reset[] = { git, "reset", "--hard", sha1.c_str(), 0 };
   OutputLogger reset_out(this->Log, "reset-out> ");
   OutputLogger reset_err(this->Log, "reset-err> ");
   return this->RunChild(&git_reset[0], &reset_out, &reset_err);
@@ -228,11 +215,10 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom)
   std::vector<std::string> git_custom_command;
   cmSystemTools::ExpandListArgument(custom, git_custom_command, true);
   std::vector<char const*> git_custom;
-  for(std::vector<std::string>::const_iterator
-        i = git_custom_command.begin(); i != git_custom_command.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = git_custom_command.begin();
+       i != git_custom_command.end(); ++i) {
     git_custom.push_back(i->c_str());
-    }
+  }
   git_custom.push_back(0);
 
   OutputLogger custom_out(this->Log, "custom-out> ");
@@ -243,19 +229,17 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom)
 bool cmCTestGIT::UpdateInternal()
 {
   std::string custom = this->CTest->GetCTestConfiguration("GITUpdateCustom");
-  if(!custom.empty())
-    {
+  if (!custom.empty()) {
     return this->UpdateByCustom(custom);
-    }
+  }
   return this->UpdateByFetchAndReset();
 }
 
 bool cmCTestGIT::UpdateImpl()
 {
-  if(!this->UpdateInternal())
-    {
+  if (!this->UpdateInternal()) {
     return false;
-    }
+  }
 
   std::string top_dir = this->FindTopDir();
   const char* git = this->CommandLineTool.c_str();
@@ -263,26 +247,22 @@ bool cmCTestGIT::UpdateImpl()
   const char* sync_recursive = "--recursive";
 
   // Git < 1.6.5 did not support submodule --recursive
-  if(this->GetGitVersion() < cmCTestGITVersion(1,6,5,0))
-    {
+  if (this->GetGitVersion() < cmCTestGITVersion(1, 6, 5, 0)) {
     recursive = 0;
     // No need to require >= 1.6.5 if there are no submodules.
-    if(cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str()))
-      {
+    if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) {
       this->Log << "Git < 1.6.5 cannot update submodules recursively\n";
-      }
     }
+  }
 
   // Git < 1.8.1 did not support sync --recursive
-  if(this->GetGitVersion() < cmCTestGITVersion(1,8,1,0))
-    {
+  if (this->GetGitVersion() < cmCTestGITVersion(1, 8, 1, 0)) {
     sync_recursive = 0;
     // No need to require >= 1.8.1 if there are no submodules.
-    if(cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str()))
-      {
+    if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) {
       this->Log << "Git < 1.8.1 cannot synchronize submodules recursively\n";
-      }
     }
+  }
 
   OutputLogger submodule_out(this->Log, "submodule-out> ");
   OutputLogger submodule_err(this->Log, "submodule-err> ");
@@ -291,50 +271,45 @@ bool cmCTestGIT::UpdateImpl()
 
   std::string init_submodules =
     this->CTest->GetCTestConfiguration("GITInitSubmodules");
-  if (cmSystemTools::IsOn(init_submodules.c_str()))
-    {
-    char const* git_submodule_init[] = {git, "submodule", "init", 0};
+  if (cmSystemTools::IsOn(init_submodules.c_str())) {
+    char const* git_submodule_init[] = { git, "submodule", "init", 0 };
     ret = this->RunChild(git_submodule_init, &submodule_out, &submodule_err,
                          top_dir.c_str());
 
-    if (!ret)
-      {
+    if (!ret) {
       return false;
-      }
     }
+  }
 
-  char const* git_submodule_sync[] = {git, "submodule", "sync",
-                                      sync_recursive, 0};
+  char const* git_submodule_sync[] = { git, "submodule", "sync",
+                                       sync_recursive, 0 };
   ret = this->RunChild(git_submodule_sync, &submodule_out, &submodule_err,
                        top_dir.c_str());
 
-  if (!ret)
-    {
+  if (!ret) {
     return false;
-    }
+  }
 
-  char const* git_submodule[] = {git, "submodule", "update", recursive, 0};
+  char const* git_submodule[] = { git, "submodule", "update", recursive, 0 };
   return this->RunChild(git_submodule, &submodule_out, &submodule_err,
                         top_dir.c_str());
 }
 
 unsigned int cmCTestGIT::GetGitVersion()
 {
-  if(!this->CurrentGitVersion)
-    {
+  if (!this->CurrentGitVersion) {
     const char* git = this->CommandLineTool.c_str();
-    char const* git_version[] = {git, "--version", 0};
+    char const* git_version[] = { git, "--version", 0 };
     std::string version;
     OneLineParser version_out(this, "version-out> ", version);
     OutputLogger version_err(this->Log, "version-err> ");
-    unsigned int v[4] = {0,0,0,0};
-    if(this->RunChild(git_version, &version_out, &version_err) &&
-       sscanf(version.c_str(), "git version %u.%u.%u.%u",
-              &v[0], &v[1], &v[2], &v[3]) >= 3)
-      {
+    unsigned int v[4] = { 0, 0, 0, 0 };
+    if (this->RunChild(git_version, &version_out, &version_err) &&
+        sscanf(version.c_str(), "git version %u.%u.%u.%u", &v[0], &v[1], &v[2],
+               &v[3]) >= 3) {
       this->CurrentGitVersion = cmCTestGITVersion(v[0], v[1], v[2], v[3]);
-      }
     }
+  }
   return this->CurrentGitVersion;
 }
 
@@ -348,76 +323,73 @@ unsigned int cmCTestGIT::GetGitVersion()
    line appears only for lines with status 'C' or 'R'.  See 'git help
    diff-tree' for details.
 */
-class cmCTestGIT::DiffParser: public cmCTestVC::LineParser
+class cmCTestGIT::DiffParser : public cmCTestVC::LineParser
 {
 public:
-  DiffParser(cmCTestGIT* git, const char* prefix):
-    LineParser('\0', false), GIT(git), DiffField(DiffFieldNone)
-    {
+  DiffParser(cmCTestGIT* git, const char* prefix)
+    : LineParser('\0', false)
+    , GIT(git)
+    , DiffField(DiffFieldNone)
+  {
     this->SetLog(&git->Log, prefix);
-    }
+  }
 
   typedef cmCTestGIT::Change Change;
   std::vector<Change> Changes;
+
 protected:
   cmCTestGIT* GIT;
-  enum DiffFieldType { DiffFieldNone, DiffFieldChange,
-                       DiffFieldSrc, DiffFieldDst };
+  enum DiffFieldType
+  {
+    DiffFieldNone,
+    DiffFieldChange,
+    DiffFieldSrc,
+    DiffFieldDst
+  };
   DiffFieldType DiffField;
   Change CurChange;
 
   void DiffReset()
-    {
+  {
     this->DiffField = DiffFieldNone;
     this->Changes.clear();
-    }
+  }
 
   virtual bool ProcessLine()
-    {
-    if(this->Line[0] == ':')
-      {
+  {
+    if (this->Line[0] == ':') {
       this->DiffField = DiffFieldChange;
       this->CurChange = Change();
-      }
-    if(this->DiffField == DiffFieldChange)
-      {
+    }
+    if (this->DiffField == DiffFieldChange) {
       // :src-mode dst-mode src-sha1 dst-sha1 status
-      if(this->Line[0] != ':')
-        {
+      if (this->Line[0] != ':') {
         this->DiffField = DiffFieldNone;
         return true;
-        }
-      const char* src_mode_first = this->Line.c_str()+1;
-      const char* src_mode_last  = this->ConsumeField(src_mode_first);
+      }
+      const char* src_mode_first = this->Line.c_str() + 1;
+      const char* src_mode_last = this->ConsumeField(src_mode_first);
       const char* dst_mode_first = this->ConsumeSpace(src_mode_last);
-      const char* dst_mode_last  = this->ConsumeField(dst_mode_first);
+      const char* dst_mode_last = this->ConsumeField(dst_mode_first);
       const char* src_sha1_first = this->ConsumeSpace(dst_mode_last);
-      const char* src_sha1_last  = this->ConsumeField(src_sha1_first);
+      const char* src_sha1_last = this->ConsumeField(src_sha1_first);
       const char* dst_sha1_first = this->ConsumeSpace(src_sha1_last);
-      const char* dst_sha1_last  = this->ConsumeField(dst_sha1_first);
-      const char* status_first   = this->ConsumeSpace(dst_sha1_last);
-      const char* status_last    = this->ConsumeField(status_first);
-      if(status_first != status_last)
-        {
+      const char* dst_sha1_last = this->ConsumeField(dst_sha1_first);
+      const char* status_first = this->ConsumeSpace(dst_sha1_last);
+      const char* status_last = this->ConsumeField(status_first);
+      if (status_first != status_last) {
         this->CurChange.Action = *status_first;
         this->DiffField = DiffFieldSrc;
-        }
-      else
-        {
+      } else {
         this->DiffField = DiffFieldNone;
-        }
       }
-    else if(this->DiffField == DiffFieldSrc)
-      {
+    } else if (this->DiffField == DiffFieldSrc) {
       // src-path
-      if(this->CurChange.Action == 'C')
-        {
+      if (this->CurChange.Action == 'C') {
         // Convert copy to addition of destination.
         this->CurChange.Action = 'A';
         this->DiffField = DiffFieldDst;
-        }
-      else if(this->CurChange.Action == 'R')
-        {
+      } else if (this->CurChange.Action == 'R') {
         // Convert rename to deletion of source and addition of destination.
         this->CurChange.Action = 'D';
         this->CurChange.Path = this->Line;
@@ -425,34 +397,34 @@ protected:
 
         this->CurChange = Change('A');
         this->DiffField = DiffFieldDst;
-        }
-      else
-        {
+      } else {
         this->CurChange.Path = this->Line;
         this->Changes.push_back(this->CurChange);
         this->DiffField = this->DiffFieldNone;
-        }
       }
-    else if(this->DiffField == DiffFieldDst)
-      {
+    } else if (this->DiffField == DiffFieldDst) {
       // dst-path
       this->CurChange.Path = this->Line;
       this->Changes.push_back(this->CurChange);
       this->DiffField = this->DiffFieldNone;
-      }
-    return true;
     }
+    return true;
+  }
 
   const char* ConsumeSpace(const char* c)
-    {
-    while(*c && isspace(*c)) { ++c; }
-    return c;
+  {
+    while (*c && isspace(*c)) {
+      ++c;
     }
-  const char* ConsumeField(const char* c)
-    {
-    while(*c && !isspace(*c)) { ++c; }
     return c;
+  }
+  const char* ConsumeField(const char* c)
+  {
+    while (*c && !isspace(*c)) {
+      ++c;
     }
+    return c;
+  }
 };
 
 /* Commit format:
@@ -474,18 +446,25 @@ protected:
 
    The header may have more fields.  See 'git help diff-tree'.
 */
-class cmCTestGIT::CommitParser: public cmCTestGIT::DiffParser
+class cmCTestGIT::CommitParser : public cmCTestGIT::DiffParser
 {
 public:
-  CommitParser(cmCTestGIT* git, const char* prefix):
-    DiffParser(git, prefix), Section(SectionHeader)
-    {
+  CommitParser(cmCTestGIT* git, const char* prefix)
+    : DiffParser(git, prefix)
+    , Section(SectionHeader)
+  {
     this->Separator = SectionSep[this->Section];
-    }
+  }
 
 private:
   typedef cmCTestGIT::Revision Revision;
-  enum SectionType { SectionHeader, SectionBody, SectionDiff, SectionCount };
+  enum SectionType
+  {
+    SectionHeader,
+    SectionBody,
+    SectionDiff,
+    SectionCount
+  };
   static char const SectionSep[SectionCount];
   SectionType Section;
   Revision Rev;
@@ -496,141 +475,147 @@ private:
     std::string EMail;
     unsigned long Time;
     long TimeZone;
-    Person(): Name(), EMail(), Time(0), TimeZone(0) {}
+    Person()
+      : Name()
+      , EMail()
+      , Time(0)
+      , TimeZone(0)
+    {
+    }
   };
 
   void ParsePerson(const char* str, Person& person)
-    {
+  {
     // Person Name <person@domain.com> 1234567890 +0000
     const char* c = str;
-    while(*c && isspace(*c)) { ++c; }
+    while (*c && isspace(*c)) {
+      ++c;
+    }
 
     const char* name_first = c;
-    while(*c && *c != '<') { ++c; }
+    while (*c && *c != '<') {
+      ++c;
+    }
     const char* name_last = c;
-    while(name_last != name_first && isspace(*(name_last-1))) { --name_last; }
-    person.Name.assign(name_first, name_last-name_first);
+    while (name_last != name_first && isspace(*(name_last - 1))) {
+      --name_last;
+    }
+    person.Name.assign(name_first, name_last - name_first);
 
-    const char* email_first = *c? ++c : c;
-    while(*c && *c != '>') { ++c; }
-    const char* email_last = *c? c++ : c;
-    person.EMail.assign(email_first, email_last-email_first);
+    const char* email_first = *c ? ++c : c;
+    while (*c && *c != '>') {
+      ++c;
+    }
+    const char* email_last = *c ? c++ : c;
+    person.EMail.assign(email_first, email_last - email_first);
 
     person.Time = strtoul(c, (char**)&c, 10);
     person.TimeZone = strtol(c, (char**)&c, 10);
-    }
+  }
 
   virtual bool ProcessLine()
-    {
-    if(this->Line.empty())
-      {
-      if(this->Section == SectionBody && this->LineEnd == '\0')
-        {
+  {
+    if (this->Line.empty()) {
+      if (this->Section == SectionBody && this->LineEnd == '\0') {
         // Skip SectionDiff
         this->NextSection();
-        }
-      this->NextSection();
       }
-    else
-      {
-      switch(this->Section)
-        {
-        case SectionHeader: this->DoHeaderLine(); break;
-        case SectionBody:   this->DoBodyLine(); break;
-        case SectionDiff:   this->DiffParser::ProcessLine(); break;
-        case SectionCount:  break; // never happens
-        }
+      this->NextSection();
+    } else {
+      switch (this->Section) {
+        case SectionHeader:
+          this->DoHeaderLine();
+          break;
+        case SectionBody:
+          this->DoBodyLine();
+          break;
+        case SectionDiff:
+          this->DiffParser::ProcessLine();
+          break;
+        case SectionCount:
+          break; // never happens
       }
-    return true;
     }
+    return true;
+  }
 
   void NextSection()
-    {
-    this->Section = SectionType((this->Section+1) % SectionCount);
+  {
+    this->Section = SectionType((this->Section + 1) % SectionCount);
     this->Separator = SectionSep[this->Section];
-    if(this->Section == SectionHeader)
-      {
+    if (this->Section == SectionHeader) {
       this->GIT->DoRevision(this->Rev, this->Changes);
       this->Rev = Revision();
       this->DiffReset();
-      }
     }
+  }
 
   void DoHeaderLine()
-    {
+  {
     // Look for header fields that we need.
-    if(cmHasLiteralPrefix(this->Line.c_str(), "commit "))
-      {
-      this->Rev.Rev = this->Line.c_str()+7;
-      }
-    else if(cmHasLiteralPrefix(this->Line.c_str(), "author "))
-      {
+    if (cmHasLiteralPrefix(this->Line.c_str(), "commit ")) {
+      this->Rev.Rev = this->Line.c_str() + 7;
+    } else if (cmHasLiteralPrefix(this->Line.c_str(), "author ")) {
       Person author;
-      this->ParsePerson(this->Line.c_str()+7, author);
+      this->ParsePerson(this->Line.c_str() + 7, author);
       this->Rev.Author = author.Name;
       this->Rev.EMail = author.EMail;
       this->Rev.Date = this->FormatDateTime(author);
-      }
-    else if(cmHasLiteralPrefix(this->Line.c_str(), "committer "))
-      {
+    } else if (cmHasLiteralPrefix(this->Line.c_str(), "committer ")) {
       Person committer;
-      this->ParsePerson(this->Line.c_str()+10, committer);
+      this->ParsePerson(this->Line.c_str() + 10, committer);
       this->Rev.Committer = committer.Name;
       this->Rev.CommitterEMail = committer.EMail;
       this->Rev.CommitDate = this->FormatDateTime(committer);
-      }
     }
+  }
 
   void DoBodyLine()
-    {
+  {
     // Commit log lines are indented by 4 spaces.
-    if(this->Line.size() >= 4)
-      {
+    if (this->Line.size() >= 4) {
       this->Rev.Log += this->Line.substr(4);
-      }
-    this->Rev.Log += "\n";
     }
+    this->Rev.Log += "\n";
+  }
 
   std::string FormatDateTime(Person const& person)
-    {
+  {
     // Convert the time to a human-readable format that is also easy
     // to machine-parse: "CCYY-MM-DD hh:mm:ss".
     time_t seconds = static_cast<time_t>(person.Time);
     struct tm* t = gmtime(&seconds);
     char dt[1024];
-    sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d",
-            t->tm_year+1900, t->tm_mon+1, t->tm_mday,
-            t->tm_hour, t->tm_min, t->tm_sec);
+    sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900,
+            t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
     std::string out = dt;
 
     // Add the time-zone field "+zone" or "-zone".
     char tz[32];
-    if(person.TimeZone >= 0)
-      {
+    if (person.TimeZone >= 0) {
       sprintf(tz, " +%04ld", person.TimeZone);
-      }
-    else
-      {
+    } else {
       sprintf(tz, " -%04ld", -person.TimeZone);
-      }
+    }
     out += tz;
     return out;
-    }
+  }
 };
 
-char const cmCTestGIT::CommitParser::SectionSep[SectionCount] =
-{'\n', '\n', '\0'};
+char const cmCTestGIT::CommitParser::SectionSep[SectionCount] = { '\n', '\n',
+                                                                  '\0' };
 
 void cmCTestGIT::LoadRevisions()
 {
   // Use 'git rev-list ... | git diff-tree ...' to get revisions.
   std::string range = this->OldRevision + ".." + this->NewRevision;
   const char* git = this->CommandLineTool.c_str();
-  const char* git_rev_list[] =
-    {git, "rev-list", "--reverse", range.c_str(), "--", 0};
-  const char* git_diff_tree[] =
-    {git, "diff-tree", "--stdin", "--always", "-z", "-r", "--pretty=raw",
-     "--encoding=utf-8", 0};
+  const char* git_rev_list[] = { git,           "rev-list", "--reverse",
+                                 range.c_str(), "--",       0 };
+  const char* git_diff_tree[] = {
+    git,  "diff-tree",    "--stdin",          "--always", "-z",
+    "-r", "--pretty=raw", "--encoding=utf-8", 0
+  };
   this->Log << this->ComputeCommandLine(git_rev_list) << " | "
             << this->ComputeCommandLine(git_diff_tree) << "\n";
 
@@ -654,20 +639,19 @@ void cmCTestGIT::LoadModifications()
   const char* git = this->CommandLineTool.c_str();
 
   // Use 'git update-index' to refresh the index w.r.t. the work tree.
-  const char* git_update_index[] = {git, "update-index", "--refresh", 0};
+  const char* git_update_index[] = { git, "update-index", "--refresh", 0 };
   OutputLogger ui_out(this->Log, "ui-out> ");
   OutputLogger ui_err(this->Log, "ui-err> ");
   this->RunChild(git_update_index, &ui_out, &ui_err);
 
   // Use 'git diff-index' to get modified files.
-  const char* git_diff_index[] = {git, "diff-index", "-z", "HEAD", "--", 0};
+  const char* git_diff_index[] = { git, "diff-index", "-z", "HEAD", "--", 0 };
   DiffParser out(this, "di-out> ");
   OutputLogger err(this->Log, "di-err> ");
   this->RunChild(git_diff_index, &out, &err);
 
-  for(std::vector<Change>::const_iterator ci = out.Changes.begin();
-      ci != out.Changes.end(); ++ci)
-    {
+  for (std::vector<Change>::const_iterator ci = out.Changes.begin();
+       ci != out.Changes.end(); ++ci) {
     this->DoModification(PathModified, ci->Path);
-    }
+  }
 }
diff --git a/Source/CTest/cmCTestGIT.h b/Source/CTest/cmCTestGIT.h
index 3d45da8..685cc31 100644
--- a/Source/CTest/cmCTestGIT.h
+++ b/Source/CTest/cmCTestGIT.h
@@ -18,7 +18,7 @@
  * \brief Interaction with git command-line tool
  *
  */
-class cmCTestGIT: public cmCTestGlobalVC
+class cmCTestGIT : public cmCTestGlobalVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
@@ -46,7 +46,6 @@ private:
 
   // "public" needed by older Sun compilers
 public:
-
   // Parsing helper classes.
   class OneLineParser;
   class DiffParser;
diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx
index 2e9dd1f..1c80acd 100644
--- a/Source/CTest/cmCTestGenericHandler.cxx
+++ b/Source/CTest/cmCTestGenericHandler.cxx
@@ -32,16 +32,14 @@ cmCTestGenericHandler::~cmCTestGenericHandler()
 
 void cmCTestGenericHandler::SetOption(const std::string& op, const char* value)
 {
-  if ( !value )
-    {
-    cmCTestGenericHandler::t_StringToString::iterator remit
-      = this->Options.find(op);
-    if ( remit != this->Options.end() )
-      {
+  if (!value) {
+    cmCTestGenericHandler::t_StringToString::iterator remit =
+      this->Options.find(op);
+    if (remit != this->Options.end()) {
       this->Options.erase(remit);
-      }
-    return;
     }
+    return;
+  }
 
   this->Options[op] = value;
 }
@@ -50,16 +48,14 @@ void cmCTestGenericHandler::SetPersistentOption(const std::string& op,
                                                 const char* value)
 {
   this->SetOption(op, value);
-  if ( !value )
-    {
-    cmCTestGenericHandler::t_StringToString::iterator remit
-      = this->PersistentOptions.find(op);
-    if ( remit != this->PersistentOptions.end() )
-      {
+  if (!value) {
+    cmCTestGenericHandler::t_StringToString::iterator remit =
+      this->PersistentOptions.find(op);
+    if (remit != this->PersistentOptions.end()) {
       this->PersistentOptions.erase(remit);
-      }
-    return;
     }
+    return;
+  }
 
   this->PersistentOptions[op] = value;
 }
@@ -70,22 +66,19 @@ void cmCTestGenericHandler::Initialize()
   this->TestLoad = 0;
   this->Options.clear();
   t_StringToString::iterator it;
-  for ( it = this->PersistentOptions.begin();
-    it != this->PersistentOptions.end();
-    ++ it )
-    {
+  for (it = this->PersistentOptions.begin();
+       it != this->PersistentOptions.end(); ++it) {
     this->Options[it->first] = it->second.c_str();
-    }
+  }
 }
 
 const char* cmCTestGenericHandler::GetOption(const std::string& op)
 {
-  cmCTestGenericHandler::t_StringToString::iterator remit
-    = this->Options.find(op);
-  if ( remit == this->Options.end() )
-    {
+  cmCTestGenericHandler::t_StringToString::iterator remit =
+    this->Options.find(op);
+  if (remit == this->Options.end()) {
     return 0;
-    }
+  }
   return remit->second.c_str();
 }
 
@@ -93,67 +86,60 @@ bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part,
                                               const char* name,
                                               cmGeneratedFileStream& xofs)
 {
-  if ( !name )
-    {
+  if (!name) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot create resulting XML file without providing the name"
-      << std::endl;);
+               "Cannot create resulting XML file without providing the name"
+                 << std::endl;);
     return false;
-    }
+  }
   std::ostringstream ostr;
   ostr << name;
-  if ( this->SubmitIndex > 0 )
-    {
+  if (this->SubmitIndex > 0) {
     ostr << "_" << this->SubmitIndex;
-    }
+  }
   ostr << ".xml";
-  if(this->CTest->GetCurrentTag().empty())
-    {
+  if (this->CTest->GetCurrentTag().empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Current Tag empty, this may mean NightlyStartTime / "
                "CTEST_NIGHTLY_START_TIME was not set correctly. Or "
                "maybe you forgot to call ctest_start() before calling "
-               "ctest_configure()." << std::endl);
+               "ctest_configure()."
+                 << std::endl);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
-  if( !this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(),
-      ostr.str(), xofs, true) )
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot create resulting XML file: " << ostr.str()
-      << std::endl);
+  }
+  if (!this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(), ostr.str(),
+                                   xofs, true)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create resulting XML file: "
+                 << ostr.str() << std::endl);
     return false;
-    }
+  }
   this->CTest->AddSubmitFile(part, ostr.str().c_str());
   return true;
 }
 
 bool cmCTestGenericHandler::StartLogFile(const char* name,
-  cmGeneratedFileStream& xofs)
+                                         cmGeneratedFileStream& xofs)
 {
-  if ( !name )
-    {
+  if (!name) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot create log file without providing the name" << std::endl;);
+               "Cannot create log file without providing the name"
+                 << std::endl;);
     return false;
-    }
+  }
   std::ostringstream ostr;
   ostr << "Last" << name;
-  if ( this->SubmitIndex > 0 )
-    {
+  if (this->SubmitIndex > 0) {
     ostr << "_" << this->SubmitIndex;
-    }
-  if ( !this->CTest->GetCurrentTag().empty() )
-    {
+  }
+  if (!this->CTest->GetCurrentTag().empty()) {
     ostr << "_" << this->CTest->GetCurrentTag();
-    }
+  }
   ostr << ".log";
-  if( !this->CTest->OpenOutputFile("Temporary", ostr.str(), xofs) )
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create log file: "
-      << ostr.str() << std::endl);
+  if (!this->CTest->OpenOutputFile("Temporary", ostr.str(), xofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot create log file: " << ostr.str() << std::endl);
     return false;
-    }
+  }
   return true;
 }
diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h
index 7a7e034..ad349ac 100644
--- a/Source/CTest/cmCTestGenericHandler.h
+++ b/Source/CTest/cmCTestGenericHandler.h
@@ -33,13 +33,15 @@ public:
    * If verbose then more informaiton is printed out
    */
   void SetVerbose(bool val)
-    { this->HandlerVerbose = val ?
-      cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE; }
+  {
+    this->HandlerVerbose =
+      val ? cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE;
+  }
 
   /**
    * Populate internals from CTest custom scripts
    */
-  virtual void PopulateCustomVectors(cmMakefile *) {}
+  virtual void PopulateCustomVectors(cmMakefile*) {}
 
   /**
    * Do the actual processing. Subclass has to override it.
@@ -52,7 +54,10 @@ public:
    */
   virtual int ProcessCommandLineArguments(
     const std::string& /*currentArg*/, size_t& /*idx*/,
-    const std::vector<std::string>& /*allArgs*/) { return 1; }
+    const std::vector<std::string>& /*allArgs*/)
+  {
+    return 1;
+  }
 
   /**
    * Initialize handler
@@ -71,17 +76,13 @@ public:
   cmCTestGenericHandler();
   virtual ~cmCTestGenericHandler();
 
-  typedef std::map<std::string,std::string> t_StringToString;
-
+  typedef std::map<std::string, std::string> t_StringToString;
 
   void SetPersistentOption(const std::string& op, const char* value);
   void SetOption(const std::string& op, const char* value);
   const char* GetOption(const std::string& op);
 
-  void SetCommand(cmCTestCommand* command)
-    {
-    this->Command = command;
-    }
+  void SetCommand(cmCTestCommand* command) { this->Command = command; }
 
   void SetSubmitIndex(int idx) { this->SubmitIndex = idx; }
   int GetSubmitIndex() { return this->SubmitIndex; }
@@ -90,18 +91,18 @@ public:
   void SetQuiet(bool b) { this->Quiet = b; }
   bool GetQuiet() { return this->Quiet; }
   void SetTestLoad(unsigned long load) { this->TestLoad = load; }
-  unsigned long GetTestLoad() const { return this->TestLoad;  }
+  unsigned long GetTestLoad() const { return this->TestLoad; }
 
 protected:
-  bool StartResultingXML(cmCTest::Part part,
-                         const char* name, cmGeneratedFileStream& xofs);
+  bool StartResultingXML(cmCTest::Part part, const char* name,
+                         cmGeneratedFileStream& xofs);
   bool StartLogFile(const char* name, cmGeneratedFileStream& xofs);
 
   bool AppendXML;
   bool Quiet;
   unsigned long TestLoad;
   cmSystemTools::OutputOption HandlerVerbose;
-  cmCTest *CTest;
+  cmCTest* CTest;
   t_StringToString Options;
   t_StringToString PersistentOptions;
 
@@ -110,4 +111,3 @@ protected:
 };
 
 #endif
-
diff --git a/Source/CTest/cmCTestGlobalVC.cxx b/Source/CTest/cmCTestGlobalVC.cxx
index 7c565fb..0c7ca4d 100644
--- a/Source/CTest/cmCTestGlobalVC.cxx
+++ b/Source/CTest/cmCTestGlobalVC.cxx
@@ -17,8 +17,8 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log):
-  cmCTestVC(ct, log)
+cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log)
+  : cmCTestVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
@@ -36,11 +36,10 @@ void cmCTestGlobalVC::DoRevision(Revision const& revision,
                                  std::vector<Change> const& changes)
 {
   // Ignore changes in the old revision.
-  if(revision.Rev == this->OldRevision)
-    {
+  if (revision.Rev == this->OldRevision) {
     this->PriorRev = revision;
     return;
-    }
+  }
 
   // Indicate we found a revision.
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "." << std::flush);
@@ -57,19 +56,18 @@ void cmCTestGlobalVC::DoRevision(Revision const& revision,
   /* clang-format on */
 
   // Update information about revisions of the changed files.
-  for(std::vector<Change>::const_iterator ci = changes.begin();
-      ci != changes.end(); ++ci)
-    {
-    if(const char* local = this->LocalPath(ci->Path))
-      {
+  for (std::vector<Change>::const_iterator ci = changes.begin();
+       ci != changes.end(); ++ci) {
+    if (const char* local = this->LocalPath(ci->Path)) {
       std::string dir = cmSystemTools::GetFilenamePath(local);
       std::string name = cmSystemTools::GetFilenameName(local);
       File& file = this->Dirs[dir][name];
-      file.PriorRev = file.Rev? file.Rev : &this->PriorRev;
+      file.PriorRev = file.Rev ? file.Rev : &this->PriorRev;
       file.Rev = &rev;
-      this->Log << "  " << ci->Action << " " << local << " " << "\n";
-      }
+      this->Log << "  " << ci->Action << " " << local << " "
+                << "\n";
     }
+  }
 }
 
 void cmCTestGlobalVC::DoModification(PathStatus status,
@@ -81,44 +79,41 @@ void cmCTestGlobalVC::DoModification(PathStatus status,
   file.Status = status;
   // For local modifications the current rev is unknown and the
   // prior rev is the latest from svn.
-  if(!file.Rev && !file.PriorRev)
-    {
+  if (!file.Rev && !file.PriorRev) {
     file.PriorRev = &this->PriorRev;
-    }
+  }
 }
 
 void cmCTestGlobalVC::WriteXMLDirectory(cmXMLWriter& xml,
                                         std::string const& path,
                                         Directory const& dir)
 {
-  const char* slash = path.empty()? "":"/";
+  const char* slash = path.empty() ? "" : "/";
   xml.StartElement("Directory");
   xml.Element("Name", path);
-  for(Directory::const_iterator fi = dir.begin(); fi != dir.end(); ++fi)
-    {
+  for (Directory::const_iterator fi = dir.begin(); fi != dir.end(); ++fi) {
     std::string full = path + slash + fi->first;
     this->WriteXMLEntry(xml, path, fi->first, full, fi->second);
-    }
+  }
   xml.EndElement(); // Directory
 }
 
 void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml)
 {
-  if(!this->NewRevision.empty())
-    {
+  if (!this->NewRevision.empty()) {
     xml.Element("Revision", this->NewRevision);
-    }
-  if(!this->OldRevision.empty() && this->OldRevision != this->NewRevision)
-    {
+  }
+  if (!this->OldRevision.empty() && this->OldRevision != this->NewRevision) {
     xml.Element("PriorRevision", this->OldRevision);
-    }
+  }
 }
 
 bool cmCTestGlobalVC::WriteXMLUpdates(cmXMLWriter& xml)
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              "   Gathering version information (one . per revision):\n"
-             "    " << std::flush);
+             "    "
+               << std::flush);
   this->LoadRevisions();
   cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
 
@@ -126,11 +121,11 @@ bool cmCTestGlobalVC::WriteXMLUpdates(cmXMLWriter& xml)
 
   this->WriteXMLGlobal(xml);
 
-  for(std::map<std::string, Directory>::const_iterator
-        di = this->Dirs.begin(); di != this->Dirs.end(); ++di)
-    {
+  for (std::map<std::string, Directory>::const_iterator di =
+         this->Dirs.begin();
+       di != this->Dirs.end(); ++di) {
     this->WriteXMLDirectory(xml, di->first, di->second);
-    }
+  }
 
   return true;
 }
diff --git a/Source/CTest/cmCTestGlobalVC.h b/Source/CTest/cmCTestGlobalVC.h
index d0e9410..9a5357f 100644
--- a/Source/CTest/cmCTestGlobalVC.h
+++ b/Source/CTest/cmCTestGlobalVC.h
@@ -20,7 +20,7 @@
  * \brief Base class for handling globally-versioned trees
  *
  */
-class cmCTestGlobalVC: public cmCTestVC
+class cmCTestGlobalVC : public cmCTestVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
@@ -37,11 +37,16 @@ protected:
   {
     char Action;
     std::string Path;
-    Change(char a = '?'): Action(a) {}
+    Change(char a = '?')
+      : Action(a)
+    {
+    }
   };
 
   // Update status for files in each directory.
-  class Directory: public std::map<std::string, File> {};
+  class Directory : public std::map<std::string, File>
+  {
+  };
   std::map<std::string, Directory> Dirs;
 
   // Old and new repository revisions.
diff --git a/Source/CTest/cmCTestHG.cxx b/Source/CTest/cmCTestHG.cxx
index 4dcd805..c6cfa44 100644
--- a/Source/CTest/cmCTestHG.cxx
+++ b/Source/CTest/cmCTestHG.cxx
@@ -17,8 +17,8 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log):
-  cmCTestGlobalVC(ct, log)
+cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
@@ -27,74 +27,80 @@ cmCTestHG::~cmCTestHG()
 {
 }
 
-class cmCTestHG::IdentifyParser: public cmCTestVC::LineParser
+class cmCTestHG::IdentifyParser : public cmCTestVC::LineParser
 {
 public:
-  IdentifyParser(cmCTestHG* hg, const char* prefix,
-                 std::string& rev): Rev(rev)
-    {
+  IdentifyParser(cmCTestHG* hg, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
     this->SetLog(&hg->Log, prefix);
     this->RegexIdentify.compile("^([0-9a-f]+)");
-    }
+  }
+
 private:
   std::string& Rev;
   cmsys::RegularExpression RegexIdentify;
 
   bool ProcessLine()
-    {
-    if(this->RegexIdentify.find(this->Line))
-      {
+  {
+    if (this->RegexIdentify.find(this->Line)) {
       this->Rev = this->RegexIdentify.match(1);
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 };
 
-class cmCTestHG::StatusParser: public cmCTestVC::LineParser
+class cmCTestHG::StatusParser : public cmCTestVC::LineParser
 {
 public:
-  StatusParser(cmCTestHG* hg, const char* prefix): HG(hg)
-    {
+  StatusParser(cmCTestHG* hg, const char* prefix)
+    : HG(hg)
+  {
     this->SetLog(&hg->Log, prefix);
     this->RegexStatus.compile("([MARC!?I]) (.*)");
-    }
+  }
 
 private:
   cmCTestHG* HG;
   cmsys::RegularExpression RegexStatus;
 
   bool ProcessLine()
-    {
-    if(this->RegexStatus.find(this->Line))
-      {
-      this->DoPath(this->RegexStatus.match(1)[0],
-                   this->RegexStatus.match(2));
-      }
-    return true;
+  {
+    if (this->RegexStatus.find(this->Line)) {
+      this->DoPath(this->RegexStatus.match(1)[0], this->RegexStatus.match(2));
     }
+    return true;
+  }
 
   void DoPath(char status, std::string const& path)
-    {
-    if(path.empty()) return;
+  {
+    if (path.empty())
+      return;
 
     // See "hg help status".  Note that there is no 'conflict' status.
-    switch(status)
-      {
-      case 'M': case 'A': case '!': case 'R':
+    switch (status) {
+      case 'M':
+      case 'A':
+      case '!':
+      case 'R':
         this->HG->DoModification(PathModified, path);
         break;
-      case 'I': case '?': case 'C': case ' ': default:
+      case 'I':
+      case '?':
+      case 'C':
+      case ' ':
+      default:
         break;
-      }
     }
+  }
 };
 
 std::string cmCTestHG::GetWorkingRevision()
 {
   // Run plumbing "hg identify" to get work tree revision.
   const char* hg = this->CommandLineTool.c_str();
-  const char* hg_identify[] = {hg, "identify","-i", 0};
+  const char* hg_identify[] = { hg, "identify", "-i", 0 };
   std::string rev;
   IdentifyParser out(this, "rev-out> ", rev);
   OutputLogger err(this->Log, "rev-err> ");
@@ -106,7 +112,7 @@ void cmCTestHG::NoteOldRevision()
 {
   this->OldRevision = this->GetWorkingRevision();
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-             << this->OldRevision << "\n");
+               << this->OldRevision << "\n");
   this->PriorRev.Rev = this->OldRevision;
 }
 
@@ -114,18 +120,18 @@ void cmCTestHG::NoteNewRevision()
 {
   this->NewRevision = this->GetWorkingRevision();
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-             << this->NewRevision << "\n");
+               << this->NewRevision << "\n");
 }
 
 bool cmCTestHG::UpdateImpl()
 {
   // Use "hg pull" followed by "hg update" to update the working tree.
   {
-  const char* hg = this->CommandLineTool.c_str();
-  const char* hg_pull[] = {hg, "pull","-v", 0};
-  OutputLogger out(this->Log, "pull-out> ");
-  OutputLogger err(this->Log, "pull-err> ");
-  this->RunChild(&hg_pull[0], &out, &err);
+    const char* hg = this->CommandLineTool.c_str();
+    const char* hg_pull[] = { hg, "pull", "-v", 0 };
+    OutputLogger out(this->Log, "pull-out> ");
+    OutputLogger err(this->Log, "pull-err> ");
+    this->RunChild(&hg_pull[0], &out, &err);
   }
 
   // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
@@ -137,16 +143,14 @@ bool cmCTestHG::UpdateImpl()
 
   // Add user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("HGUpdateOptions");
-    }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     hg_update.push_back(ai->c_str());
-    }
+  }
 
   // Sentinel argument.
   hg_update.push_back(0);
@@ -156,12 +160,16 @@ bool cmCTestHG::UpdateImpl()
   return this->RunUpdateCommand(&hg_update[0], &out, &err);
 }
 
-class cmCTestHG::LogParser: public cmCTestVC::OutputLogger,
-                            private cmXMLParser
+class cmCTestHG::LogParser : public cmCTestVC::OutputLogger,
+                             private cmXMLParser
 {
 public:
-  LogParser(cmCTestHG* hg, const char* prefix):
-    OutputLogger(hg->Log, prefix), HG(hg) { this->InitializeParser(); }
+  LogParser(cmCTestHG* hg, const char* prefix)
+    : OutputLogger(hg->Log, prefix)
+    , HG(hg)
+  {
+    this->InitializeParser();
+  }
   ~LogParser() { this->CleanupParser(); }
 private:
   cmCTestHG* HG;
@@ -174,114 +182,88 @@ private:
   std::vector<char> CData;
 
   virtual bool ProcessChunk(const char* data, int length)
-    {
+  {
     this->OutputLogger::ProcessChunk(data, length);
     this->ParseChunk(data, length);
     return true;
-    }
+  }
 
   virtual void StartElement(const std::string& name, const char** atts)
-    {
+  {
     this->CData.clear();
-    if(name == "logentry")
-      {
+    if (name == "logentry") {
       this->Rev = Revision();
-      if(const char* rev = this->FindAttribute(atts, "revision"))
-        {
+      if (const char* rev = this->FindAttribute(atts, "revision")) {
         this->Rev.Rev = rev;
-        }
-      this->Changes.clear();
       }
+      this->Changes.clear();
     }
+  }
 
   virtual void CharacterDataHandler(const char* data, int length)
-    {
-    this->CData.insert(this->CData.end(), data, data+length);
-    }
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
 
   virtual void EndElement(const std::string& name)
-    {
-    if(name == "logentry")
-      {
+  {
+    if (name == "logentry") {
       this->HG->DoRevision(this->Rev, this->Changes);
-      }
-    else if(!this->CData.empty() && name == "author")
-      {
+    } else if (!this->CData.empty() && name == "author") {
       this->Rev.Author.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "email")
-      {
+    } else if (!this->CData.empty() && name == "email") {
       this->Rev.EMail.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "date")
-      {
+    } else if (!this->CData.empty() && name == "date") {
       this->Rev.Date.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "msg")
-      {
+    } else if (!this->CData.empty() && name == "msg") {
       this->Rev.Log.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "files")
-      {
+    } else if (!this->CData.empty() && name == "files") {
       std::vector<std::string> paths = this->SplitCData();
-      for(unsigned int i = 0; i < paths.size(); ++i)
-        {
+      for (unsigned int i = 0; i < paths.size(); ++i) {
         // Updated by default, will be modified using file_adds and
         // file_dels.
         this->CurChange = Change('U');
         this->CurChange.Path = paths[i];
         this->Changes.push_back(this->CurChange);
-        }
       }
-    else if(!this->CData.empty() && name == "file_adds")
-      {
+    } else if (!this->CData.empty() && name == "file_adds") {
       std::string added_paths(this->CData.begin(), this->CData.end());
-      for(unsigned int i = 0; i < this->Changes.size(); ++i)
-        {
-        if(added_paths.find(this->Changes[i].Path) != std::string::npos)
-          {
+      for (unsigned int i = 0; i < this->Changes.size(); ++i) {
+        if (added_paths.find(this->Changes[i].Path) != std::string::npos) {
           this->Changes[i].Action = 'A';
-          }
         }
       }
-     else if(!this->CData.empty() && name == "file_dels")
-      {
+    } else if (!this->CData.empty() && name == "file_dels") {
       std::string added_paths(this->CData.begin(), this->CData.end());
-      for(unsigned int i = 0; i < this->Changes.size(); ++i)
-        {
-        if(added_paths.find(this->Changes[i].Path) != std::string::npos)
-          {
+      for (unsigned int i = 0; i < this->Changes.size(); ++i) {
+        if (added_paths.find(this->Changes[i].Path) != std::string::npos) {
           this->Changes[i].Action = 'D';
-          }
         }
       }
-    this->CData.clear();
     }
+    this->CData.clear();
+  }
 
   std::vector<std::string> SplitCData()
-    {
+  {
     std::vector<std::string> output;
     std::string currPath;
-    for(unsigned int i=0; i < this->CData.size(); ++i)
-      {
-      if(this->CData[i] != ' ')
-        {
+    for (unsigned int i = 0; i < this->CData.size(); ++i) {
+      if (this->CData[i] != ' ') {
         currPath += this->CData[i];
-        }
-      else
-        {
+      } else {
         output.push_back(currPath);
         currPath = "";
-        }
       }
+    }
     output.push_back(currPath);
     return output;
-    }
+  }
 
   virtual void ReportError(int, int, const char* msg)
-    {
+  {
     this->HG->Log << "Error parsing hg log xml: " << msg << "\n";
-    }
+  }
 };
 
 void cmCTestHG::LoadRevisions()
@@ -294,19 +276,19 @@ void cmCTestHG::LoadRevisions()
   // proper XML escapes.
   std::string range = this->OldRevision + ":" + this->NewRevision;
   const char* hg = this->CommandLineTool.c_str();
-  const char* hgXMLTemplate =
-    "<logentry\n"
-    "   revision=\"{node|short}\">\n"
-    "  <author>{author|person}</author>\n"
-    "  <email>{author|email}</email>\n"
-    "  <date>{date|isodate}</date>\n"
-    "  <msg>{desc}</msg>\n"
-    "  <files>{files}</files>\n"
-    "  <file_adds>{file_adds}</file_adds>\n"
-    "  <file_dels>{file_dels}</file_dels>\n"
-    "</logentry>\n";
-  const char* hg_log[] = {hg, "log","--removed", "-r", range.c_str(),
-                          "--template", hgXMLTemplate, 0};
+  const char* hgXMLTemplate = "<logentry\n"
+                              "   revision=\"{node|short}\">\n"
+                              "  <author>{author|person}</author>\n"
+                              "  <email>{author|email}</email>\n"
+                              "  <date>{date|isodate}</date>\n"
+                              "  <msg>{desc}</msg>\n"
+                              "  <files>{files}</files>\n"
+                              "  <file_adds>{file_adds}</file_adds>\n"
+                              "  <file_dels>{file_dels}</file_dels>\n"
+                              "</logentry>\n";
+  const char* hg_log[] = {
+    hg, "log", "--removed", "-r", range.c_str(), "--template", hgXMLTemplate, 0
+  };
 
   LogParser out(this, "log-out> ");
   out.Process("<?xml version=\"1.0\"?>\n"
@@ -320,7 +302,7 @@ void cmCTestHG::LoadModifications()
 {
   // Use 'hg status' to get modified files.
   const char* hg = this->CommandLineTool.c_str();
-  const char* hg_status[] = {hg, "status", 0};
+  const char* hg_status[] = { hg, "status", 0 };
   StatusParser out(this, "status-out> ");
   OutputLogger err(this->Log, "status-err> ");
   this->RunChild(hg_status, &out, &err);
diff --git a/Source/CTest/cmCTestHG.h b/Source/CTest/cmCTestHG.h
index 1eaf933..8cc8c7a 100644
--- a/Source/CTest/cmCTestHG.h
+++ b/Source/CTest/cmCTestHG.h
@@ -18,7 +18,7 @@
  * \brief Interaction with Mercurial command-line tool
  *
  */
-class cmCTestHG: public cmCTestGlobalVC
+class cmCTestHG : public cmCTestGlobalVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx
index 4b24a199..76f971d 100644
--- a/Source/CTest/cmCTestHandlerCommand.cxx
+++ b/Source/CTest/cmCTestHandlerCommand.cxx
@@ -19,10 +19,9 @@ cmCTestHandlerCommand::cmCTestHandlerCommand()
   const size_t INIT_SIZE = 100;
   size_t cc;
   this->Arguments.reserve(INIT_SIZE);
-  for ( cc = 0; cc < INIT_SIZE; ++ cc )
-    {
+  for (cc = 0; cc < INIT_SIZE; ++cc) {
     this->Arguments.push_back(0);
-    }
+  }
   this->Arguments[ct_RETURN_VALUE] = "RETURN_VALUE";
   this->Arguments[ct_SOURCE] = "SOURCE";
   this->Arguments[ct_BUILD] = "BUILD";
@@ -32,8 +31,8 @@ cmCTestHandlerCommand::cmCTestHandlerCommand()
   this->Quiet = false;
 }
 
-bool cmCTestHandlerCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
+                                        cmExecutionStatus&)
 {
   // Allocate space for argument values.
   this->Values.clear();
@@ -41,24 +40,21 @@ bool cmCTestHandlerCommand
 
   // Process input arguments.
   this->ArgumentDoing = ArgumentDoingNone;
-  for(unsigned int i=0; i < args.size(); ++i)
-    {
+  for (unsigned int i = 0; i < args.size(); ++i) {
     // Check this argument.
-    if(!this->CheckArgumentKeyword(args[i]) &&
-       !this->CheckArgumentValue(args[i]))
-      {
+    if (!this->CheckArgumentKeyword(args[i]) &&
+        !this->CheckArgumentValue(args[i])) {
       std::ostringstream e;
       e << "called with unknown argument \"" << args[i] << "\".";
       this->SetError(e.str());
       return false;
-      }
+    }
 
     // Quit if an argument is invalid.
-    if(this->ArgumentDoing == ArgumentDoingError)
-      {
+    if (this->ArgumentDoing == ArgumentDoingError) {
       return false;
-      }
     }
+  }
 
   // Set the config type of this ctest to the current value of the
   // CTEST_CONFIGURATION_TYPE script variable if it is defined.
@@ -66,94 +62,83 @@ bool cmCTestHandlerCommand
   // line.
   const char* ctestConfigType =
     this->Makefile->GetDefinition("CTEST_CONFIGURATION_TYPE");
-  if (ctestConfigType)
-    {
+  if (ctestConfigType) {
     this->CTest->SetConfigType(ctestConfigType);
-    }
+  }
 
-  if ( this->Values[ct_BUILD] )
-    {
-    this->CTest->SetCTestConfiguration("BuildDirectory",
-      cmSystemTools::CollapseFullPath(
-        this->Values[ct_BUILD]).c_str(), this->Quiet);
-    }
-  else
-    {
+  if (this->Values[ct_BUILD]) {
+    this->CTest->SetCTestConfiguration(
+      "BuildDirectory",
+      cmSystemTools::CollapseFullPath(this->Values[ct_BUILD]).c_str(),
+      this->Quiet);
+  } else {
     const char* bdir =
       this->Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
-    if(bdir)
-      {
-      this->
-        CTest->SetCTestConfiguration("BuildDirectory",
-          cmSystemTools::CollapseFullPath(bdir).c_str(), this->Quiet);
-      }
-    else
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-                 "CTEST_BINARY_DIRECTORY not set" << std::endl;);
-      }
-    }
-  if ( this->Values[ct_SOURCE] )
-    {
-    cmCTestLog(this->CTest, DEBUG,
-      "Set source directory to: " << this->Values[ct_SOURCE] << std::endl);
-    this->CTest->SetCTestConfiguration("SourceDirectory",
-      cmSystemTools::CollapseFullPath(
-        this->Values[ct_SOURCE]).c_str(), this->Quiet);
+    if (bdir) {
+      this->CTest->SetCTestConfiguration(
+        "BuildDirectory", cmSystemTools::CollapseFullPath(bdir).c_str(),
+        this->Quiet);
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "CTEST_BINARY_DIRECTORY not set"
+                   << std::endl;);
     }
-  else
-    {
-    this->CTest->SetCTestConfiguration("SourceDirectory",
+  }
+  if (this->Values[ct_SOURCE]) {
+    cmCTestLog(this->CTest, DEBUG, "Set source directory to: "
+                 << this->Values[ct_SOURCE] << std::endl);
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
+      cmSystemTools::CollapseFullPath(this->Values[ct_SOURCE]).c_str(),
+      this->Quiet);
+  } else {
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
       cmSystemTools::CollapseFullPath(
-        this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY")).c_str(),
+        this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY"))
+        .c_str(),
       this->Quiet);
-    }
+  }
 
-  if(const char* changeId =
-     this->Makefile->GetDefinition("CTEST_CHANGE_ID"))
-    {
+  if (const char* changeId =
+        this->Makefile->GetDefinition("CTEST_CHANGE_ID")) {
     this->CTest->SetCTestConfiguration("ChangeId", changeId, this->Quiet);
-    }
+  }
 
   cmCTestLog(this->CTest, DEBUG, "Initialize handler" << std::endl;);
   cmCTestGenericHandler* handler = this->InitializeHandler();
-  if ( !handler )
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Cannot instantiate test handler " << this->GetName()
-               << std::endl);
+  if (!handler) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot instantiate test handler "
+                 << this->GetName() << std::endl);
     return false;
-    }
+  }
 
   handler->SetAppendXML(this->AppendXML);
 
   handler->PopulateCustomVectors(this->Makefile);
-  if ( this->Values[ct_SUBMIT_INDEX] )
-    {
-    if(!this->CTest->GetDropSiteCDash() && this->CTest->GetDartVersion() <= 1)
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
+  if (this->Values[ct_SUBMIT_INDEX]) {
+    if (!this->CTest->GetDropSiteCDash() &&
+        this->CTest->GetDartVersion() <= 1) {
+      cmCTestLog(
+        this->CTest, ERROR_MESSAGE,
         "Dart before version 2.0 does not support collecting submissions."
-        << std::endl
-        << "Please upgrade the server to Dart 2 or higher, or do not use "
-        "SUBMIT_INDEX." << std::endl);
-      }
-    else
-      {
+          << std::endl
+          << "Please upgrade the server to Dart 2 or higher, or do not use "
+             "SUBMIT_INDEX."
+          << std::endl);
+    } else {
       handler->SetSubmitIndex(atoi(this->Values[ct_SUBMIT_INDEX]));
-      }
     }
+  }
   std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
   cmSystemTools::ChangeDirectory(
     this->CTest->GetCTestConfiguration("BuildDirectory"));
   int res = handler->ProcessHandler();
-  if ( this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE])
-    {
+  if (this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE]) {
     std::ostringstream str;
     str << res;
-    this->Makefile->AddDefinition(
-      this->Values[ct_RETURN_VALUE], str.str().c_str());
-    }
+    this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE],
+                                  str.str().c_str());
+  }
   cmSystemTools::ChangeDirectory(current_dir);
   return true;
 }
@@ -161,50 +146,44 @@ bool cmCTestHandlerCommand
 bool cmCTestHandlerCommand::CheckArgumentKeyword(std::string const& arg)
 {
   // Look for non-value arguments common to all commands.
-  if(arg == "APPEND")
-    {
+  if (arg == "APPEND") {
     this->ArgumentDoing = ArgumentDoingNone;
     this->AppendXML = true;
     return true;
-    }
-  if(arg == "QUIET")
-    {
+  }
+  if (arg == "QUIET") {
     this->ArgumentDoing = ArgumentDoingNone;
     this->Quiet = true;
     return true;
-    }
+  }
 
   // Check for a keyword in our argument/value table.
-  for(unsigned int k=0; k < this->Arguments.size(); ++k)
-    {
-    if(this->Arguments[k] && arg == this->Arguments[k])
-      {
+  for (unsigned int k = 0; k < this->Arguments.size(); ++k) {
+    if (this->Arguments[k] && arg == this->Arguments[k]) {
       this->ArgumentDoing = ArgumentDoingKeyword;
       this->ArgumentIndex = k;
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmCTestHandlerCommand::CheckArgumentValue(std::string const& arg)
 {
-  if(this->ArgumentDoing == ArgumentDoingKeyword)
-    {
+  if (this->ArgumentDoing == ArgumentDoingKeyword) {
     this->ArgumentDoing = ArgumentDoingNone;
     unsigned int k = this->ArgumentIndex;
-    if(this->Values[k])
-      {
+    if (this->Values[k]) {
       std::ostringstream e;
       e << "Called with more than one value for " << this->Arguments[k];
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       this->ArgumentDoing = ArgumentDoingError;
       return true;
-      }
+    }
     this->Values[k] = arg.c_str();
-    cmCTestLog(this->CTest, DEBUG, "Set " << this->Arguments[k]
-               << " to " << arg << "\n");
+    cmCTestLog(this->CTest, DEBUG, "Set " << this->Arguments[k] << " to "
+                                          << arg << "\n");
     return true;
-    }
+  }
   return false;
 }
diff --git a/Source/CTest/cmCTestHandlerCommand.h b/Source/CTest/cmCTestHandlerCommand.h
index 87b2cd8..7248832 100644
--- a/Source/CTest/cmCTestHandlerCommand.h
+++ b/Source/CTest/cmCTestHandlerCommand.h
@@ -31,19 +31,19 @@ public:
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   cmTypeMacro(cmCTestHandlerCommand, cmCTestCommand);
 
   enum
-    {
+  {
     ct_NONE,
     ct_RETURN_VALUE,
     ct_BUILD,
     ct_SOURCE,
     ct_SUBMIT_INDEX,
     ct_LAST
-    };
+  };
 
 protected:
   virtual cmCTestGenericHandler* InitializeHandler() = 0;
@@ -70,9 +70,9 @@ protected:
   size_t Last;
 };
 
-#define CTEST_COMMAND_APPEND_OPTION_DOCS \
-  "The APPEND option marks results for append to those previously " \
-  "submitted to a dashboard server since the last ctest_start.  " \
+#define CTEST_COMMAND_APPEND_OPTION_DOCS                                      \
+  "The APPEND option marks results for append to those previously "           \
+  "submitted to a dashboard server since the last ctest_start.  "             \
   "Append semantics are defined by the dashboard server in use."
 
 #endif
diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx
index 7da81ec..4a408a2 100644
--- a/Source/CTest/cmCTestLaunch.cxx
+++ b/Source/CTest/cmCTestLaunch.cxx
@@ -34,10 +34,9 @@ cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
   this->ExitCode = 1;
   this->CWD = cmSystemTools::GetCurrentWorkingDirectory();
 
-  if(!this->ParseArguments(argc, argv))
-    {
+  if (!this->ParseArguments(argc, argv)) {
     return;
-    }
+  }
 
   this->ComputeFileNames();
 
@@ -50,138 +49,103 @@ cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
 cmCTestLaunch::~cmCTestLaunch()
 {
   cmsysProcess_Delete(this->Process);
-  if(!this->Passthru)
-    {
+  if (!this->Passthru) {
     cmSystemTools::RemoveFile(this->LogOut);
     cmSystemTools::RemoveFile(this->LogErr);
-    }
+  }
 }
 
 bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv)
 {
   // Launcher options occur first and are separated from the real
   // command line by a '--' option.
-  enum Doing { DoingNone,
-               DoingOutput,
-               DoingSource,
-               DoingLanguage,
-               DoingTargetName,
-               DoingTargetType,
-               DoingBuildDir,
-               DoingCount,
-               DoingFilterPrefix };
+  enum Doing
+  {
+    DoingNone,
+    DoingOutput,
+    DoingSource,
+    DoingLanguage,
+    DoingTargetName,
+    DoingTargetType,
+    DoingBuildDir,
+    DoingCount,
+    DoingFilterPrefix
+  };
   Doing doing = DoingNone;
   int arg0 = 0;
-  for(int i=1; !arg0 && i < argc; ++i)
-    {
+  for (int i = 1; !arg0 && i < argc; ++i) {
     const char* arg = argv[i];
-    if(strcmp(arg, "--") == 0)
-      {
-      arg0 = i+1;
-      }
-    else if(strcmp(arg, "--output") == 0)
-      {
+    if (strcmp(arg, "--") == 0) {
+      arg0 = i + 1;
+    } else if (strcmp(arg, "--output") == 0) {
       doing = DoingOutput;
-      }
-    else if(strcmp(arg, "--source") == 0)
-      {
+    } else if (strcmp(arg, "--source") == 0) {
       doing = DoingSource;
-      }
-    else if(strcmp(arg, "--language") == 0)
-      {
+    } else if (strcmp(arg, "--language") == 0) {
       doing = DoingLanguage;
-      }
-    else if(strcmp(arg, "--target-name") == 0)
-      {
+    } else if (strcmp(arg, "--target-name") == 0) {
       doing = DoingTargetName;
-      }
-    else if(strcmp(arg, "--target-type") == 0)
-      {
+    } else if (strcmp(arg, "--target-type") == 0) {
       doing = DoingTargetType;
-      }
-    else if(strcmp(arg, "--build-dir") == 0)
-      {
+    } else if (strcmp(arg, "--build-dir") == 0) {
       doing = DoingBuildDir;
-      }
-    else if(strcmp(arg, "--filter-prefix") == 0)
-      {
+    } else if (strcmp(arg, "--filter-prefix") == 0) {
       doing = DoingFilterPrefix;
-      }
-    else if(doing == DoingOutput)
-      {
+    } else if (doing == DoingOutput) {
       this->OptionOutput = arg;
       doing = DoingNone;
-      }
-    else if(doing == DoingSource)
-      {
+    } else if (doing == DoingSource) {
       this->OptionSource = arg;
       doing = DoingNone;
-      }
-    else if(doing == DoingLanguage)
-      {
+    } else if (doing == DoingLanguage) {
       this->OptionLanguage = arg;
-      if(this->OptionLanguage == "CXX")
-        {
+      if (this->OptionLanguage == "CXX") {
         this->OptionLanguage = "C++";
-        }
-      doing = DoingNone;
       }
-    else if(doing == DoingTargetName)
-      {
+      doing = DoingNone;
+    } else if (doing == DoingTargetName) {
       this->OptionTargetName = arg;
       doing = DoingNone;
-      }
-    else if(doing == DoingTargetType)
-      {
+    } else if (doing == DoingTargetType) {
       this->OptionTargetType = arg;
       doing = DoingNone;
-      }
-    else if(doing == DoingBuildDir)
-      {
+    } else if (doing == DoingBuildDir) {
       this->OptionBuildDir = arg;
       doing = DoingNone;
-      }
-    else if(doing == DoingFilterPrefix)
-      {
+    } else if (doing == DoingFilterPrefix) {
       this->OptionFilterPrefix = arg;
       doing = DoingNone;
-      }
     }
+  }
 
   // Extract the real command line.
-  if(arg0)
-    {
+  if (arg0) {
     this->RealArgC = argc - arg0;
     this->RealArgV = argv + arg0;
-    for(int i=0; i < this->RealArgC; ++i)
-      {
+    for (int i = 0; i < this->RealArgC; ++i) {
       this->HandleRealArg(this->RealArgV[i]);
-      }
-    return true;
     }
-  else
-    {
+    return true;
+  } else {
     this->RealArgC = 0;
     this->RealArgV = 0;
     std::cerr << "No launch/command separator ('--') found!\n";
     return false;
-    }
+  }
 }
 
 void cmCTestLaunch::HandleRealArg(const char* arg)
 {
 #ifdef _WIN32
   // Expand response file arguments.
-  if(arg[0] == '@' && cmSystemTools::FileExists(arg+1))
-    {
-    cmsys::ifstream fin(arg+1);
+  if (arg[0] == '@' && cmSystemTools::FileExists(arg + 1)) {
+    cmsys::ifstream fin(arg + 1);
     std::string line;
-    while(cmSystemTools::GetLineFromStream(fin, line))
-      {
+    while (cmSystemTools::GetLineFromStream(fin, line)) {
       cmSystemTools::ParseWindowsCommandLine(line.c_str(), this->RealArgs);
-      }
-    return;
     }
+    return;
+  }
 #endif
   this->RealArgs.push_back(arg);
 }
@@ -191,10 +155,9 @@ void cmCTestLaunch::ComputeFileNames()
   // We just passthru the behavior of the real command unless the
   // CTEST_LAUNCH_LOGS environment variable is set.
   const char* d = getenv("CTEST_LAUNCH_LOGS");
-  if(!(d && *d))
-    {
+  if (!(d && *d)) {
     return;
-    }
+  }
   this->Passthru = false;
 
   // The environment variable specifies the directory into which we
@@ -209,11 +172,10 @@ void cmCTestLaunch::ComputeFileNames()
   cmsysMD5* md5 = cmsysMD5_New();
   cmsysMD5_Initialize(md5);
   cmsysMD5_Append(md5, (unsigned char const*)(this->CWD.c_str()), -1);
-  for(std::vector<std::string>::const_iterator ai = this->RealArgs.begin();
-      ai != this->RealArgs.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = this->RealArgs.begin();
+       ai != this->RealArgs.end(); ++ai) {
     cmsysMD5_Append(md5, (unsigned char const*)ai->c_str(), -1);
-    }
+  }
   cmsysMD5_FinalizeHex(md5, hash);
   cmsysMD5_Delete(md5);
   this->LogHash.assign(hash, 32);
@@ -232,11 +194,10 @@ void cmCTestLaunch::ComputeFileNames()
 void cmCTestLaunch::RunChild()
 {
   // Ignore noopt make rules
-  if(this->RealArgs.empty() || this->RealArgs[0] == ":")
-    {
+  if (this->RealArgs.empty() || this->RealArgs[0] == ":") {
     this->ExitCode = 0;
     return;
-    }
+  }
 
   // Prepare to run the real command.
   cmsysProcess* cp = this->Process;
@@ -244,20 +205,15 @@ void cmCTestLaunch::RunChild()
 
   cmsys::ofstream fout;
   cmsys::ofstream ferr;
-  if(this->Passthru)
-    {
+  if (this->Passthru) {
     // In passthru mode we just share the output pipes.
     cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDOUT, 1);
     cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDERR, 1);
-    }
-  else
-    {
+  } else {
     // In full mode we record the child output pipes to log files.
-    fout.open(this->LogOut.c_str(),
-              std::ios::out | std::ios::binary);
-    ferr.open(this->LogErr.c_str(),
-              std::ios::out | std::ios::binary);
-    }
+    fout.open(this->LogOut.c_str(), std::ios::out | std::ios::binary);
+    ferr.open(this->LogErr.c_str(), std::ios::out | std::ios::binary);
+  }
 
 #ifdef _WIN32
   // Do this so that newline transformation is not done when writing to cout
@@ -270,26 +226,21 @@ void cmCTestLaunch::RunChild()
   cmsysProcess_Execute(cp);
 
   // Record child stdout and stderr if necessary.
-  if(!this->Passthru)
-    {
+  if (!this->Passthru) {
     char* data = 0;
     int length = 0;
-    while(int p = cmsysProcess_WaitForData(cp, &data, &length, 0))
-      {
-      if(p == cmsysProcess_Pipe_STDOUT)
-        {
+    while (int p = cmsysProcess_WaitForData(cp, &data, &length, 0)) {
+      if (p == cmsysProcess_Pipe_STDOUT) {
         fout.write(data, length);
         std::cout.write(data, length);
         this->HaveOut = true;
-        }
-      else if(p == cmsysProcess_Pipe_STDERR)
-        {
+      } else if (p == cmsysProcess_Pipe_STDERR) {
         ferr.write(data, length);
         std::cerr.write(data, length);
         this->HaveErr = true;
-        }
       }
     }
+  }
 
   // Wait for the real command to finish.
   cmsysProcess_WaitForExit(cp, 0);
@@ -298,18 +249,16 @@ void cmCTestLaunch::RunChild()
 
 int cmCTestLaunch::Run()
 {
-  if(!this->Process)
-    {
+  if (!this->Process) {
     std::cerr << "Could not allocate cmsysProcess instance!\n";
     return -1;
-    }
+  }
 
   this->RunChild();
 
-  if(this->CheckResults())
-    {
+  if (this->CheckResults()) {
     return this->ExitCode;
-    }
+  }
 
   this->LoadConfig();
   this->WriteXML();
@@ -319,10 +268,9 @@ int cmCTestLaunch::Run()
 
 void cmCTestLaunch::LoadLabels()
 {
-  if(this->OptionBuildDir.empty() || this->OptionTargetName.empty())
-    {
+  if (this->OptionBuildDir.empty() || this->OptionTargetName.empty()) {
     return;
-    }
+  }
 
   // Labels are listed in per-target files.
   std::string fname = this->OptionBuildDir;
@@ -337,38 +285,31 @@ void cmCTestLaunch::LoadLabels()
 
   // Load the labels file.
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
-  if(!fin) { return; }
+  if (!fin) {
+    return;
+  }
   bool inTarget = true;
   bool inSource = false;
   std::string line;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if(line.empty() || line[0] == '#')
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty() || line[0] == '#') {
       // Ignore blank and comment lines.
       continue;
-      }
-    else if(line[0] == ' ')
-      {
+    } else if (line[0] == ' ') {
       // Label lines appear indented by one space.
-      if(inTarget || inSource)
-        {
-        this->Labels.insert(line.c_str()+1);
-        }
+      if (inTarget || inSource) {
+        this->Labels.insert(line.c_str() + 1);
       }
-    else if(!this->OptionSource.empty() && !inSource)
-      {
+    } else if (!this->OptionSource.empty() && !inSource) {
       // Non-indented lines specify a source file name.  The first one
       // is the end of the target-wide labels.  Use labels following a
       // matching source.
       inTarget = false;
       inSource = this->SourceMatches(line, source);
-      }
-    else
-      {
+    } else {
       return;
-      }
     }
+  }
 }
 
 bool cmCTestLaunch::SourceMatches(std::string const& lhs,
@@ -390,7 +331,7 @@ void cmCTestLaunch::WriteXML()
 {
   // Name the xml file.
   std::string logXML = this->LogDir;
-  logXML += this->IsError()? "error-" : "warning-";
+  logXML += this->IsError() ? "error-" : "warning-";
   logXML += this->LogHash;
   logXML += ".xml";
 
@@ -412,71 +353,54 @@ void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml)
   xml.StartElement("Action");
 
   // TargetName
-  if(!this->OptionTargetName.empty())
-    {
+  if (!this->OptionTargetName.empty()) {
     xml.Element("TargetName", this->OptionTargetName);
-    }
+  }
 
   // Language
-  if(!this->OptionLanguage.empty())
-    {
+  if (!this->OptionLanguage.empty()) {
     xml.Element("Language", this->OptionLanguage);
-    }
+  }
 
   // SourceFile
-  if(!this->OptionSource.empty())
-    {
+  if (!this->OptionSource.empty()) {
     std::string source = this->OptionSource;
     cmSystemTools::ConvertToUnixSlashes(source);
 
     // If file is in source tree use its relative location.
-    if(cmSystemTools::FileIsFullPath(this->SourceDir.c_str()) &&
-       cmSystemTools::FileIsFullPath(source.c_str()) &&
-       cmSystemTools::IsSubDirectory(source,
-                                     this->SourceDir))
-      {
-      source = cmSystemTools::RelativePath(this->SourceDir.c_str(),
-                                           source.c_str());
-      }
+    if (cmSystemTools::FileIsFullPath(this->SourceDir.c_str()) &&
+        cmSystemTools::FileIsFullPath(source.c_str()) &&
+        cmSystemTools::IsSubDirectory(source, this->SourceDir)) {
+      source =
+        cmSystemTools::RelativePath(this->SourceDir.c_str(), source.c_str());
+    }
 
     xml.Element("SourceFile", source);
-    }
+  }
 
   // OutputFile
-  if(!this->OptionOutput.empty())
-    {
+  if (!this->OptionOutput.empty()) {
     xml.Element("OutputFile", this->OptionOutput);
-    }
+  }
 
   // OutputType
   const char* outputType = 0;
-  if(!this->OptionTargetType.empty())
-    {
-    if(this->OptionTargetType == "EXECUTABLE")
-      {
+  if (!this->OptionTargetType.empty()) {
+    if (this->OptionTargetType == "EXECUTABLE") {
       outputType = "executable";
-      }
-    else if(this->OptionTargetType == "SHARED_LIBRARY")
-      {
+    } else if (this->OptionTargetType == "SHARED_LIBRARY") {
       outputType = "shared library";
-      }
-    else if(this->OptionTargetType == "MODULE_LIBRARY")
-      {
+    } else if (this->OptionTargetType == "MODULE_LIBRARY") {
       outputType = "module library";
-      }
-    else if(this->OptionTargetType == "STATIC_LIBRARY")
-      {
+    } else if (this->OptionTargetType == "STATIC_LIBRARY") {
       outputType = "static library";
-      }
     }
-  else if(!this->OptionSource.empty())
-    {
+  } else if (!this->OptionSource.empty()) {
     outputType = "object file";
-    }
-  if(outputType)
-    {
+  }
+  if (outputType) {
     xml.Element("OutputType", outputType);
-    }
+  }
 
   xml.EndElement(); // Action
 }
@@ -485,15 +409,13 @@ void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml)
 {
   xml.Comment("Details of command");
   xml.StartElement("Command");
-  if(!this->CWD.empty())
-    {
+  if (!this->CWD.empty()) {
     xml.Element("WorkingDirectory", this->CWD);
-    }
-  for(std::vector<std::string>::const_iterator ai = this->RealArgs.begin();
-      ai != this->RealArgs.end(); ++ai)
-    {
+  }
+  for (std::vector<std::string>::const_iterator ai = this->RealArgs.begin();
+       ai != this->RealArgs.end(); ++ai) {
     xml.Element("Argument", *ai);
-    }
+  }
   xml.EndElement(); // Command
 }
 
@@ -515,28 +437,35 @@ void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml)
   // ExitCondition
   xml.StartElement("ExitCondition");
   cmsysProcess* cp = this->Process;
-  switch (cmsysProcess_GetState(cp))
-    {
+  switch (cmsysProcess_GetState(cp)) {
     case cmsysProcess_State_Starting:
-      xml.Content("No process has been executed"); break;
+      xml.Content("No process has been executed");
+      break;
     case cmsysProcess_State_Executing:
-      xml.Content("The process is still executing"); break;
+      xml.Content("The process is still executing");
+      break;
     case cmsysProcess_State_Disowned:
-      xml.Content("Disowned"); break;
+      xml.Content("Disowned");
+      break;
     case cmsysProcess_State_Killed:
-      xml.Content("Killed by parent"); break;
+      xml.Content("Killed by parent");
+      break;
 
     case cmsysProcess_State_Expired:
-      xml.Content("Killed when timeout expired"); break;
+      xml.Content("Killed when timeout expired");
+      break;
     case cmsysProcess_State_Exited:
-      xml.Content(this->ExitCode); break;
+      xml.Content(this->ExitCode);
+      break;
     case cmsysProcess_State_Exception:
       xml.Content("Terminated abnormally: ");
-      xml.Content(cmsysProcess_GetExceptionString(cp)); break;
+      xml.Content(cmsysProcess_GetExceptionString(cp));
+      break;
     case cmsysProcess_State_Error:
       xml.Content("Error administrating child process: ");
-      xml.Content(cmsysProcess_GetErrorString(cp)); break;
-    };
+      xml.Content(cmsysProcess_GetErrorString(cp));
+      break;
+  };
   xml.EndElement(); // ExitCondition
 
   xml.EndElement(); // Result
@@ -545,69 +474,60 @@ void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml)
 void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml)
 {
   this->LoadLabels();
-  if(!this->Labels.empty())
-    {
+  if (!this->Labels.empty()) {
     xml.Comment("Interested parties");
     xml.StartElement("Labels");
-    for(std::set<std::string>::const_iterator li = this->Labels.begin();
-        li != this->Labels.end(); ++li)
-      {
+    for (std::set<std::string>::const_iterator li = this->Labels.begin();
+         li != this->Labels.end(); ++li) {
       xml.Element("Label", *li);
-      }
-    xml.EndElement(); // Labels
     }
+    xml.EndElement(); // Labels
+  }
 }
 
-void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml,
-                                  std::string const& fname)
+void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml, std::string const& fname)
 {
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
 
   std::string line;
   const char* sep = "";
 
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if(MatchesFilterPrefix(line))
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (MatchesFilterPrefix(line)) {
       continue;
-      }
+    }
 
     xml.Content(sep);
     xml.Content(line);
     sep = "\n";
-    }
+  }
 }
 
 bool cmCTestLaunch::CheckResults()
 {
   // Skip XML in passthru mode.
-  if(this->Passthru)
-    {
+  if (this->Passthru) {
     return true;
-    }
+  }
 
   // We always report failure for error conditions.
-  if(this->IsError())
-    {
+  if (this->IsError()) {
     return false;
-    }
+  }
 
   // Scrape the output logs to look for warnings.
-  if((this->HaveErr && this->ScrapeLog(this->LogErr)) ||
-     (this->HaveOut && this->ScrapeLog(this->LogOut)))
-    {
+  if ((this->HaveErr && this->ScrapeLog(this->LogErr)) ||
+      (this->HaveOut && this->ScrapeLog(this->LogOut))) {
     return false;
-    }
+  }
   return true;
 }
 
 void cmCTestLaunch::LoadScrapeRules()
 {
-  if(this->ScrapeRulesLoaded)
-    {
+  if (this->ScrapeRulesLoaded) {
     return;
-    }
+  }
   this->ScrapeRulesLoaded = true;
 
   // Common compiler warning formats.  These are much simpler than the
@@ -622,10 +542,8 @@ void cmCTestLaunch::LoadScrapeRules()
   this->LoadScrapeRules("WarningSuppress", this->RegexWarningSuppress);
 }
 
-void
-cmCTestLaunch
-::LoadScrapeRules(const char* purpose,
-                  std::vector<cmsys::RegularExpression>& regexps)
+void cmCTestLaunch::LoadScrapeRules(
+  const char* purpose, std::vector<cmsys::RegularExpression>& regexps)
 {
   std::string fname = this->LogDir;
   fname += "Custom";
@@ -634,13 +552,11 @@ cmCTestLaunch
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
   std::string line;
   cmsys::RegularExpression rex;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if(rex.compile(line.c_str()))
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (rex.compile(line.c_str())) {
       regexps.push_back(rex);
-      }
     }
+  }
 }
 
 bool cmCTestLaunch::ScrapeLog(std::string const& fname)
@@ -651,54 +567,48 @@ bool cmCTestLaunch::ScrapeLog(std::string const& fname)
   // suppression expressions.
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
   std::string line;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if(MatchesFilterPrefix(line))
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (MatchesFilterPrefix(line)) {
       continue;
-      }
+    }
 
-    if(this->Match(line, this->RegexWarning) &&
-       !this->Match(line, this->RegexWarningSuppress))
-      {
+    if (this->Match(line, this->RegexWarning) &&
+        !this->Match(line, this->RegexWarningSuppress)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmCTestLaunch::Match(std::string const& line,
                           std::vector<cmsys::RegularExpression>& regexps)
 {
-  for(std::vector<cmsys::RegularExpression>::iterator ri = regexps.begin();
-      ri != regexps.end(); ++ri)
-    {
-    if(ri->find(line.c_str()))
-      {
+  for (std::vector<cmsys::RegularExpression>::iterator ri = regexps.begin();
+       ri != regexps.end(); ++ri) {
+    if (ri->find(line.c_str())) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const
 {
-  if(!this->OptionFilterPrefix.empty() && cmSystemTools::StringStartsWith(
-      line.c_str(), this->OptionFilterPrefix.c_str()))
-    {
+  if (!this->OptionFilterPrefix.empty() &&
+      cmSystemTools::StringStartsWith(line.c_str(),
+                                      this->OptionFilterPrefix.c_str())) {
     return true;
-    }
+  }
   return false;
 }
 
 int cmCTestLaunch::Main(int argc, const char* const argv[])
 {
-  if(argc == 2)
-    {
+  if (argc == 2) {
     std::cerr << "ctest --launch: this mode is for internal CTest use only"
               << std::endl;
     return 1;
-    }
+  }
   cmCTestLaunch self(argc, argv);
   return self.Run();
 }
@@ -717,10 +627,9 @@ void cmCTestLaunch::LoadConfig()
   cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
   std::string fname = this->LogDir;
   fname += "CTestLaunchConfig.cmake";
-  if(cmSystemTools::FileExists(fname.c_str()) &&
-     mf->ReadListFile(fname.c_str()))
-    {
+  if (cmSystemTools::FileExists(fname.c_str()) &&
+      mf->ReadListFile(fname.c_str())) {
     this->SourceDir = mf->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
     cmSystemTools::ConvertToUnixSlashes(this->SourceDir);
-    }
+  }
 }
diff --git a/Source/CTest/cmCTestLaunch.h b/Source/CTest/cmCTestLaunch.h
index 1a908a3..cbcc9ec 100644
--- a/Source/CTest/cmCTestLaunch.h
+++ b/Source/CTest/cmCTestLaunch.h
@@ -28,6 +28,7 @@ class cmCTestLaunch
 public:
   /** Entry point from ctest executable main().  */
   static int Main(int argc, const char* const argv[]);
+
 private:
   // Initialize the launcher from its command line.
   cmCTestLaunch(int argc, const char* const* argv);
@@ -78,8 +79,7 @@ private:
   // Labels associated with the build rule.
   std::set<std::string> Labels;
   void LoadLabels();
-  bool SourceMatches(std::string const& lhs,
-                     std::string const& rhs);
+  bool SourceMatches(std::string const& lhs, std::string const& rhs);
 
   // Regular expressions to match warnings and their exceptions.
   bool ScrapeRulesLoaded;
diff --git a/Source/CTest/cmCTestMemCheckCommand.cxx b/Source/CTest/cmCTestMemCheckCommand.cxx
index b379d32..d53dcd0 100644
--- a/Source/CTest/cmCTestMemCheckCommand.cxx
+++ b/Source/CTest/cmCTestMemCheckCommand.cxx
@@ -14,27 +14,26 @@
 #include "cmCTest.h"
 #include "cmCTestGenericHandler.h"
 
-
 cmCTestGenericHandler* cmCTestMemCheckCommand::InitializeActualHandler()
 {
-  cmCTestGenericHandler* handler
-    = this->CTest->GetInitializedHandler("memcheck");
-
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "MemoryCheckType", "CTEST_MEMORYCHECK_TYPE", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "MemoryCheckSanitizerOptions", "CTEST_MEMORYCHECK_SANITIZER_OPTIONS",
-    this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "MemoryCheckCommand", "CTEST_MEMORYCHECK_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "MemoryCheckCommandOptions", "CTEST_MEMORYCHECK_COMMAND_OPTIONS",
-    this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "MemoryCheckSuppressionFile", "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE",
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("memcheck");
+
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckType", "CTEST_MEMORYCHECK_TYPE", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckSanitizerOptions",
+    "CTEST_MEMORYCHECK_SANITIZER_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckCommand", "CTEST_MEMORYCHECK_COMMAND",
     this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckCommandOptions",
+    "CTEST_MEMORYCHECK_COMMAND_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "MemoryCheckSuppressionFile",
+    "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE", this->Quiet);
 
   handler->SetQuiet(this->Quiet);
   return handler;
 }
-
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
index e239d46..245892c 100644
--- a/Source/CTest/cmCTestMemCheckCommand.h
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -24,24 +24,23 @@ class cmCTestGenericHandler;
 class cmCTestMemCheckCommand : public cmCTestTestCommand
 {
 public:
-
   cmCTestMemCheckCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestMemCheckCommand* ni = new cmCTestMemCheckCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_memcheck";}
+  virtual std::string GetName() const { return "ctest_memcheck"; }
 
   cmTypeMacro(cmCTestMemCheckCommand, cmCTestTestCommand);
 
@@ -49,6 +48,4 @@ protected:
   cmCTestGenericHandler* InitializeActualHandler();
 };
 
-
 #endif
-
diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx
index dd2a5b8..2cbd64d 100644
--- a/Source/CTest/cmCTestMemCheckHandler.cxx
+++ b/Source/CTest/cmCTestMemCheckHandler.cxx
@@ -34,24 +34,22 @@ struct CatToErrorType
   int ErrorCode;
 };
 
-
 static CatToErrorType cmCTestMemCheckBoundsChecker[] = {
   // Error tags
-  {"Write Overrun", cmCTestMemCheckHandler::ABW},
-  {"Read Overrun",  cmCTestMemCheckHandler::ABR},
-  {"Memory Overrun", cmCTestMemCheckHandler::ABW},
-  {"Allocation Conflict",  cmCTestMemCheckHandler::FMM},
-  {"Bad Pointer Use", cmCTestMemCheckHandler::FMW},
-  {"Dangling Pointer", cmCTestMemCheckHandler::FMR},
-  {0,0}
+  { "Write Overrun", cmCTestMemCheckHandler::ABW },
+  { "Read Overrun", cmCTestMemCheckHandler::ABR },
+  { "Memory Overrun", cmCTestMemCheckHandler::ABW },
+  { "Allocation Conflict", cmCTestMemCheckHandler::FMM },
+  { "Bad Pointer Use", cmCTestMemCheckHandler::FMW },
+  { "Dangling Pointer", cmCTestMemCheckHandler::FMR },
+  { 0, 0 }
 };
 
 static void xmlReportError(int line, const char* msg, void* data)
 {
   cmCTest* ctest = (cmCTest*)data;
-  cmCTestLog(ctest, ERROR_MESSAGE,
-             "Error parsing XML in stream at line "
-             << line << ": " << msg << std::endl);
+  cmCTestLog(ctest, ERROR_MESSAGE, "Error parsing XML in stream at line "
+               << line << ": " << msg << std::endl);
 }
 
 // parse the xml file containing the results of last BoundsChecker run
@@ -59,87 +57,70 @@ class cmBoundsCheckerParser : public cmXMLParser
 {
 public:
   cmBoundsCheckerParser(cmCTest* c)
-    {
-      this->CTest = c;
-      this->SetErrorCallback(xmlReportError, (void*)c);
-    }
+  {
+    this->CTest = c;
+    this->SetErrorCallback(xmlReportError, (void*)c);
+  }
   void StartElement(const std::string& name, const char** atts)
-    {
-      if(name == "MemoryLeak" ||
-         name == "ResourceLeak")
-        {
-        this->Errors.push_back(cmCTestMemCheckHandler::MLK);
-        }
-      else if(name == "Error" ||
-              name == "Dangling Pointer")
-        {
-        this->ParseError(atts);
-        }
-      // Create the log
-      std::ostringstream ostr;
-      ostr << name << ":\n";
-      int i = 0;
-      for(; atts[i] != 0; i+=2)
-        {
-        ostr << "   " << atts[i]
-             << " - " << atts[i+1] << "\n";
-        }
-      ostr << "\n";
-      this->Log += ostr.str();
+  {
+    if (name == "MemoryLeak" || name == "ResourceLeak") {
+      this->Errors.push_back(cmCTestMemCheckHandler::MLK);
+    } else if (name == "Error" || name == "Dangling Pointer") {
+      this->ParseError(atts);
     }
-  void EndElement(const std::string& )
-    {
+    // Create the log
+    std::ostringstream ostr;
+    ostr << name << ":\n";
+    int i = 0;
+    for (; atts[i] != 0; i += 2) {
+      ostr << "   " << atts[i] << " - " << atts[i + 1] << "\n";
     }
+    ostr << "\n";
+    this->Log += ostr.str();
+  }
+  void EndElement(const std::string&) {}
 
   const char* GetAttribute(const char* name, const char** atts)
-    {
-      int i = 0;
-      for(; atts[i] != 0; ++i)
-        {
-        if(strcmp(name, atts[i]) == 0)
-          {
-          return atts[i+1];
-          }
-        }
-      return 0;
+  {
+    int i = 0;
+    for (; atts[i] != 0; ++i) {
+      if (strcmp(name, atts[i]) == 0) {
+        return atts[i + 1];
+      }
     }
+    return 0;
+  }
   void ParseError(const char** atts)
-    {
-      CatToErrorType* ptr = cmCTestMemCheckBoundsChecker;
-      const char* cat = this->GetAttribute("ErrorCategory", atts);
-      if(!cat)
-        {
-        this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
-        cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "No Category found in Bounds checker XML\n" );
-        return;
-        }
-      while(ptr->ErrorCategory && cat)
-        {
-        if(strcmp(ptr->ErrorCategory, cat) == 0)
-          {
-          this->Errors.push_back(ptr->ErrorCode);
-          return; // found it we are done
-          }
-        ptr++;
-        }
-      if(ptr->ErrorCategory)
-        {
-        this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
-        cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "Found unknown Bounds Checker error "
-                   << ptr->ErrorCategory << std::endl);
-        }
+  {
+    CatToErrorType* ptr = cmCTestMemCheckBoundsChecker;
+    const char* cat = this->GetAttribute("ErrorCategory", atts);
+    if (!cat) {
+      this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "No Category found in Bounds checker XML\n");
+      return;
+    }
+    while (ptr->ErrorCategory && cat) {
+      if (strcmp(ptr->ErrorCategory, cat) == 0) {
+        this->Errors.push_back(ptr->ErrorCode);
+        return; // found it we are done
+      }
+      ptr++;
     }
+    if (ptr->ErrorCategory) {
+      this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Found unknown Bounds Checker error " << ptr->ErrorCategory
+                                                       << std::endl);
+    }
+  }
   cmCTest* CTest;
   std::vector<int> Errors;
   std::string Log;
 };
 
-#define BOUNDS_CHECKER_MARKER \
-"******######*****Begin BOUNDS CHECKER XML******######******"
-
-
+#define BOUNDS_CHECKER_MARKER                                                 \
+  "******######*****Begin BOUNDS CHECKER XML******######******"
 
 cmCTestMemCheckHandler::cmCTestMemCheckHandler()
 {
@@ -164,28 +145,25 @@ void cmCTestMemCheckHandler::Initialize()
 
 int cmCTestMemCheckHandler::PreProcessHandler()
 {
-  if ( !this->InitializeMemoryChecking() )
-    {
+  if (!this->InitializeMemoryChecking()) {
     return 0;
-    }
+  }
 
-  if ( !this->ExecuteCommands(this->CustomPreMemCheck) )
-    {
+  if (!this->ExecuteCommands(this->CustomPreMemCheck)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Problem executing pre-memcheck command(s)." << std::endl);
+               "Problem executing pre-memcheck command(s)." << std::endl);
     return 0;
-    }
+  }
   return 1;
 }
 
 int cmCTestMemCheckHandler::PostProcessHandler()
 {
-  if ( !this->ExecuteCommands(this->CustomPostMemCheck) )
-    {
+  if (!this->ExecuteCommands(this->CustomPostMemCheck)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Problem executing post-memcheck command(s)." << std::endl);
+               "Problem executing post-memcheck command(s)." << std::endl);
     return 0;
-    }
+  }
   return 1;
 }
 
@@ -195,104 +173,77 @@ void cmCTestMemCheckHandler::GenerateTestCommand(
   std::vector<std::string>::size_type pp;
   std::string index;
   std::ostringstream stream;
-  std::string memcheckcommand
-    = cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str());
+  std::string memcheckcommand =
+    cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str());
   stream << test;
   index = stream.str();
-  for ( pp = 0; pp < this->MemoryTesterDynamicOptions.size(); pp ++ )
-    {
+  for (pp = 0; pp < this->MemoryTesterDynamicOptions.size(); pp++) {
     std::string arg = this->MemoryTesterDynamicOptions[pp];
     std::string::size_type pos = arg.find("??");
-    if (pos != std::string::npos)
-      {
+    if (pos != std::string::npos) {
       arg.replace(pos, 2, index);
-      }
+    }
     args.push_back(arg);
     memcheckcommand += " \"";
     memcheckcommand += arg;
     memcheckcommand += "\"";
-    }
+  }
   // Create a copy of the memory tester environment variable.
   // This is used for memory testing programs that pass options
   // via environment varaibles.
   std::string memTesterEnvironmentVariable =
     this->MemoryTesterEnvironmentVariable;
-  for ( pp = 0; pp < this->MemoryTesterOptions.size(); pp ++ )
-    {
-    if(!memTesterEnvironmentVariable.empty())
-      {
+  for (pp = 0; pp < this->MemoryTesterOptions.size(); pp++) {
+    if (!memTesterEnvironmentVariable.empty()) {
       // If we are using env to pass options, append all the options to
       // this string with space separation.
       memTesterEnvironmentVariable += " " + this->MemoryTesterOptions[pp];
-      }
+    }
     // for regular options just add them to args and memcheckcommand
     // which is just used for display
-    else
-      {
+    else {
       args.push_back(this->MemoryTesterOptions[pp]);
       memcheckcommand += " \"";
       memcheckcommand += this->MemoryTesterOptions[pp];
       memcheckcommand += "\"";
-      }
     }
+  }
   // if this is an env option type, then add the env string as a single
   // argument.
-  if(!memTesterEnvironmentVariable.empty())
-    {
+  if (!memTesterEnvironmentVariable.empty()) {
     std::string::size_type pos = memTesterEnvironmentVariable.find("??");
-    if (pos != std::string::npos)
-      {
+    if (pos != std::string::npos) {
       memTesterEnvironmentVariable.replace(pos, 2, index);
-      }
+    }
     memcheckcommand += " " + memTesterEnvironmentVariable;
     args.push_back(memTesterEnvironmentVariable);
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Memory check command: " << memcheckcommand << std::endl, this->Quiet);
+                     "Memory check command: " << memcheckcommand << std::endl,
+                     this->Quiet);
 }
 
 void cmCTestMemCheckHandler::InitializeResultsVectors()
 {
   // fill these members
-//  cmsys::vector<std::string> ResultStrings;
-//  cmsys::vector<std::string> ResultStringsLong;
-//  cmsys::vector<int>         GlobalResults;
+  //  cmsys::vector<std::string> ResultStrings;
+  //  cmsys::vector<std::string> ResultStringsLong;
+  //  cmsys::vector<int>         GlobalResults;
   this->ResultStringsLong.clear();
   this->ResultStrings.clear();
   this->GlobalResults.clear();
   // If we are working with style checkers that dynamically fill
   // the results strings then return.
-  if(this->MemoryTesterStyle > cmCTestMemCheckHandler::BOUNDS_CHECKER)
-    {
+  if (this->MemoryTesterStyle > cmCTestMemCheckHandler::BOUNDS_CHECKER) {
     return;
-    }
+  }
 
   // define the standard set of errors
   //----------------------------------------------------------------------
   static const char* cmCTestMemCheckResultStrings[] = {
-    "ABR",
-    "ABW",
-    "ABWL",
-    "COR",
-    "EXU",
-    "FFM",
-    "FIM",
-    "FMM",
-    "FMR",
-    "FMW",
-    "FUM",
-    "IPR",
-    "IPW",
-    "MAF",
-    "MLK",
-    "MPK",
-    "NPR",
-    "ODS",
-    "PAR",
-    "PLK",
-    "UMC",
-    "UMR",
-    0
+    "ABR", "ABW", "ABWL", "COR", "EXU", "FFM", "FIM", "FMM",
+    "FMR", "FMW", "FUM",  "IPR", "IPW", "MAF", "MLK", "MPK",
+    "NPR", "ODS", "PAR",  "PLK", "UMC", "UMR", 0
   };
   static const char* cmCTestMemCheckResultLongStrings[] = {
     "Threading Problem",
@@ -320,40 +271,36 @@ void cmCTestMemCheckHandler::InitializeResultsVectors()
     0
   };
   this->GlobalResults.clear();
-  for(int i =0; cmCTestMemCheckResultStrings[i] != 0; ++i)
-    {
+  for (int i = 0; cmCTestMemCheckResultStrings[i] != 0; ++i) {
     this->ResultStrings.push_back(cmCTestMemCheckResultStrings[i]);
     this->ResultStringsLong.push_back(cmCTestMemCheckResultLongStrings[i]);
     this->GlobalResults.push_back(0);
-    }
+  }
 }
 
-void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf)
+void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile* mf)
 {
   this->cmCTestTestHandler::PopulateCustomVectors(mf);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_MEMCHECK",
-                                this->CustomPreMemCheck);
+                                    this->CustomPreMemCheck);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_MEMCHECK",
-                                this->CustomPostMemCheck);
+                                    this->CustomPostMemCheck);
 
-  this->CTest->PopulateCustomVector(mf,
-                             "CTEST_CUSTOM_MEMCHECK_IGNORE",
-                             this->CustomTestsIgnore);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_MEMCHECK_IGNORE",
+                                    this->CustomTestsIgnore);
   std::string cmake = cmSystemTools::GetCMakeCommand();
   this->CTest->SetCTestConfiguration("CMakeCommand", cmake.c_str(),
-    this->Quiet);
+                                     this->Quiet);
 }
 
 void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml)
 {
-  if ( !this->CTest->GetProduceXML() )
-    {
+  if (!this->CTest->GetProduceXML()) {
     return;
-    }
+  }
   this->CTest->StartXML(xml, this->AppendXML);
   xml.StartElement("DynamicAnalysis");
-  switch ( this->MemoryTesterStyle )
-    {
+  switch (this->MemoryTesterStyle) {
     case cmCTestMemCheckHandler::VALGRIND:
       xml.Attribute("Checker", "Valgrind");
       break;
@@ -377,98 +324,91 @@ void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml)
       break;
     default:
       xml.Attribute("Checker", "Unknown");
-    }
+  }
 
   xml.Element("StartDateTime", this->StartTest);
   xml.Element("StartTestTime", this->StartTestTime);
   xml.StartElement("TestList");
   cmCTestMemCheckHandler::TestResultsVector::size_type cc;
-  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
-    {
-    cmCTestTestResult *result = &this->TestResults[cc];
+  for (cc = 0; cc < this->TestResults.size(); cc++) {
+    cmCTestTestResult* result = &this->TestResults[cc];
     std::string testPath = result->Path + "/" + result->Name;
     xml.Element("Test", this->CTest->GetShortPathToFile(testPath.c_str()));
-    }
+  }
   xml.EndElement(); // TestList
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-    "-- Processing memory checking output: ", this->Quiet);
+                     "-- Processing memory checking output: ", this->Quiet);
   size_t total = this->TestResults.size();
   size_t step = total / 10;
   size_t current = 0;
-  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
-    {
-    cmCTestTestResult *result = &this->TestResults[cc];
+  for (cc = 0; cc < this->TestResults.size(); cc++) {
+    cmCTestTestResult* result = &this->TestResults[cc];
     std::string memcheckstr;
     std::vector<int> memcheckresults(this->ResultStrings.size(), 0);
     bool res = this->ProcessMemCheckOutput(result->Output, memcheckstr,
-      memcheckresults);
-    if ( res && result->Status == cmCTestMemCheckHandler::COMPLETED )
-      {
+                                           memcheckresults);
+    if (res && result->Status == cmCTestMemCheckHandler::COMPLETED) {
       continue;
-      }
-    this->CleanTestOutput(memcheckstr,
+    }
+    this->CleanTestOutput(
+      memcheckstr,
       static_cast<size_t>(this->CustomMaximumFailedTestOutputSize));
     this->WriteTestResultHeader(xml, result);
     xml.StartElement("Results");
-    for(std::vector<int>::size_type kk = 0;
-        kk < memcheckresults.size(); ++kk)
-      {
-      if ( memcheckresults[kk] )
-        {
+    for (std::vector<int>::size_type kk = 0; kk < memcheckresults.size();
+         ++kk) {
+      if (memcheckresults[kk]) {
         xml.StartElement("Defect");
         xml.Attribute("type", this->ResultStringsLong[kk]);
         xml.Content(memcheckresults[kk]);
         xml.EndElement(); // Defect
-        }
-      this->GlobalResults[kk] += memcheckresults[kk];
       }
+      this->GlobalResults[kk] += memcheckresults[kk];
+    }
     xml.EndElement(); // Results
 
     xml.StartElement("Log");
-    if(this->CTest->ShouldCompressMemCheckOutput())
-      {
+    if (this->CTest->ShouldCompressMemCheckOutput()) {
       this->CTest->CompressString(memcheckstr);
       xml.Attribute("compression", "gzip");
       xml.Attribute("encoding", "base64");
-      }
+    }
     xml.Content(memcheckstr);
     xml.EndElement(); // Log
 
     this->WriteTestResultFooter(xml, result);
-    if ( current < cc )
-      {
+    if (current < cc) {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "#" << std::flush,
-        this->Quiet);
+                         this->Quiet);
       current += step;
-      }
     }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet);
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Memory checking results:"
-    << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "Memory checking results:" << std::endl, this->Quiet);
   xml.StartElement("DefectList");
-  for ( cc = 0; cc < this->GlobalResults.size(); cc ++ )
-    {
-    if ( this->GlobalResults[cc] )
-      {
+  for (cc = 0; cc < this->GlobalResults.size(); cc++) {
+    if (this->GlobalResults[cc]) {
 #ifdef cerr
-#  undef cerr
+#undef cerr
 #endif
       std::cerr.width(35);
 #define cerr no_cerr
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        this->ResultStringsLong[cc] << " - "
-        << this->GlobalResults[cc] << std::endl, this->Quiet);
+                         this->ResultStringsLong[cc]
+                           << " - " << this->GlobalResults[cc] << std::endl,
+                         this->Quiet);
       xml.StartElement("Defect");
       xml.Attribute("Type", this->ResultStringsLong[cc]);
       xml.EndElement();
-      }
     }
+  }
   xml.EndElement(); // DefectList
 
   xml.Element("EndDateTime", this->EndTest);
   xml.Element("EndTestTime", this->EndTestTime);
   xml.Element("ElapsedMinutes",
-    static_cast<int>(this->ElapsedTestingTime/6)/10.0);
+              static_cast<int>(this->ElapsedTestingTime / 6) / 10.0);
 
   xml.EndElement(); // DynamicAnalysis
   this->CTest->EndXML(xml);
@@ -479,187 +419,156 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
   this->MemoryTesterEnvironmentVariable = "";
   this->MemoryTester = "";
   // Setup the command
-  if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-        "MemoryCheckCommand").c_str()) )
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str();
+  if (cmSystemTools::FileExists(
+        this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str())) {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str();
     std::string testerName =
       cmSystemTools::GetFilenameName(this->MemoryTester);
     // determine the checker type
-    if ( testerName.find("valgrind") != std::string::npos ||
-         this->CTest->GetCTestConfiguration("MemoryCheckType")
-         == "Valgrind")
-      {
-        this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
-      }
-    else if ( testerName.find("purify") != std::string::npos )
-      {
+    if (testerName.find("valgrind") != std::string::npos ||
+        this->CTest->GetCTestConfiguration("MemoryCheckType") == "Valgrind") {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
+    } else if (testerName.find("purify") != std::string::npos) {
       this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
-      }
-    else if ( testerName.find("BC") != std::string::npos )
-      {
+    } else if (testerName.find("BC") != std::string::npos) {
       this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
-      }
-    else
-      {
+    } else {
       this->MemoryTesterStyle = cmCTestMemCheckHandler::UNKNOWN;
-      }
     }
-  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-        "PurifyCommand").c_str()) )
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("PurifyCommand").c_str();
+  } else if (cmSystemTools::FileExists(
+               this->CTest->GetCTestConfiguration("PurifyCommand").c_str())) {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("PurifyCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
-    }
-  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-        "ValgrindCommand").c_str()) )
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("ValgrindCommand").c_str();
+  } else if (cmSystemTools::FileExists(
+               this->CTest->GetCTestConfiguration("ValgrindCommand")
+                 .c_str())) {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("ValgrindCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
-    }
-  else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-        "BoundsCheckerCommand").c_str()) )
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("BoundsCheckerCommand").c_str();
+  } else if (cmSystemTools::FileExists(
+               this->CTest->GetCTestConfiguration("BoundsCheckerCommand")
+                 .c_str())) {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("BoundsCheckerCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
-    }
-  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
-       == "AddressSanitizer")
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "AddressSanitizer") {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::ADDRESS_SANITIZER;
     this->LogWithPID = true; // even if we give the log file the pid is added
-    }
-  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
-       == "ThreadSanitizer")
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "ThreadSanitizer") {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::THREAD_SANITIZER;
     this->LogWithPID = true; // even if we give the log file the pid is added
-    }
-  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
-       == "MemorySanitizer")
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "MemorySanitizer") {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::MEMORY_SANITIZER;
     this->LogWithPID = true; // even if we give the log file the pid is added
-    }
-  if ( this->CTest->GetCTestConfiguration("MemoryCheckType")
-       == "UndefinedBehaviorSanitizer")
-    {
-    this->MemoryTester
-      = this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
+  }
+  if (this->CTest->GetCTestConfiguration("MemoryCheckType") ==
+      "UndefinedBehaviorSanitizer") {
+    this->MemoryTester =
+      this->CTest->GetCTestConfiguration("CMakeCommand").c_str();
     this->MemoryTesterStyle = cmCTestMemCheckHandler::UB_SANITIZER;
     this->LogWithPID = true; // even if we give the log file the pid is added
-    }
+  }
   // Check the MemoryCheckType
-  if(this->MemoryTesterStyle == cmCTestMemCheckHandler::UNKNOWN)
-    {
+  if (this->MemoryTesterStyle == cmCTestMemCheckHandler::UNKNOWN) {
     std::string checkType =
       this->CTest->GetCTestConfiguration("MemoryCheckType");
-    if(checkType == "Purify")
-      {
+    if (checkType == "Purify") {
       this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
-      }
-    else if(checkType == "BoundsChecker")
-      {
+    } else if (checkType == "BoundsChecker") {
       this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
-      }
-    else if(checkType == "Valgrind")
-      {
+    } else if (checkType == "Valgrind") {
       this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
-      }
     }
-  if(this->MemoryTester.empty())
-    {
+  }
+  if (this->MemoryTester.empty()) {
     cmCTestOptionalLog(this->CTest, WARNING,
-               "Memory checker (MemoryCheckCommand) "
-               "not set, or cannot find the specified program."
-               << std::endl, this->Quiet);
+                       "Memory checker (MemoryCheckCommand) "
+                       "not set, or cannot find the specified program."
+                         << std::endl,
+                       this->Quiet);
     return false;
-    }
+  }
 
   // Setup the options
   std::string memoryTesterOptions;
-  if ( this->CTest->GetCTestConfiguration(
-      "MemoryCheckCommandOptions").size() )
-    {
-    memoryTesterOptions = this->CTest->GetCTestConfiguration(
-      "MemoryCheckCommandOptions");
-    }
-  else if ( this->CTest->GetCTestConfiguration(
-      "ValgrindCommandOptions").size() )
-    {
-    memoryTesterOptions = this->CTest->GetCTestConfiguration(
-      "ValgrindCommandOptions");
-    }
-  this->MemoryTesterOptions
-    = cmSystemTools::ParseArguments(memoryTesterOptions.c_str());
+  if (this->CTest->GetCTestConfiguration("MemoryCheckCommandOptions").size()) {
+    memoryTesterOptions =
+      this->CTest->GetCTestConfiguration("MemoryCheckCommandOptions");
+  } else if (this->CTest->GetCTestConfiguration("ValgrindCommandOptions")
+               .size()) {
+    memoryTesterOptions =
+      this->CTest->GetCTestConfiguration("ValgrindCommandOptions");
+  }
+  this->MemoryTesterOptions =
+    cmSystemTools::ParseArguments(memoryTesterOptions.c_str());
 
-  this->MemoryTesterOutputFile
-    = this->CTest->GetBinaryDir()
-    + "/Testing/Temporary/MemoryChecker.??.log";
+  this->MemoryTesterOutputFile =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.??.log";
 
-  switch ( this->MemoryTesterStyle )
-    {
-    case cmCTestMemCheckHandler::VALGRIND:
-      {
-      if ( this->MemoryTesterOptions.empty() )
-        {
+  switch (this->MemoryTesterStyle) {
+    case cmCTestMemCheckHandler::VALGRIND: {
+      if (this->MemoryTesterOptions.empty()) {
         this->MemoryTesterOptions.push_back("-q");
         this->MemoryTesterOptions.push_back("--tool=memcheck");
         this->MemoryTesterOptions.push_back("--leak-check=yes");
         this->MemoryTesterOptions.push_back("--show-reachable=yes");
         this->MemoryTesterOptions.push_back("--num-callers=50");
-        }
-      if ( this->CTest->GetCTestConfiguration(
-          "MemoryCheckSuppressionFile").size() )
-        {
-        if ( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-              "MemoryCheckSuppressionFile").c_str()) )
-          {
+      }
+      if (this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+            .size()) {
+        if (!cmSystemTools::FileExists(
+              this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+                .c_str())) {
           cmCTestLog(this->CTest, ERROR_MESSAGE,
-            "Cannot find memory checker suppression file: "
-            << this->CTest->GetCTestConfiguration(
-              "MemoryCheckSuppressionFile") << std::endl);
+                     "Cannot find memory checker suppression file: "
+                       << this->CTest->GetCTestConfiguration(
+                            "MemoryCheckSuppressionFile")
+                       << std::endl);
           return false;
-          }
-        std::string suppressions = "--suppressions="
-          + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
-        this->MemoryTesterOptions.push_back(suppressions);
         }
-      std::string outputFile = "--log-file="
-        + this->MemoryTesterOutputFile;
+        std::string suppressions = "--suppressions=" +
+          this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+        this->MemoryTesterOptions.push_back(suppressions);
+      }
+      std::string outputFile = "--log-file=" + this->MemoryTesterOutputFile;
       this->MemoryTesterDynamicOptions.push_back(outputFile);
       break;
-      }
-    case cmCTestMemCheckHandler::PURIFY:
-      {
+    }
+    case cmCTestMemCheckHandler::PURIFY: {
       std::string outputFile;
 #ifdef _WIN32
-      if( this->CTest->GetCTestConfiguration(
-            "MemoryCheckSuppressionFile").size() )
-        {
-        if( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-                                       "MemoryCheckSuppressionFile").c_str()) )
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE,
-                     "Cannot find memory checker suppression file: "
-                     << this->CTest->GetCTestConfiguration(
-                       "MemoryCheckSuppressionFile").c_str() << std::endl);
+      if (this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+            .size()) {
+        if (!cmSystemTools::FileExists(
+              this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile")
+                .c_str())) {
+          cmCTestLog(
+            this->CTest, ERROR_MESSAGE,
+            "Cannot find memory checker suppression file: "
+              << this->CTest
+                   ->GetCTestConfiguration("MemoryCheckSuppressionFile")
+                   .c_str()
+              << std::endl);
           return false;
-          }
-        std::string filterFiles = "/FilterFiles="
-          + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
-        this->MemoryTesterOptions.push_back(filterFiles);
         }
+        std::string filterFiles = "/FilterFiles=" +
+          this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+        this->MemoryTesterOptions.push_back(filterFiles);
+      }
       outputFile = "/SAVETEXTDATA=";
 #else
       outputFile = "-log-file=";
@@ -667,12 +576,11 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
       outputFile += this->MemoryTesterOutputFile;
       this->MemoryTesterDynamicOptions.push_back(outputFile);
       break;
-      }
-    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
-      {
+    }
+    case cmCTestMemCheckHandler::BOUNDS_CHECKER: {
       this->BoundsCheckerXMLFile = this->MemoryTesterOutputFile;
-      std::string dpbdFile = this->CTest->GetBinaryDir()
-        + "/Testing/Temporary/MemoryChecker.??.DPbd";
+      std::string dpbdFile = this->CTest->GetBinaryDir() +
+        "/Testing/Temporary/MemoryChecker.??.DPbd";
       this->BoundsCheckerDPBDFile = dpbdFile;
       this->MemoryTesterDynamicOptions.push_back("/B");
       this->MemoryTesterDynamicOptions.push_back(dpbdFile);
@@ -680,13 +588,12 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
       this->MemoryTesterDynamicOptions.push_back(this->MemoryTesterOutputFile);
       this->MemoryTesterOptions.push_back("/M");
       break;
-      }
-      // these are almost the same but the env var used is different
+    }
+    // these are almost the same but the env var used is different
     case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
     case cmCTestMemCheckHandler::THREAD_SANITIZER:
     case cmCTestMemCheckHandler::MEMORY_SANITIZER:
-    case cmCTestMemCheckHandler::UB_SANITIZER:
-      {
+    case cmCTestMemCheckHandler::UB_SANITIZER: {
       // To pass arguments to ThreadSanitizer the environment variable
       // TSAN_OPTIONS is used. This is done with the cmake -E env command.
       // The MemoryTesterDynamicOptions is setup with the -E env
@@ -697,36 +604,31 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
       std::string envVar;
       std::string extraOptions =
         this->CTest->GetCTestConfiguration("MemoryCheckSanitizerOptions");
-      if(this->MemoryTesterStyle == cmCTestMemCheckHandler::ADDRESS_SANITIZER)
-        {
+      if (this->MemoryTesterStyle ==
+          cmCTestMemCheckHandler::ADDRESS_SANITIZER) {
         envVar = "ASAN_OPTIONS";
         extraOptions += " detect_leaks=1";
-        }
-      else if(this->MemoryTesterStyle ==
-              cmCTestMemCheckHandler::THREAD_SANITIZER)
-        {
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::THREAD_SANITIZER) {
         envVar = "TSAN_OPTIONS";
-        }
-      else if(this->MemoryTesterStyle ==
-              cmCTestMemCheckHandler::MEMORY_SANITIZER)
-        {
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::MEMORY_SANITIZER) {
         envVar = "MSAN_OPTIONS";
-        }
-      else if(this->MemoryTesterStyle == cmCTestMemCheckHandler::UB_SANITIZER)
-        {
+      } else if (this->MemoryTesterStyle ==
+                 cmCTestMemCheckHandler::UB_SANITIZER) {
         envVar = "UBSAN_OPTIONS";
-        }
-      std::string outputFile = envVar + "=log_path=\""
-        + this->MemoryTesterOutputFile + "\" ";
+      }
+      std::string outputFile =
+        envVar + "=log_path=\"" + this->MemoryTesterOutputFile + "\" ";
       this->MemoryTesterEnvironmentVariable = outputFile + extraOptions;
       break;
-      }
+    }
     default:
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Do not understand memory checker: " << this->MemoryTester
-        << std::endl);
+                 "Do not understand memory checker: " << this->MemoryTester
+                                                      << std::endl);
       return false;
-    }
+  }
 
   this->InitializeResultsVectors();
   // std::vector<std::string>::size_type cc;
@@ -737,66 +639,52 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
   return true;
 }
 
-bool cmCTestMemCheckHandler::
-ProcessMemCheckOutput(const std::string& str,
-                      std::string& log, std::vector<int>& results)
+bool cmCTestMemCheckHandler::ProcessMemCheckOutput(const std::string& str,
+                                                   std::string& log,
+                                                   std::vector<int>& results)
 {
-  if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND )
-    {
+  if (this->MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND) {
     return this->ProcessMemCheckValgrindOutput(str, log, results);
-    }
-  else if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY )
-    {
+  } else if (this->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY) {
     return this->ProcessMemCheckPurifyOutput(str, log, results);
-    }
-  else if ( this->MemoryTesterStyle ==
-            cmCTestMemCheckHandler::ADDRESS_SANITIZER ||
-            this->MemoryTesterStyle ==
-            cmCTestMemCheckHandler::THREAD_SANITIZER ||
-            this->MemoryTesterStyle ==
-            cmCTestMemCheckHandler::MEMORY_SANITIZER ||
-            this->MemoryTesterStyle ==
-            cmCTestMemCheckHandler::UB_SANITIZER)
-    {
+  } else if (this->MemoryTesterStyle ==
+               cmCTestMemCheckHandler::ADDRESS_SANITIZER ||
+             this->MemoryTesterStyle ==
+               cmCTestMemCheckHandler::THREAD_SANITIZER ||
+             this->MemoryTesterStyle ==
+               cmCTestMemCheckHandler::MEMORY_SANITIZER ||
+             this->MemoryTesterStyle == cmCTestMemCheckHandler::UB_SANITIZER) {
     return this->ProcessMemCheckSanitizerOutput(str, log, results);
-    }
-  else if ( this->MemoryTesterStyle ==
-    cmCTestMemCheckHandler::BOUNDS_CHECKER )
-    {
+  } else if (this->MemoryTesterStyle ==
+             cmCTestMemCheckHandler::BOUNDS_CHECKER) {
     return this->ProcessMemCheckBoundsCheckerOutput(str, log, results);
-    }
-  else
-    {
+  } else {
     log.append("\nMemory checking style used was: ");
     log.append("None that I know");
     log = str;
-    }
+  }
   return true;
 }
 
 std::vector<int>::size_type cmCTestMemCheckHandler::FindOrAddWarning(
   const std::string& warning)
 {
-  for(std::vector<std::string>::size_type i =0;
-      i < this->ResultStrings.size(); ++i)
-    {
-    if(this->ResultStrings[i] == warning)
-      {
+  for (std::vector<std::string>::size_type i = 0;
+       i < this->ResultStrings.size(); ++i) {
+    if (this->ResultStrings[i] == warning) {
       return i;
-      }
     }
+  }
   this->GlobalResults.push_back(0); // this must stay the same size
   this->ResultStrings.push_back(warning);
   this->ResultStringsLong.push_back(warning);
-  return this->ResultStrings.size()-1;
+  return this->ResultStrings.size() - 1;
 }
 bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
-  const std::string& str, std::string& log,
-  std::vector<int>& result)
+  const std::string& str, std::string& log, std::vector<int>& result)
 {
   std::string regex;
-  switch ( this->MemoryTesterStyle )
-    {
+  switch (this->MemoryTesterStyle) {
     case cmCTestMemCheckHandler::ADDRESS_SANITIZER:
       regex = "ERROR: AddressSanitizer: (.*) on.*";
       break;
@@ -811,7 +699,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
       break;
     default:
       break;
-    }
+  }
   cmsys::RegularExpression sanitizerWarning(regex);
   cmsys::RegularExpression leakWarning("(Direct|Indirect) leak of .*");
   int defects = 0;
@@ -819,44 +707,34 @@ bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput(
   cmSystemTools::Split(str.c_str(), lines);
   std::ostringstream ostr;
   log = "";
-  for( std::vector<std::string>::iterator i = lines.begin();
-       i != lines.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = lines.begin(); i != lines.end();
+       ++i) {
     std::string resultFound;
-    if(leakWarning.find(*i))
-      {
-      resultFound = leakWarning.match(1)+" leak";
-      }
-    else if (sanitizerWarning.find(*i))
-      {
+    if (leakWarning.find(*i)) {
+      resultFound = leakWarning.match(1) + " leak";
+    } else if (sanitizerWarning.find(*i)) {
       resultFound = sanitizerWarning.match(1);
-      }
-    if(!resultFound.empty())
-      {
+    }
+    if (!resultFound.empty()) {
       std::vector<int>::size_type idx = this->FindOrAddWarning(resultFound);
-      if(result.empty() || idx > result.size()-1)
-        {
+      if (result.empty() || idx > result.size() - 1) {
         result.push_back(1);
-        }
-      else
-        {
+      } else {
         result[idx]++;
-        }
-      defects++;
-      ostr << "<b>" <<  this->ResultStrings[idx] << "</b> ";
       }
-    ostr << *i << std::endl;
+      defects++;
+      ostr << "<b>" << this->ResultStrings[idx] << "</b> ";
     }
+    ostr << *i << std::endl;
+  }
   log = ostr.str();
-  if(defects)
-    {
+  if (defects) {
     return false;
-    }
+  }
   return true;
 }
 bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
-  const std::string& str, std::string& log,
-  std::vector<int>& results)
+  const std::string& str, std::string& log, std::vector<int>& results)
 {
   std::vector<std::string> lines;
   cmSystemTools::Split(str.c_str(), lines);
@@ -867,58 +745,49 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
 
   int defects = 0;
 
-  for( std::vector<std::string>::iterator i = lines.begin();
-       i != lines.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = lines.begin(); i != lines.end();
+       ++i) {
     std::vector<int>::size_type failure = this->ResultStrings.size();
-    if ( pfW.find(*i) )
-      {
+    if (pfW.find(*i)) {
       std::vector<int>::size_type cc;
-      for ( cc = 0; cc < this->ResultStrings.size(); cc ++ )
-        {
-        if ( pfW.match(1) == this->ResultStrings[cc] )
-          {
+      for (cc = 0; cc < this->ResultStrings.size(); cc++) {
+        if (pfW.match(1) == this->ResultStrings[cc]) {
           failure = cc;
           break;
-          }
         }
-      if ( cc == this->ResultStrings.size() )
-        {
+      }
+      if (cc == this->ResultStrings.size()) {
         cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown Purify memory fault: "
-          << pfW.match(1) << std::endl);
+                     << pfW.match(1) << std::endl);
         ostr << "*** Unknown Purify memory fault: " << pfW.match(1)
-          << std::endl;
-        }
-      }
-    if ( failure != this->ResultStrings.size() )
-      {
-      ostr << "<b>" <<  this->ResultStrings[failure] << "</b> ";
-      results[failure] ++;
-      defects ++;
+             << std::endl;
       }
-    ostr << *i << std::endl;
     }
+    if (failure != this->ResultStrings.size()) {
+      ostr << "<b>" << this->ResultStrings[failure] << "</b> ";
+      results[failure]++;
+      defects++;
+    }
+    ostr << *i << std::endl;
+  }
 
   log = ostr.str();
-  if ( defects )
-    {
+  if (defects) {
     return false;
-    }
+  }
   return true;
 }
 
 bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
-  const std::string& str, std::string& log,
-  std::vector<int>& results)
+  const std::string& str, std::string& log, std::vector<int>& results)
 {
   std::vector<std::string> lines;
   cmSystemTools::Split(str.c_str(), lines);
   bool unlimitedOutput = false;
-  if(str.find("CTEST_FULL_OUTPUT") != str.npos ||
-    this->CustomMaximumFailedTestOutputSize == 0)
-    {
+  if (str.find("CTEST_FULL_OUTPUT") != str.npos ||
+      this->CustomMaximumFailedTestOutputSize == 0) {
     unlimitedOutput = true;
-    }
+  }
 
   std::string::size_type cc;
 
@@ -935,7 +804,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
     "== .*Mismatched free\\(\\) / delete / delete \\[\\]");
   cmsys::RegularExpression vgMLK1(
     "== .*[0-9,]+ bytes in [0-9,]+ blocks are definitely lost"
-   " in loss record [0-9,]+ of [0-9,]+");
+    " in loss record [0-9,]+ of [0-9,]+");
   cmsys::RegularExpression vgMLK2(
     "== .*[0-9,]+ \\([0-9,]+ direct, [0-9,]+ indirect\\)"
     " bytes in [0-9,]+ blocks are definitely lost"
@@ -954,298 +823,239 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
     "== .*Use of uninitialised value of size [0-9,]+");
   cmsys::RegularExpression vgUMR2("== .*Invalid read of size [0-9,]+");
   cmsys::RegularExpression vgUMR3("== .*Jump to the invalid address ");
-  cmsys::RegularExpression vgUMR4("== .*Syscall param .* contains "
+  cmsys::RegularExpression vgUMR4(
+    "== .*Syscall param .* contains "
     "uninitialised or unaddressable byte\\(s\\)");
   cmsys::RegularExpression vgUMR5("== .*Syscall param .* uninitialised");
   cmsys::RegularExpression vgIPW("== .*Invalid write of size [0-9,]+");
   cmsys::RegularExpression vgABR("== .*pthread_mutex_unlock: mutex is "
-    "locked by a different thread");
+                                 "locked by a different thread");
   std::vector<std::string::size_type> nonValGrindOutput;
   double sttime = cmSystemTools::GetTime();
   cmCTestOptionalLog(this->CTest, DEBUG,
-    "Start test: " << lines.size() << std::endl, this->Quiet);
+                     "Start test: " << lines.size() << std::endl, this->Quiet);
   std::string::size_type totalOutputSize = 0;
-  for ( cc = 0; cc < lines.size(); cc ++ )
-    {
-    cmCTestOptionalLog(this->CTest, DEBUG, "test line "
-               << lines[cc] << std::endl, this->Quiet);
+  for (cc = 0; cc < lines.size(); cc++) {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "test line " << lines[cc] << std::endl, this->Quiet);
 
-    if ( valgrindLine.find(lines[cc]) )
-      {
-      cmCTestOptionalLog(this->CTest, DEBUG, "valgrind  line "
-                 << lines[cc] << std::endl, this->Quiet);
+    if (valgrindLine.find(lines[cc])) {
+      cmCTestOptionalLog(this->CTest, DEBUG,
+                         "valgrind  line " << lines[cc] << std::endl,
+                         this->Quiet);
       int failure = cmCTestMemCheckHandler::NO_MEMORY_FAULT;
-      if ( vgFIM.find(lines[cc]) )
-        {
+      if (vgFIM.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::FIM;
-        }
-      else if ( vgFMM.find(lines[cc]) )
-        {
+      } else if (vgFMM.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::FMM;
-        }
-      else if ( vgMLK1.find(lines[cc]) )
-        {
+      } else if (vgMLK1.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::MLK;
-        }
-      else if ( vgMLK2.find(lines[cc]) )
-        {
+      } else if (vgMLK2.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::MLK;
-        }
-      else if ( vgPAR.find(lines[cc]) )
-        {
+      } else if (vgPAR.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::PAR;
-        }
-      else if ( vgMPK1.find(lines[cc]) )
-        {
+      } else if (vgMPK1.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::MPK;
-        }
-      else if ( vgMPK2.find(lines[cc]) )
-        {
+      } else if (vgMPK2.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::MPK;
-        }
-      else if ( vgUMC.find(lines[cc]) )
-        {
+      } else if (vgUMC.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::UMC;
-        }
-      else if ( vgUMR1.find(lines[cc]) )
-        {
+      } else if (vgUMR1.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::UMR;
-        }
-      else if ( vgUMR2.find(lines[cc]) )
-        {
+      } else if (vgUMR2.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::UMR;
-        }
-      else if ( vgUMR3.find(lines[cc]) )
-        {
+      } else if (vgUMR3.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::UMR;
-        }
-      else if ( vgUMR4.find(lines[cc]) )
-        {
+      } else if (vgUMR4.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::UMR;
-        }
-      else if ( vgUMR5.find(lines[cc]) )
-        {
+      } else if (vgUMR5.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::UMR;
-        }
-      else if ( vgIPW.find(lines[cc]) )
-        {
+      } else if (vgIPW.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::IPW;
-        }
-      else if ( vgABR.find(lines[cc]) )
-        {
+      } else if (vgABR.find(lines[cc])) {
         failure = cmCTestMemCheckHandler::ABR;
-        }
+      }
 
-      if ( failure != cmCTestMemCheckHandler::NO_MEMORY_FAULT )
-        {
+      if (failure != cmCTestMemCheckHandler::NO_MEMORY_FAULT) {
         ostr << "<b>" << this->ResultStrings[failure] << "</b> ";
-        results[failure] ++;
-        defects ++;
-        }
+        results[failure]++;
+        defects++;
+      }
       totalOutputSize += lines[cc].size();
       ostr << lines[cc] << std::endl;
-      }
-    else
-      {
+    } else {
       nonValGrindOutput.push_back(cc);
-      }
     }
+  }
   // Now put all all the non valgrind output into the test output
   // This should be last in case it gets truncated by the output
   // limiting code
-  for(std::vector<std::string::size_type>::iterator i =
-        nonValGrindOutput.begin(); i != nonValGrindOutput.end(); ++i)
-    {
+  for (std::vector<std::string::size_type>::iterator i =
+         nonValGrindOutput.begin();
+       i != nonValGrindOutput.end(); ++i) {
     totalOutputSize += lines[*i].size();
     ostr << lines[*i] << std::endl;
-    if(!unlimitedOutput && totalOutputSize >
-       static_cast<size_t>(this->CustomMaximumFailedTestOutputSize))
-      {
+    if (!unlimitedOutput &&
+        totalOutputSize >
+          static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) {
       ostr << "....\n";
       ostr << "Test Output for this test has been truncated see testing"
-        " machine logs for full output,\n";
+              " machine logs for full output,\n";
       ostr << "or put CTEST_FULL_OUTPUT in the output of "
-        "this test program.\n";
-      break;  // stop the copy of output if we are full
-      }
+              "this test program.\n";
+      break; // stop the copy of output if we are full
     }
+  }
   cmCTestOptionalLog(this->CTest, DEBUG, "End test (elapsed: "
-             << (cmSystemTools::GetTime() - sttime) << std::endl, this->Quiet);
+                       << (cmSystemTools::GetTime() - sttime) << std::endl,
+                     this->Quiet);
   log = ostr.str();
-  if ( defects )
-    {
+  if (defects) {
     return false;
-    }
+  }
   return true;
 }
 
-
-
 bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput(
-  const std::string& str, std::string& log,
-  std::vector<int>& results)
+  const std::string& str, std::string& log, std::vector<int>& results)
 {
   log = "";
   double sttime = cmSystemTools::GetTime();
   std::vector<std::string> lines;
   cmSystemTools::Split(str.c_str(), lines);
   cmCTestOptionalLog(this->CTest, DEBUG,
-    "Start test: " << lines.size() << std::endl, this->Quiet);
+                     "Start test: " << lines.size() << std::endl, this->Quiet);
   std::vector<std::string>::size_type cc;
-  for ( cc = 0; cc < lines.size(); cc ++ )
-    {
-    if(lines[cc] == BOUNDS_CHECKER_MARKER)
-      {
+  for (cc = 0; cc < lines.size(); cc++) {
+    if (lines[cc] == BOUNDS_CHECKER_MARKER) {
       break;
-      }
     }
+  }
   cmBoundsCheckerParser parser(this->CTest);
   parser.InitializeParser();
-  if(cc < lines.size())
-    {
-    for(cc++; cc < lines.size(); ++cc)
-      {
+  if (cc < lines.size()) {
+    for (cc++; cc < lines.size(); ++cc) {
       std::string& theLine = lines[cc];
       // check for command line arguments that are not escaped
       // correctly by BC
-      if(theLine.find("TargetArgs=") != theLine.npos)
-        {
+      if (theLine.find("TargetArgs=") != theLine.npos) {
         // skip this because BC gets it wrong and we can't parse it
-        }
-      else if(!parser.ParseChunk(theLine.c_str(), theLine.size()))
-        {
+      } else if (!parser.ParseChunk(theLine.c_str(), theLine.size())) {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "Error in ParseChunk: " << theLine
-                   << std::endl);
-        }
+                   "Error in ParseChunk: " << theLine << std::endl);
       }
     }
+  }
   int defects = 0;
-  for(cc =0; cc < parser.Errors.size(); ++cc)
-    {
+  for (cc = 0; cc < parser.Errors.size(); ++cc) {
     results[parser.Errors[cc]]++;
     defects++;
-    }
+  }
   cmCTestOptionalLog(this->CTest, DEBUG, "End test (elapsed: "
-    << (cmSystemTools::GetTime() - sttime) << std::endl, this->Quiet);
-  if(defects)
-    {
+                       << (cmSystemTools::GetTime() - sttime) << std::endl,
+                     this->Quiet);
+  if (defects) {
     // only put the output of Bounds Checker if there were
     // errors or leaks detected
     log = parser.Log;
     return false;
-    }
+  }
   return true;
 }
 
 // PostProcessTest memcheck results
-void
-cmCTestMemCheckHandler::PostProcessTest(cmCTestTestResult& res,
-                                        int test)
+void cmCTestMemCheckHandler::PostProcessTest(cmCTestTestResult& res, int test)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-             "PostProcessTest memcheck results for : "
-             << res.Name << std::endl, this->Quiet);
-  if(this->MemoryTesterStyle
-     == cmCTestMemCheckHandler::BOUNDS_CHECKER)
-    {
+                     "PostProcessTest memcheck results for : " << res.Name
+                                                               << std::endl,
+                     this->Quiet);
+  if (this->MemoryTesterStyle == cmCTestMemCheckHandler::BOUNDS_CHECKER) {
     this->PostProcessBoundsCheckerTest(res, test);
-    }
-  else
-    {
+  } else {
     std::vector<std::string> files;
     this->TestOutputFileNames(test, files);
-    for(std::vector<std::string>::iterator i = files.begin();
-        i != files.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = files.begin();
+         i != files.end(); ++i) {
       this->AppendMemTesterOutput(res, *i);
-      }
     }
+  }
 }
 
-
 // This method puts the bounds checker output file into the output
 // for the test
-void
-cmCTestMemCheckHandler::PostProcessBoundsCheckerTest(cmCTestTestResult& res,
-                                                     int test)
+void cmCTestMemCheckHandler::PostProcessBoundsCheckerTest(
+  cmCTestTestResult& res, int test)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-             "PostProcessBoundsCheckerTest for : "
-             << res.Name << std::endl, this->Quiet);
+                     "PostProcessBoundsCheckerTest for : " << res.Name
+                                                           << std::endl,
+                     this->Quiet);
   std::vector<std::string> files;
   this->TestOutputFileNames(test, files);
-  if (files.empty())
-    {
+  if (files.empty()) {
     return;
-    }
+  }
   std::string ofile = files[0];
-  if ( ofile.empty() )
-    {
+  if (ofile.empty()) {
     return;
-    }
+  }
   // put a scope around this to close ifs so the file can be removed
   {
-  cmsys::ifstream ifs(ofile.c_str());
-  if ( !ifs )
-    {
-    std::string log = "Cannot read memory tester output file: " + ofile;
-    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
-    return;
+    cmsys::ifstream ifs(ofile.c_str());
+    if (!ifs) {
+      std::string log = "Cannot read memory tester output file: " + ofile;
+      cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
+      return;
     }
-  res.Output += BOUNDS_CHECKER_MARKER;
-  res.Output += "\n";
-  std::string line;
-  while ( cmSystemTools::GetLineFromStream(ifs, line) )
-    {
-    res.Output += line;
+    res.Output += BOUNDS_CHECKER_MARKER;
     res.Output += "\n";
+    std::string line;
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
+      res.Output += line;
+      res.Output += "\n";
     }
   }
   cmSystemTools::Delay(1000);
   cmSystemTools::RemoveFile(this->BoundsCheckerDPBDFile);
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: "
-    << this->BoundsCheckerDPBDFile << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Remove: " << this->BoundsCheckerDPBDFile << std::endl,
+                     this->Quiet);
   cmSystemTools::RemoveFile(this->BoundsCheckerXMLFile);
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: "
-    << this->BoundsCheckerXMLFile << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Remove: " << this->BoundsCheckerXMLFile << std::endl,
+                     this->Quiet);
 }
 
-void
-cmCTestMemCheckHandler::AppendMemTesterOutput(cmCTestTestResult& res,
-                                              std::string const& ofile)
+void cmCTestMemCheckHandler::AppendMemTesterOutput(cmCTestTestResult& res,
+                                                   std::string const& ofile)
 {
-  if ( ofile.empty() )
-    {
+  if (ofile.empty()) {
     return;
-    }
+  }
   // put ifs in scope so file can be deleted if needed
   {
-  cmsys::ifstream ifs(ofile.c_str());
-  if ( !ifs )
-    {
-    std::string log = "Cannot read memory tester output file: " + ofile;
-    cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
-    return;
+    cmsys::ifstream ifs(ofile.c_str());
+    if (!ifs) {
+      std::string log = "Cannot read memory tester output file: " + ofile;
+      cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
+      return;
     }
-  std::string line;
-  while ( cmSystemTools::GetLineFromStream(ifs, line) )
-    {
-    res.Output += line;
-    res.Output += "\n";
+    std::string line;
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
+      res.Output += line;
+      res.Output += "\n";
     }
   }
-  if(this->LogWithPID)
-    {
+  if (this->LogWithPID) {
     cmSystemTools::RemoveFile(ofile);
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Remove: "<< ofile <<"\n", this->Quiet);
-    }
+                       "Remove: " << ofile << "\n", this->Quiet);
+  }
 }
 
-void cmCTestMemCheckHandler::TestOutputFileNames(int test,
-                                                 std::vector<std::string>&
-                                                 files)
+void cmCTestMemCheckHandler::TestOutputFileNames(
+  int test, std::vector<std::string>& files)
 {
   std::string index;
   std::ostringstream stream;
@@ -1254,30 +1064,22 @@ void cmCTestMemCheckHandler::TestOutputFileNames(int test,
   std::string ofile = this->MemoryTesterOutputFile;
   std::string::size_type pos = ofile.find("??");
   ofile.replace(pos, 2, index);
-  if(this->LogWithPID)
-    {
+  if (this->LogWithPID) {
     ofile += ".*";
     cmsys::Glob g;
     g.FindFiles(ofile);
-    if(g.GetFiles().empty())
-      {
-      std::string log = "Cannot find memory tester output file: "
-        + ofile;
+    if (g.GetFiles().empty()) {
+      std::string log = "Cannot find memory tester output file: " + ofile;
       cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
       ofile = "";
-      }
-    else
-      {
+    } else {
       files = g.GetFiles();
       return;
-      }
     }
-  else if ( !cmSystemTools::FileExists(ofile.c_str()) )
-    {
-    std::string log = "Cannot find memory tester output file: "
-      + ofile;
+  } else if (!cmSystemTools::FileExists(ofile.c_str())) {
+    std::string log = "Cannot find memory tester output file: " + ofile;
     cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl);
     ofile = "";
-    }
+  }
   files.push_back(ofile);
 }
diff --git a/Source/CTest/cmCTestMemCheckHandler.h b/Source/CTest/cmCTestMemCheckHandler.h
index 6232924..8f0cc47 100644
--- a/Source/CTest/cmCTestMemCheckHandler.h
+++ b/Source/CTest/cmCTestMemCheckHandler.h
@@ -29,22 +29,24 @@ class cmXMLWriter;
 class cmCTestMemCheckHandler : public cmCTestTestHandler
 {
   friend class cmCTestRunTest;
+
 public:
   cmTypeMacro(cmCTestMemCheckHandler, cmCTestTestHandler);
 
-  void PopulateCustomVectors(cmMakefile *mf);
+  void PopulateCustomVectors(cmMakefile* mf);
 
   cmCTestMemCheckHandler();
 
   void Initialize();
+
 protected:
   virtual int PreProcessHandler();
   virtual int PostProcessHandler();
   virtual void GenerateTestCommand(std::vector<std::string>& args, int test);
 
 private:
-
-  enum { // Memory checkers
+  enum
+  { // Memory checkers
     UNKNOWN = 0,
     VALGRIND,
     PURIFY,
@@ -55,8 +57,10 @@ private:
     MEMORY_SANITIZER,
     UB_SANITIZER
   };
+
 public:
-  enum { // Memory faults
+  enum
+  { // Memory faults
     ABR = 0,
     ABW,
     ABWL,
@@ -81,8 +85,10 @@ public:
     UMR,
     NO_MEMORY_FAULT
   };
+
 private:
-  enum { // Program statuses
+  enum
+  { // Program statuses
     NOT_RUN = 0,
     TIMEOUT,
     SEGFAULT,
@@ -94,19 +100,19 @@ private:
     BAD_COMMAND,
     COMPLETED
   };
-  std::string              BoundsCheckerDPBDFile;
-  std::string              BoundsCheckerXMLFile;
-  std::string              MemoryTester;
+  std::string BoundsCheckerDPBDFile;
+  std::string BoundsCheckerXMLFile;
+  std::string MemoryTester;
   std::vector<std::string> MemoryTesterDynamicOptions;
   std::vector<std::string> MemoryTesterOptions;
-  int                      MemoryTesterStyle;
-  std::string              MemoryTesterOutputFile;
-  std::string              MemoryTesterEnvironmentVariable;
+  int MemoryTesterStyle;
+  std::string MemoryTesterOutputFile;
+  std::string MemoryTesterEnvironmentVariable;
   // these are used to store the types of errors that can show up
   std::vector<std::string> ResultStrings;
   std::vector<std::string> ResultStringsLong;
-  std::vector<int>         GlobalResults;
-  bool                     LogWithPID; // does log file add pid
+  std::vector<int> GlobalResults;
+  bool LogWithPID; // does log file add pid
 
   std::vector<int>::size_type FindOrAddWarning(const std::string& warning);
   // initialize the ResultStrings and ResultStringsLong for
@@ -125,18 +131,15 @@ private:
   std::vector<std::string> CustomPostMemCheck;
 
   //! Parse Valgrind/Purify/Bounds Checker result out of the output
-  //string. After running, log holds the output and results hold the
-  //different memmory errors.
-  bool ProcessMemCheckOutput(const std::string& str,
-                             std::string& log, std::vector<int>& results);
-  bool ProcessMemCheckValgrindOutput(const std::string& str,
-                                     std::string& log,
+  // string. After running, log holds the output and results hold the
+  // different memmory errors.
+  bool ProcessMemCheckOutput(const std::string& str, std::string& log,
+                             std::vector<int>& results);
+  bool ProcessMemCheckValgrindOutput(const std::string& str, std::string& log,
                                      std::vector<int>& results);
-  bool ProcessMemCheckPurifyOutput(const std::string& str,
-                                   std::string& log,
+  bool ProcessMemCheckPurifyOutput(const std::string& str, std::string& log,
                                    std::vector<int>& results);
-  bool ProcessMemCheckSanitizerOutput(const std::string& str,
-                                      std::string& log,
+  bool ProcessMemCheckSanitizerOutput(const std::string& str, std::string& log,
                                       std::vector<int>& results);
   bool ProcessMemCheckBoundsCheckerOutput(const std::string& str,
                                           std::string& log,
@@ -154,4 +157,3 @@ private:
 };
 
 #endif
-
diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx
index d92ac77..d155023 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.cxx
+++ b/Source/CTest/cmCTestMultiProcessHandler.cxx
@@ -27,15 +27,18 @@
 class TestComparator
 {
 public:
-  TestComparator(cmCTestMultiProcessHandler* handler) : Handler(handler) {}
+  TestComparator(cmCTestMultiProcessHandler* handler)
+    : Handler(handler)
+  {
+  }
   ~TestComparator() {}
 
   // Sorts tests in descending order of cost
-  bool operator() (int index1, int index2) const
-    {
+  bool operator()(int index1, int index2) const
+  {
     return Handler->Properties[index1]->Cost >
       Handler->Properties[index2]->Cost;
-    }
+  }
 
 private:
   cmCTestMultiProcessHandler* Handler;
@@ -56,34 +59,30 @@ cmCTestMultiProcessHandler::~cmCTestMultiProcessHandler()
 {
 }
 
-  // Set the tests
-void
-cmCTestMultiProcessHandler::SetTests(TestMap& tests,
-                                     PropertiesMap& properties)
+// Set the tests
+void cmCTestMultiProcessHandler::SetTests(TestMap& tests,
+                                          PropertiesMap& properties)
 {
   this->Tests = tests;
   this->Properties = properties;
   this->Total = this->Tests.size();
   // set test run map to false for all
-  for(TestMap::iterator i = this->Tests.begin();
-      i != this->Tests.end(); ++i)
-    {
+  for (TestMap::iterator i = this->Tests.begin(); i != this->Tests.end();
+       ++i) {
     this->TestRunningMap[i->first] = false;
     this->TestFinishMap[i->first] = false;
-    }
-  if(!this->CTest->GetShowOnly())
-    {
+  }
+  if (!this->CTest->GetShowOnly()) {
     this->ReadCostData();
     this->HasCycles = !this->CheckCycles();
-    if(this->HasCycles)
-      {
+    if (this->HasCycles) {
       return;
-      }
-    this->CreateTestCostList();
     }
+    this->CreateTestCostList();
+  }
 }
 
-  // Set the max number of tests that can be run at the same time.
+// Set the max number of tests that can be run at the same time.
 void cmCTestMultiProcessHandler::SetParallelLevel(size_t level)
 {
   this->ParallelLevel = level < 1 ? 1 : level;
@@ -97,25 +96,21 @@ void cmCTestMultiProcessHandler::SetTestLoad(unsigned long load)
 void cmCTestMultiProcessHandler::RunTests()
 {
   this->CheckResume();
-  if(this->HasCycles)
-    {
+  if (this->HasCycles) {
     return;
-    }
+  }
   this->TestHandler->SetMaxIndex(this->FindMaxIndex());
   this->StartNextTests();
-  while(!this->Tests.empty())
-    {
-    if(this->StopTimePassed)
-      {
+  while (!this->Tests.empty()) {
+    if (this->StopTimePassed) {
       return;
-      }
+    }
     this->CheckOutput();
     this->StartNextTests();
-    }
+  }
   // let all running tests finish
-  while(this->CheckOutput())
-    {
-    }
+  while (this->CheckOutput()) {
+  }
   this->MarkFinished();
   this->UpdateCostData();
 }
@@ -123,18 +118,17 @@ void cmCTestMultiProcessHandler::RunTests()
 void cmCTestMultiProcessHandler::StartTestProcess(int test)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "test " << test << "\n", this->Quiet);
+                     "test " << test << "\n", this->Quiet);
   this->TestRunningMap[test] = true; // mark the test as running
   // now remove the test itself
   this->EraseTest(test);
   this->RunningCount += GetProcessorsUsed(test);
 
   cmCTestRunTest* testRun = new cmCTestRunTest(this->TestHandler);
-  if(this->CTest->GetRepeatUntilFail())
-    {
+  if (this->CTest->GetRepeatUntilFail()) {
     testRun->SetRunUntilFailOn();
     testRun->SetNumberOfRuns(this->CTest->GetTestRepeat());
-    }
+  }
   testRun->SetIndex(test);
   testRun->SetTestProperties(this->Properties[test]);
 
@@ -144,24 +138,18 @@ void cmCTestMultiProcessHandler::StartTestProcess(int test)
   // Lock the resources we'll be using
   this->LockResources(test);
 
-  if(testRun->StartTest(this->Total))
-    {
+  if (testRun->StartTest(this->Total)) {
     this->RunningTests.insert(testRun);
-    }
-  else if(testRun->IsStopTimePassed())
-    {
+  } else if (testRun->IsStopTimePassed()) {
     this->StopTimePassed = true;
     delete testRun;
     return;
-    }
-  else
-    {
+  } else {
 
-    for(TestMap::iterator j = this->Tests.begin();
-      j != this->Tests.end(); ++j)
-      {
+    for (TestMap::iterator j = this->Tests.begin(); j != this->Tests.end();
+         ++j) {
       j->second.erase(test);
-      }
+    }
 
     this->UnlockResources(test);
     this->Completed++;
@@ -171,34 +159,31 @@ void cmCTestMultiProcessHandler::StartTestProcess(int test)
     testRun->EndTest(this->Completed, this->Total, false);
     this->Failed->push_back(this->Properties[test]->Name);
     delete testRun;
-    }
+  }
   cmSystemTools::ChangeDirectory(current_dir);
 }
 
 void cmCTestMultiProcessHandler::LockResources(int index)
 {
   this->LockedResources.insert(
-      this->Properties[index]->LockedResources.begin(),
-      this->Properties[index]->LockedResources.end());
+    this->Properties[index]->LockedResources.begin(),
+    this->Properties[index]->LockedResources.end());
 
-  if (this->Properties[index]->RunSerial)
-    {
+  if (this->Properties[index]->RunSerial) {
     this->SerialTestRunning = true;
-    }
+  }
 }
 
 void cmCTestMultiProcessHandler::UnlockResources(int index)
 {
-  for(std::set<std::string>::iterator i =
-      this->Properties[index]->LockedResources.begin();
-      i != this->Properties[index]->LockedResources.end(); ++i)
-    {
+  for (std::set<std::string>::iterator i =
+         this->Properties[index]->LockedResources.begin();
+       i != this->Properties[index]->LockedResources.end(); ++i) {
     this->LockedResources.erase(*i);
-    }
-  if (this->Properties[index]->RunSerial)
-    {
+  }
+  if (this->Properties[index]->RunSerial) {
     this->SerialTestRunning = false;
-    }
+  }
 }
 
 void cmCTestMultiProcessHandler::EraseTest(int test)
@@ -210,14 +195,12 @@ void cmCTestMultiProcessHandler::EraseTest(int test)
 
 inline size_t cmCTestMultiProcessHandler::GetProcessorsUsed(int test)
 {
-  size_t processors =
-    static_cast<int>(this->Properties[test]->Processors);
-  //If processors setting is set higher than the -j
-  //setting, we default to using all of the process slots.
-  if (processors > this->ParallelLevel)
-    {
+  size_t processors = static_cast<int>(this->Properties[test]->Processors);
+  // If processors setting is set higher than the -j
+  // setting, we default to using all of the process slots.
+  if (processors > this->ParallelLevel) {
     processors = this->ParallelLevel;
-    }
+  }
   return processors;
 }
 
@@ -228,23 +211,20 @@ std::string cmCTestMultiProcessHandler::GetName(int test)
 
 bool cmCTestMultiProcessHandler::StartTest(int test)
 {
-  //Check for locked resources
-  for(std::set<std::string>::iterator i =
-      this->Properties[test]->LockedResources.begin();
-      i != this->Properties[test]->LockedResources.end(); ++i)
-    {
-    if(this->LockedResources.find(*i) != this->LockedResources.end())
-      {
+  // Check for locked resources
+  for (std::set<std::string>::iterator i =
+         this->Properties[test]->LockedResources.begin();
+       i != this->Properties[test]->LockedResources.end(); ++i) {
+    if (this->LockedResources.find(*i) != this->LockedResources.end()) {
       return false;
-      }
     }
+  }
 
   // if there are no depends left then run this test
-  if(this->Tests[test].empty())
-    {
+  if (this->Tests[test].empty()) {
     this->StartTestProcess(test);
     return true;
-    }
+  }
   // This test was not able to start because it is waiting
   // on depends to run
   return false;
@@ -253,22 +233,19 @@ bool cmCTestMultiProcessHandler::StartTest(int test)
 void cmCTestMultiProcessHandler::StartNextTests()
 {
   size_t numToStart = 0;
-  if(this->RunningCount < this->ParallelLevel)
-    {
+  if (this->RunningCount < this->ParallelLevel) {
     numToStart = this->ParallelLevel - this->RunningCount;
-    }
+  }
 
-  if(numToStart == 0)
-    {
+  if (numToStart == 0) {
     return;
-    }
+  }
 
   // Don't start any new tests if one with the RUN_SERIAL property
   // is already running.
-  if (this->SerialTestRunning)
-    {
+  if (this->SerialTestRunning) {
     return;
-    }
+  }
 
   bool allTestsFailedTestLoadCheck = false;
   bool usedFakeLoadForTesting = false;
@@ -279,101 +256,79 @@ void cmCTestMultiProcessHandler::StartNextTests()
 
   unsigned long systemLoad = 0;
   size_t spareLoad = 0;
-  if (this->TestLoad > 0)
-    {
+  if (this->TestLoad > 0) {
     // Activate possible wait.
     allTestsFailedTestLoadCheck = true;
 
     // Check for a fake load average value used in testing.
     if (const char* fake_load_value =
-        cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING"))
-      {
+          cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING")) {
       usedFakeLoadForTesting = true;
-      if (!cmSystemTools::StringToULong(fake_load_value, &systemLoad))
-        {
+      if (!cmSystemTools::StringToULong(fake_load_value, &systemLoad)) {
         cmSystemTools::Error("Failed to parse fake load value: ",
                              fake_load_value);
-        }
       }
+    }
     // If it's not set, look up the true load average.
-    else
-      {
+    else {
       systemLoad = static_cast<unsigned long>(ceil(info.GetLoadAverage()));
-      }
-    spareLoad = (this->TestLoad > systemLoad ?
-                 this->TestLoad - systemLoad : 0);
+    }
+    spareLoad =
+      (this->TestLoad > systemLoad ? this->TestLoad - systemLoad : 0);
 
     // Don't start more tests than the spare load can support.
-    if (numToStart > spareLoad)
-      {
+    if (numToStart > spareLoad) {
       numToStart = spareLoad;
-      }
     }
+  }
 
   TestList copy = this->SortedTests;
-  for(TestList::iterator test = copy.begin(); test != copy.end(); ++test)
-    {
+  for (TestList::iterator test = copy.begin(); test != copy.end(); ++test) {
     // Take a nap if we're currently performing a RUN_SERIAL test.
-    if (this->SerialTestRunning)
-      {
+    if (this->SerialTestRunning) {
       break;
-      }
+    }
     // We can only start a RUN_SERIAL test if no other tests are also running.
-    if (this->Properties[*test]->RunSerial && this->RunningCount > 0)
-      {
+    if (this->Properties[*test]->RunSerial && this->RunningCount > 0) {
       continue;
-      }
+    }
 
     size_t processors = GetProcessorsUsed(*test);
     bool testLoadOk = true;
-    if (this->TestLoad > 0)
-      {
-      if (processors <= spareLoad)
-        {
-        cmCTestLog(this->CTest, DEBUG,
-                    "OK to run " << GetName(*test) <<
-                    ", it requires " << processors <<
-                    " procs & system load is: " <<
-                    systemLoad << std::endl);
+    if (this->TestLoad > 0) {
+      if (processors <= spareLoad) {
+        cmCTestLog(this->CTest, DEBUG, "OK to run "
+                     << GetName(*test) << ", it requires " << processors
+                     << " procs & system load is: " << systemLoad
+                     << std::endl);
         allTestsFailedTestLoadCheck = false;
-        }
-      else
-        {
+      } else {
         testLoadOk = false;
-        }
       }
+    }
 
-    if (processors <= minProcessorsRequired)
-      {
+    if (processors <= minProcessorsRequired) {
       minProcessorsRequired = processors;
       testWithMinProcessors = GetName(*test);
-      }
+    }
 
-    if(testLoadOk && processors <= numToStart && this->StartTest(*test))
-      {
-      if(this->StopTimePassed)
-        {
+    if (testLoadOk && processors <= numToStart && this->StartTest(*test)) {
+      if (this->StopTimePassed) {
         return;
-        }
+      }
 
       numToStart -= processors;
-      }
-    else if(numToStart == 0)
-      {
+    } else if (numToStart == 0) {
       break;
-      }
     }
+  }
 
-  if (allTestsFailedTestLoadCheck)
-    {
+  if (allTestsFailedTestLoadCheck) {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "***** WAITING, ");
-    if (this->SerialTestRunning)
-      {
+    if (this->SerialTestRunning) {
       cmCTestLog(this->CTest, HANDLER_OUTPUT,
                  "Waiting for RUN_SERIAL test to finish.");
-      }
-    else
-      {
+    } else {
       /* clang-format off */
       cmCTestLog(this->CTest, HANDLER_OUTPUT,
                  "System Load: " << systemLoad << ", "
@@ -381,68 +336,57 @@ void cmCTestMultiProcessHandler::StartNextTests()
                  "Smallest test " << testWithMinProcessors <<
                  " requires " << minProcessorsRequired);
       /* clang-format on */
-      }
+    }
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "*****" << std::endl);
 
-    if (usedFakeLoadForTesting)
-      {
+    if (usedFakeLoadForTesting) {
       // Break out of the infinite loop of waiting for our fake load
       // to come down.
       this->StopTimePassed = true;
-      }
-    else
-      {
+    } else {
       // Wait between 1 and 5 seconds before trying again.
-      cmCTestScriptHandler::SleepInSeconds(
-        cmSystemTools::RandomSeed() % 5 + 1);
-      }
+      cmCTestScriptHandler::SleepInSeconds(cmSystemTools::RandomSeed() % 5 +
+                                           1);
     }
+  }
 }
 
 bool cmCTestMultiProcessHandler::CheckOutput()
 {
   // no more output we are done
-  if(this->RunningTests.empty())
-    {
+  if (this->RunningTests.empty()) {
     return false;
-    }
+  }
   std::vector<cmCTestRunTest*> finished;
   std::string out, err;
-  for(std::set<cmCTestRunTest*>::const_iterator i = this->RunningTests.begin();
-      i != this->RunningTests.end(); ++i)
-    {
+  for (std::set<cmCTestRunTest*>::const_iterator i =
+         this->RunningTests.begin();
+       i != this->RunningTests.end(); ++i) {
     cmCTestRunTest* p = *i;
-    if(!p->CheckOutput())
-      {
+    if (!p->CheckOutput()) {
       finished.push_back(p);
-      }
     }
-  for( std::vector<cmCTestRunTest*>::iterator i = finished.begin();
-       i != finished.end(); ++i)
-    {
+  }
+  for (std::vector<cmCTestRunTest*>::iterator i = finished.begin();
+       i != finished.end(); ++i) {
     this->Completed++;
     cmCTestRunTest* p = *i;
     int test = p->GetIndex();
 
     bool testResult = p->EndTest(this->Completed, this->Total, true);
-    if(p->StartAgain())
-      {
+    if (p->StartAgain()) {
       this->Completed--; // remove the completed test because run again
       continue;
-      }
-    if(testResult)
-      {
+    }
+    if (testResult) {
       this->Passed->push_back(p->GetTestProperties()->Name);
-      }
-    else
-      {
+    } else {
       this->Failed->push_back(p->GetTestProperties()->Name);
-      }
-    for(TestMap::iterator j = this->Tests.begin();
-        j != this->Tests.end(); ++j)
-      {
+    }
+    for (TestMap::iterator j = this->Tests.begin(); j != this->Tests.end();
+         ++j) {
       j->second.erase(test);
-      }
+    }
     this->TestFinishMap[test] = true;
     this->TestRunningMap[test] = false;
     this->RunningTests.erase(p);
@@ -450,7 +394,7 @@ bool cmCTestMultiProcessHandler::CheckOutput()
     this->UnlockResources(test);
     this->RunningCount -= GetProcessorsUsed(test);
     delete p;
-    }
+  }
   return true;
 }
 
@@ -463,56 +407,50 @@ void cmCTestMultiProcessHandler::UpdateCostData()
 
   PropertiesMap temp = this->Properties;
 
-  if(cmSystemTools::FileExists(fname.c_str()))
-    {
+  if (cmSystemTools::FileExists(fname.c_str())) {
     cmsys::ifstream fin;
     fin.open(fname.c_str());
 
     std::string line;
-    while(std::getline(fin, line))
-      {
-      if(line == "---") break;
-      std::vector<cmsys::String> parts =
-        cmSystemTools::SplitString(line, ' ');
-      //Format: <name> <previous_runs> <avg_cost>
-      if(parts.size() < 3) break;
+    while (std::getline(fin, line)) {
+      if (line == "---")
+        break;
+      std::vector<cmsys::String> parts = cmSystemTools::SplitString(line, ' ');
+      // Format: <name> <previous_runs> <avg_cost>
+      if (parts.size() < 3)
+        break;
 
       std::string name = parts[0];
       int prev = atoi(parts[1].c_str());
       float cost = static_cast<float>(atof(parts[2].c_str()));
 
       int index = this->SearchByName(name);
-      if(index == -1)
-        {
+      if (index == -1) {
         // This test is not in memory. We just rewrite the entry
         fout << name << " " << prev << " " << cost << "\n";
-        }
-      else
-        {
+      } else {
         // Update with our new average cost
         fout << name << " " << this->Properties[index]->PreviousRuns << " "
-          << this->Properties[index]->Cost << "\n";
+             << this->Properties[index]->Cost << "\n";
         temp.erase(index);
-        }
       }
+    }
     fin.close();
     cmSystemTools::RemoveFile(fname);
-    }
+  }
 
   // Add all tests not previously listed in the file
-  for(PropertiesMap::iterator i = temp.begin(); i != temp.end(); ++i)
-    {
+  for (PropertiesMap::iterator i = temp.begin(); i != temp.end(); ++i) {
     fout << i->second->Name << " " << i->second->PreviousRuns << " "
-      << i->second->Cost << "\n";
-    }
+         << i->second->Cost << "\n";
+  }
 
   // Write list of failed tests
   fout << "---\n";
-  for(std::vector<std::string>::iterator i = this->Failed->begin();
-      i != this->Failed->end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->Failed->begin();
+       i != this->Failed->end(); ++i) {
     fout << i->c_str() << "\n";
-    }
+  }
   fout.close();
   cmSystemTools::RenameFile(tmpout.c_str(), fname.c_str());
 }
@@ -521,78 +459,67 @@ void cmCTestMultiProcessHandler::ReadCostData()
 {
   std::string fname = this->CTest->GetCostDataFile();
 
-  if(cmSystemTools::FileExists(fname.c_str(), true))
-    {
+  if (cmSystemTools::FileExists(fname.c_str(), true)) {
     cmsys::ifstream fin;
     fin.open(fname.c_str());
     std::string line;
-    while(std::getline(fin, line))
-      {
-      if(line == "---") break;
+    while (std::getline(fin, line)) {
+      if (line == "---")
+        break;
 
-      std::vector<cmsys::String> parts =
-        cmSystemTools::SplitString(line, ' ');
+      std::vector<cmsys::String> parts = cmSystemTools::SplitString(line, ' ');
 
       // Probably an older version of the file, will be fixed next run
-      if(parts.size() < 3)
-        {
+      if (parts.size() < 3) {
         fin.close();
         return;
-        }
+      }
 
       std::string name = parts[0];
       int prev = atoi(parts[1].c_str());
       float cost = static_cast<float>(atof(parts[2].c_str()));
 
       int index = this->SearchByName(name);
-      if(index == -1) continue;
+      if (index == -1)
+        continue;
 
       this->Properties[index]->PreviousRuns = prev;
       // When not running in parallel mode, don't use cost data
-      if(this->ParallelLevel > 1 &&
-         this->Properties[index] &&
-         this->Properties[index]->Cost == 0)
-        {
+      if (this->ParallelLevel > 1 && this->Properties[index] &&
+          this->Properties[index]->Cost == 0) {
         this->Properties[index]->Cost = cost;
-        }
       }
+    }
     // Next part of the file is the failed tests
-    while(std::getline(fin, line))
-      {
-      if(line != "")
-        {
+    while (std::getline(fin, line)) {
+      if (line != "") {
         this->LastTestsFailed.push_back(line);
-        }
       }
-    fin.close();
     }
+    fin.close();
+  }
 }
 
 int cmCTestMultiProcessHandler::SearchByName(std::string name)
 {
   int index = -1;
 
-  for(PropertiesMap::iterator i = this->Properties.begin();
-      i != this->Properties.end(); ++i)
-    {
-    if(i->second->Name == name)
-      {
+  for (PropertiesMap::iterator i = this->Properties.begin();
+       i != this->Properties.end(); ++i) {
+    if (i->second->Name == name) {
       index = i->first;
-      }
     }
+  }
   return index;
 }
 
 void cmCTestMultiProcessHandler::CreateTestCostList()
 {
-  if(this->ParallelLevel > 1)
-    {
+  if (this->ParallelLevel > 1) {
     CreateParallelTestCostList();
-    }
-  else
-    {
+  } else {
     CreateSerialTestCostList();
-    }
+  }
 }
 
 void cmCTestMultiProcessHandler::CreateParallelTestCostList()
@@ -601,140 +528,125 @@ void cmCTestMultiProcessHandler::CreateParallelTestCostList()
 
   std::list<TestSet> priorityStack;
   priorityStack.push_back(TestSet());
-  TestSet &topLevel = priorityStack.back();
+  TestSet& topLevel = priorityStack.back();
 
   // In parallel test runs add previously failed tests to the front
   // of the cost list and queue other tests for further sorting
-  for(TestMap::const_iterator i = this->Tests.begin();
-    i != this->Tests.end(); ++i)
-    {
-    if(std::find(this->LastTestsFailed.begin(), this->LastTestsFailed.end(),
-       this->Properties[i->first]->Name) != this->LastTestsFailed.end())
-      {
-      //If the test failed last time, it should be run first.
+  for (TestMap::const_iterator i = this->Tests.begin(); i != this->Tests.end();
+       ++i) {
+    if (std::find(this->LastTestsFailed.begin(), this->LastTestsFailed.end(),
+                  this->Properties[i->first]->Name) !=
+        this->LastTestsFailed.end()) {
+      // If the test failed last time, it should be run first.
       this->SortedTests.push_back(i->first);
       alreadySortedTests.insert(i->first);
-      }
-    else
-      {
+    } else {
       topLevel.insert(i->first);
-      }
     }
+  }
 
   // In parallel test runs repeatedly move dependencies of the tests on
   // the current dependency level to the next level until no
   // further dependencies exist.
-  while(priorityStack.back().size())
-    {
-    TestSet &previousSet = priorityStack.back();
+  while (priorityStack.back().size()) {
+    TestSet& previousSet = priorityStack.back();
     priorityStack.push_back(TestSet());
-    TestSet &currentSet = priorityStack.back();
+    TestSet& currentSet = priorityStack.back();
 
-    for(TestSet::const_iterator i = previousSet.begin();
-      i != previousSet.end(); ++i)
-      {
+    for (TestSet::const_iterator i = previousSet.begin();
+         i != previousSet.end(); ++i) {
       TestSet const& dependencies = this->Tests[*i];
       currentSet.insert(dependencies.begin(), dependencies.end());
-      }
+    }
 
-    for(TestSet::const_iterator i = currentSet.begin();
-      i != currentSet.end(); ++i)
-      {
+    for (TestSet::const_iterator i = currentSet.begin(); i != currentSet.end();
+         ++i) {
       previousSet.erase(*i);
-      }
     }
+  }
 
   // Remove the empty dependency level
   priorityStack.pop_back();
 
   // Reverse iterate over the different dependency levels (deepest first).
   // Sort tests within each level by COST and append them to the cost list.
-  for(std::list<TestSet>::reverse_iterator i = priorityStack.rbegin();
-    i != priorityStack.rend(); ++i)
-    {
+  for (std::list<TestSet>::reverse_iterator i = priorityStack.rbegin();
+       i != priorityStack.rend(); ++i) {
     TestSet const& currentSet = *i;
     TestComparator comp(this);
 
     TestList sortedCopy;
 
-    sortedCopy.insert(sortedCopy.end(),
-                      currentSet.begin(), currentSet.end());
+    sortedCopy.insert(sortedCopy.end(), currentSet.begin(), currentSet.end());
 
     std::stable_sort(sortedCopy.begin(), sortedCopy.end(), comp);
 
-    for(TestList::const_iterator j = sortedCopy.begin();
-      j != sortedCopy.end(); ++j)
-      {
-      if(alreadySortedTests.find(*j) == alreadySortedTests.end())
-        {
+    for (TestList::const_iterator j = sortedCopy.begin();
+         j != sortedCopy.end(); ++j) {
+      if (alreadySortedTests.find(*j) == alreadySortedTests.end()) {
         this->SortedTests.push_back(*j);
         alreadySortedTests.insert(*j);
-        }
       }
     }
+  }
 }
 
-void cmCTestMultiProcessHandler::GetAllTestDependencies(
-    int test, TestList& dependencies)
+void cmCTestMultiProcessHandler::GetAllTestDependencies(int test,
+                                                        TestList& dependencies)
 {
   TestSet const& dependencySet = this->Tests[test];
-  for(TestSet::const_iterator i = dependencySet.begin();
-    i != dependencySet.end(); ++i)
-    {
+  for (TestSet::const_iterator i = dependencySet.begin();
+       i != dependencySet.end(); ++i) {
     GetAllTestDependencies(*i, dependencies);
     dependencies.push_back(*i);
-    }
+  }
 }
 
 void cmCTestMultiProcessHandler::CreateSerialTestCostList()
 {
   TestList presortedList;
 
-  for(TestMap::iterator i = this->Tests.begin();
-    i != this->Tests.end(); ++i)
-    {
+  for (TestMap::iterator i = this->Tests.begin(); i != this->Tests.end();
+       ++i) {
     presortedList.push_back(i->first);
-    }
+  }
 
   TestComparator comp(this);
   std::stable_sort(presortedList.begin(), presortedList.end(), comp);
 
   TestSet alreadySortedTests;
 
-  for(TestList::const_iterator i = presortedList.begin();
-    i != presortedList.end(); ++i)
-    {
-      int test = *i;
+  for (TestList::const_iterator i = presortedList.begin();
+       i != presortedList.end(); ++i) {
+    int test = *i;
 
-      if(alreadySortedTests.find(test) != alreadySortedTests.end())
-        {
-        continue;
-        }
-
-      TestList dependencies;
-      GetAllTestDependencies(test, dependencies);
+    if (alreadySortedTests.find(test) != alreadySortedTests.end()) {
+      continue;
+    }
 
-      for(TestList::const_iterator j = dependencies.begin();
-        j != dependencies.end(); ++j)
-        {
-        int testDependency = *j;
+    TestList dependencies;
+    GetAllTestDependencies(test, dependencies);
 
-        if(alreadySortedTests.find(testDependency) == alreadySortedTests.end())
-          {
-          alreadySortedTests.insert(testDependency);
-          this->SortedTests.push_back(testDependency);
-          }
-        }
+    for (TestList::const_iterator j = dependencies.begin();
+         j != dependencies.end(); ++j) {
+      int testDependency = *j;
 
-      alreadySortedTests.insert(test);
-      this->SortedTests.push_back(test);
+      if (alreadySortedTests.find(testDependency) ==
+          alreadySortedTests.end()) {
+        alreadySortedTests.insert(testDependency);
+        this->SortedTests.push_back(testDependency);
+      }
     }
+
+    alreadySortedTests.insert(test);
+    this->SortedTests.push_back(test);
+  }
 }
 
 void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
 {
-  std::string fname = this->CTest->GetBinaryDir()
-    + "/Testing/Temporary/CTestCheckpoint.txt";
+  std::string fname =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
   cmsys::ofstream fout;
   fout.open(fname.c_str(), std::ios::app);
   fout << index << "\n";
@@ -743,130 +655,118 @@ void cmCTestMultiProcessHandler::WriteCheckpoint(int index)
 
 void cmCTestMultiProcessHandler::MarkFinished()
 {
-  std::string fname = this->CTest->GetBinaryDir()
-    + "/Testing/Temporary/CTestCheckpoint.txt";
+  std::string fname =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
   cmSystemTools::RemoveFile(fname);
 }
 
-//For ShowOnly mode
+// For ShowOnly mode
 void cmCTestMultiProcessHandler::PrintTestList()
 {
   this->TestHandler->SetMaxIndex(this->FindMaxIndex());
   int count = 0;
 
   for (PropertiesMap::iterator it = this->Properties.begin();
-       it != this->Properties.end(); ++it)
-    {
+       it != this->Properties.end(); ++it) {
     count++;
     cmCTestTestHandler::cmCTestTestProperties& p = *it->second;
 
-    //push working dir
+    // push working dir
     std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
     cmSystemTools::ChangeDirectory(p.Directory);
 
     cmCTestRunTest testRun(this->TestHandler);
     testRun.SetIndex(p.Index);
     testRun.SetTestProperties(&p);
-    testRun.ComputeArguments(); //logs the command in verbose mode
+    testRun.ComputeArguments(); // logs the command in verbose mode
 
-    if(!p.Labels.empty()) //print the labels
-      {
+    if (!p.Labels.empty()) // print the labels
+    {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Labels:",
-        this->Quiet);
-      }
-    for(std::vector<std::string>::iterator label = p.Labels.begin();
-        label != p.Labels.end(); ++label)
-      {
+                         this->Quiet);
+    }
+    for (std::vector<std::string>::iterator label = p.Labels.begin();
+         label != p.Labels.end(); ++label) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " " << *label,
-        this->Quiet);
-      }
-    if(!p.Labels.empty()) //print the labels
-      {
+                         this->Quiet);
+    }
+    if (!p.Labels.empty()) // print the labels
+    {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
-        this->Quiet);
-      }
+                         this->Quiet);
+    }
 
-    if (this->TestHandler->MemCheck)
-      {
+    if (this->TestHandler->MemCheck) {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "  Memory Check",
-        this->Quiet);
-      }
-     else
-      {
+                         this->Quiet);
+    } else {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "  Test", this->Quiet);
-      }
+    }
     std::ostringstream indexStr;
     indexStr << " #" << p.Index << ":";
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_OUTPUT,
       std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex()))
-      << indexStr.str(), this->Quiet);
+        << indexStr.str(),
+      this->Quiet);
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " ", this->Quiet);
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      p.Name.c_str() << std::endl, this->Quiet);
-    //pop working dir
+                       p.Name.c_str() << std::endl, this->Quiet);
+    // pop working dir
     cmSystemTools::ChangeDirectory(current_dir);
-    }
+  }
 
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl << "Total Tests: "
-    << this->Total << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl
+                       << "Total Tests: " << this->Total << std::endl,
+                     this->Quiet);
 }
 
 void cmCTestMultiProcessHandler::PrintLabels()
 {
   std::set<std::string> allLabels;
   for (PropertiesMap::iterator it = this->Properties.begin();
-       it != this->Properties.end(); ++it)
-    {
+       it != this->Properties.end(); ++it) {
     cmCTestTestHandler::cmCTestTestProperties& p = *it->second;
     allLabels.insert(p.Labels.begin(), p.Labels.end());
-    }
+  }
 
-  if(!allLabels.empty())
-    {
+  if (!allLabels.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "All Labels:" << std::endl,
+                       this->Quiet);
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "All Labels:" << std::endl, this->Quiet);
-    }
-  else
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "No Labels Exist" << std::endl, this->Quiet);
-    }
-  for(std::set<std::string>::iterator label = allLabels.begin();
-      label != allLabels.end(); ++label)
-    {
+                       "No Labels Exist" << std::endl, this->Quiet);
+  }
+  for (std::set<std::string>::iterator label = allLabels.begin();
+       label != allLabels.end(); ++label) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "  " << *label << std::endl, this->Quiet);
-    }
+                       "  " << *label << std::endl, this->Quiet);
+  }
 }
 
 void cmCTestMultiProcessHandler::CheckResume()
 {
-  std::string fname = this->CTest->GetBinaryDir()
-      + "/Testing/Temporary/CTestCheckpoint.txt";
-  if(this->CTest->GetFailover())
-    {
-    if(cmSystemTools::FileExists(fname.c_str(), true))
-      {
-      *this->TestHandler->LogFile << "Resuming previously interrupted test set"
-        << std::endl
+  std::string fname =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/CTestCheckpoint.txt";
+  if (this->CTest->GetFailover()) {
+    if (cmSystemTools::FileExists(fname.c_str(), true)) {
+      *this->TestHandler->LogFile
+        << "Resuming previously interrupted test set" << std::endl
         << "----------------------------------------------------------"
         << std::endl;
 
       cmsys::ifstream fin;
       fin.open(fname.c_str());
       std::string line;
-      while(std::getline(fin, line))
-        {
+      while (std::getline(fin, line)) {
         int index = atoi(line.c_str());
         this->RemoveTest(index);
-        }
-      fin.close();
       }
+      fin.close();
     }
-  else if(cmSystemTools::FileExists(fname.c_str(), true))
-    {
+  } else if (cmSystemTools::FileExists(fname.c_str(), true)) {
     cmSystemTools::RemoveFile(fname);
-    }
+  }
 }
 
 void cmCTestMultiProcessHandler::RemoveTest(int index)
@@ -882,56 +782,51 @@ int cmCTestMultiProcessHandler::FindMaxIndex()
 {
   int max = 0;
   cmCTestMultiProcessHandler::TestMap::iterator i = this->Tests.begin();
-  for(; i != this->Tests.end(); ++i)
-    {
-    if(i->first > max)
-      {
+  for (; i != this->Tests.end(); ++i) {
+    if (i->first > max) {
       max = i->first;
-      }
     }
+  }
   return max;
 }
 
-//Returns true if no cycles exist in the dependency graph
+// Returns true if no cycles exist in the dependency graph
 bool cmCTestMultiProcessHandler::CheckCycles()
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-             "Checking test dependency graph..." << std::endl, this->Quiet);
-  for(TestMap::iterator it = this->Tests.begin();
-      it != this->Tests.end(); ++it)
-    {
-    //DFS from each element to itself
+                     "Checking test dependency graph..." << std::endl,
+                     this->Quiet);
+  for (TestMap::iterator it = this->Tests.begin(); it != this->Tests.end();
+       ++it) {
+    // DFS from each element to itself
     int root = it->first;
     std::set<int> visited;
     std::stack<int> s;
     s.push(root);
-    while(!s.empty())
-      {
+    while (!s.empty()) {
       int test = s.top();
       s.pop();
-      if(visited.insert(test).second)
-        {
-        for(TestSet::iterator d = this->Tests[test].begin();
-            d != this->Tests[test].end(); ++d)
-          {
-          if(*d == root)
-            {
-            //cycle exists
-            cmCTestLog(this->CTest, ERROR_MESSAGE,
-                       "Error: a cycle exists in the test dependency graph "
-                       "for the test \"" << this->Properties[root]->Name <<
-                       "\".\nPlease fix the cycle and run ctest again.\n");
+      if (visited.insert(test).second) {
+        for (TestSet::iterator d = this->Tests[test].begin();
+             d != this->Tests[test].end(); ++d) {
+          if (*d == root) {
+            // cycle exists
+            cmCTestLog(
+              this->CTest, ERROR_MESSAGE,
+              "Error: a cycle exists in the test dependency graph "
+              "for the test \""
+                << this->Properties[root]->Name
+                << "\".\nPlease fix the cycle and run ctest again.\n");
             return false;
-            }
-          else
-            {
+          } else {
             s.push(*d);
-            }
           }
         }
       }
     }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-             "Checking test dependency graph end" << std::endl, this->Quiet);
+                     "Checking test dependency graph end" << std::endl,
+                     this->Quiet);
   return true;
 }
diff --git a/Source/CTest/cmCTestMultiProcessHandler.h b/Source/CTest/cmCTestMultiProcessHandler.h
index 64e56e6..cb709cc 100644
--- a/Source/CTest/cmCTestMultiProcessHandler.h
+++ b/Source/CTest/cmCTestMultiProcessHandler.h
@@ -24,12 +24,21 @@
 class cmCTestMultiProcessHandler
 {
   friend class TestComparator;
+
 public:
-  struct TestSet : public std::set<int> {};
-  struct TestMap : public std::map<int, TestSet> {};
-  struct TestList : public std::vector<int> {};
-  struct PropertiesMap : public
-     std::map<int, cmCTestTestHandler::cmCTestTestProperties*> {};
+  struct TestSet : public std::set<int>
+  {
+  };
+  struct TestMap : public std::map<int, TestSet>
+  {
+  };
+  struct TestList : public std::vector<int>
+  {
+  };
+  struct PropertiesMap
+    : public std::map<int, cmCTestTestHandler::cmCTestTestProperties*>
+  {
+  };
 
   cmCTestMultiProcessHandler();
   virtual ~cmCTestMultiProcessHandler();
@@ -44,20 +53,23 @@ public:
 
   void SetPassFailVectors(std::vector<std::string>* passed,
                           std::vector<std::string>* failed)
-    {
+  {
     this->Passed = passed;
     this->Failed = failed;
-    }
+  }
   void SetTestResults(std::vector<cmCTestTestHandler::cmCTestTestResult>* r)
-  { this->TestResults = r; }
+  {
+    this->TestResults = r;
+  }
 
-  void SetCTest(cmCTest* ctest) { this->CTest = ctest;}
+  void SetCTest(cmCTest* ctest) { this->CTest = ctest; }
 
-  void SetTestHandler(cmCTestTestHandler * handler)
-  { this->TestHandler = handler; }
+  void SetTestHandler(cmCTestTestHandler* handler)
+  {
+    this->TestHandler = handler;
+  }
 
-  cmCTestTestHandler * GetTestHandler()
-  { return this->TestHandler; }
+  cmCTestTestHandler* GetTestHandler() { return this->TestHandler; }
 
   void SetQuiet(bool b) { this->Quiet = b; }
 protected:
@@ -88,9 +100,9 @@ protected:
   // check all running processes for output and exit case
   bool CheckOutput();
   void RemoveTest(int index);
-  //Check if we need to resume an interrupted test set
+  // Check if we need to resume an interrupted test set
   void CheckResume();
-  //Check if there are any circular dependencies
+  // Check if there are any circular dependencies
   bool CheckCycles();
   int FindMaxIndex();
   inline size_t GetProcessorsUsed(int index);
@@ -101,13 +113,13 @@ protected:
   // map from test number to set of depend tests
   TestMap Tests;
   TestList SortedTests;
-  //Total number of tests we'll be running
+  // Total number of tests we'll be running
   size_t Total;
-  //Number of tests that are complete
+  // Number of tests that are complete
   size_t Completed;
   size_t RunningCount;
   bool StopTimePassed;
-  //list of test properties (indices concurrent to the test map)
+  // list of test properties (indices concurrent to the test map)
   PropertiesMap Properties;
   std::map<int, bool> TestRunningMap;
   std::map<int, bool> TestFinishMap;
@@ -119,8 +131,8 @@ protected:
   std::vector<cmCTestTestHandler::cmCTestTestResult>* TestResults;
   size_t ParallelLevel; // max number of process that can be run at once
   unsigned long TestLoad;
-  std::set<cmCTestRunTest*> RunningTests;  // current running tests
-  cmCTestTestHandler * TestHandler;
+  std::set<cmCTestRunTest*> RunningTests; // current running tests
+  cmCTestTestHandler* TestHandler;
   cmCTest* CTest;
   bool HasCycles;
   bool Quiet;
diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx
index e05b77a..07f9dad 100644
--- a/Source/CTest/cmCTestP4.cxx
+++ b/Source/CTest/cmCTestP4.cxx
@@ -21,8 +21,8 @@
 #include <sys/types.h>
 #include <time.h>
 
-cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log):
-  cmCTestGlobalVC(ct, log)
+cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
@@ -31,68 +31,70 @@ cmCTestP4::~cmCTestP4()
 {
 }
 
-class cmCTestP4::IdentifyParser: public cmCTestVC::LineParser
+class cmCTestP4::IdentifyParser : public cmCTestVC::LineParser
 {
 public:
-  IdentifyParser(cmCTestP4* p4, const char* prefix,
-                 std::string& rev): Rev(rev)
-    {
+  IdentifyParser(cmCTestP4* p4, const char* prefix, std::string& rev)
+    : Rev(rev)
+  {
     this->SetLog(&p4->Log, prefix);
     this->RegexIdentify.compile("^Change ([0-9]+) on");
-    }
+  }
+
 private:
   std::string& Rev;
   cmsys::RegularExpression RegexIdentify;
 
   bool ProcessLine()
-    {
-    if(this->RegexIdentify.find(this->Line))
-      {
+  {
+    if (this->RegexIdentify.find(this->Line)) {
       this->Rev = this->RegexIdentify.match(1);
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 };
 
-class cmCTestP4::ChangesParser: public cmCTestVC::LineParser
+class cmCTestP4::ChangesParser : public cmCTestVC::LineParser
 {
 public:
-  ChangesParser(cmCTestP4* p4, const char* prefix) : P4(p4)
-    {
+  ChangesParser(cmCTestP4* p4, const char* prefix)
+    : P4(p4)
+  {
     this->SetLog(&P4->Log, prefix);
     this->RegexIdentify.compile("^Change ([0-9]+) on");
-    }
+  }
+
 private:
   cmsys::RegularExpression RegexIdentify;
   cmCTestP4* P4;
 
   bool ProcessLine()
-    {
-    if(this->RegexIdentify.find(this->Line))
-      {
+  {
+    if (this->RegexIdentify.find(this->Line)) {
       P4->ChangeLists.push_back(this->RegexIdentify.match(1));
-      }
-    return true;
     }
+    return true;
+  }
 };
 
-class cmCTestP4::UserParser: public cmCTestVC::LineParser
+class cmCTestP4::UserParser : public cmCTestVC::LineParser
 {
 public:
-  UserParser(cmCTestP4* p4, const char* prefix) : P4(p4)
-    {
+  UserParser(cmCTestP4* p4, const char* prefix)
+    : P4(p4)
+  {
     this->SetLog(&P4->Log, prefix);
     this->RegexUser.compile("^(.+) <(.*)> \\((.*)\\) accessed (.*)$");
-    }
+  }
+
 private:
   cmsys::RegularExpression RegexUser;
   cmCTestP4* P4;
 
   bool ProcessLine()
-    {
-    if(this->RegexUser.find(this->Line))
-      {
+  {
+    if (this->RegexUser.find(this->Line)) {
       User NewUser;
 
       NewUser.UserName = this->RegexUser.match(1);
@@ -102,9 +104,9 @@ private:
       P4->Users[this->RegexUser.match(1)] = NewUser;
 
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 };
 
 /* Diff format:
@@ -116,15 +118,17 @@ private:
 ==== //depot/file4#rev - /absolute/path/to/file4 ====
 (diff data)
 */
-class cmCTestP4::DiffParser: public cmCTestVC::LineParser
+class cmCTestP4::DiffParser : public cmCTestVC::LineParser
 {
 public:
   DiffParser(cmCTestP4* p4, const char* prefix)
-             : P4(p4), AlreadyNotified(false)
-    {
+    : P4(p4)
+    , AlreadyNotified(false)
+  {
     this->SetLog(&P4->Log, prefix);
     this->RegexDiff.compile("^==== (.*)#[0-9]+ - (.*)");
-    }
+  }
+
 private:
   cmCTestP4* P4;
   bool AlreadyNotified;
@@ -132,32 +136,27 @@ private:
   cmsys::RegularExpression RegexDiff;
 
   bool ProcessLine()
-    {
-    if(!this->Line.empty() && this->Line[0] == '='
-       && this->RegexDiff.find(this->Line))
-      {
-        CurrentPath = this->RegexDiff.match(1);
-        AlreadyNotified = false;
-      }
-    else
-      {
-      if(!AlreadyNotified)
-        {
+  {
+    if (!this->Line.empty() && this->Line[0] == '=' &&
+        this->RegexDiff.find(this->Line)) {
+      CurrentPath = this->RegexDiff.match(1);
+      AlreadyNotified = false;
+    } else {
+      if (!AlreadyNotified) {
         P4->DoModification(PathModified, CurrentPath);
         AlreadyNotified = true;
-        }
       }
-    return true;
     }
+    return true;
+  }
 };
 
 cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
 {
   std::map<std::string, cmCTestP4::User>::const_iterator it =
-          Users.find(username);
+    Users.find(username);
 
-  if(it == Users.end())
-    {
+  if (it == Users.end()) {
     std::vector<char const*> p4_users;
     SetP4Options(p4_users);
     p4_users.push_back("users");
@@ -172,11 +171,10 @@ cmCTestP4::User cmCTestP4::GetUserData(const std::string& username)
 
     // The user should now be added to the map. Search again.
     it = Users.find(username);
-    if(it == Users.end())
-      {
+    if (it == Users.end()) {
       return cmCTestP4::User();
-      }
     }
+  }
 
   return it->second;
 }
@@ -195,16 +193,19 @@ Affected files ...
 ... //path/to/file#rev delete
 ... //path/to/file#rev integrate
 */
-class cmCTestP4::DescribeParser: public cmCTestVC::LineParser
+class cmCTestP4::DescribeParser : public cmCTestVC::LineParser
 {
 public:
-  DescribeParser(cmCTestP4* p4, const char* prefix):
-      LineParser('\n', false), P4(p4), Section(SectionHeader)
-    {
+  DescribeParser(cmCTestP4* p4, const char* prefix)
+    : LineParser('\n', false)
+    , P4(p4)
+    , Section(SectionHeader)
+  {
     this->SetLog(&P4->Log, prefix);
     this->RegexHeader.compile("^Change ([0-9]+) by (.+)@(.+) on (.*)$");
     this->RegexDiff.compile("^\\.\\.\\. (.*)#[0-9]+ ([^ ]+)$");
-    }
+  }
+
 private:
   cmsys::RegularExpression RegexHeader;
   cmsys::RegularExpression RegexDiff;
@@ -213,46 +214,54 @@ private:
   typedef cmCTestP4::Revision Revision;
   typedef cmCTestP4::Change Change;
   std::vector<Change> Changes;
-  enum SectionType { SectionHeader, SectionBody, SectionDiffHeader,
-                     SectionDiff, SectionCount };
+  enum SectionType
+  {
+    SectionHeader,
+    SectionBody,
+    SectionDiffHeader,
+    SectionDiff,
+    SectionCount
+  };
   SectionType Section;
   Revision Rev;
 
   virtual bool ProcessLine()
-    {
-    if(this->Line.empty())
-      {
+  {
+    if (this->Line.empty()) {
       this->NextSection();
+    } else {
+      switch (this->Section) {
+        case SectionHeader:
+          this->DoHeaderLine();
+          break;
+        case SectionBody:
+          this->DoBodyLine();
+          break;
+        case SectionDiffHeader:
+          break; // nothing to do
+        case SectionDiff:
+          this->DoDiffLine();
+          break;
+        case SectionCount:
+          break; // never happens
       }
-    else
-      {
-      switch(this->Section)
-        {
-        case SectionHeader:     this->DoHeaderLine(); break;
-        case SectionBody:       this->DoBodyLine(); break;
-        case SectionDiffHeader: break; // nothing to do
-        case SectionDiff:       this->DoDiffLine(); break;
-        case SectionCount:      break; // never happens
-        }
-      }
-      return true;
-      }
+    }
+    return true;
+  }
 
   void NextSection()
-    {
-    if(this->Section == SectionDiff)
-    {
+  {
+    if (this->Section == SectionDiff) {
       this->P4->DoRevision(this->Rev, this->Changes);
       this->Rev = Revision();
     }
 
-    this->Section = SectionType((this->Section+1) % SectionCount);
-    }
+    this->Section = SectionType((this->Section + 1) % SectionCount);
+  }
 
   void DoHeaderLine()
-    {
-    if(this->RegexHeader.find(this->Line))
-      {
+  {
+    if (this->RegexHeader.find(this->Line)) {
       this->Rev.Rev = this->RegexHeader.match(1);
       this->Rev.Date = this->RegexHeader.match(4);
 
@@ -263,90 +272,78 @@ private:
       this->Rev.Committer = this->Rev.Author;
       this->Rev.CommitterEMail = this->Rev.EMail;
       this->Rev.CommitDate = this->Rev.Date;
-      }
     }
+  }
 
   void DoBodyLine()
-    {
-    if(this->Line[0] == '\t')
-      {
+  {
+    if (this->Line[0] == '\t') {
       this->Rev.Log += this->Line.substr(1);
-      }
-    this->Rev.Log += "\n";
     }
+    this->Rev.Log += "\n";
+  }
 
   void DoDiffLine()
-    {
-    if(this->RegexDiff.find(this->Line))
-    {
-    Change change;
-    std::string Path = this->RegexDiff.match(1);
-    if(Path.length() > 2 && Path[0] == '/' && Path[1] == '/')
-      {
-      size_t found = Path.find('/', 2);
-      if(found != std::string::npos)
-        {
-        Path = Path.substr(found + 1);
+  {
+    if (this->RegexDiff.find(this->Line)) {
+      Change change;
+      std::string Path = this->RegexDiff.match(1);
+      if (Path.length() > 2 && Path[0] == '/' && Path[1] == '/') {
+        size_t found = Path.find('/', 2);
+        if (found != std::string::npos) {
+          Path = Path.substr(found + 1);
         }
       }
 
-    change.Path = Path;
-    std::string action = this->RegexDiff.match(2);
+      change.Path = Path;
+      std::string action = this->RegexDiff.match(2);
 
-    if(action == "add")
-      {
-      change.Action = 'A';
-      }
-    else if(action == "delete")
-      {
-      change.Action = 'D';
-      }
-    else if(action == "edit" || action == "integrate")
-      {
-      change.Action = 'M';
+      if (action == "add") {
+        change.Action = 'A';
+      } else if (action == "delete") {
+        change.Action = 'D';
+      } else if (action == "edit" || action == "integrate") {
+        change.Action = 'M';
       }
 
-    Changes.push_back(change);
+      Changes.push_back(change);
     }
   }
 };
 
-void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions)
+void cmCTestP4::SetP4Options(std::vector<char const*>& CommandOptions)
 {
-  if(P4Options.empty())
-    {
+  if (P4Options.empty()) {
     const char* p4 = this->CommandLineTool.c_str();
     P4Options.push_back(p4);
 
-    //The CTEST_P4_CLIENT variable sets the P4 client used when issuing
-    //Perforce commands, if it's different from the default one.
+    // The CTEST_P4_CLIENT variable sets the P4 client used when issuing
+    // Perforce commands, if it's different from the default one.
     std::string client = this->CTest->GetCTestConfiguration("P4Client");
-    if(!client.empty())
-      {
+    if (!client.empty()) {
       P4Options.push_back("-c");
       P4Options.push_back(client);
-      }
+    }
 
-    //Set the message language to be English, in case the P4 admin
-    //has localized them
+    // Set the message language to be English, in case the P4 admin
+    // has localized them
     P4Options.push_back("-L");
     P4Options.push_back("en");
 
-    //The CTEST_P4_OPTIONS variable adds additional Perforce command line
-    //options before the main command
+    // The CTEST_P4_OPTIONS variable adds additional Perforce command line
+    // options before the main command
     std::string opts = this->CTest->GetCTestConfiguration("P4Options");
     std::vector<std::string> args =
-            cmSystemTools::ParseArguments(opts.c_str());
+      cmSystemTools::ParseArguments(opts.c_str());
 
     P4Options.insert(P4Options.end(), args.begin(), args.end());
-    }
+  }
 
   CommandOptions.clear();
-  for(std::vector<std::string>::iterator i = P4Options.begin();
-      i != P4Options.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = P4Options.begin();
+       i != P4Options.end(); ++i) {
     CommandOptions.push_back(i->c_str());
-    }
+  }
 }
 
 std::string cmCTestP4::GetWorkingRevision()
@@ -370,19 +367,15 @@ std::string cmCTestP4::GetWorkingRevision()
   bool result = RunChild(&p4_identify[0], &out, &err);
 
   // If there was a problem contacting the server return "<unknown>"
-  if(!result)
-    {
+  if (!result) {
     return "<unknown>";
-    }
+  }
 
-  if(rev.empty())
-    {
+  if (rev.empty()) {
     return "0";
-    }
-  else
-    {
+  } else {
     return rev;
-    }
+  }
 }
 
 void cmCTestP4::NoteOldRevision()
@@ -390,7 +383,7 @@ void cmCTestP4::NoteOldRevision()
   this->OldRevision = this->GetWorkingRevision();
 
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
-             << this->OldRevision << "\n");
+               << this->OldRevision << "\n");
   this->PriorRev.Rev = this->OldRevision;
 }
 
@@ -399,7 +392,7 @@ void cmCTestP4::NoteNewRevision()
   this->NewRevision = this->GetWorkingRevision();
 
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
-             << this->NewRevision << "\n");
+               << this->NewRevision << "\n");
 }
 
 void cmCTestP4::LoadRevisions()
@@ -412,15 +405,16 @@ void cmCTestP4::LoadRevisions()
 
   // If any revision is unknown it means we couldn't contact the server.
   // Do not process updates
-  if(this->OldRevision == "<unknown>" || this->NewRevision == "<unknown>")
-    {
+  if (this->OldRevision == "<unknown>" || this->NewRevision == "<unknown>") {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   At least one of the revisions "
-               << "is unknown. No repository changes will be reported.\n");
+                 << "is unknown. No repository changes will be reported.\n");
     return;
-    }
+  }
 
-  range.append("@").append(this->OldRevision)
-       .append(",").append(this->NewRevision);
+  range.append("@")
+    .append(this->OldRevision)
+    .append(",")
+    .append(this->NewRevision);
 
   p4_changes.push_back("changes");
   p4_changes.push_back(range.c_str());
@@ -432,14 +426,13 @@ void cmCTestP4::LoadRevisions()
   ChangeLists.clear();
   this->RunChild(&p4_changes[0], &out, &err);
 
-  if(ChangeLists.empty())
-      return;
+  if (ChangeLists.empty())
+    return;
 
-  //p4 describe -s ...@1111111,2222222
+  // p4 describe -s ...@1111111,2222222
   std::vector<char const*> p4_describe;
-  for(std::vector<std::string>::reverse_iterator i = ChangeLists.rbegin();
-      i != ChangeLists.rend(); ++i)
-    {
+  for (std::vector<std::string>::reverse_iterator i = ChangeLists.rbegin();
+       i != ChangeLists.rend(); ++i) {
     SetP4Options(p4_describe);
     p4_describe.push_back("describe");
     p4_describe.push_back("-s");
@@ -449,7 +442,7 @@ void cmCTestP4::LoadRevisions()
     DescribeParser outDescribe(this, "p4_describe-out> ");
     OutputLogger errDescribe(this->Log, "p4_describe-err> ");
     this->RunChild(&p4_describe[0], &outDescribe, &errDescribe);
-    }
+  }
 }
 
 void cmCTestP4::LoadModifications()
@@ -459,7 +452,7 @@ void cmCTestP4::LoadModifications()
 
   p4_diff.push_back("diff");
 
-  //Ideally we would use -Od but not all clients support it
+  // Ideally we would use -Od but not all clients support it
   p4_diff.push_back("-dn");
   std::string source = this->SourceDirectory + "/...";
   p4_diff.push_back(source.c_str());
@@ -476,11 +469,10 @@ bool cmCTestP4::UpdateCustom(const std::string& custom)
   cmSystemTools::ExpandListArgument(custom, p4_custom_command, true);
 
   std::vector<char const*> p4_custom;
-  for(std::vector<std::string>::const_iterator
-        i = p4_custom_command.begin(); i != p4_custom_command.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = p4_custom_command.begin();
+       i != p4_custom_command.end(); ++i) {
     p4_custom.push_back(i->c_str());
-    }
+  }
   p4_custom.push_back(0);
 
   OutputLogger custom_out(this->Log, "p4_customsync-out> ");
@@ -492,18 +484,16 @@ bool cmCTestP4::UpdateCustom(const std::string& custom)
 bool cmCTestP4::UpdateImpl()
 {
   std::string custom = this->CTest->GetCTestConfiguration("P4UpdateCustom");
-  if(!custom.empty())
-    {
+  if (!custom.empty()) {
     return this->UpdateCustom(custom);
-    }
+  }
 
   // If we couldn't get a revision number before updating, abort.
-  if(this->OldRevision == "<unknown>")
-    {
+  if (this->OldRevision == "<unknown>") {
     this->UpdateCommandLine = "Unknown current revision";
     cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown current revision\n");
     return false;
-    }
+  }
 
   std::vector<char const*> p4_sync;
   SetP4Options(p4_sync);
@@ -512,29 +502,26 @@ bool cmCTestP4::UpdateImpl()
 
   // Get user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("P4UpdateOptions");
-    }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     p4_sync.push_back(ai->c_str());
-    }
+  }
 
   std::string source = this->SourceDirectory + "/...";
 
   // Specify the start time for nightly testing.
-  if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
-    {
+  if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
     std::string date = this->GetNightlyTime();
-    //CTest reports the date as YYYY-MM-DD, Perforce needs it as YYYY/MM/DD
+    // CTest reports the date as YYYY-MM-DD, Perforce needs it as YYYY/MM/DD
     std::replace(date.begin(), date.end(), '-', '/');
 
-    //Revision specification: /...@"YYYY/MM/DD HH:MM:SS"
+    // Revision specification: /...@"YYYY/MM/DD HH:MM:SS"
     source.append("@\"").append(date).append("\"");
-    }
+  }
 
   p4_sync.push_back(source.c_str());
   p4_sync.push_back(0);
diff --git a/Source/CTest/cmCTestP4.h b/Source/CTest/cmCTestP4.h
index d666bd8..917751e 100644
--- a/Source/CTest/cmCTestP4.h
+++ b/Source/CTest/cmCTestP4.h
@@ -21,7 +21,7 @@
  * \brief Interaction with the Perforce command-line tool
  *
  */
-class cmCTestP4: public cmCTestGlobalVC
+class cmCTestP4 : public cmCTestGlobalVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
@@ -33,19 +33,25 @@ private:
   std::vector<std::string> ChangeLists;
 
   struct User
-    {
+  {
     std::string UserName;
     std::string Name;
     std::string EMail;
     std::string AccessTime;
 
-    User(): UserName(), Name(), EMail(), AccessTime() {}
-    };
+    User()
+      : UserName()
+      , Name()
+      , EMail()
+      , AccessTime()
+    {
+    }
+  };
   std::map<std::string, User> Users;
   std::vector<std::string> P4Options;
 
   User GetUserData(const std::string& username);
-  void SetP4Options(std::vector<char const*> &options);
+  void SetP4Options(std::vector<char const*>& options);
 
   std::string GetWorkingRevision();
   virtual void NoteOldRevision();
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.cxx b/Source/CTest/cmCTestReadCustomFilesCommand.cxx
index 5db01f9..2613c1c 100644
--- a/Source/CTest/cmCTestReadCustomFilesCommand.cxx
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.cxx
@@ -13,23 +13,18 @@
 
 #include "cmCTest.h"
 
-bool cmCTestReadCustomFilesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestReadCustomFilesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if (args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::vector<std::string>::const_iterator dit;
-  for ( dit = args.begin(); dit != args.end(); ++ dit )
-    {
-    this->CTest->ReadCustomConfigurationFileTree(dit->c_str(),
-      this->Makefile);
-    }
+  for (dit = args.begin(); dit != args.end(); ++dit) {
+    this->CTest->ReadCustomConfigurationFileTree(dit->c_str(), this->Makefile);
+  }
 
   return true;
 }
-
-
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.h b/Source/CTest/cmCTestReadCustomFilesCommand.h
index c95694a..713fc66 100644
--- a/Source/CTest/cmCTestReadCustomFilesCommand.h
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.h
@@ -23,34 +23,31 @@
 class cmCTestReadCustomFilesCommand : public cmCTestCommand
 {
 public:
-
   cmCTestReadCustomFilesCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestReadCustomFilesCommand* ni = new cmCTestReadCustomFilesCommand;
     ni->CTest = this->CTest;
     return ni;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_read_custom_files";}
+  virtual std::string GetName() const { return "ctest_read_custom_files"; }
 
   cmTypeMacro(cmCTestReadCustomFilesCommand, cmCTestCommand);
-
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestRunScriptCommand.cxx b/Source/CTest/cmCTestRunScriptCommand.cxx
index 7afbe04..e143d50 100644
--- a/Source/CTest/cmCTestRunScriptCommand.cxx
+++ b/Source/CTest/cmCTestRunScriptCommand.cxx
@@ -13,53 +13,41 @@
 
 #include "cmCTestScriptHandler.h"
 
-bool cmCTestRunScriptCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->CTestScriptHandler->RunCurrentScript();
     return true;
-    }
+  }
 
   bool np = false;
   unsigned int i = 0;
-  if (args[i] == "NEW_PROCESS")
-    {
+  if (args[i] == "NEW_PROCESS") {
     np = true;
     i++;
-    }
+  }
   int start = i;
   // run each script
   std::string returnVariable;
-  for (i = start; i < args.size(); ++i)
-    {
-    if(args[i] == "RETURN_VALUE")
-      {
+  for (i = start; i < args.size(); ++i) {
+    if (args[i] == "RETURN_VALUE") {
       ++i;
-      if(i < args.size())
-        {
+      if (i < args.size()) {
         returnVariable = args[i];
-        }
       }
     }
-  for (i = start; i < args.size(); ++i)
-    {
-    if(args[i] == "RETURN_VALUE")
-      {
+  }
+  for (i = start; i < args.size(); ++i) {
+    if (args[i] == "RETURN_VALUE") {
       ++i;
-      }
-    else
-      {
+    } else {
       int ret;
-      cmCTestScriptHandler::RunScript(this->CTest, args[i].c_str(), !np,
-        &ret);
+      cmCTestScriptHandler::RunScript(this->CTest, args[i].c_str(), !np, &ret);
       std::ostringstream str;
       str << ret;
       this->Makefile->AddDefinition(returnVariable, str.str().c_str());
-      }
     }
+  }
   return true;
 }
-
-
diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h
index 0998e5c..c503516 100644
--- a/Source/CTest/cmCTestRunScriptCommand.h
+++ b/Source/CTest/cmCTestRunScriptCommand.h
@@ -23,34 +23,32 @@
 class cmCTestRunScriptCommand : public cmCTestCommand
 {
 public:
-
   cmCTestRunScriptCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestRunScriptCommand* ni = new cmCTestRunScriptCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_run_script";}
+  virtual std::string GetName() const { return "ctest_run_script"; }
 
   cmTypeMacro(cmCTestRunScriptCommand, cmCTestCommand);
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx
index 1fa008d..59383af 100644
--- a/Source/CTest/cmCTestRunTest.cxx
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -25,7 +25,7 @@ cmCTestRunTest::cmCTestRunTest(cmCTestTestHandler* handler)
   this->CTest = handler->CTest;
   this->TestHandler = handler;
   this->TestProcess = 0;
-  this->TestResult.ExecutionTime =0;
+  this->TestResult.ExecutionTime = 0;
   this->TestResult.ReturnValue = 0;
   this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
   this->TestResult.TestCount = 0;
@@ -36,7 +36,7 @@ cmCTestRunTest::cmCTestRunTest(cmCTestTestHandler* handler)
   this->StopTimePassed = false;
   this->NumberOfRunsLeft = 1; // default to 1 run of the test
   this->RunUntilFail = false; // default to run the test once
-  this->RunAgain = false;   // default to not having to run again
+  this->RunAgain = false;     // default to not having to run again
 }
 
 cmCTestRunTest::~cmCTestRunTest()
@@ -49,51 +49,44 @@ bool cmCTestRunTest::CheckOutput()
   double timeout = 0.1;
   double timeEnd = cmSystemTools::GetTime() + timeout;
   std::string line;
-  while((timeout = timeEnd - cmSystemTools::GetTime(), timeout > 0))
-    {
+  while ((timeout = timeEnd - cmSystemTools::GetTime(), timeout > 0)) {
     int p = this->TestProcess->GetNextOutputLine(line, timeout);
-    if(p == cmsysProcess_Pipe_None)
-      {
+    if (p == cmsysProcess_Pipe_None) {
       // Process has terminated and all output read.
       return false;
-      }
-    else if(p == cmsysProcess_Pipe_STDOUT)
-      {
+    } else if (p == cmsysProcess_Pipe_STDOUT) {
       // Store this line of output.
-      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                 this->GetIndex() << ": " << line << std::endl);
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
+                   << ": " << line << std::endl);
       this->ProcessOutput += line;
       this->ProcessOutput += "\n";
 
       // Check for TIMEOUT_AFTER_MATCH property.
-      if (!this->TestProperties->TimeoutRegularExpressions.empty())
-        {
-        std::vector<std::pair<cmsys::RegularExpression,
-          std::string> >::iterator regIt;
-        for ( regIt = this->TestProperties->TimeoutRegularExpressions.begin();
-              regIt != this->TestProperties->TimeoutRegularExpressions.end();
-              ++ regIt )
-          {
-          if ( regIt->first.find(this->ProcessOutput.c_str()) )
-            {
-            cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                       this->GetIndex() << ": " <<
-                       "Test timeout changed to " <<
-                       this->TestProperties->AlternateTimeout << std::endl);
+      if (!this->TestProperties->TimeoutRegularExpressions.empty()) {
+        std::vector<
+          std::pair<cmsys::RegularExpression, std::string> >::iterator regIt;
+        for (regIt = this->TestProperties->TimeoutRegularExpressions.begin();
+             regIt != this->TestProperties->TimeoutRegularExpressions.end();
+             ++regIt) {
+          if (regIt->first.find(this->ProcessOutput.c_str())) {
+            cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->GetIndex()
+                         << ": "
+                         << "Test timeout changed to "
+                         << this->TestProperties->AlternateTimeout
+                         << std::endl);
             this->TestProcess->ResetStartTime();
             this->TestProcess->ChangeTimeout(
               this->TestProperties->AlternateTimeout);
             this->TestProperties->TimeoutRegularExpressions.clear();
             break;
-            }
           }
         }
       }
-    else // if(p == cmsysProcess_Pipe_Timeout)
-      {
+    } else // if(p == cmsysProcess_Pipe_Timeout)
+    {
       break;
-      }
     }
+  }
   return true;
 }
 
@@ -104,10 +97,9 @@ void cmCTestRunTest::CompressOutput()
   int ret;
   z_stream strm;
 
-  unsigned char* in =
-    reinterpret_cast<unsigned char*>(
+  unsigned char* in = reinterpret_cast<unsigned char*>(
     const_cast<char*>(this->ProcessOutput.c_str()));
-  //zlib makes the guarantee that this is the maximum output size
+  // zlib makes the guarantee that this is the maximum output size
   int outSize = static_cast<int>(
     static_cast<double>(this->ProcessOutput.size()) * 1.001 + 13.0);
   unsigned char* out = new unsigned char[outSize];
@@ -115,12 +107,11 @@ void cmCTestRunTest::CompressOutput()
   strm.zalloc = Z_NULL;
   strm.zfree = Z_NULL;
   strm.opaque = Z_NULL;
-  ret = deflateInit(&strm, -1); //default compression level
-  if (ret != Z_OK)
-    {
+  ret = deflateInit(&strm, -1); // default compression level
+  if (ret != Z_OK) {
     delete[] out;
     return;
-    }
+  }
 
   strm.avail_in = static_cast<uInt>(this->ProcessOutput.size());
   strm.next_in = in;
@@ -128,139 +119,116 @@ void cmCTestRunTest::CompressOutput()
   strm.next_out = out;
   ret = deflate(&strm, Z_FINISH);
 
-  if(ret == Z_STREAM_ERROR || ret != Z_STREAM_END)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error during output "
-      "compression. Sending uncompressed output." << std::endl);
+  if (ret == Z_STREAM_ERROR || ret != Z_STREAM_END) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error during output "
+               "compression. Sending uncompressed output."
+                 << std::endl);
     delete[] out;
     return;
-    }
+  }
 
   (void)deflateEnd(&strm);
 
-  unsigned char *encoded_buffer
-    = new unsigned char[static_cast<int>(outSize * 1.5)];
+  unsigned char* encoded_buffer =
+    new unsigned char[static_cast<int>(outSize * 1.5)];
 
-  size_t rlen
-    = cmsysBase64_Encode(out, strm.total_out, encoded_buffer, 1);
+  size_t rlen = cmsysBase64_Encode(out, strm.total_out, encoded_buffer, 1);
 
-  for(size_t i = 0; i < rlen; i++)
-    {
+  for (size_t i = 0; i < rlen; i++) {
     this->CompressedOutput += encoded_buffer[i];
-    }
+  }
 
-  if(strm.total_in)
-    {
-    this->CompressionRatio = static_cast<double>(strm.total_out) /
-                             static_cast<double>(strm.total_in);
-    }
+  if (strm.total_in) {
+    this->CompressionRatio =
+      static_cast<double>(strm.total_out) / static_cast<double>(strm.total_in);
+  }
 
-  delete [] encoded_buffer;
-  delete [] out;
+  delete[] encoded_buffer;
+  delete[] out;
 }
 
 bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
 {
   if ((!this->TestHandler->MemCheck &&
-      this->CTest->ShouldCompressTestOutput()) ||
+       this->CTest->ShouldCompressTestOutput()) ||
       (this->TestHandler->MemCheck &&
-      this->CTest->ShouldCompressMemCheckOutput()))
-    {
+       this->CTest->ShouldCompressMemCheckOutput())) {
     this->CompressOutput();
-    }
+  }
 
   this->WriteLogOutputTop(completed, total);
   std::string reason;
   bool passed = true;
-  int res = started ? this->TestProcess->GetProcessStatus()
-                    : cmsysProcess_State_Error;
+  int res =
+    started ? this->TestProcess->GetProcessStatus() : cmsysProcess_State_Error;
   int retVal = this->TestProcess->GetExitValue();
-  std::vector<std::pair<cmsys::RegularExpression,
-    std::string> >::iterator passIt;
+  std::vector<std::pair<cmsys::RegularExpression, std::string> >::iterator
+    passIt;
   bool forceFail = false;
   bool outputTestErrorsToConsole = false;
-  if (!this->TestProperties->RequiredRegularExpressions.empty())
-    {
+  if (!this->TestProperties->RequiredRegularExpressions.empty()) {
     bool found = false;
-    for ( passIt = this->TestProperties->RequiredRegularExpressions.begin();
-          passIt != this->TestProperties->RequiredRegularExpressions.end();
-          ++ passIt )
-      {
-      if ( passIt->first.find(this->ProcessOutput.c_str()) )
-        {
+    for (passIt = this->TestProperties->RequiredRegularExpressions.begin();
+         passIt != this->TestProperties->RequiredRegularExpressions.end();
+         ++passIt) {
+      if (passIt->first.find(this->ProcessOutput.c_str())) {
         found = true;
         reason = "Required regular expression found.";
         break;
-        }
       }
-    if ( !found )
-      {
+    }
+    if (!found) {
       reason = "Required regular expression not found.";
       forceFail = true;
-      }
-    reason +=  "Regex=[";
-    for ( passIt = this->TestProperties->RequiredRegularExpressions.begin();
-          passIt != this->TestProperties->RequiredRegularExpressions.end();
-          ++ passIt )
-      {
+    }
+    reason += "Regex=[";
+    for (passIt = this->TestProperties->RequiredRegularExpressions.begin();
+         passIt != this->TestProperties->RequiredRegularExpressions.end();
+         ++passIt) {
       reason += passIt->second;
       reason += "\n";
-      }
-    reason += "]";
     }
-  if (!this->TestProperties->ErrorRegularExpressions.empty())
-    {
-    for ( passIt = this->TestProperties->ErrorRegularExpressions.begin();
-          passIt != this->TestProperties->ErrorRegularExpressions.end();
-          ++ passIt )
-      {
-      if ( passIt->first.find(this->ProcessOutput.c_str()) )
-        {
+    reason += "]";
+  }
+  if (!this->TestProperties->ErrorRegularExpressions.empty()) {
+    for (passIt = this->TestProperties->ErrorRegularExpressions.begin();
+         passIt != this->TestProperties->ErrorRegularExpressions.end();
+         ++passIt) {
+      if (passIt->first.find(this->ProcessOutput.c_str())) {
         reason = "Error regular expression found in output.";
         reason += " Regex=[";
         reason += passIt->second;
         reason += "]";
         forceFail = true;
         break;
-        }
       }
     }
-  if (res == cmsysProcess_State_Exited)
-    {
-    bool success =
-      !forceFail &&  (retVal == 0 ||
-      this->TestProperties->RequiredRegularExpressions.size());
-    if(this->TestProperties->SkipReturnCode >= 0
-      && this->TestProperties->SkipReturnCode == retVal)
-      {
+  }
+  if (res == cmsysProcess_State_Exited) {
+    bool success = !forceFail &&
+      (retVal == 0 || this->TestProperties->RequiredRegularExpressions.size());
+    if (this->TestProperties->SkipReturnCode >= 0 &&
+        this->TestProperties->SkipReturnCode == retVal) {
       this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
       cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Skipped ");
-      }
-    else if((success && !this->TestProperties->WillFail)
-      || (!success && this->TestProperties->WillFail))
-      {
+    } else if ((success && !this->TestProperties->WillFail) ||
+               (!success && this->TestProperties->WillFail)) {
       this->TestResult.Status = cmCTestTestHandler::COMPLETED;
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Passed  " );
-      }
-    else
-      {
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Passed  ");
+    } else {
       this->TestResult.Status = cmCTestTestHandler::FAILED;
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Failed  " << reason );
+      cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Failed  " << reason);
       outputTestErrorsToConsole = this->CTest->OutputTestOutputOnTestFailure;
-      }
     }
-  else if ( res == cmsysProcess_State_Expired )
-    {
+  } else if (res == cmsysProcess_State_Expired) {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Timeout ");
     this->TestResult.Status = cmCTestTestHandler::TIMEOUT;
     outputTestErrorsToConsole = this->CTest->OutputTestOutputOnTestFailure;
-    }
-  else if ( res == cmsysProcess_State_Exception )
-    {
+  } else if (res == cmsysProcess_State_Exception) {
     outputTestErrorsToConsole = this->CTest->OutputTestOutputOnTestFailure;
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Exception: ");
-    switch(this->TestProcess->GetExitException())
-      {
+    switch (this->TestProcess->GetExitException()) {
       case cmsysProcess_Exception_Fault:
         cmCTestLog(this->CTest, HANDLER_OUTPUT, "SegFault");
         this->TestResult.Status = cmCTestTestHandler::SEGFAULT;
@@ -280,27 +248,24 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
       default:
         cmCTestLog(this->CTest, HANDLER_OUTPUT, "Other");
         this->TestResult.Status = cmCTestTestHandler::OTHER_FAULT;
-      }
     }
-  else //cmsysProcess_State_Error
-    {
+  } else // cmsysProcess_State_Error
+  {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Not Run ");
-    }
+  }
 
   passed = this->TestResult.Status == cmCTestTestHandler::COMPLETED;
   char buf[1024];
   sprintf(buf, "%6.2f sec", this->TestProcess->GetTotalTime());
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, buf << "\n" );
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, buf << "\n");
 
-  if ( outputTestErrorsToConsole )
-    {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, this->ProcessOutput << std::endl );
-    }
+  if (outputTestErrorsToConsole) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, this->ProcessOutput << std::endl);
+  }
 
-  if ( this->TestHandler->LogFile )
-    {
+  if (this->TestHandler->LogFile) {
     *this->TestHandler->LogFile << "Test time = " << buf << std::endl;
-    }
+  }
 
   // Set the working directory to the tests directory
   std::string oldpath = cmSystemTools::GetCurrentWorkingDirectory();
@@ -311,28 +276,25 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
   // restore working directory
   cmSystemTools::ChangeDirectory(oldpath);
 
-
   // if this is doing MemCheck then all the output needs to be put into
   // Output since that is what is parsed by cmCTestMemCheckHandler
-  if(!this->TestHandler->MemCheck && started)
-    {
-    this->TestHandler->CleanTestOutput(this->ProcessOutput,
-      static_cast<size_t>
-      (this->TestResult.Status == cmCTestTestHandler::COMPLETED ?
-      this->TestHandler->CustomMaximumPassedTestOutputSize :
-      this->TestHandler->CustomMaximumFailedTestOutputSize));
-    }
+  if (!this->TestHandler->MemCheck && started) {
+    this->TestHandler->CleanTestOutput(
+      this->ProcessOutput,
+      static_cast<size_t>(
+        this->TestResult.Status == cmCTestTestHandler::COMPLETED
+          ? this->TestHandler->CustomMaximumPassedTestOutputSize
+          : this->TestHandler->CustomMaximumFailedTestOutputSize));
+  }
   this->TestResult.Reason = reason;
-  if (this->TestHandler->LogFile)
-    {
+  if (this->TestHandler->LogFile) {
     bool pass = true;
     const char* reasonType = "Test Pass Reason";
-    if(this->TestResult.Status != cmCTestTestHandler::COMPLETED &&
-       this->TestResult.Status != cmCTestTestHandler::NOT_RUN)
-      {
+    if (this->TestResult.Status != cmCTestTestHandler::COMPLETED &&
+        this->TestResult.Status != cmCTestTestHandler::NOT_RUN) {
       reasonType = "Test Fail Reason";
       pass = false;
-      }
+    }
     double ttime = this->TestProcess->GetTotalTime();
     int hours = static_cast<int>(ttime / (60 * 60));
     int minutes = static_cast<int>(ttime / 60) % 60;
@@ -342,61 +304,53 @@ bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started)
     *this->TestHandler->LogFile
       << "----------------------------------------------------------"
       << std::endl;
-    if(!this->TestResult.Reason.empty())
-      {
+    if (!this->TestResult.Reason.empty()) {
       *this->TestHandler->LogFile << reasonType << ":\n"
-        << this->TestResult.Reason << "\n";
-      }
-    else
-      {
-      if(pass)
-        {
+                                  << this->TestResult.Reason << "\n";
+    } else {
+      if (pass) {
         *this->TestHandler->LogFile << "Test Passed.\n";
-        }
-      else
-        {
+      } else {
         *this->TestHandler->LogFile << "Test Failed.\n";
-        }
       }
-    *this->TestHandler->LogFile << "\"" << this->TestProperties->Name
+    }
+    *this->TestHandler->LogFile
+      << "\"" << this->TestProperties->Name
       << "\" end time: " << this->CTest->CurrentTime() << std::endl
-      << "\"" << this->TestProperties->Name << "\" time elapsed: "
-      << buffer << std::endl
+      << "\"" << this->TestProperties->Name << "\" time elapsed: " << buffer
+      << std::endl
       << "----------------------------------------------------------"
-      << std::endl << std::endl;
-    }
+      << std::endl
+      << std::endl;
+  }
   // if the test actually started and ran
   // record the results in TestResult
-  if(started)
-    {
+  if (started) {
     bool compress = !this->TestHandler->MemCheck &&
-      this->CompressionRatio < 1 &&
-      this->CTest->ShouldCompressTestOutput();
-    this->TestResult.Output = compress ? this->CompressedOutput
-      : this->ProcessOutput;
+      this->CompressionRatio < 1 && this->CTest->ShouldCompressTestOutput();
+    this->TestResult.Output =
+      compress ? this->CompressedOutput : this->ProcessOutput;
     this->TestResult.CompressOutput = compress;
     this->TestResult.ReturnValue = this->TestProcess->GetExitValue();
     this->TestResult.CompletionStatus = "Completed";
     this->TestResult.ExecutionTime = this->TestProcess->GetTotalTime();
     this->MemCheckPostProcess();
     this->ComputeWeightedCost();
-    }
+  }
   // If the test does not need to rerun push the current TestResult onto the
   // TestHandler vector
-  if(!this->NeedsToRerun())
-    {
+  if (!this->NeedsToRerun()) {
     this->TestHandler->TestResults.push_back(this->TestResult);
-    }
+  }
   delete this->TestProcess;
   return passed;
 }
 
 bool cmCTestRunTest::StartAgain()
 {
-  if(!this->RunAgain)
-    {
+  if (!this->RunAgain) {
     return false;
-    }
+  }
   this->RunAgain = false; // reset
   // change to tests directory
   std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
@@ -410,19 +364,17 @@ bool cmCTestRunTest::StartAgain()
 bool cmCTestRunTest::NeedsToRerun()
 {
   this->NumberOfRunsLeft--;
-  if(this->NumberOfRunsLeft == 0)
-    {
+  if (this->NumberOfRunsLeft == 0) {
     return false;
-    }
+  }
   // if number of runs left is not 0, and we are running until
   // we find a failed test, then return true so the test can be
   // restarted
-  if(this->RunUntilFail
-     && this->TestResult.Status == cmCTestTestHandler::COMPLETED)
-    {
+  if (this->RunUntilFail &&
+      this->TestResult.Status == cmCTestTestHandler::COMPLETED) {
     this->RunAgain = true;
     return true;
-    }
+  }
   return false;
 }
 void cmCTestRunTest::ComputeWeightedCost()
@@ -431,27 +383,25 @@ void cmCTestRunTest::ComputeWeightedCost()
   double avgcost = static_cast<double>(this->TestProperties->Cost);
   double current = this->TestResult.ExecutionTime;
 
-  if(this->TestResult.Status == cmCTestTestHandler::COMPLETED)
-    {
+  if (this->TestResult.Status == cmCTestTestHandler::COMPLETED) {
     this->TestProperties->Cost =
       static_cast<float>(((prev * avgcost) + current) / (prev + 1.0));
     this->TestProperties->PreviousRuns++;
-    }
+  }
 }
 
 void cmCTestRunTest::MemCheckPostProcess()
 {
-  if(!this->TestHandler->MemCheck)
-    {
+  if (!this->TestHandler->MemCheck) {
     return;
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
-    << ": process test output now: "
-    << this->TestProperties->Name << " "
-    << this->TestResult.Name << std::endl,
-    this->TestHandler->GetQuiet());
-  cmCTestMemCheckHandler * handler = static_cast<cmCTestMemCheckHandler*>
-    (this->TestHandler);
+                       << ": process test output now: "
+                       << this->TestProperties->Name << " "
+                       << this->TestResult.Name << std::endl,
+                     this->TestHandler->GetQuiet());
+  cmCTestMemCheckHandler* handler =
+    static_cast<cmCTestMemCheckHandler*>(this->TestHandler);
   handler->PostProcessTest(this->TestResult, this->Index);
 }
 
@@ -459,11 +409,11 @@ void cmCTestRunTest::MemCheckPostProcess()
 bool cmCTestRunTest::StartTest(size_t total)
 {
   this->TotalNumberOfTests = total; // save for rerun case
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(2*getNumWidth(total) + 8)
-    << "Start "
-    << std::setw(getNumWidth(this->TestHandler->GetMaxIndex()))
-    << this->TestProperties->Index << ": "
-    << this->TestProperties->Name << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(2 * getNumWidth(total) + 8)
+               << "Start "
+               << std::setw(getNumWidth(this->TestHandler->GetMaxIndex()))
+               << this->TestProperties->Index << ": "
+               << this->TestProperties->Name << std::endl);
   this->ComputeArguments();
   std::vector<std::string>& args = this->TestProperties->Args;
   this->TestResult.Properties = this->TestProperties;
@@ -476,21 +426,17 @@ bool cmCTestRunTest::StartTest(size_t total)
   this->TestResult.Name = this->TestProperties->Name;
   this->TestResult.Path = this->TestProperties->Directory.c_str();
 
-  if(args.size() >= 2 && args[1] == "NOT_AVAILABLE")
-    {
+  if (args.size() >= 2 && args[1] == "NOT_AVAILABLE") {
     this->TestProcess = new cmProcess;
     std::string msg;
-    if(this->CTest->GetConfigType().empty())
-      {
+    if (this->CTest->GetConfigType().empty()) {
       msg = "Test not available without configuration.";
       msg += "  (Missing \"-C <config>\"?)";
-      }
-    else
-      {
+    } else {
       msg = "Test not available in configuration \"";
       msg += this->CTest->GetConfigType();
       msg += "\".";
-      }
+    }
     *this->TestHandler->LogFile << msg << std::endl;
     cmCTestLog(this->CTest, ERROR_MESSAGE, msg << std::endl);
     this->TestResult.Output = msg;
@@ -498,54 +444,50 @@ bool cmCTestRunTest::StartTest(size_t total)
     this->TestResult.CompletionStatus = "Not Run";
     this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
     return false;
-    }
+  }
 
   // Check if all required files exist
-  for(std::vector<std::string>::iterator i =
-    this->TestProperties->RequiredFiles.begin();
-    i != this->TestProperties->RequiredFiles.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i =
+         this->TestProperties->RequiredFiles.begin();
+       i != this->TestProperties->RequiredFiles.end(); ++i) {
     std::string file = *i;
 
-    if(!cmSystemTools::FileExists(file.c_str()))
-      {
-      //Required file was not found
+    if (!cmSystemTools::FileExists(file.c_str())) {
+      // Required file was not found
       this->TestProcess = new cmProcess;
-      *this->TestHandler->LogFile << "Unable to find required file: "
-               << file << std::endl;
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to find required file: "
-               << file << std::endl);
+      *this->TestHandler->LogFile << "Unable to find required file: " << file
+                                  << std::endl;
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Unable to find required file: " << file << std::endl);
       this->TestResult.Output = "Unable to find required file: " + file;
       this->TestResult.FullCommandLine = "";
       this->TestResult.CompletionStatus = "Not Run";
       this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
       return false;
-      }
     }
+  }
   // log and return if we did not find the executable
-  if (this->ActualCommand == "")
-    {
+  if (this->ActualCommand == "") {
     // if the command was not found create a TestResult object
     // that has that information
     this->TestProcess = new cmProcess;
-    *this->TestHandler->LogFile << "Unable to find executable: "
-                   << args[1] << std::endl;
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to find executable: "
-               << args[1] << std::endl);
+    *this->TestHandler->LogFile << "Unable to find executable: " << args[1]
+                                << std::endl;
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Unable to find executable: " << args[1] << std::endl);
     this->TestResult.Output = "Unable to find executable: " + args[1];
     this->TestResult.FullCommandLine = "";
     this->TestResult.CompletionStatus = "Not Run";
     this->TestResult.Status = cmCTestTestHandler::NOT_RUN;
     return false;
-    }
+  }
   this->StartTime = this->CTest->CurrentTime();
 
   double timeout = this->ResolveTimeout();
 
-  if(this->StopTimePassed)
-    {
+  if (this->StopTimePassed) {
     return false;
-    }
+  }
   return this->ForkProcess(timeout, this->TestProperties->ExplicitTimeout,
                            &this->TestProperties->Environment);
 }
@@ -557,92 +499,82 @@ void cmCTestRunTest::ComputeArguments()
     this->TestProperties->Args.begin();
   ++j; // skip test name
   // find the test executable
-  if(this->TestHandler->MemCheck)
-    {
-    cmCTestMemCheckHandler * handler = static_cast<cmCTestMemCheckHandler*>
-      (this->TestHandler);
+  if (this->TestHandler->MemCheck) {
+    cmCTestMemCheckHandler* handler =
+      static_cast<cmCTestMemCheckHandler*>(this->TestHandler);
     this->ActualCommand = handler->MemoryTester.c_str();
     this->TestProperties->Args[1] = this->TestHandler->FindTheExecutable(
       this->TestProperties->Args[1].c_str());
-    }
-  else
-    {
-    this->ActualCommand =
-      this->TestHandler->FindTheExecutable(
+  } else {
+    this->ActualCommand = this->TestHandler->FindTheExecutable(
       this->TestProperties->Args[1].c_str());
-    ++j; //skip the executable (it will be actualCommand)
-    }
-  std::string testCommand
-    = cmSystemTools::ConvertToOutputPath(this->ActualCommand.c_str());
+    ++j; // skip the executable (it will be actualCommand)
+  }
+  std::string testCommand =
+    cmSystemTools::ConvertToOutputPath(this->ActualCommand.c_str());
 
-  //Prepends memcheck args to our command string
+  // Prepends memcheck args to our command string
   this->TestHandler->GenerateTestCommand(this->Arguments, this->Index);
-  for(std::vector<std::string>::iterator i = this->Arguments.begin();
-      i != this->Arguments.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->Arguments.begin();
+       i != this->Arguments.end(); ++i) {
     testCommand += " \"";
     testCommand += *i;
     testCommand += "\"";
-    }
+  }
 
-  for(;j != this->TestProperties->Args.end(); ++j)
-    {
+  for (; j != this->TestProperties->Args.end(); ++j) {
     testCommand += " \"";
     testCommand += *j;
     testCommand += "\"";
     this->Arguments.push_back(*j);
-    }
+  }
   this->TestResult.FullCommandLine = testCommand;
 
   // Print the test command in verbose mode
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
-             << this->Index << ": "
-             << (this->TestHandler->MemCheck?"MemCheck":"Test")
-             << " command: " << testCommand
-             << std::endl);
+               << this->Index << ": "
+               << (this->TestHandler->MemCheck ? "MemCheck" : "Test")
+               << " command: " << testCommand << std::endl);
 
   // Print any test-specific env vars in verbose mode
-  if (this->TestProperties->Environment.size())
-    {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ": "
-               << "Environment variables: " << std::endl);
-    }
-  for(std::vector<std::string>::const_iterator e =
-      this->TestProperties->Environment.begin();
-      e != this->TestProperties->Environment.end(); ++e)
-    {
+  if (this->TestProperties->Environment.size()) {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
+                 << ": "
+                 << "Environment variables: " << std::endl);
+  }
+  for (std::vector<std::string>::const_iterator e =
+         this->TestProperties->Environment.begin();
+       e != this->TestProperties->Environment.end(); ++e) {
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ":  " << *e
-               << std::endl);
-    }
+                                                                << std::endl);
+  }
 }
 
 void cmCTestRunTest::DartProcessing()
 {
   if (!this->ProcessOutput.empty() &&
-     this->ProcessOutput.find("<DartMeasurement") != this->ProcessOutput.npos)
-    {
-    if (this->TestHandler->DartStuff.find(this->ProcessOutput.c_str()))
-      {
+      this->ProcessOutput.find("<DartMeasurement") !=
+        this->ProcessOutput.npos) {
+    if (this->TestHandler->DartStuff.find(this->ProcessOutput.c_str())) {
       this->TestResult.DartString = this->TestHandler->DartStuff.match(1);
       // keep searching and replacing until none are left
-      while (this->TestHandler->DartStuff1.find(this->ProcessOutput.c_str()))
-        {
+      while (this->TestHandler->DartStuff1.find(this->ProcessOutput.c_str())) {
         // replace the exact match for the string
-        cmSystemTools::ReplaceString(this->ProcessOutput,
-                         this->TestHandler->DartStuff1.match(1).c_str(), "");
-        }
+        cmSystemTools::ReplaceString(
+          this->ProcessOutput, this->TestHandler->DartStuff1.match(1).c_str(),
+          "");
       }
     }
+  }
 }
 
 double cmCTestRunTest::ResolveTimeout()
 {
   double timeout = this->TestProperties->Timeout;
 
-  if(this->CTest->GetStopTime() == "")
-    {
+  if (this->CTest->GetStopTime() == "") {
     return timeout;
-    }
+  }
   struct tm* lctime;
   time_t current_time = time(0);
   lctime = gmtime(&current_time);
@@ -652,87 +584,77 @@ double cmCTestRunTest::ResolveTimeout()
   int local_hour = lctime->tm_hour;
 
   int tzone_offset = local_hour - gm_hour;
-  if(gm_time > current_time && gm_hour < local_hour)
-    {
+  if (gm_time > current_time && gm_hour < local_hour) {
     // this means gm_time is on the next day
     tzone_offset -= 24;
-    }
-  else if(gm_time < current_time && gm_hour > local_hour)
-    {
+  } else if (gm_time < current_time && gm_hour > local_hour) {
     // this means gm_time is on the previous day
     tzone_offset += 24;
-    }
+  }
 
   tzone_offset *= 100;
   char buf[1024];
   // add todays year day and month to the time in str because
   // curl_getdate no longer assumes the day is today
-  sprintf(buf, "%d%02d%02d %s %+05i",
-          lctime->tm_year + 1900,
-          lctime->tm_mon + 1,
-          lctime->tm_mday,
-          this->CTest->GetStopTime().c_str(),
-          tzone_offset);
+  sprintf(buf, "%d%02d%02d %s %+05i", lctime->tm_year + 1900,
+          lctime->tm_mon + 1, lctime->tm_mday,
+          this->CTest->GetStopTime().c_str(), tzone_offset);
 
   time_t stop_time = curl_getdate(buf, &current_time);
-  if(stop_time == -1)
-    {
+  if (stop_time == -1) {
     return timeout;
-    }
-
-  //the stop time refers to the next day
-  if(this->CTest->NextDayStopTime)
-    {
-    stop_time += 24*60*60;
-    }
-  int stop_timeout = static_cast<int>(stop_time - current_time) % (24*60*60);
+  }
+
+  // the stop time refers to the next day
+  if (this->CTest->NextDayStopTime) {
+    stop_time += 24 * 60 * 60;
+  }
+  int stop_timeout =
+    static_cast<int>(stop_time - current_time) % (24 * 60 * 60);
   this->CTest->LastStopTimeout = stop_timeout;
 
-  if(stop_timeout <= 0 || stop_timeout > this->CTest->LastStopTimeout)
-    {
+  if (stop_timeout <= 0 || stop_timeout > this->CTest->LastStopTimeout) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "The stop time has been passed. "
-      "Stopping all tests." << std::endl);
+                                           "Stopping all tests."
+                 << std::endl);
     this->StopTimePassed = true;
     return 0;
-    }
-  return timeout == 0 ? stop_timeout :
-    (timeout < stop_timeout ? timeout : stop_timeout);
+  }
+  return timeout == 0 ? stop_timeout
+                      : (timeout < stop_timeout ? timeout : stop_timeout);
 }
 
 bool cmCTestRunTest::ForkProcess(double testTimeOut, bool explicitTimeout,
-                     std::vector<std::string>* environment)
+                                 std::vector<std::string>* environment)
 {
   this->TestProcess = new cmProcess;
   this->TestProcess->SetId(this->Index);
   this->TestProcess->SetWorkingDirectory(
-        this->TestProperties->Directory.c_str());
+    this->TestProperties->Directory.c_str());
   this->TestProcess->SetCommand(this->ActualCommand.c_str());
   this->TestProcess->SetCommandArguments(this->Arguments);
 
   // determine how much time we have
   double timeout = this->CTest->GetRemainingTimeAllowed() - 120;
-  if (this->CTest->GetTimeOut() > 0 && this->CTest->GetTimeOut() < timeout)
-    {
+  if (this->CTest->GetTimeOut() > 0 && this->CTest->GetTimeOut() < timeout) {
     timeout = this->CTest->GetTimeOut();
-    }
-  if (testTimeOut > 0
-      && testTimeOut < this->CTest->GetRemainingTimeAllowed())
-    {
+  }
+  if (testTimeOut > 0 &&
+      testTimeOut < this->CTest->GetRemainingTimeAllowed()) {
     timeout = testTimeOut;
-    }
+  }
   // always have at least 1 second if we got to here
-  if (timeout <= 0)
-    {
+  if (timeout <= 0) {
     timeout = 1;
-    }
+  }
   // handle timeout explicitly set to 0
-  if (testTimeOut == 0 && explicitTimeout)
-    {
+  if (testTimeOut == 0 && explicitTimeout) {
     timeout = 0;
-    }
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ": "
-    << "Test timeout computed to be: " << timeout << "\n",
-    this->TestHandler->GetQuiet());
+  }
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index
+                       << ": "
+                       << "Test timeout computed to be: " << timeout << "\n",
+                     this->TestHandler->GetQuiet());
 
   this->TestProcess->SetTimeout(timeout);
 
@@ -740,10 +662,9 @@ bool cmCTestRunTest::ForkProcess(double testTimeOut, bool explicitTimeout,
   cmSystemTools::SaveRestoreEnvironment sre;
 #endif
 
-  if (environment && !environment->empty())
-    {
+  if (environment && !environment->empty()) {
     cmSystemTools::AppendEnv(*environment);
-    }
+  }
 
   return this->TestProcess->StartProcess();
 }
@@ -756,69 +677,67 @@ void cmCTestRunTest::WriteLogOutputTop(size_t completed, size_t total)
   // then it will never print out the completed / total, same would
   // got for run until pass.  Trick is when this is called we don't
   // yet know if we are passing or failing.
-  if(this->NumberOfRunsLeft == 1)
-    {
+  if (this->NumberOfRunsLeft == 1) {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-               << completed << "/");
+                 << completed << "/");
     cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-               << total << " ");
-    }
+                 << total << " ");
+  }
   // if this is one of several runs of a test just print blank space
   // to keep things neat
-  else
-    {
+  else {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-               << " " << " ");
+                 << " "
+                 << " ");
     cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(getNumWidth(total))
-               << " " << " ");
-    }
+                 << " "
+                 << " ");
+  }
 
-  if ( this->TestHandler->MemCheck )
-    {
+  if (this->TestHandler->MemCheck) {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "MemCheck");
-    }
-  else
-    {
+  } else {
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "Test");
-    }
+  }
 
   std::ostringstream indexStr;
   indexStr << " #" << this->Index << ":";
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex()))
-             << indexStr.str());
+               << indexStr.str());
   cmCTestLog(this->CTest, HANDLER_OUTPUT, " ");
   const int maxTestNameWidth = this->CTest->GetMaxTestNameWidth();
   std::string outname = this->TestProperties->Name + " ";
   outname.resize(maxTestNameWidth + 4, '.');
 
   *this->TestHandler->LogFile << this->TestProperties->Index << "/"
-    << this->TestHandler->TotalNumberOfTests << " Testing: "
-    << this->TestProperties->Name << std::endl;
+                              << this->TestHandler->TotalNumberOfTests
+                              << " Testing: " << this->TestProperties->Name
+                              << std::endl;
   *this->TestHandler->LogFile << this->TestProperties->Index << "/"
-    << this->TestHandler->TotalNumberOfTests
-    << " Test: " << this->TestProperties->Name << std::endl;
+                              << this->TestHandler->TotalNumberOfTests
+                              << " Test: " << this->TestProperties->Name
+                              << std::endl;
   *this->TestHandler->LogFile << "Command: \"" << this->ActualCommand << "\"";
 
   for (std::vector<std::string>::iterator i = this->Arguments.begin();
-       i != this->Arguments.end(); ++i)
-    {
-    *this->TestHandler->LogFile
-      << " \"" << *i << "\"";
-    }
-  *this->TestHandler->LogFile << std::endl
+       i != this->Arguments.end(); ++i) {
+    *this->TestHandler->LogFile << " \"" << *i << "\"";
+  }
+  *this->TestHandler->LogFile
+    << std::endl
     << "Directory: " << this->TestProperties->Directory << std::endl
-    << "\"" << this->TestProperties->Name << "\" start time: "
-    << this->StartTime << std::endl;
+    << "\"" << this->TestProperties->Name
+    << "\" start time: " << this->StartTime << std::endl;
 
   *this->TestHandler->LogFile
     << "Output:" << std::endl
     << "----------------------------------------------------------"
     << std::endl;
-  *this->TestHandler->LogFile
-    << this->ProcessOutput << "<end of output>" << std::endl;
+  *this->TestHandler->LogFile << this->ProcessOutput << "<end of output>"
+                              << std::endl;
 
   cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
-  cmCTestLog(this->CTest, DEBUG, "Testing "
-             << this->TestProperties->Name << " ... ");
+  cmCTestLog(this->CTest, DEBUG, "Testing " << this->TestProperties->Name
+                                            << " ... ");
 }
diff --git a/Source/CTest/cmCTestRunTest.h b/Source/CTest/cmCTestRunTest.h
index 5f3467a..3dcc026 100644
--- a/Source/CTest/cmCTestRunTest.h
+++ b/Source/CTest/cmCTestRunTest.h
@@ -27,13 +27,17 @@ public:
   cmCTestRunTest(cmCTestTestHandler* handler);
   ~cmCTestRunTest();
 
-  void SetNumberOfRuns(int n) {this->NumberOfRunsLeft = n;}
-  void SetRunUntilFailOn() { this->RunUntilFail = true;}
-  void SetTestProperties(cmCTestTestHandler::cmCTestTestProperties * prop)
-  { this->TestProperties = prop; }
-
-  cmCTestTestHandler::cmCTestTestProperties * GetTestProperties()
-  { return this->TestProperties; }
+  void SetNumberOfRuns(int n) { this->NumberOfRunsLeft = n; }
+  void SetRunUntilFailOn() { this->RunUntilFail = true; }
+  void SetTestProperties(cmCTestTestHandler::cmCTestTestProperties* prop)
+  {
+    this->TestProperties = prop;
+  }
+
+  cmCTestTestHandler::cmCTestTestProperties* GetTestProperties()
+  {
+    return this->TestProperties;
+  }
 
   void SetIndex(int i) { this->Index = i; }
 
@@ -44,7 +48,9 @@ public:
   bool IsStopTimePassed() { return this->StopTimePassed; }
 
   cmCTestTestHandler::cmCTestTestResult GetTestResults()
-  { return this->TestResult; }
+  {
+    return this->TestResult;
+  }
 
   // Read and store output.  Returns true if it must be called again.
   bool CheckOutput();
@@ -52,16 +58,17 @@ public:
   // Compresses the output, writing to CompressedOutput
   void CompressOutput();
 
-  //launch the test process, return whether it started correctly
+  // launch the test process, return whether it started correctly
   bool StartTest(size_t total);
-  //capture and report the test results
+  // capture and report the test results
   bool EndTest(size_t completed, size_t total, bool started);
-  //Called by ctest -N to log the command string
+  // Called by ctest -N to log the command string
   void ComputeArguments();
 
   void ComputeWeightedCost();
 
   bool StartAgain();
+
 private:
   bool NeedsToRerun();
   void DartProcessing();
@@ -71,18 +78,18 @@ private:
   bool ForkProcess(double testTimeOut, bool explicitTimeout,
                    std::vector<std::string>* environment);
   void WriteLogOutputTop(size_t completed, size_t total);
-  //Run post processing of the process output for MemCheck
+  // Run post processing of the process output for MemCheck
   void MemCheckPostProcess();
 
-  cmCTestTestHandler::cmCTestTestProperties * TestProperties;
-  //Pointer back to the "parent"; the handler that invoked this test run
-  cmCTestTestHandler * TestHandler;
-  cmCTest * CTest;
-  cmProcess * TestProcess;
-  //If the executable to run is ctest, don't create a new process;
-  //just instantiate a new cmTest.  (Can be disabled for a single test
-  //if this option is set to false.)
-  //bool OptimizeForCTest;
+  cmCTestTestHandler::cmCTestTestProperties* TestProperties;
+  // Pointer back to the "parent"; the handler that invoked this test run
+  cmCTestTestHandler* TestHandler;
+  cmCTest* CTest;
+  cmProcess* TestProcess;
+  // If the executable to run is ctest, don't create a new process;
+  // just instantiate a new cmTest.  (Can be disabled for a single test
+  // if this option is set to false.)
+  // bool OptimizeForCTest;
 
   bool UsePrefixCommand;
   std::string PrefixCommand;
@@ -90,7 +97,7 @@ private:
   std::string ProcessOutput;
   std::string CompressedOutput;
   double CompressionRatio;
-  //The test results
+  // The test results
   cmCTestTestHandler::cmCTestTestResult TestResult;
   int Index;
   std::string StartTime;
@@ -106,16 +113,13 @@ private:
 inline int getNumWidth(size_t n)
 {
   int numWidth = 1;
-  if(n >= 10)
-    {
+  if (n >= 10) {
     numWidth = 2;
-    }
-  if(n >= 100)
-    {
+  }
+  if (n >= 100) {
     numWidth = 3;
-    }
+  }
   return numWidth;
 }
 
 #endif
-
diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx
index 507ec29..a6885aa 100644
--- a/Source/CTest/cmCTestSVN.cxx
+++ b/Source/CTest/cmCTestSVN.cxx
@@ -18,13 +18,13 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-struct cmCTestSVN::Revision: public cmCTestVC::Revision
+struct cmCTestSVN::Revision : public cmCTestVC::Revision
 {
   cmCTestSVN::SVNInfo* SVNInfo;
 };
 
-cmCTestSVN::cmCTestSVN(cmCTest* ct, std::ostream& log):
-  cmCTestGlobalVC(ct, log)
+cmCTestSVN::cmCTestSVN(cmCTest* ct, std::ostream& log)
+  : cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
 }
@@ -42,20 +42,20 @@ void cmCTestSVN::CleanupImpl()
   this->RunSVNCommand(svn_cleanup, &out, &err);
 }
 
-class cmCTestSVN::InfoParser: public cmCTestVC::LineParser
+class cmCTestSVN::InfoParser : public cmCTestVC::LineParser
 {
 public:
-  InfoParser(cmCTestSVN* svn,
-             const char* prefix,
-             std::string& rev,
-             SVNInfo& svninfo):
-      Rev(rev), SVNRepo(svninfo)
-    {
+  InfoParser(cmCTestSVN* svn, const char* prefix, std::string& rev,
+             SVNInfo& svninfo)
+    : Rev(rev)
+    , SVNRepo(svninfo)
+  {
     this->SetLog(&svn->Log, prefix);
     this->RegexRev.compile("^Revision: ([0-9]+)");
     this->RegexURL.compile("^URL: +([^ ]+) *$");
     this->RegexRoot.compile("^Repository Root: +([^ ]+) *$");
-    }
+  }
+
 private:
   std::string& Rev;
   cmCTestSVN::SVNInfo& SVNRepo;
@@ -63,38 +63,28 @@ private:
   cmsys::RegularExpression RegexURL;
   cmsys::RegularExpression RegexRoot;
   virtual bool ProcessLine()
-    {
-    if(this->RegexRev.find(this->Line))
-      {
+  {
+    if (this->RegexRev.find(this->Line)) {
       this->Rev = this->RegexRev.match(1);
-      }
-    else if(this->RegexURL.find(this->Line))
-      {
+    } else if (this->RegexURL.find(this->Line)) {
       this->SVNRepo.URL = this->RegexURL.match(1);
-      }
-    else if(this->RegexRoot.find(this->Line))
-      {
+    } else if (this->RegexRoot.find(this->Line)) {
       this->SVNRepo.Root = this->RegexRoot.match(1);
-      }
-    return true;
     }
+    return true;
+  }
 };
 
 static bool cmCTestSVNPathStarts(std::string const& p1, std::string const& p2)
 {
   // Does path p1 start with path p2?
-  if(p1.size() == p2.size())
-    {
+  if (p1.size() == p2.size()) {
     return p1 == p2;
-    }
-  else if(p1.size() > p2.size() && p1[p2.size()] == '/')
-    {
+  } else if (p1.size() > p2.size() && p1[p2.size()] == '/') {
     return strncmp(p1.c_str(), p2.c_str(), p2.size()) == 0;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
 
 std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo)
@@ -113,7 +103,7 @@ std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo)
 void cmCTestSVN::NoteOldRevision()
 {
   // Info for root repository
-  this->Repositories.push_back( SVNInfo("") );
+  this->Repositories.push_back(SVNInfo(""));
   this->RootInfo = &(this->Repositories.back());
   // Info for the external repositories
   this->LoadExternals();
@@ -121,17 +111,15 @@ void cmCTestSVN::NoteOldRevision()
   // Get info for all the repositories
   std::list<SVNInfo>::iterator itbeg = this->Repositories.begin();
   std::list<SVNInfo>::iterator itend = this->Repositories.end();
-  for( ; itbeg != itend ; itbeg++)
-    {
+  for (; itbeg != itend; itbeg++) {
     SVNInfo& svninfo = *itbeg;
     svninfo.OldRevision = this->LoadInfo(svninfo);
     this->Log << "Revision for repository '" << svninfo.LocalPath
               << "' before update: " << svninfo.OldRevision << "\n";
-    cmCTestLog(this->CTest, HANDLER_OUTPUT,
-               "   Old revision of external repository '"
-               << svninfo.LocalPath << "' is: "
-               << svninfo.OldRevision << "\n");
-    }
+    cmCTestLog(
+      this->CTest, HANDLER_OUTPUT, "   Old revision of external repository '"
+        << svninfo.LocalPath << "' is: " << svninfo.OldRevision << "\n");
+  }
 
   // Set the global old revision to the one of the root
   this->OldRevision = this->RootInfo->OldRevision;
@@ -143,16 +131,14 @@ void cmCTestSVN::NoteNewRevision()
   // Get info for the external repositories
   std::list<SVNInfo>::iterator itbeg = this->Repositories.begin();
   std::list<SVNInfo>::iterator itend = this->Repositories.end();
-  for( ; itbeg != itend ; itbeg++)
-    {
+  for (; itbeg != itend; itbeg++) {
     SVNInfo& svninfo = *itbeg;
     svninfo.NewRevision = this->LoadInfo(svninfo);
     this->Log << "Revision for repository '" << svninfo.LocalPath
               << "' after update: " << svninfo.NewRevision << "\n";
-    cmCTestLog(this->CTest, HANDLER_OUTPUT,
-               "   New revision of external repository '"
-               << svninfo.LocalPath << "' is: "
-               << svninfo.NewRevision << "\n");
+    cmCTestLog(
+      this->CTest, HANDLER_OUTPUT, "   New revision of external repository '"
+        << svninfo.LocalPath << "' is: " << svninfo.NewRevision << "\n");
 
     // svninfo.Root = ""; // uncomment to test GuessBase
     this->Log << "Repository '" << svninfo.LocalPath
@@ -162,16 +148,14 @@ void cmCTestSVN::NoteNewRevision()
 
     // Compute the base path the working tree has checked out under
     // the repository root.
-    if(!svninfo.Root.empty()
-       && cmCTestSVNPathStarts(svninfo.URL, svninfo.Root))
-      {
-      svninfo.Base = cmCTest::DecodeURL(
-            svninfo.URL.substr(svninfo.Root.size()));
+    if (!svninfo.Root.empty() &&
+        cmCTestSVNPathStarts(svninfo.URL, svninfo.Root)) {
+      svninfo.Base =
+        cmCTest::DecodeURL(svninfo.URL.substr(svninfo.Root.size()));
       svninfo.Base += "/";
-      }
+    }
     this->Log << "Repository '" << svninfo.LocalPath
               << "' Base = " << svninfo.Base << "\n";
-
   }
 
   // Set the global new revision to the one of the root
@@ -186,21 +170,18 @@ void cmCTestSVN::GuessBase(SVNInfo& svninfo,
   // changes under it.
 
   // Consider each possible URL suffix from longest to shortest.
-  for(std::string::size_type slash = svninfo.URL.find('/');
-      svninfo.Base.empty() && slash != std::string::npos;
-      slash = svninfo.URL.find('/', slash+1))
-    {
+  for (std::string::size_type slash = svninfo.URL.find('/');
+       svninfo.Base.empty() && slash != std::string::npos;
+       slash = svninfo.URL.find('/', slash + 1)) {
     // If the URL suffix is a prefix of at least one path then it is the base.
     std::string base = cmCTest::DecodeURL(svninfo.URL.substr(slash));
-    for(std::vector<Change>::const_iterator ci = changes.begin();
-        svninfo.Base.empty() && ci != changes.end(); ++ci)
-      {
-      if(cmCTestSVNPathStarts(ci->Path, base))
-        {
+    for (std::vector<Change>::const_iterator ci = changes.begin();
+         svninfo.Base.empty() && ci != changes.end(); ++ci) {
+      if (cmCTestSVNPathStarts(ci->Path, base)) {
         svninfo.Base = base;
-        }
       }
     }
+  }
 
   // We always append a slash so that we know paths beginning in the
   // base lie under its path.  If no base was found then the working
@@ -211,76 +192,76 @@ void cmCTestSVN::GuessBase(SVNInfo& svninfo,
   this->Log << "Guessed Base = " << svninfo.Base << "\n";
 }
 
-class cmCTestSVN::UpdateParser: public cmCTestVC::LineParser
+class cmCTestSVN::UpdateParser : public cmCTestVC::LineParser
 {
 public:
-  UpdateParser(cmCTestSVN* svn, const char* prefix): SVN(svn)
-    {
+  UpdateParser(cmCTestSVN* svn, const char* prefix)
+    : SVN(svn)
+  {
     this->SetLog(&svn->Log, prefix);
     this->RegexUpdate.compile("^([ADUCGE ])([ADUCGE ])[B ] +(.+)$");
-    }
+  }
+
 private:
   cmCTestSVN* SVN;
   cmsys::RegularExpression RegexUpdate;
 
   bool ProcessLine()
-    {
-    if(this->RegexUpdate.find(this->Line))
-      {
+  {
+    if (this->RegexUpdate.find(this->Line)) {
       this->DoPath(this->RegexUpdate.match(1)[0],
-                   this->RegexUpdate.match(2)[0],
-                   this->RegexUpdate.match(3));
-      }
-    return true;
+                   this->RegexUpdate.match(2)[0], this->RegexUpdate.match(3));
     }
+    return true;
+  }
 
   void DoPath(char path_status, char prop_status, std::string const& path)
-    {
-    char status = (path_status != ' ')? path_status : prop_status;
+  {
+    char status = (path_status != ' ') ? path_status : prop_status;
     std::string dir = cmSystemTools::GetFilenamePath(path);
     std::string name = cmSystemTools::GetFilenameName(path);
     // See "svn help update".
-    switch(status)
-      {
+    switch (status) {
       case 'G':
         this->SVN->Dirs[dir][name].Status = PathModified;
         break;
       case 'C':
         this->SVN->Dirs[dir][name].Status = PathConflicting;
         break;
-      case 'A': case 'D': case 'U':
+      case 'A':
+      case 'D':
+      case 'U':
         this->SVN->Dirs[dir][name].Status = PathUpdated;
         break;
       case 'E': // TODO?
-      case '?': case ' ': default:
+      case '?':
+      case ' ':
+      default:
         break;
-      }
     }
+  }
 };
 
 bool cmCTestSVN::UpdateImpl()
 {
   // Get user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
-  if(opts.empty())
-    {
+  if (opts.empty()) {
     opts = this->CTest->GetCTestConfiguration("SVNUpdateOptions");
-    }
+  }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());
 
   // Specify the start time for nightly testing.
-  if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)
-    {
+  if (this->CTest->GetTestModel() == cmCTest::NIGHTLY) {
     args.push_back("-r{" + this->GetNightlyTime() + " +0000}");
-    }
+  }
 
   std::vector<char const*> svn_update;
   svn_update.push_back("update");
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     svn_update.push_back(ai->c_str());
-    }
+  }
 
   UpdateParser out(this, "up-out> ");
   OutputLogger err(this->Log, "up-err> ");
@@ -288,9 +269,10 @@ bool cmCTestSVN::UpdateImpl()
 }
 
 bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
-    OutputParser* out, OutputParser* err)
+                               OutputParser* out, OutputParser* err)
 {
-  if(parameters.empty()) return false;
+  if (parameters.empty())
+    return false;
 
   std::vector<char const*> args;
   args.push_back(this->CommandLineTool.c_str());
@@ -299,36 +281,35 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters,
 
   args.push_back("--non-interactive");
 
-  std::string userOptions =
-    this->CTest->GetCTestConfiguration("SVNOptions");
+  std::string userOptions = this->CTest->GetCTestConfiguration("SVNOptions");
 
   std::vector<std::string> parsedUserOptions =
     cmSystemTools::ParseArguments(userOptions.c_str());
-  for(std::vector<std::string>::iterator i = parsedUserOptions.begin();
-      i != parsedUserOptions.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = parsedUserOptions.begin();
+       i != parsedUserOptions.end(); ++i) {
     args.push_back(i->c_str());
-    }
+  }
 
   args.push_back(0);
 
-  if(strcmp(parameters[0], "update") == 0)
-    {
+  if (strcmp(parameters[0], "update") == 0) {
     return RunUpdateCommand(&args[0], out, err);
-    }
-  else
-    {
+  } else {
     return RunChild(&args[0], out, err);
-    }
+  }
 }
 
-class cmCTestSVN::LogParser: public cmCTestVC::OutputLogger,
-                             private cmXMLParser
+class cmCTestSVN::LogParser : public cmCTestVC::OutputLogger,
+                              private cmXMLParser
 {
 public:
-  LogParser(cmCTestSVN* svn, const char* prefix, SVNInfo& svninfo):
-    OutputLogger(svn->Log, prefix), SVN(svn), SVNRepo(svninfo)
-  { this->InitializeParser(); }
+  LogParser(cmCTestSVN* svn, const char* prefix, SVNInfo& svninfo)
+    : OutputLogger(svn->Log, prefix)
+    , SVN(svn)
+    , SVNRepo(svninfo)
+  {
+    this->InitializeParser();
+  }
   ~LogParser() { this->CleanupParser(); }
 private:
   cmCTestSVN* SVN;
@@ -342,72 +323,58 @@ private:
   std::vector<char> CData;
 
   virtual bool ProcessChunk(const char* data, int length)
-    {
+  {
     this->OutputLogger::ProcessChunk(data, length);
     this->ParseChunk(data, length);
     return true;
-    }
+  }
 
   virtual void StartElement(const std::string& name, const char** atts)
-    {
+  {
     this->CData.clear();
-    if(name == "logentry")
-      {
+    if (name == "logentry") {
       this->Rev = Revision();
       this->Rev.SVNInfo = &SVNRepo;
-      if(const char* rev = this->FindAttribute(atts, "revision"))
-        {
+      if (const char* rev = this->FindAttribute(atts, "revision")) {
         this->Rev.Rev = rev;
-        }
-      this->Changes.clear();
       }
-    else if(name == "path")
-      {
+      this->Changes.clear();
+    } else if (name == "path") {
       this->CurChange = Change();
-      if(const char* action = this->FindAttribute(atts, "action"))
-        {
+      if (const char* action = this->FindAttribute(atts, "action")) {
         this->CurChange.Action = action[0];
-        }
       }
     }
+  }
 
   virtual void CharacterDataHandler(const char* data, int length)
-    {
-    this->CData.insert(this->CData.end(), data, data+length);
-    }
+  {
+    this->CData.insert(this->CData.end(), data, data + length);
+  }
 
   virtual void EndElement(const std::string& name)
-    {
-    if(name == "logentry")
-      {
+  {
+    if (name == "logentry") {
       this->SVN->DoRevisionSVN(this->Rev, this->Changes);
-      }
-    else if(!this->CData.empty() && name == "path")
-      {
+    } else if (!this->CData.empty() && name == "path") {
       std::string orig_path(&this->CData[0], this->CData.size());
-      std::string new_path = SVNRepo.BuildLocalPath( orig_path );
+      std::string new_path = SVNRepo.BuildLocalPath(orig_path);
       this->CurChange.Path.assign(new_path);
       this->Changes.push_back(this->CurChange);
-      }
-    else if(!this->CData.empty() && name == "author")
-      {
+    } else if (!this->CData.empty() && name == "author") {
       this->Rev.Author.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "date")
-      {
+    } else if (!this->CData.empty() && name == "date") {
       this->Rev.Date.assign(&this->CData[0], this->CData.size());
-      }
-    else if(!this->CData.empty() && name == "msg")
-      {
+    } else if (!this->CData.empty() && name == "msg") {
       this->Rev.Log.assign(&this->CData[0], this->CData.size());
-      }
-    this->CData.clear();
     }
+    this->CData.clear();
+  }
 
   virtual void ReportError(int, int, const char* msg)
-    {
+  {
     this->SVN->Log << "Error parsing svn log xml: " << msg << "\n";
-    }
+  }
 };
 
 void cmCTestSVN::LoadRevisions()
@@ -415,25 +382,21 @@ void cmCTestSVN::LoadRevisions()
   // Get revisions for all the external repositories
   std::list<SVNInfo>::iterator itbeg = this->Repositories.begin();
   std::list<SVNInfo>::iterator itend = this->Repositories.end();
-  for( ; itbeg != itend ; itbeg++)
-    {
+  for (; itbeg != itend; itbeg++) {
     SVNInfo& svninfo = *itbeg;
     LoadRevisions(svninfo);
-    }
+  }
 }
 
-void cmCTestSVN::LoadRevisions(SVNInfo &svninfo)
+void cmCTestSVN::LoadRevisions(SVNInfo& svninfo)
 {
   // We are interested in every revision included in the update.
   std::string revs;
-  if(atoi(svninfo.OldRevision.c_str()) < atoi(svninfo.NewRevision.c_str()))
-    {
+  if (atoi(svninfo.OldRevision.c_str()) < atoi(svninfo.NewRevision.c_str())) {
     revs = "-r" + svninfo.OldRevision + ":" + svninfo.NewRevision;
-    }
-  else
-    {
+  } else {
     revs = "-r" + svninfo.NewRevision;
-    }
+  }
 
   // Run "svn log" to get all global revisions of interest.
   std::vector<const char*> svn_log;
@@ -451,59 +414,65 @@ void cmCTestSVN::DoRevisionSVN(Revision const& revision,
                                std::vector<Change> const& changes)
 {
   // Guess the base checkout path from the changes if necessary.
-  if(this->RootInfo->Base.empty() && !changes.empty())
-    {
+  if (this->RootInfo->Base.empty() && !changes.empty()) {
     this->GuessBase(*this->RootInfo, changes);
-    }
+  }
 
   // Ignore changes in the old revision for external repositories
-  if(revision.Rev == revision.SVNInfo->OldRevision
-     && revision.SVNInfo->LocalPath != "")
-    {
+  if (revision.Rev == revision.SVNInfo->OldRevision &&
+      revision.SVNInfo->LocalPath != "") {
     return;
-    }
+  }
 
   this->cmCTestGlobalVC::DoRevision(revision, changes);
 }
 
-class cmCTestSVN::StatusParser: public cmCTestVC::LineParser
+class cmCTestSVN::StatusParser : public cmCTestVC::LineParser
 {
 public:
-  StatusParser(cmCTestSVN* svn, const char* prefix): SVN(svn)
-    {
+  StatusParser(cmCTestSVN* svn, const char* prefix)
+    : SVN(svn)
+  {
     this->SetLog(&svn->Log, prefix);
     this->RegexStatus.compile("^([ACDIMRX?!~ ])([CM ])[ L]... +(.+)$");
-    }
+  }
+
 private:
   cmCTestSVN* SVN;
   cmsys::RegularExpression RegexStatus;
   bool ProcessLine()
-    {
-    if(this->RegexStatus.find(this->Line))
-      {
+  {
+    if (this->RegexStatus.find(this->Line)) {
       this->DoPath(this->RegexStatus.match(1)[0],
-                   this->RegexStatus.match(2)[0],
-                   this->RegexStatus.match(3));
-      }
-    return true;
+                   this->RegexStatus.match(2)[0], this->RegexStatus.match(3));
     }
+    return true;
+  }
 
   void DoPath(char path_status, char prop_status, std::string const& path)
-    {
-    char status = (path_status != ' ')? path_status : prop_status;
+  {
+    char status = (path_status != ' ') ? path_status : prop_status;
     // See "svn help status".
-    switch(status)
-      {
-      case 'M': case '!': case 'A': case 'D': case 'R':
+    switch (status) {
+      case 'M':
+      case '!':
+      case 'A':
+      case 'D':
+      case 'R':
         this->SVN->DoModification(PathModified, path);
         break;
-      case 'C': case '~':
+      case 'C':
+      case '~':
         this->SVN->DoModification(PathConflicting, path);
         break;
-      case 'X': case 'I': case '?': case ' ': default:
+      case 'X':
+      case 'I':
+      case '?':
+      case ' ':
+      default:
         break;
-      }
     }
+  }
 };
 
 void cmCTestSVN::LoadModifications()
@@ -523,42 +492,40 @@ void cmCTestSVN::WriteXMLGlobal(cmXMLWriter& xml)
   xml.Element("SVNPath", this->RootInfo->Base);
 }
 
-class cmCTestSVN::ExternalParser: public cmCTestVC::LineParser
+class cmCTestSVN::ExternalParser : public cmCTestVC::LineParser
 {
 public:
-  ExternalParser(cmCTestSVN* svn, const char* prefix): SVN(svn)
-    {
+  ExternalParser(cmCTestSVN* svn, const char* prefix)
+    : SVN(svn)
+  {
     this->SetLog(&svn->Log, prefix);
     this->RegexExternal.compile("^X..... +(.+)$");
-    }
+  }
+
 private:
   cmCTestSVN* SVN;
   cmsys::RegularExpression RegexExternal;
   bool ProcessLine()
-    {
-    if(this->RegexExternal.find(this->Line))
-      {
+  {
+    if (this->RegexExternal.find(this->Line)) {
       this->DoPath(this->RegexExternal.match(1));
-      }
-    return true;
     }
+    return true;
+  }
 
   void DoPath(std::string const& path)
-    {
+  {
     // Get local path relative to the source directory
     std::string local_path;
-    if(path.size() > this->SVN->SourceDirectory.size() &&
-       strncmp(path.c_str(), this->SVN->SourceDirectory.c_str(),
-               this->SVN->SourceDirectory.size()) == 0)
-      {
+    if (path.size() > this->SVN->SourceDirectory.size() &&
+        strncmp(path.c_str(), this->SVN->SourceDirectory.c_str(),
+                this->SVN->SourceDirectory.size()) == 0) {
       local_path = path.c_str() + this->SVN->SourceDirectory.size() + 1;
-      }
-    else
-      {
+    } else {
       local_path = path;
-      }
-    this->SVN->Repositories.push_back( SVNInfo(local_path.c_str()) );
     }
+    this->SVN->Repositories.push_back(SVNInfo(local_path.c_str()));
+  }
 };
 
 void cmCTestSVN::LoadExternals()
@@ -576,20 +543,16 @@ std::string cmCTestSVN::SVNInfo::BuildLocalPath(std::string const& path) const
   std::string local_path;
 
   // Add local path prefix if not empty
-  if (!this->LocalPath.empty())
-    {
+  if (!this->LocalPath.empty()) {
     local_path += this->LocalPath;
     local_path += "/";
-    }
+  }
 
   // Add path with base prefix removed
-  if(path.size() > this->Base.size() &&
-     strncmp(path.c_str(), this->Base.c_str(), this->Base.size()) == 0)
-    {
+  if (path.size() > this->Base.size() &&
+      strncmp(path.c_str(), this->Base.c_str(), this->Base.size()) == 0) {
     local_path += (path.c_str() + this->Base.size());
-    }
-  else
-    {
+  } else {
     local_path += path;
   }
 
diff --git a/Source/CTest/cmCTestSVN.h b/Source/CTest/cmCTestSVN.h
index f9febc5..e596bdc 100644
--- a/Source/CTest/cmCTestSVN.h
+++ b/Source/CTest/cmCTestSVN.h
@@ -20,7 +20,7 @@
  * \brief Interaction with subversion command-line tool
  *
  */
-class cmCTestSVN: public cmCTestGlobalVC
+class cmCTestSVN : public cmCTestGlobalVC
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
@@ -36,12 +36,16 @@ private:
   virtual bool UpdateImpl();
 
   bool RunSVNCommand(std::vector<char const*> const& parameters,
-    OutputParser* out, OutputParser* err);
+                     OutputParser* out, OutputParser* err);
 
   // Information about an SVN repository (root repository or external)
-  struct SVNInfo {
+  struct SVNInfo
+  {
 
-    SVNInfo(const char* path) : LocalPath(path) {}
+    SVNInfo(const char* path)
+      : LocalPath(path)
+    {
+    }
     // Remove base from the filename
     std::string BuildLocalPath(std::string const& path) const;
 
@@ -60,7 +64,6 @@ private:
     // Old and new repository revisions.
     std::string OldRevision;
     std::string NewRevision;
-
   };
 
   // Extended revision structure to include info about external it refers to.
@@ -79,7 +82,7 @@ private:
   void LoadRevisions();
   void LoadRevisions(SVNInfo& svninfo);
 
-  void GuessBase(SVNInfo &svninfo, std::vector<Change> const& changes);
+  void GuessBase(SVNInfo& svninfo, std::vector<Change> const& changes);
 
   void DoRevisionSVN(Revision const& revision,
                      std::vector<Change> const& changes);
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index bde7a6d..0c09cc7 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -35,7 +35,7 @@
 
 // needed for sleep
 #if !defined(_WIN32)
-# include <unistd.h>
+#include <unistd.h>
 #endif
 
 #include "cmCTestBuildCommand.h"
@@ -60,19 +60,18 @@ class cmCTestScriptFunctionBlocker : public cmFunctionBlocker
 public:
   cmCTestScriptFunctionBlocker() {}
   virtual ~cmCTestScriptFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
-                                 cmMakefile &mf,
-                                 cmExecutionStatus &);
-  //virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
-  //virtual void ScopeEnded(cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                                 cmExecutionStatus&);
+  // virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
+  // virtual void ScopeEnded(cmMakefile &mf);
 
   cmCTestScriptHandler* CTestScriptHandler;
 };
 
 // simply update the time and don't block anything
-bool cmCTestScriptFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& , cmMakefile &,
-                  cmExecutionStatus &)
+bool cmCTestScriptFunctionBlocker::IsFunctionBlocked(const cmListFileFunction&,
+                                                     cmMakefile&,
+                                                     cmExecutionStatus&)
 {
   this->CTestScriptHandler->UpdateElapsedTime();
   return false;
@@ -90,7 +89,7 @@ cmCTestScriptHandler::cmCTestScriptHandler()
   this->ScriptStartTime = 0;
 
   // the *60 is becuase the settings are in minutes but GetTime is seconds
-  this->MinimumInterval = 30*60;
+  this->MinimumInterval = 30 * 60;
   this->ContinuousDuration = -1;
 }
 
@@ -115,7 +114,7 @@ void cmCTestScriptHandler::Initialize()
   this->CMOutFile = "";
   this->ExtraUpdates.clear();
 
-  this->MinimumInterval = 20*60;
+  this->MinimumInterval = 20 * 60;
   this->ContinuousDuration = -1;
 
   // what time in seconds did this script start running
@@ -137,46 +136,41 @@ cmCTestScriptHandler::~cmCTestScriptHandler()
   delete this->CMake;
 }
 
-
 // just adds an argument to the vector
-void cmCTestScriptHandler::AddConfigurationScript(const char *script,
+void cmCTestScriptHandler::AddConfigurationScript(const char* script,
                                                   bool pscope)
 {
   this->ConfigurationScripts.push_back(script);
   this->ScriptProcessScope.push_back(pscope);
 }
 
-
 // the generic entry point for handling scripts, this routine will run all
 // the scripts provides a -S arguments
 int cmCTestScriptHandler::ProcessHandler()
 {
   int res = 0;
-  for (size_t i=0; i <  this->ConfigurationScripts.size(); ++i)
-    {
+  for (size_t i = 0; i < this->ConfigurationScripts.size(); ++i) {
     // for each script run it
-    res |= this->RunConfigurationScript
-      (cmSystemTools::CollapseFullPath(this->ConfigurationScripts[i]),
-       this->ScriptProcessScope[i]);
-    }
-  if ( res )
-    {
+    res |= this->RunConfigurationScript(
+      cmSystemTools::CollapseFullPath(this->ConfigurationScripts[i]),
+      this->ScriptProcessScope[i]);
+  }
+  if (res) {
     return -1;
-    }
+  }
   return 0;
 }
 
 void cmCTestScriptHandler::UpdateElapsedTime()
 {
-  if (this->Makefile)
-    {
+  if (this->Makefile) {
     // set the current elapsed time
     char timeString[20];
-    int itime = static_cast<unsigned int>(cmSystemTools::GetTime()
-                                          - this->ScriptStartTime);
-    sprintf(timeString,"%i",itime);
+    int itime = static_cast<unsigned int>(cmSystemTools::GetTime() -
+                                          this->ScriptStartTime);
+    sprintf(timeString, "%i", itime);
     this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString);
-    }
+  }
 }
 
 void cmCTestScriptHandler::AddCTestCommand(cmCTestCommand* command)
@@ -196,115 +190,97 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
   argv.push_back("-SR");
   argv.push_back(total_script_arg.c_str());
 
-  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-             "Executable for CTest is: " <<
-             cmSystemTools::GetCTestCommand() << "\n");
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Executable for CTest is: "
+               << cmSystemTools::GetCTestCommand() << "\n");
 
   // now pass through all the other arguments
-  std::vector<std::string> &initArgs =
+  std::vector<std::string>& initArgs =
     this->CTest->GetInitialCommandLineArguments();
   //*** need to make sure this does not have the current script ***
-  for(size_t i=1; i < initArgs.size(); ++i)
-    {
+  for (size_t i = 1; i < initArgs.size(); ++i) {
     argv.push_back(initArgs[i].c_str());
-    }
+  }
   argv.push_back(0);
 
   // Now create process object
   cmsysProcess* cp = cmsysProcess_New();
   cmsysProcess_SetCommand(cp, &*argv.begin());
-  //cmsysProcess_SetWorkingDirectory(cp, dir);
+  // cmsysProcess_SetWorkingDirectory(cp, dir);
   cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
-  //cmsysProcess_SetTimeout(cp, timeout);
+  // cmsysProcess_SetTimeout(cp, timeout);
   cmsysProcess_Execute(cp);
 
   std::vector<char> out;
   std::vector<char> err;
   std::string line;
   int pipe = cmSystemTools::WaitForLine(cp, line, 100.0, out, err);
-  while(pipe != cmsysProcess_Pipe_None)
-    {
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Output: "
-               << line << "\n");
-    if(pipe == cmsysProcess_Pipe_STDERR)
-      {
+  while (pipe != cmsysProcess_Pipe_None) {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Output: " << line
+                                                               << "\n");
+    if (pipe == cmsysProcess_Pipe_STDERR) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, line << "\n");
-      }
-    else if(pipe == cmsysProcess_Pipe_STDOUT)
-      {
+    } else if (pipe == cmsysProcess_Pipe_STDOUT) {
       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, line << "\n");
-      }
-    pipe = cmSystemTools::WaitForLine(cp, line, 100, out, err);
     }
+    pipe = cmSystemTools::WaitForLine(cp, line, 100, out, err);
+  }
 
   // Properly handle output of the build command
   cmsysProcess_WaitForExit(cp, 0);
   int result = cmsysProcess_GetState(cp);
   int retVal = 0;
   bool failed = false;
-  if(result == cmsysProcess_State_Exited)
-    {
+  if (result == cmsysProcess_State_Exited) {
     retVal = cmsysProcess_GetExitValue(cp);
-    }
-  else if(result == cmsysProcess_State_Exception)
-    {
+  } else if (result == cmsysProcess_State_Exception) {
     retVal = cmsysProcess_GetExitException(cp);
     cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was an exception: "
-               << cmsysProcess_GetExceptionString(cp) << " " <<
-               retVal << std::endl);
+                 << cmsysProcess_GetExceptionString(cp) << " " << retVal
+                 << std::endl);
     failed = true;
-    }
-  else if(result == cmsysProcess_State_Expired)
-    {
+  } else if (result == cmsysProcess_State_Expired) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
-               << std::endl);
+                 << std::endl);
     failed = true;
-    }
-  else if(result == cmsysProcess_State_Error)
-    {
+  } else if (result == cmsysProcess_State_Error) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing ctest: "
-               << cmsysProcess_GetErrorString(cp) << std::endl);
+                 << cmsysProcess_GetErrorString(cp) << std::endl);
     failed = true;
-    }
+  }
   cmsysProcess_Delete(cp);
-  if(failed)
-    {
+  if (failed) {
     std::ostringstream message;
     message << "Error running command: [";
     message << result << "] ";
-    for(std::vector<const char*>::iterator i = argv.begin();
-        i != argv.end(); ++i)
-      {
-      if(*i)
-        {
-        message  << *i << " ";
-        }
+    for (std::vector<const char*>::iterator i = argv.begin(); i != argv.end();
+         ++i) {
+      if (*i) {
+        message << *i << " ";
       }
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               message.str() << argv[0] << std::endl);
-    return -1;
     }
+    cmCTestLog(this->CTest, ERROR_MESSAGE, message.str() << argv[0]
+                                                         << std::endl);
+    return -1;
+  }
   return retVal;
 }
 
-static void ctestScriptProgressCallback(const char *m, float, void* cd)
+static void ctestScriptProgressCallback(const char* m, float, void* cd)
 {
   cmCTest* ctest = static_cast<cmCTest*>(cd);
-  if(m && *m)
-    {
+  if (m && *m) {
     cmCTestLog(ctest, HANDLER_OUTPUT, "-- " << m << std::endl);
-    }
+  }
 }
 
 void cmCTestScriptHandler::CreateCMake()
 {
   // create a cmake instance to read the configuration script
-  if (this->CMake)
-    {
+  if (this->CMake) {
     delete this->CMake;
     delete this->GlobalGenerator;
     delete this->Makefile;
-    }
+  }
   this->CMake = new cmake;
   this->CMake->SetHomeDirectory("");
   this->CMake->SetHomeOutputDirectory("");
@@ -354,27 +330,25 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
   // passed into the scripts as S_ARG
   std::string script = total_script_arg;
   std::string script_arg;
-  if (total_script_arg.find(",") != std::string::npos)
-    {
-    script = total_script_arg.substr(0,total_script_arg.find(","));
-    script_arg = total_script_arg.substr(total_script_arg.find(",")+1);
-    }
+  if (total_script_arg.find(",") != std::string::npos) {
+    script = total_script_arg.substr(0, total_script_arg.find(","));
+    script_arg = total_script_arg.substr(total_script_arg.find(",") + 1);
+  }
   // make sure the file exists
-  if (!cmSystemTools::FileExists(script.c_str()))
-    {
+  if (!cmSystemTools::FileExists(script.c_str())) {
     cmSystemTools::Error("Cannot find file: ", script.c_str());
     return 1;
-    }
+  }
 
   // read in the list file to fill the cache
   // create a cmake instance to read the configuration script
   this->CreateCMake();
 
   // set a variable with the path to the current script
-  this->Makefile->AddDefinition("CTEST_SCRIPT_DIRECTORY",
-                            cmSystemTools::GetFilenamePath(script).c_str());
-  this->Makefile->AddDefinition("CTEST_SCRIPT_NAME",
-                            cmSystemTools::GetFilenameName(script).c_str());
+  this->Makefile->AddDefinition(
+    "CTEST_SCRIPT_DIRECTORY", cmSystemTools::GetFilenamePath(script).c_str());
+  this->Makefile->AddDefinition(
+    "CTEST_SCRIPT_NAME", cmSystemTools::GetFilenameName(script).c_str());
   this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
                                 cmSystemTools::GetCTestCommand().c_str());
   this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
@@ -383,59 +357,53 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
   this->UpdateElapsedTime();
 
   // add the script arg if defined
-  if (!script_arg.empty())
-    {
+  if (!script_arg.empty()) {
     this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg.c_str());
-    }
+  }
 
 #if defined(__CYGWIN__)
   this->Makefile->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0");
 #endif
 
   // always add a function blocker to update the elapsed time
-  cmCTestScriptFunctionBlocker *f = new cmCTestScriptFunctionBlocker();
+  cmCTestScriptFunctionBlocker* f = new cmCTestScriptFunctionBlocker();
   f->CTestScriptHandler = this;
   this->Makefile->AddFunctionBlocker(f);
 
-
   /* Execute CTestScriptMode.cmake, which loads CMakeDetermineSystem and
   CMakeSystemSpecificInformation, so
   that variables like CMAKE_SYSTEM and also the search paths for libraries,
   header and executables are set correctly and can be used. Makes new-style
   ctest scripting easier. */
   std::string systemFile =
-      this->Makefile->GetModulesFile("CTestScriptMode.cmake");
+    this->Makefile->GetModulesFile("CTestScriptMode.cmake");
   if (!this->Makefile->ReadListFile(systemFile.c_str()) ||
-      cmSystemTools::GetErrorOccuredFlag())
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in read:"
-               << systemFile << "\n");
+      cmSystemTools::GetErrorOccuredFlag()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in read:" << systemFile
+                                                            << "\n");
     return 2;
-    }
+  }
 
   // Add definitions of variables passed in on the command line:
-  const std::map<std::string, std::string> &defs =
+  const std::map<std::string, std::string>& defs =
     this->CTest->GetDefinitions();
   for (std::map<std::string, std::string>::const_iterator it = defs.begin();
-       it != defs.end(); ++it)
-    {
+       it != defs.end(); ++it) {
     this->Makefile->AddDefinition(it->first, it->second.c_str());
-    }
+  }
 
   // finally read in the script
   if (!this->Makefile->ReadListFile(script.c_str()) ||
-    cmSystemTools::GetErrorOccuredFlag())
-    {
+      cmSystemTools::GetErrorOccuredFlag()) {
     // Reset the error flag so that it can run more than
     // one script with an error when you use ctest_run_script.
     cmSystemTools::ResetErrorOccuredFlag();
     return 2;
-    }
+  }
 
   return 0;
 }
 
-
 // extract variabels from the script to set ivars
 int cmCTestScriptHandler::ExtractVariables()
 {
@@ -443,80 +411,64 @@ int cmCTestScriptHandler::ExtractVariables()
   const char* minInterval;
   const char* contDuration;
 
-  this->SourceDir
-    = this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
-  this->BinaryDir
-    = this->Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
+  this->SourceDir =
+    this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
+  this->BinaryDir =
+    this->Makefile->GetSafeDefinition("CTEST_BINARY_DIRECTORY");
 
   // add in translations for src and bin
   cmSystemTools::AddKeepPath(this->SourceDir);
   cmSystemTools::AddKeepPath(this->BinaryDir);
 
-  this->CTestCmd
-    = this->Makefile->GetSafeDefinition("CTEST_COMMAND");
-  this->CVSCheckOut
-    = this->Makefile->GetSafeDefinition("CTEST_CVS_CHECKOUT");
-  this->CTestRoot
-    = this->Makefile->GetSafeDefinition("CTEST_DASHBOARD_ROOT");
-  this->UpdateCmd
-    = this->Makefile->GetSafeDefinition("CTEST_UPDATE_COMMAND");
-  if ( this->UpdateCmd.empty() )
-    {
-    this->UpdateCmd
-      = this->Makefile->GetSafeDefinition("CTEST_CVS_COMMAND");
-    }
-  this->CTestEnv
-    = this->Makefile->GetSafeDefinition("CTEST_ENVIRONMENT");
-  this->InitialCache
-    = this->Makefile->GetSafeDefinition("CTEST_INITIAL_CACHE");
-  this->CMakeCmd
-    = this->Makefile->GetSafeDefinition("CTEST_CMAKE_COMMAND");
-  this->CMOutFile
-    = this->Makefile->GetSafeDefinition("CTEST_CMAKE_OUTPUT_FILE_NAME");
-
-  this->Backup
-    = this->Makefile->IsOn("CTEST_BACKUP_AND_RESTORE");
-  this->EmptyBinDir
-    = this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY");
-  this->EmptyBinDirOnce
-    = this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE");
-
-  minInterval
-    = this->Makefile->GetDefinition("CTEST_CONTINUOUS_MINIMUM_INTERVAL");
-  contDuration
-    = this->Makefile->GetDefinition("CTEST_CONTINUOUS_DURATION");
+  this->CTestCmd = this->Makefile->GetSafeDefinition("CTEST_COMMAND");
+  this->CVSCheckOut = this->Makefile->GetSafeDefinition("CTEST_CVS_CHECKOUT");
+  this->CTestRoot = this->Makefile->GetSafeDefinition("CTEST_DASHBOARD_ROOT");
+  this->UpdateCmd = this->Makefile->GetSafeDefinition("CTEST_UPDATE_COMMAND");
+  if (this->UpdateCmd.empty()) {
+    this->UpdateCmd = this->Makefile->GetSafeDefinition("CTEST_CVS_COMMAND");
+  }
+  this->CTestEnv = this->Makefile->GetSafeDefinition("CTEST_ENVIRONMENT");
+  this->InitialCache =
+    this->Makefile->GetSafeDefinition("CTEST_INITIAL_CACHE");
+  this->CMakeCmd = this->Makefile->GetSafeDefinition("CTEST_CMAKE_COMMAND");
+  this->CMOutFile =
+    this->Makefile->GetSafeDefinition("CTEST_CMAKE_OUTPUT_FILE_NAME");
+
+  this->Backup = this->Makefile->IsOn("CTEST_BACKUP_AND_RESTORE");
+  this->EmptyBinDir =
+    this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY");
+  this->EmptyBinDirOnce =
+    this->Makefile->IsOn("CTEST_START_WITH_EMPTY_BINARY_DIRECTORY_ONCE");
+
+  minInterval =
+    this->Makefile->GetDefinition("CTEST_CONTINUOUS_MINIMUM_INTERVAL");
+  contDuration = this->Makefile->GetDefinition("CTEST_CONTINUOUS_DURATION");
 
   char updateVar[40];
   int i;
-  for (i = 1; i < 10; ++i)
-    {
-    sprintf(updateVar,"CTEST_EXTRA_UPDATES_%i",i);
-    const char *updateVal = this->Makefile->GetDefinition(updateVar);
-    if ( updateVal )
-      {
-      if ( this->UpdateCmd.empty() )
-        {
-        cmSystemTools::Error(updateVar,
-          " specified without specifying CTEST_CVS_COMMAND.");
+  for (i = 1; i < 10; ++i) {
+    sprintf(updateVar, "CTEST_EXTRA_UPDATES_%i", i);
+    const char* updateVal = this->Makefile->GetDefinition(updateVar);
+    if (updateVal) {
+      if (this->UpdateCmd.empty()) {
+        cmSystemTools::Error(
+          updateVar, " specified without specifying CTEST_CVS_COMMAND.");
         return 12;
-        }
-      this->ExtraUpdates.push_back(updateVal);
       }
+      this->ExtraUpdates.push_back(updateVal);
     }
+  }
 
   // in order to backup and restore we also must have the cvs root
-  if (this->Backup && this->CVSCheckOut.empty())
-    {
+  if (this->Backup && this->CVSCheckOut.empty()) {
     cmSystemTools::Error(
       "Backup was requested without specifying CTEST_CVS_CHECKOUT.");
     return 3;
-    }
+  }
 
   // make sure the required info is here
-  if (this->SourceDir.empty() ||
-      this->BinaryDir.empty() ||
-      this->CTestCmd.empty())
-    {
+  if (this->SourceDir.empty() || this->BinaryDir.empty() ||
+      this->CTestCmd.empty()) {
     std::string msg = "CTEST_SOURCE_DIRECTORY = ";
     msg += (!this->SourceDir.empty()) ? this->SourceDir.c_str() : "(Null)";
     msg += "\nCTEST_BINARY_DIRECTORY = ";
@@ -527,25 +479,21 @@ int cmCTestScriptHandler::ExtractVariables()
       "Some required settings in the configuration file were missing:\n",
       msg.c_str());
     return 4;
-    }
+  }
 
   // if the dashboard root isn't specified then we can compute it from the
   // this->SourceDir
-  if (this->CTestRoot.empty() )
-    {
+  if (this->CTestRoot.empty()) {
     this->CTestRoot = cmSystemTools::GetFilenamePath(this->SourceDir).c_str();
-    }
+  }
 
   // the script may override the minimum continuous interval
-  if (minInterval)
-    {
+  if (minInterval) {
     this->MinimumInterval = 60 * atof(minInterval);
-    }
-  if (contDuration)
-    {
+  }
+  if (contDuration) {
     this->ContinuousDuration = 60.0 * atof(contDuration);
-    }
-
+  }
 
   this->UpdateElapsedTime();
 
@@ -555,15 +503,15 @@ int cmCTestScriptHandler::ExtractVariables()
 void cmCTestScriptHandler::SleepInSeconds(unsigned int secondsToWait)
 {
 #if defined(_WIN32)
-        Sleep(1000*secondsToWait);
+  Sleep(1000 * secondsToWait);
 #else
-        sleep(secondsToWait);
+  sleep(secondsToWait);
 #endif
 }
 
 // run a specific script
-int cmCTestScriptHandler::RunConfigurationScript
-(const std::string& total_script_arg, bool pscope)
+int cmCTestScriptHandler::RunConfigurationScript(
+  const std::string& total_script_arg, bool pscope)
 {
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmSystemTools::SaveRestoreEnvironment sre;
@@ -571,32 +519,26 @@ int cmCTestScriptHandler::RunConfigurationScript
 
   int result;
 
-  this->ScriptStartTime =
-    cmSystemTools::GetTime();
+  this->ScriptStartTime = cmSystemTools::GetTime();
 
   // read in the script
-  if (pscope)
-    {
+  if (pscope) {
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Reading Script: " << total_script_arg << std::endl);
+               "Reading Script: " << total_script_arg << std::endl);
     result = this->ReadInScript(total_script_arg);
-    }
-  else
-    {
+  } else {
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Executing Script: " << total_script_arg << std::endl);
+               "Executing Script: " << total_script_arg << std::endl);
     result = this->ExecuteScript(total_script_arg);
-    }
-  if (result)
-    {
+  }
+  if (result) {
     return result;
-    }
+  }
 
   // only run the curent script if we should
-  if (this->Makefile && this->Makefile->IsOn("CTEST_RUN_CURRENT_SCRIPT"))
-    {
+  if (this->Makefile && this->Makefile->IsOn("CTEST_RUN_CURRENT_SCRIPT")) {
     return this->RunCurrentScript();
-    }
+  }
   return result;
 }
 
@@ -612,52 +554,43 @@ int cmCTestScriptHandler::RunCurrentScript()
 
   // extract the vars from the cache and store in ivars
   result = this->ExtractVariables();
-  if (result)
-    {
+  if (result) {
     return result;
-    }
+  }
 
   // set any environment variables
-  if (!this->CTestEnv.empty())
-    {
+  if (!this->CTestEnv.empty()) {
     std::vector<std::string> envArgs;
-    cmSystemTools::ExpandListArgument(this->CTestEnv,envArgs);
+    cmSystemTools::ExpandListArgument(this->CTestEnv, envArgs);
     cmSystemTools::AppendEnv(envArgs);
-    }
+  }
 
   // now that we have done most of the error checking finally run the
   // dashboard, we may be asked to repeatedly run this dashboard, such as
   // for a continuous, do we ned to run it more than once?
-  if ( this->ContinuousDuration >= 0 )
-    {
+  if (this->ContinuousDuration >= 0) {
     this->UpdateElapsedTime();
-    double ending_time  = cmSystemTools::GetTime() + this->ContinuousDuration;
-    if (this->EmptyBinDirOnce)
-      {
+    double ending_time = cmSystemTools::GetTime() + this->ContinuousDuration;
+    if (this->EmptyBinDirOnce) {
       this->EmptyBinDir = true;
-      }
-    do
-      {
+    }
+    do {
       double interval = cmSystemTools::GetTime();
       result = this->RunConfigurationDashboard();
       interval = cmSystemTools::GetTime() - interval;
-      if (interval < this->MinimumInterval)
-        {
+      if (interval < this->MinimumInterval) {
         this->SleepInSeconds(
           static_cast<unsigned int>(this->MinimumInterval - interval));
-        }
-      if (this->EmptyBinDirOnce)
-        {
+      }
+      if (this->EmptyBinDirOnce) {
         this->EmptyBinDir = false;
-        }
       }
-    while (cmSystemTools::GetTime() < ending_time);
-    }
+    } while (cmSystemTools::GetTime() < ending_time);
+  }
   // otherwise just run it once
-  else
-    {
+  else {
     result = this->RunConfigurationDashboard();
-    }
+  }
 
   return result;
 }
@@ -670,23 +603,20 @@ int cmCTestScriptHandler::CheckOutSourceDir()
   bool res;
 
   if (!cmSystemTools::FileExists(this->SourceDir.c_str()) &&
-      !this->CVSCheckOut.empty())
-    {
+      !this->CVSCheckOut.empty()) {
     // we must now checkout the src dir
     output = "";
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Run cvs: " << this->CVSCheckOut << std::endl);
+               "Run cvs: " << this->CVSCheckOut << std::endl);
     res = cmSystemTools::RunSingleCommand(
-      this->CVSCheckOut.c_str(), &output, &output,
-      &retVal, this->CTestRoot.c_str(), this->HandlerVerbose,
-      0 /*this->TimeOut*/);
-    if (!res || retVal != 0)
-      {
+      this->CVSCheckOut.c_str(), &output, &output, &retVal,
+      this->CTestRoot.c_str(), this->HandlerVerbose, 0 /*this->TimeOut*/);
+    if (!res || retVal != 0) {
       cmSystemTools::Error("Unable to perform cvs checkout:\n",
                            output.c_str());
       return 6;
-      }
     }
+  }
   return 0;
 }
 
@@ -701,17 +631,14 @@ int cmCTestScriptHandler::BackupDirectories()
   this->BackupBinaryDir += "_CMakeBackup";
 
   // backup the binary and src directories if requested
-  if (this->Backup)
-    {
+  if (this->Backup) {
     // if for some reason those directories exist then first delete them
-    if (cmSystemTools::FileExists(this->BackupSourceDir.c_str()))
-      {
+    if (cmSystemTools::FileExists(this->BackupSourceDir.c_str())) {
       cmSystemTools::RemoveADirectory(this->BackupSourceDir);
-      }
-    if (cmSystemTools::FileExists(this->BackupBinaryDir.c_str()))
-      {
+    }
+    if (cmSystemTools::FileExists(this->BackupBinaryDir.c_str())) {
       cmSystemTools::RemoveADirectory(this->BackupBinaryDir);
-      }
+    }
 
     // first rename the src and binary directories
     rename(this->SourceDir.c_str(), this->BackupSourceDir.c_str());
@@ -719,17 +646,15 @@ int cmCTestScriptHandler::BackupDirectories()
 
     // we must now checkout the src dir
     retVal = this->CheckOutSourceDir();
-    if (retVal)
-      {
+    if (retVal) {
       this->RestoreBackupDirectories();
       return retVal;
-      }
     }
+  }
 
   return 0;
 }
 
-
 int cmCTestScriptHandler::PerformExtraUpdates()
 {
   std::string command;
@@ -740,38 +665,30 @@ int cmCTestScriptHandler::PerformExtraUpdates()
   // do an initial cvs update as required
   command = this->UpdateCmd;
   std::vector<std::string>::iterator it;
-  for (it = this->ExtraUpdates.begin();
-    it != this->ExtraUpdates.end();
-    ++ it )
-    {
+  for (it = this->ExtraUpdates.begin(); it != this->ExtraUpdates.end(); ++it) {
     std::vector<std::string> cvsArgs;
-    cmSystemTools::ExpandListArgument(*it,cvsArgs);
-    if (cvsArgs.size() == 2)
-      {
+    cmSystemTools::ExpandListArgument(*it, cvsArgs);
+    if (cvsArgs.size() == 2) {
       std::string fullCommand = command;
       fullCommand += " update ";
       fullCommand += cvsArgs[1];
       output = "";
       retVal = 0;
-      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run Update: "
-        << fullCommand << std::endl);
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Run Update: " << fullCommand << std::endl);
       res = cmSystemTools::RunSingleCommand(
-        fullCommand.c_str(), &output, &output,
-        &retVal, cvsArgs[0].c_str(),
+        fullCommand.c_str(), &output, &output, &retVal, cvsArgs[0].c_str(),
         this->HandlerVerbose, 0 /*this->TimeOut*/);
-      if (!res || retVal != 0)
-        {
-        cmSystemTools::Error("Unable to perform extra updates:\n",
-          it->c_str(), "\nWith output:\n",
-          output.c_str());
+      if (!res || retVal != 0) {
+        cmSystemTools::Error("Unable to perform extra updates:\n", it->c_str(),
+                             "\nWith output:\n", output.c_str());
         return 0;
-        }
       }
     }
+  }
   return 0;
 }
 
-
 // run a single dashboard entry
 int cmCTestScriptHandler::RunConfigurationDashboard()
 {
@@ -784,180 +701,153 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
   // make sure the src directory is there, if it isn't then we might be able
   // to check it out from cvs
   retVal = this->CheckOutSourceDir();
-  if (retVal)
-    {
+  if (retVal) {
     return retVal;
-    }
+  }
 
   // backup the dirs if requested
   retVal = this->BackupDirectories();
-  if (retVal)
-    {
+  if (retVal) {
     return retVal;
-    }
+  }
 
   // clear the binary directory?
-  if (this->EmptyBinDir)
-    {
-    if ( !cmCTestScriptHandler::EmptyBinaryDirectory(
-        this->BinaryDir.c_str()) )
-      {
+  if (this->EmptyBinDir) {
+    if (!cmCTestScriptHandler::EmptyBinaryDirectory(this->BinaryDir.c_str())) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Problem removing the binary directory" << std::endl);
-      }
+                 "Problem removing the binary directory" << std::endl);
     }
+  }
 
   // make sure the binary directory exists if it isn't the srcdir
   if (!cmSystemTools::FileExists(this->BinaryDir.c_str()) &&
-      this->SourceDir != this->BinaryDir)
-    {
-    if (!cmSystemTools::MakeDirectory(this->BinaryDir.c_str()))
-      {
+      this->SourceDir != this->BinaryDir) {
+    if (!cmSystemTools::MakeDirectory(this->BinaryDir.c_str())) {
       cmSystemTools::Error("Unable to create the binary directory:\n",
                            this->BinaryDir.c_str());
       this->RestoreBackupDirectories();
       return 7;
-      }
     }
+  }
 
   // if the binary directory and the source directory are the same,
   // and we are starting with an empty binary directory, then that means
   // we must check out the source tree
-  if (this->EmptyBinDir && this->SourceDir == this->BinaryDir)
-    {
+  if (this->EmptyBinDir && this->SourceDir == this->BinaryDir) {
     // make sure we have the required info
-    if (this->CVSCheckOut.empty())
-      {
-      cmSystemTools::Error("You have specified the source and binary "
+    if (this->CVSCheckOut.empty()) {
+      cmSystemTools::Error(
+        "You have specified the source and binary "
         "directories to be the same (an in source build). You have also "
         "specified that the binary directory is to be erased. This means "
         "that the source will have to be checked out from CVS. But you have "
         "not specified CTEST_CVS_CHECKOUT");
       return 8;
-      }
+    }
 
     // we must now checkout the src dir
     retVal = this->CheckOutSourceDir();
-    if (retVal)
-      {
+    if (retVal) {
       this->RestoreBackupDirectories();
       return retVal;
-      }
     }
+  }
 
   // backup the dirs if requested
   retVal = this->PerformExtraUpdates();
-  if (retVal)
-    {
+  if (retVal) {
     return retVal;
-    }
+  }
 
   // put the initial cache into the bin dir
-  if (!this->InitialCache.empty())
-    {
+  if (!this->InitialCache.empty()) {
     if (!this->WriteInitialCache(this->BinaryDir.c_str(),
-         this->InitialCache.c_str()))
-      {
+                                 this->InitialCache.c_str())) {
       this->RestoreBackupDirectories();
       return 9;
-      }
     }
+  }
 
   // do an initial cmake to setup the DartConfig file
   int cmakeFailed = 0;
   std::string cmakeFailedOuput;
-  if (!this->CMakeCmd.empty())
-    {
+  if (!this->CMakeCmd.empty()) {
     command = this->CMakeCmd;
     command += " \"";
     command += this->SourceDir;
     output = "";
     command += "\"";
     retVal = 0;
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run cmake command: "
-      << command << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Run cmake command: " << command << std::endl);
     res = cmSystemTools::RunSingleCommand(
-      command.c_str(), &output, &output,
-      &retVal, this->BinaryDir.c_str(),
+      command.c_str(), &output, &output, &retVal, this->BinaryDir.c_str(),
       this->HandlerVerbose, 0 /*this->TimeOut*/);
 
-    if ( !this->CMOutFile.empty() )
-      {
+    if (!this->CMOutFile.empty()) {
       std::string cmakeOutputFile = this->CMOutFile;
-      if ( !cmSystemTools::FileIsFullPath(cmakeOutputFile.c_str()) )
-        {
+      if (!cmSystemTools::FileIsFullPath(cmakeOutputFile.c_str())) {
         cmakeOutputFile = this->BinaryDir + "/" + cmakeOutputFile;
-        }
+      }
 
       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "Write CMake output to file: " << cmakeOutputFile
-        << std::endl);
+                 "Write CMake output to file: " << cmakeOutputFile
+                                                << std::endl);
       cmGeneratedFileStream fout(cmakeOutputFile.c_str());
-      if ( fout )
-        {
+      if (fout) {
         fout << output.c_str();
-        }
-      else
-        {
+      } else {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-          "Cannot open CMake output file: "
-          << cmakeOutputFile << " for writing" << std::endl);
-        }
+                   "Cannot open CMake output file: "
+                     << cmakeOutputFile << " for writing" << std::endl);
       }
-    if (!res || retVal != 0)
-      {
+    }
+    if (!res || retVal != 0) {
       // even if this fails continue to the next step
       cmakeFailed = 1;
       cmakeFailedOuput = output;
-      }
     }
+  }
 
   // run ctest, it may be more than one command in here
   std::vector<std::string> ctestCommands;
-  cmSystemTools::ExpandListArgument(this->CTestCmd,ctestCommands);
+  cmSystemTools::ExpandListArgument(this->CTestCmd, ctestCommands);
   // for each variable/argument do a putenv
-  for (unsigned i = 0; i < ctestCommands.size(); ++i)
-    {
+  for (unsigned i = 0; i < ctestCommands.size(); ++i) {
     command = ctestCommands[i];
     output = "";
     retVal = 0;
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run ctest command: "
-      << command << std::endl);
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Run ctest command: " << command << std::endl);
     res = cmSystemTools::RunSingleCommand(
-      command.c_str(), &output, &output,
-      &retVal, this->BinaryDir.c_str(), this->HandlerVerbose,
-      0 /*this->TimeOut*/);
+      command.c_str(), &output, &output, &retVal, this->BinaryDir.c_str(),
+      this->HandlerVerbose, 0 /*this->TimeOut*/);
 
     // did something critical fail in ctest
-    if (!res || cmakeFailed ||
-        retVal & cmCTest::BUILD_ERRORS)
-      {
+    if (!res || cmakeFailed || retVal & cmCTest::BUILD_ERRORS) {
       this->RestoreBackupDirectories();
-      if (cmakeFailed)
-        {
+      if (cmakeFailed) {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-          "Unable to run cmake:" << std::endl
-          << cmakeFailedOuput << std::endl);
+                   "Unable to run cmake:" << std::endl
+                                          << cmakeFailedOuput << std::endl);
         return 10;
-        }
+      }
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Unable to run ctest:" << std::endl
-        << "command: " << command << std::endl
-        << "output: " << output << std::endl);
-      if (!res)
-        {
+                 "Unable to run ctest:" << std::endl
+                                        << "command: " << command << std::endl
+                                        << "output: " << output << std::endl);
+      if (!res) {
         return 11;
-        }
-      return retVal * 100;
       }
+      return retVal * 100;
     }
+  }
 
   // if all was succesful, delete the backup dirs to free up disk space
-  if (this->Backup)
-    {
+  if (this->Backup) {
     cmSystemTools::RemoveADirectory(this->BackupSourceDir);
     cmSystemTools::RemoveADirectory(this->BackupBinaryDir);
-    }
+  }
 
   return 0;
 }
@@ -968,15 +858,13 @@ bool cmCTestScriptHandler::WriteInitialCache(const char* directory,
   std::string cacheFile = directory;
   cacheFile += "/CMakeCache.txt";
   cmGeneratedFileStream fout(cacheFile.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return false;
-    }
+  }
 
-  if (text!=0)
-    {
+  if (text != 0) {
     fout.write(text, strlen(text));
-    }
+  }
 
   // Make sure the operating system has finished writing the file
   // before closing it.  This will ensure the file is finished before
@@ -990,69 +878,60 @@ void cmCTestScriptHandler::RestoreBackupDirectories()
 {
   // if we backed up the dirs and the build failed, then restore
   // the backed up dirs
-  if (this->Backup)
-    {
+  if (this->Backup) {
     // if for some reason those directories exist then first delete them
-    if (cmSystemTools::FileExists(this->SourceDir.c_str()))
-      {
+    if (cmSystemTools::FileExists(this->SourceDir.c_str())) {
       cmSystemTools::RemoveADirectory(this->SourceDir);
-      }
-    if (cmSystemTools::FileExists(this->BinaryDir.c_str()))
-      {
+    }
+    if (cmSystemTools::FileExists(this->BinaryDir.c_str())) {
       cmSystemTools::RemoveADirectory(this->BinaryDir);
-      }
+    }
     // rename the src and binary directories
     rename(this->BackupSourceDir.c_str(), this->SourceDir.c_str());
     rename(this->BackupBinaryDir.c_str(), this->BinaryDir.c_str());
-    }
+  }
 }
 
-bool cmCTestScriptHandler::RunScript(cmCTest* ctest, const char *sname,
+bool cmCTestScriptHandler::RunScript(cmCTest* ctest, const char* sname,
                                      bool InProcess, int* returnValue)
 {
   cmCTestScriptHandler* sh = new cmCTestScriptHandler();
   sh->SetCTestInstance(ctest);
-  sh->AddConfigurationScript(sname,InProcess);
+  sh->AddConfigurationScript(sname, InProcess);
   int res = sh->ProcessHandler();
-  if(returnValue)
-    {
+  if (returnValue) {
     *returnValue = res;
-    }
+  }
   delete sh;
   return true;
 }
 
-bool cmCTestScriptHandler::EmptyBinaryDirectory(const char *sname)
+bool cmCTestScriptHandler::EmptyBinaryDirectory(const char* sname)
 {
   // try to avoid deleting root
-  if (!sname || strlen(sname) < 2)
-    {
+  if (!sname || strlen(sname) < 2) {
     return false;
-    }
+  }
 
   // consider non existing target directory a success
-  if(!cmSystemTools::FileExists(sname))
-    {
+  if (!cmSystemTools::FileExists(sname)) {
     return true;
-    }
+  }
 
   // try to avoid deleting directories that we shouldn't
   std::string check = sname;
   check += "/CMakeCache.txt";
 
-  if(!cmSystemTools::FileExists(check.c_str()))
-    {
+  if (!cmSystemTools::FileExists(check.c_str())) {
     return false;
-    }
+  }
 
-  for(int i = 0; i < 5; ++i)
-    {
-    if(TryToRemoveBinaryDirectoryOnce(sname))
-      {
+  for (int i = 0; i < 5; ++i) {
+    if (TryToRemoveBinaryDirectoryOnce(sname)) {
       return true;
-      }
-    cmSystemTools::Delay(100);
     }
+    cmSystemTools::Delay(100);
+  }
 
   return false;
 }
@@ -1063,34 +942,27 @@ bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce(
   cmsys::Directory directory;
   directory.Load(directoryPath);
 
-  for(unsigned long i = 0; i < directory.GetNumberOfFiles(); ++i)
-    {
+  for (unsigned long i = 0; i < directory.GetNumberOfFiles(); ++i) {
     std::string path = directory.GetFile(i);
 
-    if(path == "." || path == ".." || path == "CMakeCache.txt")
-      {
+    if (path == "." || path == ".." || path == "CMakeCache.txt") {
       continue;
-      }
+    }
 
     std::string fullPath = directoryPath + std::string("/") + path;
 
     bool isDirectory = cmSystemTools::FileIsDirectory(fullPath) &&
       !cmSystemTools::FileIsSymlink(fullPath);
 
-    if(isDirectory)
-      {
-      if(!cmSystemTools::RemoveADirectory(fullPath))
-        {
+    if (isDirectory) {
+      if (!cmSystemTools::RemoveADirectory(fullPath)) {
         return false;
-        }
       }
-    else
-      {
-      if(!cmSystemTools::RemoveFile(fullPath))
-        {
+    } else {
+      if (!cmSystemTools::RemoveFile(fullPath)) {
         return false;
-        }
       }
+    }
   }
 
   return cmSystemTools::RemoveADirectory(directoryPath);
@@ -1098,18 +970,15 @@ bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce(
 
 double cmCTestScriptHandler::GetRemainingTimeAllowed()
 {
-  if (!this->Makefile)
-    {
+  if (!this->Makefile) {
     return 1.0e7;
-    }
+  }
 
-  const char *timelimitS
-    = this->Makefile->GetDefinition("CTEST_TIME_LIMIT");
+  const char* timelimitS = this->Makefile->GetDefinition("CTEST_TIME_LIMIT");
 
-  if (!timelimitS)
-    {
+  if (!timelimitS) {
     return 1.0e7;
-    }
+  }
 
   double timelimit = atof(timelimitS);
 
diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h
index 2b66f70..e09e040 100644
--- a/Source/CTest/cmCTestScriptHandler.h
+++ b/Source/CTest/cmCTestScriptHandler.h
@@ -66,7 +66,7 @@ public:
   /**
    * Add a script to run, and if is should run in the current process
    */
-  void AddConfigurationScript(const char *, bool pscope);
+  void AddConfigurationScript(const char*, bool pscope);
 
   /**
    * Run a dashboard using a specified confiuration script
@@ -76,14 +76,14 @@ public:
   /*
    * Run a script
    */
-  static bool RunScript(cmCTest* ctest, const char *script, bool InProcess,
-    int* returnValue);
+  static bool RunScript(cmCTest* ctest, const char* script, bool InProcess,
+                        int* returnValue);
   int RunCurrentScript();
 
   /*
    * Empty Binary Directory
    */
-  static bool EmptyBinaryDirectory(const char *dir);
+  static bool EmptyBinaryDirectory(const char* dir);
 
   /*
    * Write an initial CMakeCache.txt from the given contents.
@@ -109,7 +109,7 @@ public:
   void Initialize();
 
   void CreateCMake();
-  cmake* GetCMake() { return this->CMake;}
+  cmake* GetCMake() { return this->CMake; }
 private:
   // reads in a script
   int ReadInScript(const std::string& total_script_arg);
@@ -164,9 +164,9 @@ private:
   // what time in seconds did this script start running
   double ScriptStartTime;
 
-  cmMakefile *Makefile;
-  cmGlobalGenerator *GlobalGenerator;
-  cmake *CMake;
+  cmMakefile* Makefile;
+  cmGlobalGenerator* GlobalGenerator;
+  cmake* CMake;
 };
 
 #endif
diff --git a/Source/CTest/cmCTestSleepCommand.cxx b/Source/CTest/cmCTestSleepCommand.cxx
index 7e87550..102a303 100644
--- a/Source/CTest/cmCTestSleepCommand.cxx
+++ b/Source/CTest/cmCTestSleepCommand.cxx
@@ -14,42 +14,36 @@
 #include "cmCTestScriptHandler.h"
 #include <stdlib.h> // required for atoi
 
-bool cmCTestSleepCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestSleepCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus&)
 {
-  if (args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // sleep for specified seconds
   unsigned int time1 = atoi(args[0].c_str());
-  if(args.size() == 1 )
-    {
+  if (args.size() == 1) {
     cmCTestScriptHandler::SleepInSeconds(time1);
     // update the elapsed time since it could have slept for a while
     this->CTestScriptHandler->UpdateElapsedTime();
     return true;
-    }
+  }
 
   // sleep up to a duration
-  if(args.size() == 3 )
-    {
+  if (args.size() == 3) {
     unsigned int duration = atoi(args[1].c_str());
     unsigned int time2 = atoi(args[2].c_str());
-    if (time1 + duration > time2)
-      {
+    if (time1 + duration > time2) {
       duration = (time1 + duration - time2);
       cmCTestScriptHandler::SleepInSeconds(duration);
       // update the elapsed time since it could have slept for a while
       this->CTestScriptHandler->UpdateElapsedTime();
-      }
-    return true;
     }
+    return true;
+  }
 
   this->SetError("called with incorrect number of arguments");
   return false;
 }
-
-
diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h
index 740a7e1..ff7f146 100644
--- a/Source/CTest/cmCTestSleepCommand.h
+++ b/Source/CTest/cmCTestSleepCommand.h
@@ -23,35 +23,32 @@
 class cmCTestSleepCommand : public cmCTestCommand
 {
 public:
-
   cmCTestSleepCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestSleepCommand* ni = new cmCTestSleepCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_sleep";}
+  virtual std::string GetName() const { return "ctest_sleep"; }
 
   cmTypeMacro(cmCTestSleepCommand, cmCTestCommand);
-
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
index fef5637..d561393 100644
--- a/Source/CTest/cmCTestStartCommand.cxx
+++ b/Source/CTest/cmCTestStartCommand.cxx
@@ -22,14 +22,13 @@ cmCTestStartCommand::cmCTestStartCommand()
   this->Quiet = false;
 }
 
-bool cmCTestStartCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus&)
 {
-  if (args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   size_t cnt = 0;
   const char* smodel = args[cnt].c_str();
@@ -39,62 +38,50 @@ bool cmCTestStartCommand
   cnt++;
 
   this->CTest->SetSpecificTrack(0);
-  if ( cnt < args.size() -1 )
-    {
-    if ( args[cnt] == "TRACK" )
-      {
-      cnt ++;
+  if (cnt < args.size() - 1) {
+    if (args[cnt] == "TRACK") {
+      cnt++;
       this->CTest->SetSpecificTrack(args[cnt].c_str());
-      cnt ++;
-      }
+      cnt++;
     }
+  }
 
-  if (cnt < args.size())
-    {
-    if (args[cnt] == "APPEND")
-      {
-      cnt ++;
+  if (cnt < args.size()) {
+    if (args[cnt] == "APPEND") {
+      cnt++;
       this->CreateNewTag = false;
-      }
     }
-  if (cnt < args.size())
-    {
-    if (args[cnt] == "QUIET")
-      {
-      cnt ++;
+  }
+  if (cnt < args.size()) {
+    if (args[cnt] == "QUIET") {
+      cnt++;
       this->Quiet = true;
-      }
     }
+  }
 
-  if ( cnt < args.size() )
-    {
+  if (cnt < args.size()) {
     src_dir = args[cnt].c_str();
-    cnt ++;
-    if ( cnt < args.size() )
-      {
+    cnt++;
+    if (cnt < args.size()) {
       bld_dir = args[cnt].c_str();
-      }
     }
-  if ( !src_dir )
-    {
+  }
+  if (!src_dir) {
     src_dir = this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY");
-    }
-  if ( !bld_dir)
-    {
+  }
+  if (!bld_dir) {
     bld_dir = this->Makefile->GetDefinition("CTEST_BINARY_DIRECTORY");
-    }
-  if ( !src_dir )
-    {
+  }
+  if (!src_dir) {
     this->SetError("source directory not specified. Specify source directory "
-      "as an argument or set CTEST_SOURCE_DIRECTORY");
+                   "as an argument or set CTEST_SOURCE_DIRECTORY");
     return false;
-    }
-  if ( !bld_dir)
-    {
+  }
+  if (!bld_dir) {
     this->SetError("binary directory not specified. Specify binary directory "
-      "as an argument or set CTEST_BINARY_DIRECTORY");
+                   "as an argument or set CTEST_BINARY_DIRECTORY");
     return false;
-    }
+  }
 
   cmSystemTools::AddKeepPath(src_dir);
   cmSystemTools::AddKeepPath(bld_dir);
@@ -104,38 +91,35 @@ bool cmCTestStartCommand
   std::string sourceDir = cmSystemTools::CollapseFullPath(src_dir);
   std::string binaryDir = cmSystemTools::CollapseFullPath(bld_dir);
   this->CTest->SetCTestConfiguration("SourceDirectory", sourceDir.c_str(),
-    this->Quiet);
+                                     this->Quiet);
   this->CTest->SetCTestConfiguration("BuildDirectory", binaryDir.c_str(),
-    this->Quiet);
+                                     this->Quiet);
 
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Run dashboard with model "
-    << smodel << std::endl
-    << "   Source directory: " << src_dir << std::endl
-    << "   Build directory: " << bld_dir << std::endl, this->Quiet);
+                       << smodel << std::endl
+                       << "   Source directory: " << src_dir << std::endl
+                       << "   Build directory: " << bld_dir << std::endl,
+                     this->Quiet);
   const char* track = this->CTest->GetSpecificTrack();
-  if ( track )
-    {
+  if (track) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "   Track: " << track << std::endl, this->Quiet);
-    }
+                       "   Track: " << track << std::endl, this->Quiet);
+  }
 
   // Log startup actions.
   std::string startLogFile = binaryDir + "/Testing/Temporary/LastStart.log";
   cmGeneratedFileStream ofs(startLogFile.c_str());
-  if(!ofs)
-    {
+  if (!ofs) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Cannot create log file: LastStart.log" << std::endl);
     return false;
-    }
+  }
 
   // Make sure the source directory exists.
-  if(!this->InitialCheckout(ofs, sourceDir))
-    {
+  if (!this->InitialCheckout(ofs, sourceDir)) {
     return false;
-    }
-  if(!cmSystemTools::FileIsDirectory(sourceDir))
-    {
+  }
+  if (!cmSystemTools::FileIsDirectory(sourceDir)) {
     std::ostringstream e;
     e << "given source path\n"
       << "  " << sourceDir << "\n"
@@ -143,7 +127,7 @@ bool cmCTestStartCommand
       << "Set CTEST_CHECKOUT_COMMAND to a command line to create it.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", "OFF");
   this->CTest->SetSuppressUpdatingCTestConfiguration(true);
@@ -154,26 +138,23 @@ bool cmCTestStartCommand
   return this->CTest->InitializeFromCommand(this);
 }
 
-bool cmCTestStartCommand::InitialCheckout(
-  std::ostream& ofs, std::string const& sourceDir)
+bool cmCTestStartCommand::InitialCheckout(std::ostream& ofs,
+                                          std::string const& sourceDir)
 {
   // Use the user-provided command to create the source tree.
-  const char* initialCheckoutCommand
-    = this->Makefile->GetDefinition("CTEST_CHECKOUT_COMMAND");
-  if(!initialCheckoutCommand)
-    {
+  const char* initialCheckoutCommand =
+    this->Makefile->GetDefinition("CTEST_CHECKOUT_COMMAND");
+  if (!initialCheckoutCommand) {
     initialCheckoutCommand =
       this->Makefile->GetDefinition("CTEST_CVS_CHECKOUT");
-    }
-  if(initialCheckoutCommand)
-    {
+  }
+  if (initialCheckoutCommand) {
     // Use a generic VC object to run and log the command.
     cmCTestVC vc(this->CTest, ofs);
     vc.SetSourceDirectory(sourceDir);
-    if(!vc.InitialCheckout(initialCheckoutCommand))
-      {
+    if (!vc.InitialCheckout(initialCheckoutCommand)) {
       return false;
-      }
     }
+  }
   return true;
 }
diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h
index eed1962..2aa6281 100644
--- a/Source/CTest/cmCTestStartCommand.h
+++ b/Source/CTest/cmCTestStartCommand.h
@@ -22,49 +22,42 @@
 class cmCTestStartCommand : public cmCTestCommand
 {
 public:
-
   cmCTestStartCommand();
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestStartCommand* ni = new cmCTestStartCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     ni->CreateNewTag = this->CreateNewTag;
     ni->Quiet = this->Quiet;
     return ni;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * Will this invocation of ctest_start create a new TAG file?
    */
-  bool ShouldCreateNewTag()
-    {
-    return this->CreateNewTag;
-    }
+  bool ShouldCreateNewTag() { return this->CreateNewTag; }
 
   /**
    * Should this invocation of ctest_start output non-error messages?
    */
-  bool ShouldBeQuiet()
-    {
-    return this->Quiet;
-    }
+  bool ShouldBeQuiet() { return this->Quiet; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_start";}
+  virtual std::string GetName() const { return "ctest_start"; }
 
   cmTypeMacro(cmCTestStartCommand, cmCTestCommand);
 
@@ -74,5 +67,4 @@ private:
   bool Quiet;
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
index 6174624..fa9bd2c 100644
--- a/Source/CTest/cmCTestSubmitCommand.cxx
+++ b/Source/CTest/cmCTestSubmitCommand.cxx
@@ -17,96 +17,87 @@
 
 cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
 {
-  const char* ctestDropMethod
-    = this->Makefile->GetDefinition("CTEST_DROP_METHOD");
-  const char* ctestDropSite
-    = this->Makefile->GetDefinition("CTEST_DROP_SITE");
-  const char* ctestDropLocation
-    = this->Makefile->GetDefinition("CTEST_DROP_LOCATION");
-  const char* ctestTriggerSite
-    = this->Makefile->GetDefinition("CTEST_TRIGGER_SITE");
-  bool ctestDropSiteCDash
-    = this->Makefile->IsOn("CTEST_DROP_SITE_CDASH");
-  const char* ctestProjectName
-    = this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
-  if ( !ctestDropMethod )
-    {
+  const char* ctestDropMethod =
+    this->Makefile->GetDefinition("CTEST_DROP_METHOD");
+  const char* ctestDropSite = this->Makefile->GetDefinition("CTEST_DROP_SITE");
+  const char* ctestDropLocation =
+    this->Makefile->GetDefinition("CTEST_DROP_LOCATION");
+  const char* ctestTriggerSite =
+    this->Makefile->GetDefinition("CTEST_TRIGGER_SITE");
+  bool ctestDropSiteCDash = this->Makefile->IsOn("CTEST_DROP_SITE_CDASH");
+  const char* ctestProjectName =
+    this->Makefile->GetDefinition("CTEST_PROJECT_NAME");
+  if (!ctestDropMethod) {
     ctestDropMethod = "http";
-    }
+  }
 
-  if ( !ctestDropSite )
-    {
+  if (!ctestDropSite) {
     // error: CDash requires CTEST_DROP_SITE definition
     // in CTestConfig.cmake
-    }
-  if ( !ctestDropLocation )
-    {
+  }
+  if (!ctestDropLocation) {
     // error: CDash requires CTEST_DROP_LOCATION definition
     // in CTestConfig.cmake
-    }
+  }
   this->CTest->SetCTestConfiguration("ProjectName", ctestProjectName,
-    this->Quiet);
+                                     this->Quiet);
   this->CTest->SetCTestConfiguration("DropMethod", ctestDropMethod,
-    this->Quiet);
+                                     this->Quiet);
   this->CTest->SetCTestConfiguration("DropSite", ctestDropSite, this->Quiet);
   this->CTest->SetCTestConfiguration("DropLocation", ctestDropLocation,
-    this->Quiet);
+                                     this->Quiet);
 
-  this->CTest->SetCTestConfiguration("IsCDash",
-    ctestDropSiteCDash ? "TRUE" : "FALSE", this->Quiet);
+  this->CTest->SetCTestConfiguration(
+    "IsCDash", ctestDropSiteCDash ? "TRUE" : "FALSE", this->Quiet);
 
   // Only propagate TriggerSite for non-CDash projects:
   //
-  if ( !ctestDropSiteCDash )
-    {
-    this->CTest->SetCTestConfiguration("TriggerSite",  ctestTriggerSite,
-      this->Quiet);
-    }
+  if (!ctestDropSiteCDash) {
+    this->CTest->SetCTestConfiguration("TriggerSite", ctestTriggerSite,
+                                       this->Quiet);
+  }
+
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CurlOptions", "CTEST_CURL_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "DropSiteUser", "CTEST_DROP_SITE_USER", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "DropSitePassword", "CTEST_DROP_SITE_PASSWORD",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "ScpCommand", "CTEST_SCP_COMMAND", this->Quiet);
 
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "CurlOptions", "CTEST_CURL_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "DropSiteUser", "CTEST_DROP_SITE_USER", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "DropSitePassword", "CTEST_DROP_SITE_PASSWORD", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "ScpCommand", "CTEST_SCP_COMMAND", this->Quiet);
-
-  const char* notesFilesVariable
-    = this->Makefile->GetDefinition("CTEST_NOTES_FILES");
-  if (notesFilesVariable)
-    {
+  const char* notesFilesVariable =
+    this->Makefile->GetDefinition("CTEST_NOTES_FILES");
+  if (notesFilesVariable) {
     std::vector<std::string> notesFiles;
     cmCTest::VectorOfStrings newNotesFiles;
-    cmSystemTools::ExpandListArgument(notesFilesVariable,notesFiles);
-    newNotesFiles.insert(newNotesFiles.end(),
-                         notesFiles.begin(), notesFiles.end());
+    cmSystemTools::ExpandListArgument(notesFilesVariable, notesFiles);
+    newNotesFiles.insert(newNotesFiles.end(), notesFiles.begin(),
+                         notesFiles.end());
     this->CTest->GenerateNotesFile(newNotesFiles);
-    }
+  }
 
-  const char* extraFilesVariable
-    = this->Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
-  if (extraFilesVariable)
-    {
+  const char* extraFilesVariable =
+    this->Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
+  if (extraFilesVariable) {
     std::vector<std::string> extraFiles;
     cmCTest::VectorOfStrings newExtraFiles;
-    cmSystemTools::ExpandListArgument(extraFilesVariable,extraFiles);
-    newExtraFiles.insert(newExtraFiles.end(),
-                         extraFiles.begin(), extraFiles.end());
-    if ( !this->CTest->SubmitExtraFiles(newExtraFiles))
-      {
+    cmSystemTools::ExpandListArgument(extraFilesVariable, extraFiles);
+    newExtraFiles.insert(newExtraFiles.end(), extraFiles.begin(),
+                         extraFiles.end());
+    if (!this->CTest->SubmitExtraFiles(newExtraFiles)) {
       this->SetError("problem submitting extra files.");
       return 0;
-      }
     }
+  }
 
-  cmCTestGenericHandler* handler
-    = this->CTest->GetInitializedHandler("submit");
-  if ( !handler )
-    {
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("submit");
+  if (!handler) {
     this->SetError("internal CTest error. Cannot instantiate submit handler");
     return 0;
-    }
+  }
 
   // If no FILES or PARTS given, *all* PARTS are submitted by default.
   //
@@ -122,8 +113,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
 
   // If given explicit FILES to submit, pass them to the handler.
   //
-  if(this->FilesMentioned)
-    {
+  if (this->FilesMentioned) {
     // Intentionally select *no* PARTS. (Pass an empty set.) If PARTS
     // were also explicitly mentioned, they will be selected below...
     // But FILES with no PARTS mentioned should just submit the FILES
@@ -133,31 +123,29 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
     static_cast<cmCTestSubmitHandler*>(handler)->SelectParts(noParts);
 
     static_cast<cmCTestSubmitHandler*>(handler)->SelectFiles(this->Files);
-    }
+  }
 
   // If a PARTS option was given, select only the named parts for submission.
   //
-  if(this->PartsMentioned)
-    {
+  if (this->PartsMentioned) {
     static_cast<cmCTestSubmitHandler*>(handler)->SelectParts(this->Parts);
-    }
+  }
 
-  static_cast<cmCTestSubmitHandler*>(handler)->SetOption("RetryDelay",
-    this->RetryDelay.c_str());
-  static_cast<cmCTestSubmitHandler*>(handler)->SetOption("RetryCount",
-    this->RetryCount.c_str());
-  static_cast<cmCTestSubmitHandler*>(handler)->SetOption("InternalTest",
-    this->InternalTest ? "ON" : "OFF");
+  static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+    "RetryDelay", this->RetryDelay.c_str());
+  static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+    "RetryCount", this->RetryCount.c_str());
+  static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+    "InternalTest", this->InternalTest ? "ON" : "OFF");
 
   handler->SetQuiet(this->Quiet);
 
-  if (this->CDashUpload)
-    {
-    static_cast<cmCTestSubmitHandler*>(handler)->
-      SetOption("CDashUploadFile", this->CDashUploadFile.c_str());
-    static_cast<cmCTestSubmitHandler*>(handler)->
-      SetOption("CDashUploadType", this->CDashUploadType.c_str());
-    }
+  if (this->CDashUpload) {
+    static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+      "CDashUploadFile", this->CDashUploadFile.c_str());
+    static_cast<cmCTestSubmitHandler*>(handler)->SetOption(
+      "CDashUploadType", this->CDashUploadType.c_str());
+  }
   return handler;
 }
 
@@ -170,124 +158,101 @@ bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
 
 bool cmCTestSubmitCommand::CheckArgumentKeyword(std::string const& arg)
 {
-  if (this->CDashUpload)
-    {
-    if(arg == "CDASH_UPLOAD")
-      {
+  if (this->CDashUpload) {
+    if (arg == "CDASH_UPLOAD") {
       this->ArgumentDoing = ArgumentDoingCDashUpload;
       return true;
-      }
+    }
 
-    if(arg == "CDASH_UPLOAD_TYPE")
-      {
+    if (arg == "CDASH_UPLOAD_TYPE") {
       this->ArgumentDoing = ArgumentDoingCDashUploadType;
       return true;
-      }
     }
-  else
-    {
+  } else {
     // Look for arguments specific to this command.
-    if(arg == "PARTS")
-      {
+    if (arg == "PARTS") {
       this->ArgumentDoing = ArgumentDoingParts;
       this->PartsMentioned = true;
       return true;
-      }
+    }
 
-    if(arg == "FILES")
-      {
+    if (arg == "FILES") {
       this->ArgumentDoing = ArgumentDoingFiles;
       this->FilesMentioned = true;
       return true;
-      }
+    }
 
-    if(arg == "RETRY_COUNT")
-      {
+    if (arg == "RETRY_COUNT") {
       this->ArgumentDoing = ArgumentDoingRetryCount;
       return true;
-      }
+    }
 
-    if(arg == "RETRY_DELAY")
-      {
+    if (arg == "RETRY_DELAY") {
       this->ArgumentDoing = ArgumentDoingRetryDelay;
       return true;
-      }
+    }
 
-    if(arg == "INTERNAL_TEST_CHECKSUM")
-      {
+    if (arg == "INTERNAL_TEST_CHECKSUM") {
       this->InternalTest = true;
       return true;
-      }
     }
+  }
 
   // Look for other arguments.
   return this->Superclass::CheckArgumentKeyword(arg);
 }
 
-
 bool cmCTestSubmitCommand::CheckArgumentValue(std::string const& arg)
 {
   // Handle states specific to this command.
-  if(this->ArgumentDoing == ArgumentDoingParts)
-    {
+  if (this->ArgumentDoing == ArgumentDoingParts) {
     cmCTest::Part p = this->CTest->GetPartFromName(arg.c_str());
-    if(p != cmCTest::PartCount)
-      {
+    if (p != cmCTest::PartCount) {
       this->Parts.insert(p);
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "Part name \"" << arg << "\" is invalid.";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       this->ArgumentDoing = ArgumentDoingError;
-      }
-    return true;
     }
+    return true;
+  }
 
-  if(this->ArgumentDoing == ArgumentDoingFiles)
-    {
+  if (this->ArgumentDoing == ArgumentDoingFiles) {
     std::string filename(arg);
-    if(cmSystemTools::FileExists(filename.c_str()))
-      {
+    if (cmSystemTools::FileExists(filename.c_str())) {
       this->Files.insert(filename);
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "File \"" << filename << "\" does not exist. Cannot submit "
-          << "a non-existent file.";
+        << "a non-existent file.";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       this->ArgumentDoing = ArgumentDoingError;
-      }
-    return true;
     }
+    return true;
+  }
 
-  if(this->ArgumentDoing == ArgumentDoingRetryCount)
-    {
+  if (this->ArgumentDoing == ArgumentDoingRetryCount) {
     this->RetryCount = arg;
     return true;
-    }
+  }
 
-  if(this->ArgumentDoing == ArgumentDoingRetryDelay)
-    {
+  if (this->ArgumentDoing == ArgumentDoingRetryDelay) {
     this->RetryDelay = arg;
     return true;
-    }
+  }
 
-  if(this->ArgumentDoing == ArgumentDoingCDashUpload)
-    {
+  if (this->ArgumentDoing == ArgumentDoingCDashUpload) {
     this->ArgumentDoing = ArgumentDoingNone;
     this->CDashUploadFile = arg;
     return true;
-    }
+  }
 
-  if(this->ArgumentDoing == ArgumentDoingCDashUploadType)
-    {
+  if (this->ArgumentDoing == ArgumentDoingCDashUploadType) {
     this->ArgumentDoing = ArgumentDoingNone;
     this->CDashUploadType = arg;
     return true;
-    }
+  }
 
   // Look for other arguments.
   return this->Superclass::CheckArgumentValue(arg);
diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h
index ebc8c36..6323d8c 100644
--- a/Source/CTest/cmCTestSubmitCommand.h
+++ b/Source/CTest/cmCTestSubmitCommand.h
@@ -25,35 +25,34 @@
 class cmCTestSubmitCommand : public cmCTestHandlerCommand
 {
 public:
-
   cmCTestSubmitCommand()
-    {
+  {
     this->PartsMentioned = false;
     this->FilesMentioned = false;
     this->InternalTest = false;
     this->RetryCount = "";
     this->RetryDelay = "";
     this->CDashUpload = false;
-    }
+  }
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestSubmitCommand* ni = new cmCTestSubmitCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_submit";}
+  virtual std::string GetName() const { return "ctest_submit"; }
 
   cmTypeMacro(cmCTestSubmitCommand, cmCTestHandlerCommand);
 
@@ -86,5 +85,4 @@ protected:
   std::string CDashUploadType;
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
index 2153b8f..bbc6b37 100644
--- a/Source/CTest/cmCTestSubmitHandler.cxx
+++ b/Source/CTest/cmCTestSubmitHandler.cxx
@@ -37,20 +37,19 @@
 
 typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
 
-class cmCTestSubmitHandler::ResponseParser: public cmXMLParser
+class cmCTestSubmitHandler::ResponseParser : public cmXMLParser
 {
 public:
   ResponseParser() { this->Status = STATUS_OK; }
   ~ResponseParser() {}
 
 public:
-
   enum StatusType
-    {
+  {
     STATUS_OK,
     STATUS_WARNING,
     STATUS_ERROR
-    };
+  };
 
   StatusType Status;
   std::string CDashVersion;
@@ -59,93 +58,78 @@ public:
   std::string Message;
 
 private:
-
   std::vector<char> CurrentValue;
 
   std::string GetCurrentValue()
-    {
+  {
     std::string val;
-    if(!this->CurrentValue.empty())
-      {
+    if (!this->CurrentValue.empty()) {
       val.assign(&this->CurrentValue[0], this->CurrentValue.size());
-      }
-    return val;
     }
+    return val;
+  }
 
   virtual void StartElement(const std::string& name, const char** atts)
-    {
+  {
     this->CurrentValue.clear();
-    if(name == "cdash")
-      {
+    if (name == "cdash") {
       this->CDashVersion = this->FindAttribute(atts, "version");
-      }
     }
+  }
 
   virtual void CharacterDataHandler(const char* data, int length)
-    {
-    this->CurrentValue.insert(this->CurrentValue.end(), data, data+length);
-    }
+  {
+    this->CurrentValue.insert(this->CurrentValue.end(), data, data + length);
+  }
 
   virtual void EndElement(const std::string& name)
-    {
-    if(name == "status")
-      {
+  {
+    if (name == "status") {
       std::string status = cmSystemTools::UpperCase(this->GetCurrentValue());
-      if(status == "OK" || status == "SUCCESS")
-        {
+      if (status == "OK" || status == "SUCCESS") {
         this->Status = STATUS_OK;
-        }
-      else if(status == "WARNING")
-        {
+      } else if (status == "WARNING") {
         this->Status = STATUS_WARNING;
-        }
-      else
-        {
+      } else {
         this->Status = STATUS_ERROR;
-        }
       }
-    else if(name == "filename")
-      {
+    } else if (name == "filename") {
       this->Filename = this->GetCurrentValue();
-      }
-    else if(name == "md5")
-      {
+    } else if (name == "md5") {
       this->MD5 = this->GetCurrentValue();
-      }
-    else if(name == "message")
-      {
+    } else if (name == "message") {
       this->Message = this->GetCurrentValue();
-      }
     }
+  }
 };
 
-
-static size_t
-cmCTestSubmitHandlerWriteMemoryCallback(void *ptr, size_t size, size_t nmemb,
-  void *data)
+static size_t cmCTestSubmitHandlerWriteMemoryCallback(void* ptr, size_t size,
+                                                      size_t nmemb, void* data)
 {
   int realsize = (int)(size * nmemb);
 
-  cmCTestSubmitHandlerVectorOfChar *vec
-    = static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
+  cmCTestSubmitHandlerVectorOfChar* vec =
+    static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
   const char* chPtr = static_cast<char*>(ptr);
   vec->insert(vec->end(), chPtr, chPtr + realsize);
 
   return realsize;
 }
 
-static size_t
-cmCTestSubmitHandlerCurlDebugCallback(CURL *, curl_infotype, char *chPtr,
-  size_t size, void *data)
+static size_t cmCTestSubmitHandlerCurlDebugCallback(CURL*, curl_infotype,
+                                                    char* chPtr, size_t size,
+                                                    void* data)
 {
-  cmCTestSubmitHandlerVectorOfChar *vec
-    = static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
+  cmCTestSubmitHandlerVectorOfChar* vec =
+    static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
   vec->insert(vec->end(), chPtr, chPtr + size);
 
   return size;
 }
 
-cmCTestSubmitHandler::cmCTestSubmitHandler() : HTTPProxy(), FTPProxy()
+cmCTestSubmitHandler::cmCTestSubmitHandler()
+  : HTTPProxy()
+  , FTPProxy()
 {
   this->Initialize();
 }
@@ -153,11 +137,10 @@ cmCTestSubmitHandler::cmCTestSubmitHandler() : HTTPProxy(), FTPProxy()
 void cmCTestSubmitHandler::Initialize()
 {
   // We submit all available parts by default.
-  for(cmCTest::Part p = cmCTest::PartStart;
-      p != cmCTest::PartCount; p = cmCTest::Part(p+1))
-    {
+  for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
+       p = cmCTest::Part(p + 1)) {
     this->SubmitPart[p] = true;
-    }
+  }
   this->CDash = false;
   this->HasWarnings = false;
   this->HasErrors = false;
@@ -172,11 +155,11 @@ void cmCTestSubmitHandler::Initialize()
 }
 
 bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
-  const std::set<std::string>& files,
-  const std::string& remoteprefix,
-  const std::string& url)
+                                          const std::set<std::string>& files,
+                                          const std::string& remoteprefix,
+                                          const std::string& url)
 {
-  CURL *curl;
+  CURL* curl;
   CURLcode res;
   FILE* ftpfile;
   char error_buffer[1024];
@@ -185,28 +168,24 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
   ::curl_global_init(CURL_GLOBAL_ALL);
 
   cmCTest::SetOfStrings::const_iterator file;
-  for ( file = files.begin(); file != files.end(); ++file )
-    {
+  for (file = files.begin(); file != files.end(); ++file) {
     /* get a curl handle */
     curl = curl_easy_init();
-    if(curl)
-      {
+    if (curl) {
       // Using proxy
-      if ( this->FTPProxyType > 0 )
-        {
+      if (this->FTPProxyType > 0) {
         curl_easy_setopt(curl, CURLOPT_PROXY, this->FTPProxy.c_str());
-        switch (this->FTPProxyType)
-          {
-        case 2:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
-          break;
-        case 3:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
-          break;
-        default:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-          }
+        switch (this->FTPProxyType) {
+          case 2:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
+            break;
+          case 3:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
+            break;
+          default:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
         }
+      }
 
       // enable uploading
       ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
@@ -214,128 +193,122 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix,
       // if there is little to no activity for too long stop submitting
       ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
       ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME,
-        SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
+                         SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
 
       ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
 
       std::string local_file = *file;
-      if ( !cmSystemTools::FileExists(local_file.c_str()) )
-        {
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
         local_file = localprefix + "/" + *file;
-        }
-      std::string upload_as
-        = url + "/" + remoteprefix + cmSystemTools::GetFilenameName(*file);
-
+      }
+      std::string upload_as =
+        url + "/" + remoteprefix + cmSystemTools::GetFilenameName(*file);
 
-      if ( !cmSystemTools::FileExists(local_file.c_str()) )
-        {
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Cannot find file: "
-          << local_file << std::endl);
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Cannot find file: " << local_file << std::endl);
         ::curl_easy_cleanup(curl);
         ::curl_global_cleanup();
         return false;
-        }
+      }
       unsigned long filelen = cmSystemTools::FileLength(local_file);
 
       ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
-      *this->LogFile << "\tUpload file: " << local_file << " to "
-          << upload_as << std::endl;
+      *this->LogFile << "\tUpload file: " << local_file << " to " << upload_as
+                     << std::endl;
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "   Upload file: " << local_file << " to " << upload_as << std::endl,
-        this->Quiet);
+                         "   Upload file: " << local_file << " to "
+                                            << upload_as << std::endl,
+                         this->Quiet);
 
       ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 
       // specify target
-      ::curl_easy_setopt(curl,CURLOPT_URL, upload_as.c_str());
+      ::curl_easy_setopt(curl, CURLOPT_URL, upload_as.c_str());
 
       // now specify which file to upload
       ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
 
       // and give the size of the upload (optional)
-      ::curl_easy_setopt(curl, CURLOPT_INFILESIZE,
-        static_cast<long>(filelen));
+      ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(filelen));
 
       // and give curl the buffer for errors
       ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
 
       // specify handler for output
       ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-        cmCTestSubmitHandlerWriteMemoryCallback);
+                         cmCTestSubmitHandlerWriteMemoryCallback);
       ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
-        cmCTestSubmitHandlerCurlDebugCallback);
+                         cmCTestSubmitHandlerCurlDebugCallback);
 
       /* we pass our 'chunk' struct to the callback function */
       cmCTestSubmitHandlerVectorOfChar chunk;
       cmCTestSubmitHandlerVectorOfChar chunkDebug;
-      ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
-      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+      ::curl_easy_setopt(curl, CURLOPT_FILE, (void*)&chunk);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
 
       // Now run off and do what you've been told!
       res = ::curl_easy_perform(curl);
 
-      if (!chunk.empty())
-        {
+      if (!chunk.empty()) {
         cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
-          << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-          << std::endl, this->Quiet);
-        }
-      if (!chunkDebug.empty())
-        {
-        cmCTestOptionalLog(this->CTest, DEBUG, "CURL debug output: ["
-          << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
-          << std::endl, this->Quiet);
-        }
+                             << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                             << "]" << std::endl,
+                           this->Quiet);
+      }
+      if (!chunkDebug.empty()) {
+        cmCTestOptionalLog(
+          this->CTest, DEBUG, "CURL debug output: ["
+            << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
+            << std::endl,
+          this->Quiet);
+      }
 
       fclose(ftpfile);
-      if ( res )
-        {
+      if (res) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when uploading file: "
+                     << local_file << std::endl);
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-          "   Error when uploading file: "
-          << local_file << std::endl);
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
-          << error_buffer << std::endl);
-        *this->LogFile << "   Error when uploading file: "
-                       << local_file
+                   "   Error message was: " << error_buffer << std::endl);
+        *this->LogFile << "   Error when uploading file: " << local_file
                        << std::endl
-                       << "   Error message was: "
-                       << error_buffer << std::endl
+                       << "   Error message was: " << error_buffer << std::endl
                        << "   Curl output was: ";
         // avoid dereference of empty vector
-        if(!chunk.empty())
-          {
+        if (!chunk.empty()) {
           *this->LogFile << cmCTestLogWrite(&*chunk.begin(), chunk.size());
           cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
-                     << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-                     << std::endl);
-          }
+                       << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                       << std::endl);
+        }
         *this->LogFile << std::endl;
         ::curl_easy_cleanup(curl);
         ::curl_global_cleanup();
         return false;
-        }
+      }
       // always cleanup
       ::curl_easy_cleanup(curl);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        "   Uploaded: " + local_file << std::endl, this->Quiet);
-      }
+                         "   Uploaded: " + local_file << std::endl,
+                         this->Quiet);
     }
+  }
   ::curl_global_cleanup();
   return true;
 }
 
 // Uploading files is simpler
 bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
-  const std::set<std::string>& files,
-  const std::string& remoteprefix,
-  const std::string& url)
+                                           const std::set<std::string>& files,
+                                           const std::string& remoteprefix,
+                                           const std::string& url)
 {
-  CURL *curl;
+  CURL* curl;
   CURLcode res;
   FILE* ftpfile;
   char error_buffer[1024];
-  struct curl_slist *headers = ::curl_slist_append(NULL,
-                                                   "Content-Type: text/xml");
+  struct curl_slist* headers =
+    ::curl_slist_append(NULL, "Content-Type: text/xml");
 
   /* In windows, this will init the winsock stuff */
   ::curl_global_init(CURL_GLOBAL_ALL);
@@ -345,65 +318,56 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
   cmSystemTools::ExpandListArgument(curlopt, args);
   bool verifyPeerOff = false;
   bool verifyHostOff = false;
-  for( std::vector<std::string>::iterator i = args.begin();
-       i != args.end(); ++i)
-    {
-    if(*i == "CURLOPT_SSL_VERIFYPEER_OFF")
-      {
+  for (std::vector<std::string>::iterator i = args.begin(); i != args.end();
+       ++i) {
+    if (*i == "CURLOPT_SSL_VERIFYPEER_OFF") {
       verifyPeerOff = true;
-      }
-    if(*i == "CURLOPT_SSL_VERIFYHOST_OFF")
-      {
+    }
+    if (*i == "CURLOPT_SSL_VERIFYHOST_OFF") {
       verifyHostOff = true;
-      }
     }
+  }
   std::string::size_type kk;
   cmCTest::SetOfStrings::const_iterator file;
-  for ( file = files.begin(); file != files.end(); ++file )
-    {
+  for (file = files.begin(); file != files.end(); ++file) {
     /* get a curl handle */
     curl = curl_easy_init();
-    if(curl)
-      {
+    if (curl) {
       cmCurlSetCAInfo(curl);
-      if(verifyPeerOff)
-        {
+      if (verifyPeerOff) {
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                   "  Set CURLOPT_SSL_VERIFYPEER to off\n", this->Quiet);
+                           "  Set CURLOPT_SSL_VERIFYPEER to off\n",
+                           this->Quiet);
         curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
-        }
-      if(verifyHostOff)
-        {
+      }
+      if (verifyHostOff) {
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                   "  Set CURLOPT_SSL_VERIFYHOST to off\n", this->Quiet);
+                           "  Set CURLOPT_SSL_VERIFYHOST to off\n",
+                           this->Quiet);
         curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
-        }
+      }
 
       // Using proxy
-      if ( this->HTTPProxyType > 0 )
-        {
+      if (this->HTTPProxyType > 0) {
         curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
-        switch (this->HTTPProxyType)
-          {
-        case 2:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
-          break;
-        case 3:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
-          break;
-        default:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-          if (!this->HTTPProxyAuth.empty())
-            {
-            curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
-              this->HTTPProxyAuth.c_str());
+        switch (this->HTTPProxyType) {
+          case 2:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
+            break;
+          case 3:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
+            break;
+          default:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+            if (!this->HTTPProxyAuth.empty()) {
+              curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
+                               this->HTTPProxyAuth.c_str());
             }
-          }
         }
-      if(this->CTest->ShouldUseHTTP10())
-        {
+      }
+      if (this->CTest->ShouldUseHTTP10()) {
         curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-        }
+      }
       // enable HTTP ERROR parsing
       curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
       /* enable uploading */
@@ -412,7 +376,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
       // if there is little to no activity for too long stop submitting
       ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
       ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME,
-        SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
+                         SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT);
 
       /* HTTP PUT please */
       ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
@@ -422,157 +386,158 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
       ::curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
 
       std::string local_file = *file;
-      if ( !cmSystemTools::FileExists(local_file.c_str()) )
-        {
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
         local_file = localprefix + "/" + *file;
-        }
-      std::string remote_file
-        = remoteprefix + cmSystemTools::GetFilenameName(*file);
+      }
+      std::string remote_file =
+        remoteprefix + cmSystemTools::GetFilenameName(*file);
 
       *this->LogFile << "\tUpload file: " << local_file << " to "
-          << remote_file << std::endl;
+                     << remote_file << std::endl;
 
       std::string ofile = "";
-      for ( kk = 0; kk < remote_file.size(); kk ++ )
-        {
+      for (kk = 0; kk < remote_file.size(); kk++) {
         char c = remote_file[kk];
         char hexCh[4] = { 0, 0, 0, 0 };
         hexCh[0] = c;
-        switch ( c )
-          {
-        case '+':
-        case '?':
-        case '/':
-        case '\\':
-        case '&':
-        case ' ':
-        case '=':
-        case '%':
-          sprintf(hexCh, "%%%02X", (int)c);
-          ofile.append(hexCh);
-          break;
-        default:
-          ofile.append(hexCh);
-          }
+        switch (c) {
+          case '+':
+          case '?':
+          case '/':
+          case '\\':
+          case '&':
+          case ' ':
+          case '=':
+          case '%':
+            sprintf(hexCh, "%%%02X", (int)c);
+            ofile.append(hexCh);
+            break;
+          default:
+            ofile.append(hexCh);
         }
-      std::string upload_as
-        = url + ((url.find("?",0) == std::string::npos) ? "?" : "&")
-        + "FileName=" + ofile;
+      }
+      std::string upload_as = url +
+        ((url.find("?", 0) == std::string::npos) ? "?" : "&") + "FileName=" +
+        ofile;
 
       upload_as += "&MD5=";
 
-      if(cmSystemTools::IsOn(this->GetOption("InternalTest")))
-        {
+      if (cmSystemTools::IsOn(this->GetOption("InternalTest"))) {
         upload_as += "bad_md5sum";
-        }
-      else
-        {
+      } else {
         char md5[33];
         cmSystemTools::ComputeFileMD5(local_file, md5);
         md5[32] = 0;
         upload_as += md5;
-        }
+      }
 
-      if( !cmSystemTools::FileExists(local_file.c_str()) )
-        {
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Cannot find file: "
-          << local_file << std::endl);
+      if (!cmSystemTools::FileExists(local_file.c_str())) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Cannot find file: " << local_file << std::endl);
         ::curl_easy_cleanup(curl);
         ::curl_slist_free_all(headers);
         ::curl_global_cleanup();
         return false;
-        }
+      }
       unsigned long filelen = cmSystemTools::FileLength(local_file);
 
       ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "   Upload file: " << local_file << " to "
-        << upload_as << " Size: " << filelen << std::endl, this->Quiet);
+                         "   Upload file: " << local_file << " to "
+                                            << upload_as << " Size: "
+                                            << filelen << std::endl,
+                         this->Quiet);
 
       // specify target
-      ::curl_easy_setopt(curl,CURLOPT_URL, upload_as.c_str());
+      ::curl_easy_setopt(curl, CURLOPT_URL, upload_as.c_str());
 
       // now specify which file to upload
       ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
 
       // and give the size of the upload (optional)
-      ::curl_easy_setopt(curl, CURLOPT_INFILESIZE,
-        static_cast<long>(filelen));
+      ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(filelen));
 
       // and give curl the buffer for errors
       ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
 
       // specify handler for output
       ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-        cmCTestSubmitHandlerWriteMemoryCallback);
+                         cmCTestSubmitHandlerWriteMemoryCallback);
       ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
-        cmCTestSubmitHandlerCurlDebugCallback);
+                         cmCTestSubmitHandlerCurlDebugCallback);
 
       /* we pass our 'chunk' struct to the callback function */
       cmCTestSubmitHandlerVectorOfChar chunk;
       cmCTestSubmitHandlerVectorOfChar chunkDebug;
-      ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
-      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+      ::curl_easy_setopt(curl, CURLOPT_FILE, (void*)&chunk);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
 
       // Now run off and do what you've been told!
       res = ::curl_easy_perform(curl);
 
-      if(cmSystemTools::IsOn(this->GetOption("InternalTest")) &&
-         cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
-         this->CTest->GetCDashVersion().c_str(), "1.7"))
-        {
+      if (cmSystemTools::IsOn(this->GetOption("InternalTest")) &&
+          cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
+                                        this->CTest->GetCDashVersion().c_str(),
+                                        "1.7")) {
         // mock failure output for internal test case
-        std::string mock_output = "<cdash version=\"1.7.0\">\n"
+        std::string mock_output =
+          "<cdash version=\"1.7.0\">\n"
           "  <status>ERROR</status>\n"
           "  <message>Checksum failed for file.</message>\n"
           "</cdash>\n";
         chunk.clear();
         chunk.assign(mock_output.begin(), mock_output.end());
-        }
+      }
 
-      if (!chunk.empty())
-        {
+      if (!chunk.empty()) {
         cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
-          << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-          << std::endl, this->Quiet);
+                             << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                             << "]" << std::endl,
+                           this->Quiet);
         this->ParseResponse(chunk);
-        }
-      if (!chunkDebug.empty())
-        {
-        cmCTestOptionalLog(this->CTest, DEBUG, "CURL debug output: ["
-          << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
-          << std::endl, this->Quiet);
-        }
+      }
+      if (!chunkDebug.empty()) {
+        cmCTestOptionalLog(
+          this->CTest, DEBUG, "CURL debug output: ["
+            << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
+            << std::endl,
+          this->Quiet);
+      }
 
       // If curl failed for any reason, or checksum fails, wait and retry
       //
-      if(res != CURLE_OK || this->HasErrors)
-        {
-        std::string retryDelay = this->GetOption("RetryDelay") == NULL ?
-          "" : this->GetOption("RetryDelay");
-        std::string retryCount = this->GetOption("RetryCount") == NULL ?
-          "" : this->GetOption("RetryCount");
-
-        int delay = retryDelay == "" ? atoi(this->CTest->GetCTestConfiguration(
-          "CTestSubmitRetryDelay").c_str()) : atoi(retryDelay.c_str());
-        int count = retryCount == "" ? atoi(this->CTest->GetCTestConfiguration(
-          "CTestSubmitRetryCount").c_str()) : atoi(retryCount.c_str());
-
-        for(int i = 0; i < count; i++)
-          {
+      if (res != CURLE_OK || this->HasErrors) {
+        std::string retryDelay = this->GetOption("RetryDelay") == NULL
+          ? ""
+          : this->GetOption("RetryDelay");
+        std::string retryCount = this->GetOption("RetryCount") == NULL
+          ? ""
+          : this->GetOption("RetryCount");
+
+        int delay = retryDelay == ""
+          ? atoi(this->CTest->GetCTestConfiguration("CTestSubmitRetryDelay")
+                   .c_str())
+          : atoi(retryDelay.c_str());
+        int count = retryCount == ""
+          ? atoi(this->CTest->GetCTestConfiguration("CTestSubmitRetryCount")
+                   .c_str())
+          : atoi(retryCount.c_str());
+
+        for (int i = 0; i < count; i++) {
           cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-            "   Submit failed, waiting " << delay << " seconds...\n",
-            this->Quiet);
+                             "   Submit failed, waiting " << delay
+                                                          << " seconds...\n",
+                             this->Quiet);
 
           double stop = cmSystemTools::GetTime() + delay;
-          while(cmSystemTools::GetTime() < stop)
-            {
+          while (cmSystemTools::GetTime() < stop) {
             cmSystemTools::Delay(100);
-            }
+          }
 
           cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-            "   Retry submission: Attempt " << (i + 1) << " of "
-            << count << std::endl, this->Quiet);
+                             "   Retry submission: Attempt "
+                               << (i + 1) << " of " << count << std::endl,
+                             this->Quiet);
 
           ::fclose(ftpfile);
           ftpfile = cmsys::SystemTools::Fopen(local_file, "rb");
@@ -584,135 +549,121 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix,
 
           res = ::curl_easy_perform(curl);
 
-          if (!chunk.empty())
-            {
-            cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
-              << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-              << std::endl, this->Quiet);
+          if (!chunk.empty()) {
+            cmCTestOptionalLog(
+              this->CTest, DEBUG, "CURL output: ["
+                << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                << std::endl,
+              this->Quiet);
             this->ParseResponse(chunk);
-            }
+          }
 
-          if(res == CURLE_OK && !this->HasErrors)
-            {
+          if (res == CURLE_OK && !this->HasErrors) {
             break;
-            }
           }
         }
+      }
 
       fclose(ftpfile);
-      if ( res )
-        {
+      if (res) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when uploading file: "
+                     << local_file << std::endl);
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-          "   Error when uploading file: "
-          << local_file << std::endl);
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
-          << error_buffer << std::endl);
-        *this->LogFile << "   Error when uploading file: "
-                       << local_file
+                   "   Error message was: " << error_buffer << std::endl);
+        *this->LogFile << "   Error when uploading file: " << local_file
                        << std::endl
                        << "   Error message was: " << error_buffer
                        << std::endl;
         // avoid deref of begin for zero size array
-        if(!chunk.empty())
-          {
+        if (!chunk.empty()) {
           *this->LogFile << "   Curl output was: "
                          << cmCTestLogWrite(&*chunk.begin(), chunk.size())
                          << std::endl;
           cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
-                     << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-                     << std::endl);
-          }
+                       << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                       << std::endl);
+        }
         ::curl_easy_cleanup(curl);
         ::curl_slist_free_all(headers);
         ::curl_global_cleanup();
         return false;
-        }
+      }
       // always cleanup
       ::curl_easy_cleanup(curl);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        "   Uploaded: " + local_file << std::endl, this->Quiet);
-      }
+                         "   Uploaded: " + local_file << std::endl,
+                         this->Quiet);
     }
+  }
   ::curl_slist_free_all(headers);
   ::curl_global_cleanup();
   return true;
 }
 
-void cmCTestSubmitHandler
-::ParseResponse(cmCTestSubmitHandlerVectorOfChar chunk)
+void cmCTestSubmitHandler::ParseResponse(
+  cmCTestSubmitHandlerVectorOfChar chunk)
 {
   std::string output = "";
   output.append(chunk.begin(), chunk.end());
 
-  if(output.find("<cdash") != output.npos)
-    {
+  if (output.find("<cdash") != output.npos) {
     ResponseParser parser;
     parser.Parse(output.c_str());
 
-    if(parser.Status != ResponseParser::STATUS_OK)
-      {
+    if (parser.Status != ResponseParser::STATUS_OK) {
       this->HasErrors = true;
-      cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission failed: " <<
-        parser.Message << std::endl);
+      cmCTestLog(this->CTest, HANDLER_OUTPUT,
+                 "   Submission failed: " << parser.Message << std::endl);
       return;
-      }
     }
+  }
   output = cmSystemTools::UpperCase(output);
-  if(output.find("WARNING") != std::string::npos)
-    {
+  if (output.find("WARNING") != std::string::npos) {
     this->HasWarnings = true;
-    }
-  if(output.find("ERROR") != std::string::npos)
-    {
+  }
+  if (output.find("ERROR") != std::string::npos) {
     this->HasErrors = true;
-    }
+  }
 
-  if(this->HasWarnings || this->HasErrors)
-    {
-    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Server Response:\n" <<
-          cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "\n");
-    }
+  if (this->HasWarnings || this->HasErrors) {
+    cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Server Response:\n"
+                 << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "\n");
+  }
 }
 
-bool cmCTestSubmitHandler::TriggerUsingHTTP(
-  const std::set<std::string>& files,
-  const std::string& remoteprefix,
-  const std::string& url)
+bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::set<std::string>& files,
+                                            const std::string& remoteprefix,
+                                            const std::string& url)
 {
-  CURL *curl;
+  CURL* curl;
   char error_buffer[1024];
 
   /* In windows, this will init the winsock stuff */
   ::curl_global_init(CURL_GLOBAL_ALL);
 
   cmCTest::SetOfStrings::const_iterator file;
-  for ( file = files.begin(); file != files.end(); ++file )
-    {
+  for (file = files.begin(); file != files.end(); ++file) {
     /* get a curl handle */
     curl = curl_easy_init();
-    if(curl)
-      {
+    if (curl) {
       // Using proxy
-      if ( this->HTTPProxyType > 0 )
-        {
+      if (this->HTTPProxyType > 0) {
         curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
-        switch (this->HTTPProxyType)
-          {
-        case 2:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
-          break;
-        case 3:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
-          break;
-        default:
-          curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
-          if (!this->HTTPProxyAuth.empty())
-            {
-            curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
-              this->HTTPProxyAuth.c_str());
+        switch (this->HTTPProxyType) {
+          case 2:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
+            break;
+          case 3:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
+            break;
+          default:
+            curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
+            if (!this->HTTPProxyAuth.empty()) {
+              curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
+                               this->HTTPProxyAuth.c_str());
             }
-          }
         }
+      }
 
       ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 
@@ -721,111 +672,105 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(
 
       // specify handler for output
       ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-        cmCTestSubmitHandlerWriteMemoryCallback);
+                         cmCTestSubmitHandlerWriteMemoryCallback);
       ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
-        cmCTestSubmitHandlerCurlDebugCallback);
+                         cmCTestSubmitHandlerCurlDebugCallback);
 
       /* we pass our 'chunk' struct to the callback function */
       cmCTestSubmitHandlerVectorOfChar chunk;
       cmCTestSubmitHandlerVectorOfChar chunkDebug;
-      ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
-      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+      ::curl_easy_setopt(curl, CURLOPT_FILE, (void*)&chunk);
+      ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
 
-      std::string rfile
-        = remoteprefix + cmSystemTools::GetFilenameName(*file);
+      std::string rfile = remoteprefix + cmSystemTools::GetFilenameName(*file);
       std::string ofile = "";
       std::string::iterator kk;
-      for ( kk = rfile.begin(); kk < rfile.end(); ++ kk)
-        {
+      for (kk = rfile.begin(); kk < rfile.end(); ++kk) {
         char c = *kk;
         char hexCh[4] = { 0, 0, 0, 0 };
         hexCh[0] = c;
-        switch ( c )
-          {
-        case '+':
-        case '?':
-        case '/':
-        case '\\':
-        case '&':
-        case ' ':
-        case '=':
-        case '%':
-          sprintf(hexCh, "%%%02X", (int)c);
-          ofile.append(hexCh);
-          break;
-        default:
-          ofile.append(hexCh);
-          }
+        switch (c) {
+          case '+':
+          case '?':
+          case '/':
+          case '\\':
+          case '&':
+          case ' ':
+          case '=':
+          case '%':
+            sprintf(hexCh, "%%%02X", (int)c);
+            ofile.append(hexCh);
+            break;
+          default:
+            ofile.append(hexCh);
         }
-      std::string turl
-        = url + ((url.find("?",0) == std::string::npos) ? "?" : "&")
-        + "xmlfile=" + ofile;
+      }
+      std::string turl = url +
+        ((url.find("?", 0) == std::string::npos) ? "?" : "&") + "xmlfile=" +
+        ofile;
       *this->LogFile << "Trigger url: " << turl << std::endl;
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "   Trigger url: " << turl << std::endl, this->Quiet);
+                         "   Trigger url: " << turl << std::endl, this->Quiet);
       curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
       curl_easy_setopt(curl, CURLOPT_URL, turl.c_str());
-      if ( curl_easy_perform(curl) )
-        {
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when triggering: "
-          << turl << std::endl);
-        cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
-          << error_buffer << std::endl);
+      if (curl_easy_perform(curl)) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Error when triggering: " << turl << std::endl);
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "   Error message was: " << error_buffer << std::endl);
         *this->LogFile << "\tTriggering failed with error: " << error_buffer
                        << std::endl
                        << "   Error message was: " << error_buffer
                        << std::endl;
-        if(!chunk.empty())
-          {
-          *this->LogFile
-            << "   Curl output was: "
-            << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
+        if (!chunk.empty()) {
+          *this->LogFile << "   Curl output was: "
+                         << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                         << std::endl;
           cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
-                     << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-                     << std::endl);
-          }
+                       << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
+                       << std::endl);
+        }
         ::curl_easy_cleanup(curl);
         ::curl_global_cleanup();
         return false;
-        }
+      }
 
-      if (!chunk.empty())
-        {
+      if (!chunk.empty()) {
         cmCTestOptionalLog(this->CTest, DEBUG, "CURL output: ["
-          << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
-          << std::endl, this->Quiet);
-        }
-      if (!chunkDebug.empty())
-        {
-        cmCTestOptionalLog(this->CTest, DEBUG, "CURL debug output: ["
-          << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size())
-          << "]" << std::endl, this->Quiet);
-        }
+                             << cmCTestLogWrite(&*chunk.begin(), chunk.size())
+                             << "]" << std::endl,
+                           this->Quiet);
+      }
+      if (!chunkDebug.empty()) {
+        cmCTestOptionalLog(
+          this->CTest, DEBUG, "CURL debug output: ["
+            << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
+            << std::endl,
+          this->Quiet);
+      }
 
       // always cleanup
       ::curl_easy_cleanup(curl);
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
-        this->Quiet);
-      }
+                         this->Quiet);
     }
+  }
   ::curl_global_cleanup();
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Dart server triggered..."
-    << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                     "   Dart server triggered..." << std::endl, this->Quiet);
   return true;
 }
 
-bool cmCTestSubmitHandler::SubmitUsingSCP(
-  const std::string& scp_command,
-  const std::string& localprefix,
-  const std::set<std::string>& files,
-  const std::string& remoteprefix,
-  const std::string& url)
+bool cmCTestSubmitHandler::SubmitUsingSCP(const std::string& scp_command,
+                                          const std::string& localprefix,
+                                          const std::set<std::string>& files,
+                                          const std::string& remoteprefix,
+                                          const std::string& url)
 {
-  if ( scp_command.empty() || localprefix.empty() ||
-    files.empty() || remoteprefix.empty() || url.empty() )
-    {
+  if (scp_command.empty() || localprefix.empty() || files.empty() ||
+      remoteprefix.empty() || url.empty()) {
     return 0;
-    }
+  }
 
   std::vector<const char*> argv;
   argv.push_back(scp_command.c_str()); // Scp command
@@ -835,13 +780,12 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
 
   cmsysProcess* cp = cmsysProcess_New();
   cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
-  //cmsysProcess_SetTimeout(cp, timeout);
+  // cmsysProcess_SetTimeout(cp, timeout);
 
   int problems = 0;
 
   cmCTest::SetOfStrings::const_iterator file;
-  for ( file = files.begin(); file != files.end(); ++file )
-    {
+  for (file = files.begin(); file != files.end(); ++file) {
     int retVal;
 
     std::string lfname = localprefix;
@@ -851,79 +795,69 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
     argv[1] = lfname.c_str();
     std::string rfname = url + "/" + remoteprefix + *file;
     argv[2] = rfname.c_str();
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
-      << argv[2] << "\"" << std::endl, this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Execute \""
+                         << argv[0] << "\" \"" << argv[1] << "\" \"" << argv[2]
+                         << "\"" << std::endl,
+                       this->Quiet);
     *this->LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
-      << argv[2] << "\"" << std::endl;
+                   << argv[2] << "\"" << std::endl;
 
     cmsysProcess_SetCommand(cp, &*argv.begin());
     cmsysProcess_Execute(cp);
     char* data;
     int length;
 
-    while(cmsysProcess_WaitForData(cp, &data, &length, 0))
-      {
+    while (cmsysProcess_WaitForData(cp, &data, &length, 0)) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        cmCTestLogWrite(data, length), this->Quiet);
-      }
+                         cmCTestLogWrite(data, length), this->Quiet);
+    }
 
     cmsysProcess_WaitForExit(cp, 0);
 
     int result = cmsysProcess_GetState(cp);
 
-    if(result == cmsysProcess_State_Exited)
-      {
+    if (result == cmsysProcess_State_Exited) {
       retVal = cmsysProcess_GetExitValue(cp);
-      if ( retVal != 0 )
-        {
+      if (retVal != 0) {
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "\tSCP returned: " << retVal << std::endl, this->Quiet);
+                           "\tSCP returned: " << retVal << std::endl,
+                           this->Quiet);
         *this->LogFile << "\tSCP returned: " << retVal << std::endl;
-        problems ++;
-        }
+        problems++;
       }
-    else if(result == cmsysProcess_State_Exception)
-      {
+    } else if (result == cmsysProcess_State_Exception) {
       retVal = cmsysProcess_GetExitException(cp);
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was an exception: "
-        << retVal << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "\tThere was an exception: " << retVal << std::endl);
       *this->LogFile << "\tThere was an exception: " << retVal << std::endl;
-      problems ++;
-      }
-    else if(result == cmsysProcess_State_Expired)
-      {
+      problems++;
+    } else if (result == cmsysProcess_State_Expired) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
-        << std::endl);
+                   << std::endl);
       *this->LogFile << "\tThere was a timeout" << std::endl;
-      problems ++;
-      }
-    else if(result == cmsysProcess_State_Error)
-      {
+      problems++;
+    } else if (result == cmsysProcess_State_Error) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing SCP: "
-        << cmsysProcess_GetErrorString(cp) << std::endl);
+                   << cmsysProcess_GetErrorString(cp) << std::endl);
       *this->LogFile << "\tError executing SCP: "
-        << cmsysProcess_GetErrorString(cp) << std::endl;
-      problems ++;
-      }
+                     << cmsysProcess_GetErrorString(cp) << std::endl;
+      problems++;
     }
+  }
   cmsysProcess_Delete(cp);
-  if ( problems )
-    {
+  if (problems) {
     return false;
-    }
+  }
   return true;
 }
 
-bool cmCTestSubmitHandler::SubmitUsingCP(
-  const std::string& localprefix,
-  const std::set<std::string>& files,
-  const std::string& remoteprefix,
-  const std::string& destination)
+bool cmCTestSubmitHandler::SubmitUsingCP(const std::string& localprefix,
+                                         const std::set<std::string>& files,
+                                         const std::string& remoteprefix,
+                                         const std::string& destination)
 {
-  if ( localprefix.empty() ||
-    files.empty() || remoteprefix.empty() || destination.empty() )
-    {
+  if (localprefix.empty() || files.empty() || remoteprefix.empty() ||
+      destination.empty()) {
     /* clang-format off */
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Missing arguments for submit via cp:\n"
@@ -933,36 +867,32 @@ bool cmCTestSubmitHandler::SubmitUsingCP(
                << "\tdestination: " << destination << std::endl);
     /* clang-format on */
     return 0;
-    }
+  }
 
   cmCTest::SetOfStrings::const_iterator file;
   bool problems = false;
-  for ( file = files.begin(); file != files.end(); ++file )
-    {
+  for (file = files.begin(); file != files.end(); ++file) {
     std::string lfname = localprefix;
     cmSystemTools::ConvertToUnixSlashes(lfname);
     lfname += "/" + *file;
     std::string rfname = destination + "/" + remoteprefix + *file;
     cmSystemTools::CopyFileAlways(lfname, rfname);
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Copy file: "
-        << lfname << " to "
-        << rfname << std::endl, this->Quiet);
-    }
+                         << lfname << " to " << rfname << std::endl,
+                       this->Quiet);
+  }
   std::string tagDoneFile = destination + "/" + remoteprefix + "DONE";
   cmSystemTools::Touch(tagDoneFile, true);
-  if ( problems )
-    {
+  if (problems) {
     return false;
-    }
+  }
   return true;
 }
 
-
 #if defined(CTEST_USE_XMLRPC)
-bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const std::string& localprefix,
-  const std::set<std::string>& files,
-  const std::string& remoteprefix,
-  const std::string& url)
+bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
+  const std::string& localprefix, const std::set<std::string>& files,
+  const std::string& remoteprefix, const std::string& url)
 {
   xmlrpc_env env;
   char ctestString[] = "CTest";
@@ -979,76 +909,72 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const std::string& localprefix,
 
   /* Call the famous server at UserLand. */
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submitting to: "
-    << realURL.c_str() << " (" << remoteprefix.c_str() << ")" << std::endl,
-    this->Quiet);
+                       << realURL.c_str() << " (" << remoteprefix.c_str()
+                       << ")" << std::endl,
+                     this->Quiet);
   cmCTest::SetOfStrings::const_iterator file;
-  for ( file = files.begin(); file != files.end(); ++file )
-    {
-    xmlrpc_value *result;
+  for (file = files.begin(); file != files.end(); ++file) {
+    xmlrpc_value* result;
 
     std::string local_file = *file;
-    if ( !cmSystemTools::FileExists(local_file.c_str()) )
-      {
+    if (!cmSystemTools::FileExists(local_file.c_str())) {
       local_file = localprefix + "/" + *file;
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submit file: "
-      << local_file.c_str() << std::endl, this->Quiet);
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submit file: " << local_file.c_str() << std::endl,
+                       this->Quiet);
     struct stat st;
-    if ( ::stat(local_file.c_str(), &st) )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot find file: "
-        << local_file.c_str() << std::endl);
+    if (::stat(local_file.c_str(), &st)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  Cannot find file: " << local_file.c_str() << std::endl);
       return false;
-      }
+    }
 
     // off_t can be bigger than size_t.  fread takes size_t.
     // make sure the file is not too big.
-    if(static_cast<off_t>(static_cast<size_t>(st.st_size)) !=
-       static_cast<off_t>(st.st_size))
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "  File too big: "
-        << local_file.c_str() << std::endl);
+    if (static_cast<off_t>(static_cast<size_t>(st.st_size)) !=
+        static_cast<off_t>(st.st_size)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  File too big: " << local_file.c_str() << std::endl);
       return false;
-      }
+    }
     size_t fileSize = static_cast<size_t>(st.st_size);
     FILE* fp = cmsys::SystemTools::Fopen(local_file.c_str(), "rb");
-    if ( !fp )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot open file: "
-        << local_file.c_str() << std::endl);
+    if (!fp) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  Cannot open file: " << local_file.c_str() << std::endl);
       return false;
-      }
+    }
 
-    unsigned char *fileBuffer = new unsigned char[fileSize];
-    if ( fread(fileBuffer, 1, fileSize, fp) != fileSize )
-      {
-      delete [] fileBuffer;
+    unsigned char* fileBuffer = new unsigned char[fileSize];
+    if (fread(fileBuffer, 1, fileSize, fp) != fileSize) {
+      delete[] fileBuffer;
       fclose(fp);
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot read file: "
-        << local_file.c_str() << std::endl);
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "  Cannot read file: " << local_file.c_str() << std::endl);
       return false;
-      }
+    }
     fclose(fp);
 
     char remoteCommand[] = "Submit.put";
     char* pRealURL = const_cast<char*>(realURL.c_str());
-    result = xmlrpc_client_call(&env, pRealURL, remoteCommand,
-      "(6)", fileBuffer, (xmlrpc_int32)fileSize );
+    result = xmlrpc_client_call(&env, pRealURL, remoteCommand, "(6)",
+                                fileBuffer, (xmlrpc_int32)fileSize);
 
-    delete [] fileBuffer;
+    delete[] fileBuffer;
 
-    if ( env.fault_occurred )
-      {
+    if (env.fault_occurred) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, " Submission problem: "
-        << env.fault_string << " (" << env.fault_code << ")" << std::endl);
+                   << env.fault_string << " (" << env.fault_code << ")"
+                   << std::endl);
       xmlrpc_env_clean(&env);
       xmlrpc_client_cleanup();
       return false;
-      }
+    }
 
     /* Dispose of our result value. */
     xmlrpc_DECREF(result);
-    }
+  }
 
   /* Clean up our error-handling environment. */
   xmlrpc_env_clean(&env);
@@ -1073,40 +999,33 @@ void cmCTestSubmitHandler::ConstructCDashURL(std::string& dropMethod,
   dropMethod = this->CTest->GetCTestConfiguration("DropMethod");
   url = dropMethod;
   url += "://";
-  if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
-    {
+  if (this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0) {
     url += this->CTest->GetCTestConfiguration("DropSiteUser");
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      this->CTest->GetCTestConfiguration("DropSiteUser").c_str(),
-      this->Quiet);
-    if ( this->CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
-      {
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_OUTPUT,
+      this->CTest->GetCTestConfiguration("DropSiteUser").c_str(), this->Quiet);
+    if (this->CTest->GetCTestConfiguration("DropSitePassword").size() > 0) {
       url += ":" + this->CTest->GetCTestConfiguration("DropSitePassword");
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******",
-        this->Quiet);
-      }
-    url += "@";
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******", this->Quiet);
     }
+    url += "@";
+  }
   url += this->CTest->GetCTestConfiguration("DropSite") +
     this->CTest->GetCTestConfiguration("DropLocation");
 }
 
-
 int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
                                                 std::string const& typeString)
 {
-  if (file.empty())
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Upload file not specified\n");
+  if (file.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Upload file not specified\n");
     return -1;
-    }
-  if (!cmSystemTools::FileExists(file))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Upload file not found: '" << file << "'\n");
+  }
+  if (!cmSystemTools::FileExists(file)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Upload file not found: '"
+                 << file << "'\n");
     return -1;
-    }
+  }
   cmCTestCurl curl(this->CTest);
   std::string curlopt(this->CTest->GetCTestConfiguration("CurlOptions"));
   std::vector<std::string> args;
@@ -1117,13 +1036,12 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
   std::string url;
   this->ConstructCDashURL(dropMethod, url);
   std::string::size_type pos = url.find("submit.php?");
-  url = url.substr(0, pos+10);
-  if ( ! (dropMethod == "http" || dropMethod == "https" ) )
-    {
+  url = url.substr(0, pos + 10);
+  if (!(dropMethod == "http" || dropMethod == "https")) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Only http and https are supported for CDASH_UPLOAD\n");
     return -1;
-    }
+  }
   char md5sum[33];
   md5sum[32] = 0;
   cmSystemTools::ComputeFileMD5(file, md5sum);
@@ -1133,75 +1051,68 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
   // a "&subproject=subprojectname" to the first POST.
   cmCTestScriptHandler* ch =
     static_cast<cmCTestScriptHandler*>(this->CTest->GetHandler("script"));
-  cmake* cm =  ch->GetCMake();
+  cmake* cm = ch->GetCMake();
   const char* subproject = cm->GetState()->GetGlobalProperty("SubProject");
   // TODO: Encode values for a URL instead of trusting caller.
   std::ostringstream str;
   str << "project="
       << curl.Escape(this->CTest->GetCTestConfiguration("ProjectName")) << "&";
-  if(subproject)
-    {
+  if (subproject) {
     str << "subproject=" << curl.Escape(subproject) << "&";
-    }
+  }
   str << "stamp=" << curl.Escape(this->CTest->GetCurrentTag()) << "-"
       << curl.Escape(this->CTest->GetTestModelString()) << "&"
       << "model=" << curl.Escape(this->CTest->GetTestModelString()) << "&"
       << "build="
       << curl.Escape(this->CTest->GetCTestConfiguration("BuildName")) << "&"
-      << "site="
-      << curl.Escape(this->CTest->GetCTestConfiguration("Site")) << "&"
-      << "track="
-      << curl.Escape(this->CTest->GetTestModelString()) << "&"
+      << "site=" << curl.Escape(this->CTest->GetCTestConfiguration("Site"))
+      << "&"
+      << "track=" << curl.Escape(this->CTest->GetTestModelString()) << "&"
       << "starttime=" << (int)cmSystemTools::GetTime() << "&"
       << "endtime=" << (int)cmSystemTools::GetTime() << "&"
       << "datafilesmd5[0]=" << md5sum << "&"
       << "type=" << curl.Escape(typeString);
   std::string fields = str.str();
-  cmCTestOptionalLog(this->CTest, DEBUG, "fields: " << fields << "\nurl:"
-             << url << "\nfile: " << file << "\n", this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "fields: " << fields << "\nurl:" << url
+                                << "\nfile: " << file << "\n",
+                     this->Quiet);
   std::string response;
-  if(!curl.HttpRequest(url, fields, response))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Error in HttpRequest\n" << response);
+  if (!curl.HttpRequest(url, fields, response)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error in HttpRequest\n"
+                 << response);
     return -1;
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Request upload response: [" << response << "]\n", this->Quiet);
+                     "Request upload response: [" << response << "]\n",
+                     this->Quiet);
   Json::Value json;
   Json::Reader reader;
-  if(!reader.parse(response, json))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "error parsing json string [" << response << "]\n"
-               << reader.getFormattedErrorMessages() << "\n");
+  if (!reader.parse(response, json)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error parsing json string ["
+                 << response << "]\n"
+                 << reader.getFormattedErrorMessages() << "\n");
     return -1;
-    }
-  if(json["status"].asInt() != 0)
-    {
+  }
+  if (json["status"].asInt() != 0) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Bad status returned from CDash: "
-               << json["status"].asInt());
+               "Bad status returned from CDash: " << json["status"].asInt());
     return -1;
-    }
-  if(json["datafilesmd5"].isArray())
-    {
+  }
+  if (json["datafilesmd5"].isArray()) {
     int datares = json["datafilesmd5"][0].asInt();
-    if(datares == 1)
-      {
+    if (datares == 1) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "File already exists on CDash, skip upload " << file << "\n",
-        this->Quiet);
+                         "File already exists on CDash, skip upload " << file
+                                                                      << "\n",
+                         this->Quiet);
       return 0;
-      }
     }
-  else
-    {
+  } else {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "bad datafilesmd5 value in response "
-               << response << "\n");
+               "bad datafilesmd5 value in response " << response << "\n");
     return -1;
-    }
+  }
 
   std::string upload_as = cmSystemTools::GetFilenameName(file);
   std::ostringstream fstr;
@@ -1209,22 +1120,20 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file,
        << "md5=" << md5sum << "&"
        << "filename=" << curl.Escape(upload_as) << "&"
        << "buildid=" << json["buildid"].asString();
-  if(!curl.UploadFile(file, url, fstr.str(), response))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "error uploading to CDash. "
-               << file << " " << url << " " << fstr.str());
+  if (!curl.UploadFile(file, url, fstr.str(), response)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error uploading to CDash. "
+                 << file << " " << url << " " << fstr.str());
     return -1;
-    }
-  if(!reader.parse(response, json))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "error parsing json string [" << response << "]\n"
-               << reader.getFormattedErrorMessages() << "\n");
+  }
+  if (!reader.parse(response, json)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error parsing json string ["
+                 << response << "]\n"
+                 << reader.getFormattedErrorMessages() << "\n");
     return -1;
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Upload file response: [" << response << "]\n", this->Quiet );
+                     "Upload file response: [" << response << "]\n",
+                     this->Quiet);
   return 0;
 }
 
@@ -1232,114 +1141,92 @@ int cmCTestSubmitHandler::ProcessHandler()
 {
   const char* cdashUploadFile = this->GetOption("CDashUploadFile");
   const char* cdashUploadType = this->GetOption("CDashUploadType");
-  if(cdashUploadFile && cdashUploadType)
-    {
+  if (cdashUploadFile && cdashUploadType) {
     return this->HandleCDashUploadFile(cdashUploadFile, cdashUploadType);
-    }
+  }
   std::string iscdash = this->CTest->GetCTestConfiguration("IsCDash");
   // cdash does not need to trigger so just return true
-  if(!iscdash.empty())
-    {
+  if (!iscdash.empty()) {
     this->CDash = true;
-    }
+  }
 
-  const std::string &buildDirectory
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
-  if (buildDirectory.empty())
-    {
+  const std::string& buildDirectory =
+    this->CTest->GetCTestConfiguration("BuildDirectory");
+  if (buildDirectory.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
-      << std::endl);
+               "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
     return -1;
-    }
+  }
 
-  if ( getenv("HTTP_PROXY") )
-    {
+  if (getenv("HTTP_PROXY")) {
     this->HTTPProxyType = 1;
     this->HTTPProxy = getenv("HTTP_PROXY");
-    if ( getenv("HTTP_PROXY_PORT") )
-      {
+    if (getenv("HTTP_PROXY_PORT")) {
       this->HTTPProxy += ":";
       this->HTTPProxy += getenv("HTTP_PROXY_PORT");
-      }
-    if ( getenv("HTTP_PROXY_TYPE") )
-      {
+    }
+    if (getenv("HTTP_PROXY_TYPE")) {
       std::string type = getenv("HTTP_PROXY_TYPE");
       // HTTP/SOCKS4/SOCKS5
-      if ( type == "HTTP" )
-        {
+      if (type == "HTTP") {
         this->HTTPProxyType = 1;
-        }
-      else if ( type == "SOCKS4" )
-        {
+      } else if (type == "SOCKS4") {
         this->HTTPProxyType = 2;
-        }
-      else if ( type == "SOCKS5" )
-        {
+      } else if (type == "SOCKS5") {
         this->HTTPProxyType = 3;
-        }
       }
-    if ( getenv("HTTP_PROXY_USER") )
-      {
+    }
+    if (getenv("HTTP_PROXY_USER")) {
       this->HTTPProxyAuth = getenv("HTTP_PROXY_USER");
-      }
-    if ( getenv("HTTP_PROXY_PASSWD") )
-      {
+    }
+    if (getenv("HTTP_PROXY_PASSWD")) {
       this->HTTPProxyAuth += ":";
       this->HTTPProxyAuth += getenv("HTTP_PROXY_PASSWD");
-      }
     }
+  }
 
-  if ( getenv("FTP_PROXY") )
-    {
+  if (getenv("FTP_PROXY")) {
     this->FTPProxyType = 1;
     this->FTPProxy = getenv("FTP_PROXY");
-    if ( getenv("FTP_PROXY_PORT") )
-      {
+    if (getenv("FTP_PROXY_PORT")) {
       this->FTPProxy += ":";
       this->FTPProxy += getenv("FTP_PROXY_PORT");
-      }
-    if ( getenv("FTP_PROXY_TYPE") )
-      {
+    }
+    if (getenv("FTP_PROXY_TYPE")) {
       std::string type = getenv("FTP_PROXY_TYPE");
       // HTTP/SOCKS4/SOCKS5
-      if ( type == "HTTP" )
-        {
+      if (type == "HTTP") {
         this->FTPProxyType = 1;
-        }
-      else if ( type == "SOCKS4" )
-        {
+      } else if (type == "SOCKS4") {
         this->FTPProxyType = 2;
-        }
-      else if ( type == "SOCKS5" )
-        {
+      } else if (type == "SOCKS5") {
         this->FTPProxyType = 3;
-        }
       }
     }
+  }
 
-  if (!this->HTTPProxy.empty())
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Use HTTP Proxy: "
-      << this->HTTPProxy << std::endl, this->Quiet);
-    }
-  if (!this->FTPProxy.empty())
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Use FTP Proxy: "
-      << this->FTPProxy << std::endl, this->Quiet);
-    }
+  if (!this->HTTPProxy.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Use HTTP Proxy: " << this->HTTPProxy << std::endl,
+                       this->Quiet);
+  }
+  if (!this->FTPProxy.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Use FTP Proxy: " << this->FTPProxy << std::endl,
+                       this->Quiet);
+  }
   cmGeneratedFileStream ofs;
   this->StartLogFile("Submit", ofs);
 
   cmCTest::SetOfStrings files;
   std::string prefix = this->GetSubmitResultsPrefix();
 
-  if (!this->Files.empty())
-    {
+  if (!this->Files.empty()) {
     // Submit the explicitly selected files:
     //
     files.insert(this->Files.begin(), this->Files.end());
-    }
+  }
 
   // Add to the list of files to submit from any selected, existing parts:
   //
@@ -1351,244 +1238,225 @@ int cmCTestSubmitHandler::ProcessHandler()
   this->CTest->AddIfExists(cmCTest::PartConfigure, "Configure.xml");
   this->CTest->AddIfExists(cmCTest::PartBuild, "Build.xml");
   this->CTest->AddIfExists(cmCTest::PartTest, "Test.xml");
-  if(this->CTest->AddIfExists(cmCTest::PartCoverage, "Coverage.xml"))
-    {
+  if (this->CTest->AddIfExists(cmCTest::PartCoverage, "Coverage.xml")) {
     std::vector<std::string> gfiles;
-    std::string gpath
-      = buildDirectory + "/Testing/" + this->CTest->GetCurrentTag();
+    std::string gpath =
+      buildDirectory + "/Testing/" + this->CTest->GetCurrentTag();
     std::string::size_type glen = gpath.size() + 1;
     gpath = gpath + "/CoverageLog*";
-    cmCTestOptionalLog(this->CTest, DEBUG, "Globbing for: " << gpath
-      << std::endl, this->Quiet);
-    if ( cmSystemTools::SimpleGlob(gpath, gfiles, 1) )
-      {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Globbing for: " << gpath << std::endl, this->Quiet);
+    if (cmSystemTools::SimpleGlob(gpath, gfiles, 1)) {
       size_t cc;
-      for ( cc = 0; cc < gfiles.size(); cc ++ )
-        {
+      for (cc = 0; cc < gfiles.size(); cc++) {
         gfiles[cc] = gfiles[cc].substr(glen);
-        cmCTestOptionalLog(this->CTest, DEBUG, "Glob file: " << gfiles[cc]
-          << std::endl, this->Quiet);
+        cmCTestOptionalLog(this->CTest, DEBUG,
+                           "Glob file: " << gfiles[cc] << std::endl,
+                           this->Quiet);
         this->CTest->AddSubmitFile(cmCTest::PartCoverage, gfiles[cc].c_str());
-        }
       }
-    else
-      {
+    } else {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem globbing" << std::endl);
-      }
     }
+  }
   this->CTest->AddIfExists(cmCTest::PartMemCheck, "DynamicAnalysis.xml");
   this->CTest->AddIfExists(cmCTest::PartMemCheck, "Purify.xml");
   this->CTest->AddIfExists(cmCTest::PartNotes, "Notes.xml");
   this->CTest->AddIfExists(cmCTest::PartUpload, "Upload.xml");
 
   // Query parts for files to submit.
-  for(cmCTest::Part p = cmCTest::PartStart;
-      p != cmCTest::PartCount; p = cmCTest::Part(p+1))
-    {
+  for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
+       p = cmCTest::Part(p + 1)) {
     // Skip parts we are not submitting.
-    if(!this->SubmitPart[p])
-      {
+    if (!this->SubmitPart[p]) {
       continue;
-      }
+    }
 
     // Submit files from this part.
     std::vector<std::string> const& pfiles = this->CTest->GetSubmitFiles(p);
     files.insert(pfiles.begin(), pfiles.end());
-    }
+  }
 
-  if ( ofs )
-    {
+  if (ofs) {
     ofs << "Upload files:" << std::endl;
     int cnt = 0;
     cmCTest::SetOfStrings::iterator it;
-    for ( it = files.begin(); it != files.end(); ++ it )
-      {
+    for (it = files.begin(); it != files.end(); ++it) {
       ofs << cnt << "\t" << *it << std::endl;
-      cnt ++;
-      }
+      cnt++;
     }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Submit files (using "
-    << this->CTest->GetCTestConfiguration("DropMethod") << ")"
-    << std::endl, this->Quiet);
+                       << this->CTest->GetCTestConfiguration("DropMethod")
+                       << ")" << std::endl,
+                     this->Quiet);
   const char* specificTrack = this->CTest->GetSpecificTrack();
-  if ( specificTrack )
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Send to track: "
-      << specificTrack << std::endl, this->Quiet);
-    }
+  if (specificTrack) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Send to track: " << specificTrack << std::endl,
+                       this->Quiet);
+  }
   this->SetLogFile(&ofs);
 
   std::string dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
 
-  if ( dropMethod == "" || dropMethod == "ftp" )
-    {
+  if (dropMethod == "" || dropMethod == "ftp") {
     ofs << "Using drop method: FTP" << std::endl;
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "   Using FTP submit method" << std::endl << "   Drop site: ftp://",
-      this->Quiet);
+                       "   Using FTP submit method" << std::endl
+                                                    << "   Drop site: ftp://",
+                       this->Quiet);
     std::string url = "ftp://";
     url += cmCTest::MakeURLSafe(
-      this->CTest->GetCTestConfiguration("DropSiteUser")) + ":" +
-      cmCTest::MakeURLSafe(this->CTest->GetCTestConfiguration(
-          "DropSitePassword")) + "@" +
-      this->CTest->GetCTestConfiguration("DropSite") +
-      cmCTest::MakeURLSafe(
-        this->CTest->GetCTestConfiguration("DropLocation"));
-    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty())
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        this->CTest->GetCTestConfiguration(
-          "DropSiteUser").c_str(), this->Quiet);
-      if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty())
-        {
+             this->CTest->GetCTestConfiguration("DropSiteUser")) +
+      ":" + cmCTest::MakeURLSafe(
+              this->CTest->GetCTestConfiguration("DropSitePassword")) +
+      "@" + this->CTest->GetCTestConfiguration("DropSite") +
+      cmCTest::MakeURLSafe(this->CTest->GetCTestConfiguration("DropLocation"));
+    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT,
+        this->CTest->GetCTestConfiguration("DropSiteUser").c_str(),
+        this->Quiet);
+      if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty()) {
         cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******",
-          this->Quiet);
-        }
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "@", this->Quiet);
+                           this->Quiet);
       }
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "@", this->Quiet);
+    }
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      this->CTest->GetCTestConfiguration("DropSite")
-      << this->CTest->GetCTestConfiguration("DropLocation") << std::endl,
-      this->Quiet);
-    if ( !this->SubmitUsingFTP(buildDirectory + "/Testing/"
-        + this->CTest->GetCurrentTag(),
-        files, prefix, url) )
-      {
+                       this->CTest->GetCTestConfiguration("DropSite")
+                         << this->CTest->GetCTestConfiguration("DropLocation")
+                         << std::endl,
+                       this->Quiet);
+    if (!this->SubmitUsingFTP(buildDirectory + "/Testing/" +
+                                this->CTest->GetCurrentTag(),
+                              files, prefix, url)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "   Problems when submitting via FTP"
-        << std::endl);
+                 "   Problems when submitting via FTP" << std::endl);
       ofs << "   Problems when submitting via FTP" << std::endl;
       return -1;
-      }
-    if(!this->CDash)
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-                 "   Using HTTP trigger method"
-                 << std::endl
-                 << "   Trigger site: "
-                 << this->CTest->GetCTestConfiguration("TriggerSite")
-                 << std::endl, this->Quiet);
-      if ( !this->
-           TriggerUsingHTTP(files, prefix,
-                            this->CTest->GetCTestConfiguration("TriggerSite")))
-        {
+    }
+    if (!this->CDash) {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
+          << std::endl
+          << "   Trigger site: "
+          << this->CTest->GetCTestConfiguration("TriggerSite") << std::endl,
+        this->Quiet);
+      if (!this->TriggerUsingHTTP(
+            files, prefix,
+            this->CTest->GetCTestConfiguration("TriggerSite"))) {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
                    "   Problems when triggering via HTTP" << std::endl);
         ofs << "   Problems when triggering via HTTP" << std::endl;
         return -1;
-        }
+      }
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        "   Submission successful" << std::endl, this->Quiet);
+                         "   Submission successful" << std::endl, this->Quiet);
       ofs << "   Submission successful" << std::endl;
       return 0;
-      }
     }
-  else if ( dropMethod == "http" || dropMethod == "https" )
-    {
+  } else if (dropMethod == "http" || dropMethod == "https") {
     std::string url = dropMethod;
     url += "://";
     ofs << "Using drop method: " << dropMethod << std::endl;
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "   Using HTTP submit method" << std::endl << "   Drop site:" << url,
-      this->Quiet);
-     if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty())
-      {
+                       "   Using HTTP submit method" << std::endl
+                                                     << "   Drop site:" << url,
+                       this->Quiet);
+    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
       url += this->CTest->GetCTestConfiguration("DropSiteUser");
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT,
         this->CTest->GetCTestConfiguration("DropSiteUser").c_str(),
         this->Quiet);
-      if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty())
-        {
+      if (!this->CTest->GetCTestConfiguration("DropSitePassword").empty()) {
         url += ":" + this->CTest->GetCTestConfiguration("DropSitePassword");
         cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, ":******",
-          this->Quiet);
-        }
+                           this->Quiet);
+      }
       url += "@";
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "@", this->Quiet);
-      }
+    }
     url += this->CTest->GetCTestConfiguration("DropSite") +
       this->CTest->GetCTestConfiguration("DropLocation");
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      this->CTest->GetCTestConfiguration("DropSite")
-      << this->CTest->GetCTestConfiguration("DropLocation") << std::endl,
-      this->Quiet);
-    if ( !this->SubmitUsingHTTP(buildDirectory + "/Testing/" +
-        this->CTest->GetCurrentTag(), files, prefix, url) )
-      {
+                       this->CTest->GetCTestConfiguration("DropSite")
+                         << this->CTest->GetCTestConfiguration("DropLocation")
+                         << std::endl,
+                       this->Quiet);
+    if (!this->SubmitUsingHTTP(buildDirectory + "/Testing/" +
+                                 this->CTest->GetCurrentTag(),
+                               files, prefix, url)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "   Problems when submitting via HTTP" << std::endl);
+                 "   Problems when submitting via HTTP" << std::endl);
       ofs << "   Problems when submitting via HTTP" << std::endl;
       return -1;
-      }
-    if(!this->CDash)
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        "   Using HTTP trigger method" << std::endl << "   Trigger site: "
-                 << this->CTest->GetCTestConfiguration("TriggerSite")
-                 << std::endl, this->Quiet);
-      if ( !this->
-           TriggerUsingHTTP(files, prefix,
-                            this->CTest->GetCTestConfiguration("TriggerSite")))
-        {
+    }
+    if (!this->CDash) {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
+          << std::endl
+          << "   Trigger site: "
+          << this->CTest->GetCTestConfiguration("TriggerSite") << std::endl,
+        this->Quiet);
+      if (!this->TriggerUsingHTTP(
+            files, prefix,
+            this->CTest->GetCTestConfiguration("TriggerSite"))) {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
                    "   Problems when triggering via HTTP" << std::endl);
         ofs << "   Problems when triggering via HTTP" << std::endl;
         return -1;
-        }
       }
-    if(this->HasErrors)
-      {
+    }
+    if (this->HasErrors) {
       cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Errors occurred during "
-        "submission." << std::endl);
+                                              "submission."
+                   << std::endl);
       ofs << "   Errors occurred during submission. " << std::endl;
-      }
-    else
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        "   Submission successful" <<
-        (this->HasWarnings ? ", with warnings." : "") << std::endl,
+    } else {
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_OUTPUT, "   Submission successful"
+          << (this->HasWarnings ? ", with warnings." : "") << std::endl,
         this->Quiet);
-      ofs << "   Submission successful" <<
-        (this->HasWarnings ? ", with warnings." : "") << std::endl;
-      }
+      ofs << "   Submission successful"
+          << (this->HasWarnings ? ", with warnings." : "") << std::endl;
+    }
 
     return 0;
-    }
-  else if ( dropMethod == "xmlrpc" )
-    {
+  } else if (dropMethod == "xmlrpc") {
 #if defined(CTEST_USE_XMLRPC)
     ofs << "Using drop method: XML-RPC" << std::endl;
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "   Using XML-RPC submit method" << std::endl, this->Quiet);
+                       "   Using XML-RPC submit method" << std::endl,
+                       this->Quiet);
     std::string url = this->CTest->GetCTestConfiguration("DropSite");
     prefix = this->CTest->GetCTestConfiguration("DropLocation");
-    if ( !this->SubmitUsingXMLRPC(buildDirectory + "/Testing/" +
-        this->CTest->GetCurrentTag(), files, prefix, url) )
-      {
+    if (!this->SubmitUsingXMLRPC(buildDirectory + "/Testing/" +
+                                   this->CTest->GetCurrentTag(),
+                                 files, prefix, url)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "   Problems when submitting via XML-RPC" << std::endl);
+                 "   Problems when submitting via XML-RPC" << std::endl);
       ofs << "   Problems when submitting via XML-RPC" << std::endl;
       return -1;
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
-      << std::endl, this->Quiet);
+    }
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submission successful" << std::endl, this->Quiet);
     ofs << "   Submission successful" << std::endl;
     return 0;
 #else
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "   Submission method \"xmlrpc\" not compiled into CTest!"
-               << std::endl);
+                 << std::endl);
     return -1;
 #endif
-    }
-  else if ( dropMethod == "scp" )
-    {
+  } else if (dropMethod == "scp") {
     std::string url;
     std::string oldWorkingDirectory;
-    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty())
-      {
+    if (!this->CTest->GetCTestConfiguration("DropSiteUser").empty()) {
       url += this->CTest->GetCTestConfiguration("DropSiteUser") + "@";
-      }
+    }
     url += this->CTest->GetCTestConfiguration("DropSite") + ":" +
       this->CTest->GetCTestConfiguration("DropLocation");
 
@@ -1597,69 +1465,58 @@ int cmCTestSubmitHandler::ProcessHandler()
     oldWorkingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
     cmSystemTools::ChangeDirectory(buildDirectory);
 
-    if ( !this->SubmitUsingSCP(
-        this->CTest->GetCTestConfiguration("ScpCommand"),
-        "Testing/"+this->CTest->GetCurrentTag(), files, prefix, url) )
-      {
+    if (!this->SubmitUsingSCP(this->CTest->GetCTestConfiguration("ScpCommand"),
+                              "Testing/" + this->CTest->GetCurrentTag(), files,
+                              prefix, url)) {
       cmSystemTools::ChangeDirectory(oldWorkingDirectory);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "   Problems when submitting via SCP"
-        << std::endl);
+                 "   Problems when submitting via SCP" << std::endl);
       ofs << "   Problems when submitting via SCP" << std::endl;
       return -1;
-      }
+    }
     cmSystemTools::ChangeDirectory(oldWorkingDirectory);
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
-      << std::endl, this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submission successful" << std::endl, this->Quiet);
     ofs << "   Submission successful" << std::endl;
     return 0;
-    }
-  else if ( dropMethod == "cp" )
-    {
-    std::string location
-      = this->CTest->GetCTestConfiguration("DropLocation");
-
+  } else if (dropMethod == "cp") {
+    std::string location = this->CTest->GetCTestConfiguration("DropLocation");
 
     // change to the build directory so that we can uses a relative path
     // on windows since scp dosn't support "c:" a drive in the path
-    std::string
-      oldWorkingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
+    std::string oldWorkingDirectory =
+      cmSystemTools::GetCurrentWorkingDirectory();
     cmSystemTools::ChangeDirectory(buildDirectory);
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "   Change directory: " << buildDirectory << std::endl, this->Quiet);
-
-    if ( !this->SubmitUsingCP(
-           "Testing/"+this->CTest->GetCurrentTag(),
-           files,
-           prefix,
-           location) )
-      {
+                       "   Change directory: " << buildDirectory << std::endl,
+                       this->Quiet);
+
+    if (!this->SubmitUsingCP("Testing/" + this->CTest->GetCurrentTag(), files,
+                             prefix, location)) {
       cmSystemTools::ChangeDirectory(oldWorkingDirectory);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "   Problems when submitting via CP"
-        << std::endl);
+                 "   Problems when submitting via CP" << std::endl);
       ofs << "   Problems when submitting via cp" << std::endl;
       return -1;
-      }
+    }
     cmSystemTools::ChangeDirectory(oldWorkingDirectory);
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
-      << std::endl, this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                       "   Submission successful" << std::endl, this->Quiet);
     ofs << "   Submission successful" << std::endl;
     return 0;
-    }
+  }
 
   cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown submission method: \""
-    << dropMethod << "\"" << std::endl);
+               << dropMethod << "\"" << std::endl);
   return -1;
 }
 
 std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
 {
-  std::string buildname = cmCTest::SafeBuildIdField(
-    this->CTest->GetCTestConfiguration("BuildName"));
-  std::string name = this->CTest->GetCTestConfiguration("Site") +
-    "___" + buildname +
-    "___" + this->CTest->GetCurrentTag() + "-" +
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->CTest->GetCTestConfiguration("BuildName"));
+  std::string name = this->CTest->GetCTestConfiguration("Site") + "___" +
+    buildname + "___" + this->CTest->GetCurrentTag() + "-" +
     this->CTest->GetTestModelString() + "___XML___";
   return name;
 }
@@ -1667,12 +1524,11 @@ std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
 void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts)
 {
   // Check whether each part is selected.
-  for(cmCTest::Part p = cmCTest::PartStart;
-      p != cmCTest::PartCount; p = cmCTest::Part(p+1))
-    {
+  for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
+       p = cmCTest::Part(p + 1)) {
     this->SubmitPart[p] =
       (std::set<cmCTest::Part>::const_iterator(parts.find(p)) != parts.end());
-    }
+  }
 }
 
 void cmCTestSubmitHandler::SelectFiles(cmCTest::SetOfStrings const& files)
diff --git a/Source/CTest/cmCTestSubmitHandler.h b/Source/CTest/cmCTestSubmitHandler.h
index f9cd894..87fa142 100644
--- a/Source/CTest/cmCTestSubmitHandler.h
+++ b/Source/CTest/cmCTestSubmitHandler.h
@@ -54,8 +54,7 @@ private:
    */
   bool SubmitUsingFTP(const std::string& localprefix,
                       const std::set<std::string>& files,
-                      const std::string& remoteprefix,
-                      const std::string& url);
+                      const std::string& remoteprefix, const std::string& url);
   bool SubmitUsingHTTP(const std::string& localprefix,
                        const std::set<std::string>& files,
                        const std::string& remoteprefix,
@@ -63,22 +62,20 @@ private:
   bool SubmitUsingSCP(const std::string& scp_command,
                       const std::string& localprefix,
                       const std::set<std::string>& files,
-                      const std::string& remoteprefix,
-                      const std::string& url);
+                      const std::string& remoteprefix, const std::string& url);
 
-  bool SubmitUsingCP( const std::string& localprefix,
-                      const std::set<std::string>& files,
-                      const std::string& remoteprefix,
-                      const std::string& url);
+  bool SubmitUsingCP(const std::string& localprefix,
+                     const std::set<std::string>& files,
+                     const std::string& remoteprefix, const std::string& url);
 
   bool TriggerUsingHTTP(const std::set<std::string>& files,
                         const std::string& remoteprefix,
                         const std::string& url);
 
   bool SubmitUsingXMLRPC(const std::string& localprefix,
-                       const std::set<std::string>& files,
-                       const std::string& remoteprefix,
-                       const std::string& url);
+                         const std::set<std::string>& files,
+                         const std::string& remoteprefix,
+                         const std::string& url);
 
   typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
 
@@ -86,12 +83,12 @@ private:
 
   std::string GetSubmitResultsPrefix();
 
-  class         ResponseParser;
-  std::string   HTTPProxy;
-  int           HTTPProxyType;
-  std::string   HTTPProxyAuth;
-  std::string   FTPProxy;
-  int           FTPProxyType;
+  class ResponseParser;
+  std::string HTTPProxy;
+  int HTTPProxyType;
+  std::string HTTPProxyAuth;
+  std::string FTPProxy;
+  int FTPProxyType;
   std::ostream* LogFile;
   bool SubmitPart[cmCTest::PartCount];
   bool CDash;
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index b7d8318..7b437c6 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -37,103 +37,78 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
     this->Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
 
   double timeout = this->CTest->GetTimeOut();
-  if ( ctestTimeout )
-    {
+  if (ctestTimeout) {
     timeout = atof(ctestTimeout);
-    }
-  else
-    {
-    if ( timeout <= 0 )
-      {
+  } else {
+    if (timeout <= 0) {
       // By default use timeout of 10 minutes
       timeout = 600;
-      }
     }
+  }
   this->CTest->SetTimeOut(timeout);
   cmCTestGenericHandler* handler = this->InitializeActualHandler();
-  if ( this->Values[ctt_START] || this->Values[ctt_END] ||
-    this->Values[ctt_STRIDE] )
-    {
+  if (this->Values[ctt_START] || this->Values[ctt_END] ||
+      this->Values[ctt_STRIDE]) {
     std::ostringstream testsToRunString;
-    if ( this->Values[ctt_START] )
-      {
+    if (this->Values[ctt_START]) {
       testsToRunString << this->Values[ctt_START];
-      }
+    }
     testsToRunString << ",";
-    if ( this->Values[ctt_END] )
-      {
+    if (this->Values[ctt_END]) {
       testsToRunString << this->Values[ctt_END];
-      }
+    }
     testsToRunString << ",";
-    if ( this->Values[ctt_STRIDE] )
-      {
+    if (this->Values[ctt_STRIDE]) {
       testsToRunString << this->Values[ctt_STRIDE];
-      }
-    handler->SetOption("TestsToRunInformation",
-      testsToRunString.str().c_str());
     }
-  if(this->Values[ctt_EXCLUDE])
-    {
+    handler->SetOption("TestsToRunInformation",
+                       testsToRunString.str().c_str());
+  }
+  if (this->Values[ctt_EXCLUDE]) {
     handler->SetOption("ExcludeRegularExpression", this->Values[ctt_EXCLUDE]);
-    }
-  if(this->Values[ctt_INCLUDE])
-    {
+  }
+  if (this->Values[ctt_INCLUDE]) {
     handler->SetOption("IncludeRegularExpression", this->Values[ctt_INCLUDE]);
-    }
-  if(this->Values[ctt_EXCLUDE_LABEL])
-    {
+  }
+  if (this->Values[ctt_EXCLUDE_LABEL]) {
     handler->SetOption("ExcludeLabelRegularExpression",
                        this->Values[ctt_EXCLUDE_LABEL]);
-    }
-  if(this->Values[ctt_INCLUDE_LABEL])
-    {
+  }
+  if (this->Values[ctt_INCLUDE_LABEL]) {
     handler->SetOption("LabelRegularExpression",
                        this->Values[ctt_INCLUDE_LABEL]);
-    }
-  if(this->Values[ctt_PARALLEL_LEVEL])
-    {
-    handler->SetOption("ParallelLevel",
-                       this->Values[ctt_PARALLEL_LEVEL]);
-    }
-  if(this->Values[ctt_SCHEDULE_RANDOM])
-    {
-    handler->SetOption("ScheduleRandom",
-                       this->Values[ctt_SCHEDULE_RANDOM]);
-    }
-  if(this->Values[ctt_STOP_TIME])
-    {
+  }
+  if (this->Values[ctt_PARALLEL_LEVEL]) {
+    handler->SetOption("ParallelLevel", this->Values[ctt_PARALLEL_LEVEL]);
+  }
+  if (this->Values[ctt_SCHEDULE_RANDOM]) {
+    handler->SetOption("ScheduleRandom", this->Values[ctt_SCHEDULE_RANDOM]);
+  }
+  if (this->Values[ctt_STOP_TIME]) {
     this->CTest->SetStopTime(this->Values[ctt_STOP_TIME]);
-    }
+  }
 
   // Test load is determined by: TEST_LOAD argument,
   // or CTEST_TEST_LOAD script variable, or ctest --test-load
   // command line argument... in that order.
   unsigned long testLoad;
-  const char* ctestTestLoad
-    = this->Makefile->GetDefinition("CTEST_TEST_LOAD");
-  if(this->Values[ctt_TEST_LOAD] && *this->Values[ctt_TEST_LOAD])
-    {
-    if (!cmSystemTools::StringToULong(this->Values[ctt_TEST_LOAD], &testLoad))
-      {
+  const char* ctestTestLoad = this->Makefile->GetDefinition("CTEST_TEST_LOAD");
+  if (this->Values[ctt_TEST_LOAD] && *this->Values[ctt_TEST_LOAD]) {
+    if (!cmSystemTools::StringToULong(this->Values[ctt_TEST_LOAD],
+                                      &testLoad)) {
       testLoad = 0;
       cmCTestLog(this->CTest, WARNING, "Invalid value for 'TEST_LOAD' : "
-          << this->Values[ctt_TEST_LOAD] << std::endl);
-      }
+                   << this->Values[ctt_TEST_LOAD] << std::endl);
     }
-  else if(ctestTestLoad && *ctestTestLoad)
-    {
-    if (!cmSystemTools::StringToULong(ctestTestLoad, &testLoad))
-      {
+  } else if (ctestTestLoad && *ctestTestLoad) {
+    if (!cmSystemTools::StringToULong(ctestTestLoad, &testLoad)) {
       testLoad = 0;
-      cmCTestLog(this->CTest, WARNING,
-        "Invalid value for 'CTEST_TEST_LOAD' : " <<
-        ctestTestLoad << std::endl);
-      }
+      cmCTestLog(this->CTest, WARNING, "Invalid value for 'CTEST_TEST_LOAD' : "
+                   << ctestTestLoad << std::endl);
     }
-  else
-    {
+  } else {
     testLoad = this->CTest->GetTestLoad();
-    }
+  }
   handler->SetTestLoad(testLoad);
 
   handler->SetQuiet(this->Quiet);
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index 0dfca97..212213e 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -22,24 +22,23 @@
 class cmCTestTestCommand : public cmCTestHandlerCommand
 {
 public:
-
   cmCTestTestCommand();
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestTestCommand* ni = new cmCTestTestCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_test";}
+  virtual std::string GetName() const { return "ctest_test"; }
 
   cmTypeMacro(cmCTestTestCommand, cmCTestHandlerCommand);
 
@@ -47,7 +46,8 @@ protected:
   virtual cmCTestGenericHandler* InitializeActualHandler();
   cmCTestGenericHandler* InitializeHandler();
 
-  enum {
+  enum
+  {
     ctt_BUILD = ct_LAST,
     ctt_RETURN_VALUE,
     ctt_START,
@@ -65,5 +65,4 @@ protected:
   };
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index b477f5f..4935f11 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -43,88 +43,76 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestSubdirCommand* c = new cmCTestSubdirCommand;
     c->TestHandler = this->TestHandler;
     return c;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &);
+                           cmExecutionStatus&);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "subdirs";}
+  virtual std::string GetName() const { return "subdirs"; }
 
   cmTypeMacro(cmCTestSubdirCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
 };
 
-bool cmCTestSubdirCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestSubdirCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::vector<std::string>::const_iterator it;
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
-  for ( it = args.begin(); it != args.end(); ++ it )
-    {
+  for (it = args.begin(); it != args.end(); ++it) {
     std::string fname;
 
-    if(cmSystemTools::FileIsFullPath(it->c_str()))
-      {
+    if (cmSystemTools::FileIsFullPath(it->c_str())) {
       fname = *it;
-      }
-    else
-      {
+    } else {
       fname = cwd;
       fname += "/";
       fname += *it;
-      }
+    }
 
-    if ( !cmSystemTools::FileIsDirectory(fname) )
-      {
+    if (!cmSystemTools::FileIsDirectory(fname)) {
       // No subdirectory? So what...
       continue;
-      }
+    }
     cmSystemTools::ChangeDirectory(fname);
     const char* testFilename;
-    if( cmSystemTools::FileExists("CTestTestfile.cmake") )
-      {
+    if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
       // does the CTestTestfile.cmake exist ?
       testFilename = "CTestTestfile.cmake";
-      }
-    else if( cmSystemTools::FileExists("DartTestfile.txt") )
-      {
+    } else if (cmSystemTools::FileExists("DartTestfile.txt")) {
       // does the DartTestfile.txt exist ?
       testFilename = "DartTestfile.txt";
-      }
-    else
-      {
+    } else {
       // No CTestTestfile? Who cares...
       continue;
-      }
+    }
     fname += "/";
     fname += testFilename;
     bool readit = this->Makefile->ReadDependentFile(fname.c_str());
     cmSystemTools::ChangeDirectory(cwd);
-    if(!readit)
-      {
+    if (!readit) {
       std::string m = "Could not find include file: ";
       m += fname;
       this->SetError(m);
       return false;
-      }
     }
+  }
   cmSystemTools::ChangeDirectory(cwd);
   return true;
 }
@@ -136,37 +124,36 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestAddSubdirectoryCommand* c = new cmCTestAddSubdirectoryCommand;
     c->TestHandler = this->TestHandler;
     return c;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &);
+                           cmExecutionStatus&);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_subdirectory";}
+  virtual std::string GetName() const { return "add_subdirectory"; }
 
   cmTypeMacro(cmCTestAddSubdirectoryCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
 };
 
-bool cmCTestAddSubdirectoryCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestAddSubdirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
   cmSystemTools::ChangeDirectory(cwd);
@@ -174,40 +161,33 @@ bool cmCTestAddSubdirectoryCommand
   fname += "/";
   fname += args[0];
 
-  if ( !cmSystemTools::FileExists(fname.c_str()) )
-    {
+  if (!cmSystemTools::FileExists(fname.c_str())) {
     // No subdirectory? So what...
     return true;
-    }
+  }
   cmSystemTools::ChangeDirectory(fname);
   const char* testFilename;
-  if( cmSystemTools::FileExists("CTestTestfile.cmake") )
-    {
+  if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
     // does the CTestTestfile.cmake exist ?
     testFilename = "CTestTestfile.cmake";
-    }
-  else if( cmSystemTools::FileExists("DartTestfile.txt") )
-    {
+  } else if (cmSystemTools::FileExists("DartTestfile.txt")) {
     // does the DartTestfile.txt exist ?
     testFilename = "DartTestfile.txt";
-    }
-  else
-    {
+  } else {
     // No CTestTestfile? Who cares...
     cmSystemTools::ChangeDirectory(cwd);
     return true;
-    }
+  }
   fname += "/";
   fname += testFilename;
   bool readit = this->Makefile->ReadDependentFile(fname.c_str());
   cmSystemTools::ChangeDirectory(cwd);
-  if(!readit)
-    {
+  if (!readit) {
     std::string m = "Could not find include file: ";
     m += fname;
     this->SetError(m);
     return false;
-    }
+  }
   return true;
 }
 
@@ -218,37 +198,36 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestAddTestCommand* c = new cmCTestAddTestCommand;
     c->TestHandler = this->TestHandler;
     return c;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &);
+                           cmExecutionStatus&);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_test";}
+  virtual std::string GetName() const { return "add_test"; }
 
   cmTypeMacro(cmCTestAddTestCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
 };
 
-bool cmCTestAddTestCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestAddTestCommand::InitialPass(std::vector<std::string> const& args,
+                                        cmExecutionStatus&)
 {
-  if ( args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   return this->TestHandler->AddTest(args);
 }
 
@@ -259,32 +238,31 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
-    cmCTestSetTestsPropertiesCommand* c
-      = new cmCTestSetTestsPropertiesCommand;
+  {
+    cmCTestSetTestsPropertiesCommand* c = new cmCTestSetTestsPropertiesCommand;
     c->TestHandler = this->TestHandler;
     return c;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
   */
   virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &);
+                           cmExecutionStatus&);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_tests_properties";}
+  virtual std::string GetName() const { return "set_tests_properties"; }
 
   cmTypeMacro(cmCTestSetTestsPropertiesCommand, cmCommand);
 
   cmCTestTestHandler* TestHandler;
 };
 
-bool cmCTestSetTestsPropertiesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCTestSetTestsPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   return this->TestHandler->SetTestsProperties(args);
 }
@@ -293,86 +271,65 @@ bool cmCTestSetTestsPropertiesCommand
 // pos is the start of the search and pos2 is the end of the search
 // pos becomes pos2 after a call to GetNextNumber.
 // -1 is returned at the end of the list.
-inline int GetNextNumber(std::string const& in,
-                         int& val,
+inline int GetNextNumber(std::string const& in, int& val,
                          std::string::size_type& pos,
                          std::string::size_type& pos2)
 {
   pos2 = in.find(',', pos);
-  if(pos2 != in.npos)
-    {
-    if(pos2-pos == 0)
-      {
+  if (pos2 != in.npos) {
+    if (pos2 - pos == 0) {
       val = -1;
-      }
-    else
-      {
-      val = atoi(in.substr(pos, pos2-pos).c_str());
-      }
-    pos = pos2+1;
+    } else {
+      val = atoi(in.substr(pos, pos2 - pos).c_str());
+    }
+    pos = pos2 + 1;
     return 1;
+  } else {
+    if (in.size() - pos == 0) {
+      val = -1;
+    } else {
+      val = atoi(in.substr(pos, in.size() - pos).c_str());
     }
-  else
-    {
-    if(in.size()-pos == 0)
-      {
-       val = -1;
-      }
-    else
-      {
-      val = atoi(in.substr(pos, in.size()-pos).c_str());
-      }
     return 0;
-    }
+  }
 }
 
 // get the next number in a string with numbers separated by ,
 // pos is the start of the search and pos2 is the end of the search
 // pos becomes pos2 after a call to GetNextNumber.
 // -1 is returned at the end of the list.
-inline int GetNextRealNumber(std::string const& in,
-                             double& val,
+inline int GetNextRealNumber(std::string const& in, double& val,
                              std::string::size_type& pos,
                              std::string::size_type& pos2)
 {
   pos2 = in.find(',', pos);
-  if(pos2 != in.npos)
-    {
-    if(pos2-pos == 0)
-      {
+  if (pos2 != in.npos) {
+    if (pos2 - pos == 0) {
       val = -1;
-      }
-    else
-      {
-      val = atof(in.substr(pos, pos2-pos).c_str());
-      }
-    pos = pos2+1;
+    } else {
+      val = atof(in.substr(pos, pos2 - pos).c_str());
+    }
+    pos = pos2 + 1;
     return 1;
+  } else {
+    if (in.size() - pos == 0) {
+      val = -1;
+    } else {
+      val = atof(in.substr(pos, in.size() - pos).c_str());
     }
-  else
-    {
-    if(in.size()-pos == 0)
-      {
-       val = -1;
-      }
-    else
-      {
-      val = atof(in.substr(pos, in.size()-pos).c_str());
-      }
     return 0;
-    }
+  }
 }
 
-
 cmCTestTestHandler::cmCTestTestHandler()
 {
   this->UseUnion = false;
 
-  this->UseIncludeLabelRegExpFlag   = false;
-  this->UseExcludeLabelRegExpFlag   = false;
-  this->UseIncludeRegExpFlag   = false;
-  this->UseExcludeRegExpFlag   = false;
-  this->UseExcludeRegExpFirst  = false;
+  this->UseIncludeLabelRegExpFlag = false;
+  this->UseExcludeLabelRegExpFlag = false;
+  this->UseIncludeRegExpFlag = false;
+  this->UseExcludeRegExpFlag = false;
+  this->UseExcludeRegExpFirst = false;
 
   this->CustomMaximumPassedTestOutputSize = 1 * 1024;
   this->CustomMaximumFailedTestOutputSize = 300 * 1024;
@@ -382,8 +339,7 @@ cmCTestTestHandler::cmCTestTestHandler()
   this->LogFile = 0;
 
   // regex to detect <DartMeasurement>...</DartMeasurement>
-  this->DartStuff.compile(
-    "(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)");
+  this->DartStuff.compile("(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)");
   // regex to detect each individual <DartMeasurement>...</DartMeasurement>
   this->DartStuff1.compile(
     "(<DartMeasurement[^<]*</DartMeasurement[a-zA-Z]*>)");
@@ -423,98 +379,89 @@ void cmCTestTestHandler::Initialize()
   this->TestList.clear();
 }
 
-void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf)
+void cmCTestTestHandler::PopulateCustomVectors(cmMakefile* mf)
 {
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST",
-                                this->CustomPreTest);
+                                    this->CustomPreTest);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_TEST",
-                                this->CustomPostTest);
-  this->CTest->PopulateCustomVector(mf,
-                             "CTEST_CUSTOM_TESTS_IGNORE",
-                             this->CustomTestsIgnore);
-  this->CTest->PopulateCustomInteger(mf,
-                             "CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
-                             this->CustomMaximumPassedTestOutputSize);
-  this->CTest->PopulateCustomInteger(mf,
-                             "CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
-                             this->CustomMaximumFailedTestOutputSize);
+                                    this->CustomPostTest);
+  this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_TESTS_IGNORE",
+                                    this->CustomTestsIgnore);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
+    this->CustomMaximumPassedTestOutputSize);
+  this->CTest->PopulateCustomInteger(
+    mf, "CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
+    this->CustomMaximumFailedTestOutputSize);
 }
 
 int cmCTestTestHandler::PreProcessHandler()
 {
-  if ( !this->ExecuteCommands(this->CustomPreTest) )
-    {
+  if (!this->ExecuteCommands(this->CustomPreTest)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Problem executing pre-test command(s)." << std::endl);
+               "Problem executing pre-test command(s)." << std::endl);
     return 0;
-    }
+  }
   return 1;
 }
 
 int cmCTestTestHandler::PostProcessHandler()
 {
-  if ( !this->ExecuteCommands(this->CustomPostTest) )
-    {
+  if (!this->ExecuteCommands(this->CustomPostTest)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Problem executing post-test command(s)." << std::endl);
+               "Problem executing post-test command(s)." << std::endl);
     return 0;
-    }
+  }
   return 1;
 }
 
-//clearly it would be nice if this were broken up into a few smaller
-//functions and commented...
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
 int cmCTestTestHandler::ProcessHandler()
 {
   // Update internal data structure from generic one
   this->SetTestsToRunInformation(this->GetOption("TestsToRunInformation"));
   this->SetUseUnion(cmSystemTools::IsOn(this->GetOption("UseUnion")));
-  if(cmSystemTools::IsOn(this->GetOption("ScheduleRandom")))
-    {
+  if (cmSystemTools::IsOn(this->GetOption("ScheduleRandom"))) {
     this->CTest->SetScheduleType("Random");
-    }
-  if(this->GetOption("ParallelLevel"))
-    {
+  }
+  if (this->GetOption("ParallelLevel")) {
     this->CTest->SetParallelLevel(atoi(this->GetOption("ParallelLevel")));
-    }
+  }
 
   const char* val;
   val = this->GetOption("LabelRegularExpression");
-  if ( val )
-    {
+  if (val) {
     this->UseIncludeLabelRegExpFlag = true;
     this->IncludeLabelRegExp = val;
-    }
+  }
   val = this->GetOption("ExcludeLabelRegularExpression");
-  if ( val )
-    {
+  if (val) {
     this->UseExcludeLabelRegExpFlag = true;
     this->ExcludeLabelRegExp = val;
-    }
+  }
   val = this->GetOption("IncludeRegularExpression");
-  if ( val )
-    {
+  if (val) {
     this->UseIncludeRegExp();
     this->SetIncludeRegExp(val);
-    }
+  }
   val = this->GetOption("ExcludeRegularExpression");
-  if ( val )
-    {
+  if (val) {
     this->UseExcludeRegExp();
     this->SetExcludeRegExp(val);
-    }
+  }
   this->SetRerunFailed(cmSystemTools::IsOn(this->GetOption("RerunFailed")));
 
   this->TestResults.clear();
 
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-             (this->MemCheck ? "Memory check" : "Test")
-             << " project " << cmSystemTools::GetCurrentWorkingDirectory()
-             << std::endl, this->Quiet);
-  if ( ! this->PreProcessHandler() )
-    {
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT, (this->MemCheck ? "Memory check" : "Test")
+      << " project " << cmSystemTools::GetCurrentWorkingDirectory()
+      << std::endl,
+    this->Quiet);
+  if (!this->PreProcessHandler()) {
     return -1;
-    }
+  }
 
   cmGeneratedFileStream mLogFile;
   this->StartLogFile((this->MemCheck ? "DynamicAnalysis" : "Test"), mLogFile);
@@ -524,7 +471,7 @@ int cmCTestTestHandler::ProcessHandler()
   std::vector<std::string> failed;
   int total;
 
-  //start the real time clock
+  // start the real time clock
   double clock_start, clock_finish;
   clock_start = cmSystemTools::GetTime();
 
@@ -534,104 +481,91 @@ int cmCTestTestHandler::ProcessHandler()
 
   total = int(passed.size()) + int(failed.size());
 
-  if (total == 0)
-    {
-    if ( !this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels() )
-      {
+  if (total == 0) {
+    if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "No tests were found!!!"
-        << std::endl);
-      }
+                   << std::endl);
     }
-  else
-    {
+  } else {
     if (this->HandlerVerbose && !passed.empty() &&
-      (this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag))
-      {
+        (this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag)) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
-        << "The following tests passed:" << std::endl, this->Quiet);
-      for(std::vector<std::string>::iterator j = passed.begin();
-          j != passed.end(); ++j)
-        {
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j
-          << std::endl, this->Quiet);
-        }
+                           << "The following tests passed:" << std::endl,
+                         this->Quiet);
+      for (std::vector<std::string>::iterator j = passed.begin();
+           j != passed.end(); ++j) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "\t" << *j << std::endl, this->Quiet);
       }
+    }
 
     float percent = float(passed.size()) * 100.0f / float(total);
-    if (!failed.empty() && percent > 99)
-      {
+    if (!failed.empty() && percent > 99) {
       percent = 99;
-      }
+    }
 
     cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
-               << static_cast<int>(percent + .5f) << "% tests passed, "
-               << failed.size() << " tests failed out of "
-               << total << std::endl);
-    if(this->CTest->GetLabelSummary())
-      {
+                 << static_cast<int>(percent + .5f) << "% tests passed, "
+                 << failed.size() << " tests failed out of " << total
+                 << std::endl);
+    if (this->CTest->GetLabelSummary()) {
       this->PrintLabelSummary();
-      }
+    }
     char realBuf[1024];
     sprintf(realBuf, "%6.2f sec", (double)(clock_finish - clock_start));
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "\nTotal Test time (real) = " << realBuf << "\n", this->Quiet );
+                       "\nTotal Test time (real) = " << realBuf << "\n",
+                       this->Quiet);
 
-    if (!failed.empty())
-      {
+    if (!failed.empty()) {
       cmGeneratedFileStream ofs;
       cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
-                 << "The following tests FAILED:" << std::endl);
+                   << "The following tests FAILED:" << std::endl);
       this->StartLogFile("TestsFailed", ofs);
 
       typedef std::set<cmCTestTestHandler::cmCTestTestResult,
-                       cmCTestTestResultLess> SetOfTests;
+                       cmCTestTestResultLess>
+        SetOfTests;
       SetOfTests resultsSet(this->TestResults.begin(),
                             this->TestResults.end());
 
-      for(SetOfTests::iterator ftit = resultsSet.begin();
-          ftit != resultsSet.end(); ++ftit)
-        {
-        if ( ftit->Status != cmCTestTestHandler::COMPLETED )
-          {
+      for (SetOfTests::iterator ftit = resultsSet.begin();
+           ftit != resultsSet.end(); ++ftit) {
+        if (ftit->Status != cmCTestTestHandler::COMPLETED) {
           ofs << ftit->TestCount << ":" << ftit->Name << std::endl;
-          cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t" << std::setw(3)
-                     << ftit->TestCount << " - "
-                     << ftit->Name << " ("
-                     << this->GetTestStatus(ftit->Status) << ")"
-                     << std::endl);
-          }
+          cmCTestLog(
+            this->CTest, HANDLER_OUTPUT, "\t"
+              << std::setw(3) << ftit->TestCount << " - " << ftit->Name << " ("
+              << this->GetTestStatus(ftit->Status) << ")" << std::endl);
         }
       }
     }
+  }
 
-  if ( this->CTest->GetProduceXML() )
-    {
+  if (this->CTest->GetProduceXML()) {
     cmGeneratedFileStream xmlfile;
-    if( !this->StartResultingXML(
+    if (!this->StartResultingXML(
           (this->MemCheck ? cmCTest::PartMemCheck : cmCTest::PartTest),
-        (this->MemCheck ? "DynamicAnalysis" : "Test"), xmlfile) )
-      {
+          (this->MemCheck ? "DynamicAnalysis" : "Test"), xmlfile)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create "
-        << (this->MemCheck ? "memory check" : "testing")
-        << " XML file" << std::endl);
+                   << (this->MemCheck ? "memory check" : "testing")
+                   << " XML file" << std::endl);
       this->LogFile = 0;
       return 1;
-      }
+    }
     cmXMLWriter xml(xmlfile);
     this->GenerateDartOutput(xml);
-    }
+  }
 
-  if ( ! this->PostProcessHandler() )
-    {
+  if (!this->PostProcessHandler()) {
     this->LogFile = 0;
     return -1;
-    }
+  }
 
-  if ( !failed.empty() )
-    {
+  if (!failed.empty()) {
     this->LogFile = 0;
     return -1;
-    }
+  }
   this->LogFile = 0;
   return 0;
 }
@@ -644,146 +578,121 @@ void cmCTestTestHandler::PrintLabelSummary()
   std::set<std::string> labels;
   // initialize maps
   std::string::size_type maxlen = 0;
-  for(; it != this->TestList.end(); ++it)
-    {
+  for (; it != this->TestList.end(); ++it) {
     cmCTestTestProperties& p = *it;
-    if(!p.Labels.empty())
-      {
-      for(std::vector<std::string>::iterator l = p.Labels.begin();
-          l !=  p.Labels.end(); ++l)
-        {
-        if((*l).size() > maxlen)
-          {
+    if (!p.Labels.empty()) {
+      for (std::vector<std::string>::iterator l = p.Labels.begin();
+           l != p.Labels.end(); ++l) {
+        if ((*l).size() > maxlen) {
           maxlen = (*l).size();
-          }
+        }
         labels.insert(*l);
         labelTimes[*l] = 0;
         labelCounts[*l] = 0;
-        }
       }
     }
+  }
   cmCTestTestHandler::TestResultsVector::iterator ri =
-      this->TestResults.begin();
+    this->TestResults.begin();
   // fill maps
-  for(; ri != this->TestResults.end(); ++ri)
-    {
-    cmCTestTestResult &result = *ri;
+  for (; ri != this->TestResults.end(); ++ri) {
+    cmCTestTestResult& result = *ri;
     cmCTestTestProperties& p = *result.Properties;
-    if(!p.Labels.empty())
-      {
-      for(std::vector<std::string>::iterator l = p.Labels.begin();
-          l !=  p.Labels.end(); ++l)
-        {
+    if (!p.Labels.empty()) {
+      for (std::vector<std::string>::iterator l = p.Labels.begin();
+           l != p.Labels.end(); ++l) {
         labelTimes[*l] += result.ExecutionTime;
         ++labelCounts[*l];
-        }
       }
     }
+  }
   // now print times
-  if(!labels.empty())
-    {
+  if (!labels.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:",
-      this->Quiet);
-    }
-  for(std::set<std::string>::const_iterator i = labels.begin();
-      i != labels.end(); ++i)
-    {
+                       this->Quiet);
+  }
+  for (std::set<std::string>::const_iterator i = labels.begin();
+       i != labels.end(); ++i) {
     std::string label = *i;
-    label.resize(maxlen +3, ' ');
+    label.resize(maxlen + 3, ' ');
 
     char buf[1024];
     sprintf(buf, "%6.2f sec", labelTimes[*i]);
 
     std::ostringstream labelCountStr;
     labelCountStr << "(" << labelCounts[*i] << " test";
-    if (labelCounts[*i] > 1)
-      {
+    if (labelCounts[*i] > 1) {
       labelCountStr << "s";
-      }
+    }
     labelCountStr << ")";
 
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n"
-               << label << " = " << buf << " " << labelCountStr.str(),
-               this->Quiet );
-    if ( this->LogFile )
-      {
-      *this->LogFile << "\n" << *i << " = "
-                     << buf << "\n";
-      }
-    }
-  if(!labels.empty())
-    {
-    if(this->LogFile)
-      {
+                         << label << " = " << buf << " "
+                         << labelCountStr.str(),
+                       this->Quiet);
+    if (this->LogFile) {
+      *this->LogFile << "\n" << *i << " = " << buf << "\n";
+    }
+  }
+  if (!labels.empty()) {
+    if (this->LogFile) {
       *this->LogFile << "\n";
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n", this->Quiet);
     }
-
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n", this->Quiet);
+  }
 }
 
 void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it)
 {
   // if not using Labels to filter then return
-  if (!this->UseIncludeLabelRegExpFlag )
-    {
+  if (!this->UseIncludeLabelRegExpFlag) {
     return;
-    }
+  }
   // if there are no labels and we are filtering by labels
   // then exclude the test as it does not have the label
-  if(it.Labels.empty())
-    {
+  if (it.Labels.empty()) {
     it.IsInBasedOnREOptions = false;
     return;
-    }
+  }
   // check to see if the label regular expression matches
-  bool found = false;  // assume it does not match
+  bool found = false; // assume it does not match
   // loop over all labels and look for match
-  for(std::vector<std::string>::iterator l = it.Labels.begin();
-      l !=  it.Labels.end(); ++l)
-    {
-    if(this->IncludeLabelRegularExpression.find(*l))
-      {
+  for (std::vector<std::string>::iterator l = it.Labels.begin();
+       l != it.Labels.end(); ++l) {
+    if (this->IncludeLabelRegularExpression.find(*l)) {
       found = true;
-      }
     }
+  }
   // if no match was found, exclude the test
-  if(!found)
-    {
+  if (!found) {
     it.IsInBasedOnREOptions = false;
-    }
+  }
 }
 
-
 void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it)
 {
   // if not using Labels to filter then return
-  if (!this->UseExcludeLabelRegExpFlag )
-    {
+  if (!this->UseExcludeLabelRegExpFlag) {
     return;
-    }
+  }
   // if there are no labels and we are excluding by labels
   // then do nothing as a no label can not be a match
-  if(it.Labels.empty())
-    {
+  if (it.Labels.empty()) {
     return;
-    }
+  }
   // check to see if the label regular expression matches
-  bool found = false;  // assume it does not match
+  bool found = false; // assume it does not match
   // loop over all labels and look for match
-  for(std::vector<std::string>::iterator l = it.Labels.begin();
-      l !=  it.Labels.end(); ++l)
-    {
-    if(this->ExcludeLabelRegularExpression.find(*l))
-      {
+  for (std::vector<std::string>::iterator l = it.Labels.begin();
+       l != it.Labels.end(); ++l) {
+    if (this->ExcludeLabelRegularExpression.find(*l)) {
       found = true;
-      }
     }
+  }
   // if match was found, exclude the test
-  if(found)
-    {
+  if (found) {
     it.IsInBasedOnREOptions = false;
-    }
+  }
 }
 
 void cmCTestTestHandler::CheckLabelFilter(cmCTestTestProperties& it)
@@ -797,70 +706,58 @@ void cmCTestTestHandler::ComputeTestList()
   this->TestList.clear(); // clear list of test
   this->GetListOfTests();
 
-  if (this->RerunFailed)
-    {
+  if (this->RerunFailed) {
     this->ComputeTestListForRerunFailed();
     return;
-    }
+  }
 
   cmCTestTestHandler::ListOfTests::size_type tmsize = this->TestList.size();
   // how many tests are in based on RegExp?
   int inREcnt = 0;
   cmCTestTestHandler::ListOfTests::iterator it;
-  for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
-    {
+  for (it = this->TestList.begin(); it != this->TestList.end(); it++) {
     this->CheckLabelFilter(*it);
-    if (it->IsInBasedOnREOptions)
-      {
-      inREcnt ++;
-      }
+    if (it->IsInBasedOnREOptions) {
+      inREcnt++;
     }
+  }
   // expand the test list based on the union flag
-  if (this->UseUnion)
-    {
+  if (this->UseUnion) {
     this->ExpandTestsToRunInformation((int)tmsize);
-    }
-  else
-    {
+  } else {
     this->ExpandTestsToRunInformation(inREcnt);
-    }
+  }
   // Now create a final list of tests to run
   int cnt = 0;
   inREcnt = 0;
   std::string last_directory = "";
   ListOfTests finalList;
-  for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
-    {
-    cnt ++;
-    if (it->IsInBasedOnREOptions)
-      {
+  for (it = this->TestList.begin(); it != this->TestList.end(); it++) {
+    cnt++;
+    if (it->IsInBasedOnREOptions) {
       inREcnt++;
-      }
+    }
 
-    if (this->UseUnion)
-      {
+    if (this->UseUnion) {
       // if it is not in the list and not in the regexp then skip
       if ((!this->TestsToRun.empty() &&
-           std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt)
-           == this->TestsToRun.end()) && !it->IsInBasedOnREOptions)
-        {
+           std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt) ==
+             this->TestsToRun.end()) &&
+          !it->IsInBasedOnREOptions) {
         continue;
-        }
       }
-    else
-      {
+    } else {
       // is this test in the list of tests to run? If not then skip it
       if ((!this->TestsToRun.empty() &&
-           std::find(this->TestsToRun.begin(),
-                     this->TestsToRun.end(), inREcnt)
-           == this->TestsToRun.end()) || !it->IsInBasedOnREOptions)
-        {
+           std::find(this->TestsToRun.begin(), this->TestsToRun.end(),
+                     inREcnt) == this->TestsToRun.end()) ||
+          !it->IsInBasedOnREOptions) {
         continue;
-        }
       }
-    it->Index = cnt;  // save the index into the test list for this test
-    finalList.push_back(*it);
     }
+    it->Index = cnt; // save the index into the test list for this test
+    finalList.push_back(*it);
+  }
   // Save the total number of tests before exclusions
   this->TotalNumberOfTests = this->TestList.size();
   // Set the TestList to the final list of all test
@@ -876,21 +773,19 @@ void cmCTestTestHandler::ComputeTestListForRerunFailed()
   cmCTestTestHandler::ListOfTests::iterator it;
   ListOfTests finalList;
   int cnt = 0;
-  for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
-    {
-    cnt ++;
+  for (it = this->TestList.begin(); it != this->TestList.end(); it++) {
+    cnt++;
 
     // if this test is not in our list of tests to run, then skip it.
     if ((!this->TestsToRun.empty() &&
-         std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt)
-         == this->TestsToRun.end()))
-      {
+         std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt) ==
+           this->TestsToRun.end())) {
       continue;
-      }
+    }
 
     it->Index = cnt;
     finalList.push_back(*it);
-    }
+  }
 
   // Save the total number of tests before exclusions
   this->TotalNumberOfTests = this->TestList.size();
@@ -904,166 +799,135 @@ void cmCTestTestHandler::ComputeTestListForRerunFailed()
 void cmCTestTestHandler::UpdateMaxTestNameWidth()
 {
   std::string::size_type max = this->CTest->GetMaxTestNameWidth();
-  for ( cmCTestTestHandler::ListOfTests::iterator it = this->TestList.begin();
-        it != this->TestList.end(); it ++ )
-    {
+  for (cmCTestTestHandler::ListOfTests::iterator it = this->TestList.begin();
+       it != this->TestList.end(); it++) {
     cmCTestTestProperties& p = *it;
-    if(max < p.Name.size())
-      {
+    if (max < p.Name.size()) {
       max = p.Name.size();
-      }
     }
-  if(static_cast<std::string::size_type>(this->CTest->GetMaxTestNameWidth())
-     != max)
-    {
+  }
+  if (static_cast<std::string::size_type>(
+        this->CTest->GetMaxTestNameWidth()) != max) {
     this->CTest->SetMaxTestNameWidth(static_cast<int>(max));
-    }
+  }
 }
 
-bool cmCTestTestHandler::GetValue(const char* tag,
-                                  int& value,
+bool cmCTestTestHandler::GetValue(const char* tag, int& value,
                                   std::istream& fin)
 {
   std::string line;
   bool ret = true;
   cmSystemTools::GetLineFromStream(fin, line);
-  if(line == tag)
-    {
+  if (line == tag) {
     fin >> value;
     ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
-    }
-  else
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "parse error: missing tag: "
-               << tag << " found [" << line << "]" << std::endl);
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
     ret = false;
-    }
+  }
   return ret;
 }
 
-bool cmCTestTestHandler::GetValue(const char* tag,
-                                  double& value,
+bool cmCTestTestHandler::GetValue(const char* tag, double& value,
                                   std::istream& fin)
 {
   std::string line;
   cmSystemTools::GetLineFromStream(fin, line);
   bool ret = true;
-  if(line == tag)
-    {
+  if (line == tag) {
     fin >> value;
     ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
-    }
-  else
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "parse error: missing tag: "
-               << tag << " found [" << line << "]" << std::endl);
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
     ret = false;
-    }
+  }
   return ret;
 }
 
-bool cmCTestTestHandler::GetValue(const char* tag,
-                                  bool& value,
+bool cmCTestTestHandler::GetValue(const char* tag, bool& value,
                                   std::istream& fin)
 {
   std::string line;
   cmSystemTools::GetLineFromStream(fin, line);
   bool ret = true;
-  if(line == tag)
-    {
+  if (line == tag) {
 #ifdef __HAIKU__
     int tmp = 0;
     fin >> tmp;
     value = false;
-    if(tmp)
-      {
+    if (tmp) {
       value = true;
-      }
+    }
 #else
     fin >> value;
 #endif
     ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
-    }
-  else
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "parse error: missing tag: "
-               << tag << " found [" << line << "]" << std::endl);
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
     ret = false;
-    }
+  }
   return ret;
 }
 
-bool cmCTestTestHandler::GetValue(const char* tag,
-                                  size_t& value,
+bool cmCTestTestHandler::GetValue(const char* tag, size_t& value,
                                   std::istream& fin)
 {
   std::string line;
   cmSystemTools::GetLineFromStream(fin, line);
   bool ret = true;
-  if(line == tag)
-    {
+  if (line == tag) {
     fin >> value;
     ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
-    }
-  else
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "parse error: missing tag: "
-               << tag << " found [" << line << "]" << std::endl);
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
     ret = false;
-    }
+  }
   return ret;
 }
 
-bool cmCTestTestHandler::GetValue(const char* tag,
-                                  std::string& value,
+bool cmCTestTestHandler::GetValue(const char* tag, std::string& value,
                                   std::istream& fin)
 {
   std::string line;
   cmSystemTools::GetLineFromStream(fin, line);
   bool ret = true;
-  if(line == tag)
-    {
-    ret =  cmSystemTools::GetLineFromStream(fin, value);
-    }
-  else
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "parse error: missing tag: "
-               << tag << " found [" << line << "]" << std::endl);
+  if (line == tag) {
+    ret = cmSystemTools::GetLineFromStream(fin, value);
+  } else {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "parse error: missing tag: "
+                 << tag << " found [" << line << "]" << std::endl);
     ret = false;
-    }
+  }
   return ret;
 }
 
-void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
-                                         std::vector<std::string> &failed)
+void cmCTestTestHandler::ProcessDirectory(std::vector<std::string>& passed,
+                                          std::vector<std::string>& failed)
 {
   this->ComputeTestList();
   this->StartTest = this->CTest->CurrentTime();
   this->StartTestTime = static_cast<unsigned int>(cmSystemTools::GetTime());
   double elapsed_time_start = cmSystemTools::GetTime();
 
-  cmCTestMultiProcessHandler* parallel = this->CTest->GetBatchJobs() ?
-    new cmCTestBatchTestHandler : new cmCTestMultiProcessHandler;
+  cmCTestMultiProcessHandler* parallel = this->CTest->GetBatchJobs()
+    ? new cmCTestBatchTestHandler
+    : new cmCTestMultiProcessHandler;
   parallel->SetCTest(this->CTest);
   parallel->SetParallelLevel(this->CTest->GetParallelLevel());
   parallel->SetTestHandler(this);
   parallel->SetQuiet(this->Quiet);
-  if(this->TestLoad > 0)
-    {
+  if (this->TestLoad > 0) {
     parallel->SetTestLoad(this->TestLoad);
-    }
-  else
-    {
+  } else {
     parallel->SetTestLoad(this->CTest->GetTestLoad());
-    }
+  }
 
-  *this->LogFile << "Start testing: "
-    << this->CTest->CurrentTime() << std::endl
+  *this->LogFile
+    << "Start testing: " << this->CTest->CurrentTime() << std::endl
     << "----------------------------------------------------------"
     << std::endl;
 
@@ -1071,69 +935,55 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
   cmCTestMultiProcessHandler::PropertiesMap properties;
 
   bool randomSchedule = this->CTest->GetScheduleType() == "Random";
-  if(randomSchedule)
-    {
+  if (randomSchedule) {
     srand((unsigned)time(0));
-    }
+  }
 
   for (ListOfTests::iterator it = this->TestList.begin();
-       it != this->TestList.end(); ++it)
-    {
+       it != this->TestList.end(); ++it) {
     cmCTestTestProperties& p = *it;
     cmCTestMultiProcessHandler::TestSet depends;
 
-    if(randomSchedule)
-      {
+    if (randomSchedule) {
       p.Cost = static_cast<float>(rand());
-      }
+    }
 
-    if(p.Timeout == 0 && this->CTest->GetGlobalTimeout() != 0)
-      {
+    if (p.Timeout == 0 && this->CTest->GetGlobalTimeout() != 0) {
       p.Timeout = this->CTest->GetGlobalTimeout();
-      }
+    }
 
-    if(!p.Depends.empty())
-      {
-      for(std::vector<std::string>::iterator i = p.Depends.begin();
-          i != p.Depends.end(); ++i)
-        {
-        for(ListOfTests::iterator it2 = this->TestList.begin();
-            it2 != this->TestList.end(); ++it2)
-          {
-          if(it2->Name == *i)
-            {
+    if (!p.Depends.empty()) {
+      for (std::vector<std::string>::iterator i = p.Depends.begin();
+           i != p.Depends.end(); ++i) {
+        for (ListOfTests::iterator it2 = this->TestList.begin();
+             it2 != this->TestList.end(); ++it2) {
+          if (it2->Name == *i) {
             depends.insert(it2->Index);
             break; // break out of test loop as name can only match 1
-            }
           }
         }
       }
+    }
     tests[it->Index] = depends;
     properties[it->Index] = &*it;
-    }
+  }
   parallel->SetTests(tests, properties);
   parallel->SetPassFailVectors(&passed, &failed);
   this->TestResults.clear();
   parallel->SetTestResults(&this->TestResults);
 
-  if(this->CTest->ShouldPrintLabels())
-    {
+  if (this->CTest->ShouldPrintLabels()) {
     parallel->PrintLabels();
-    }
-  else if(this->CTest->GetShowOnly())
-    {
+  } else if (this->CTest->GetShowOnly()) {
     parallel->PrintTestList();
-    }
-  else
-    {
+  } else {
     parallel->RunTests();
-    }
+  }
   delete parallel;
   this->EndTest = this->CTest->CurrentTime();
   this->EndTestTime = static_cast<unsigned int>(cmSystemTools::GetTime());
   this->ElapsedTestingTime = cmSystemTools::GetTime() - elapsed_time_start;
-  *this->LogFile << "End testing: "
-     << this->CTest->CurrentTime() << std::endl;
+  *this->LogFile << "End testing: " << this->CTest->CurrentTime() << std::endl;
 }
 
 void cmCTestTestHandler::GenerateTestCommand(std::vector<std::string>&, int)
@@ -1142,10 +992,9 @@ void cmCTestTestHandler::GenerateTestCommand(std::vector<std::string>&, int)
 
 void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
 {
-  if ( !this->CTest->GetProduceXML() )
-    {
+  if (!this->CTest->GetProduceXML()) {
     return;
-    }
+  }
 
   this->CTest->StartXML(xml, this->AppendXML);
   xml.StartElement("Testing");
@@ -1153,23 +1002,19 @@ void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
   xml.Element("StartTestTime", this->StartTestTime);
   xml.StartElement("TestList");
   cmCTestTestHandler::TestResultsVector::size_type cc;
-  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
-    {
-    cmCTestTestResult *result = &this->TestResults[cc];
+  for (cc = 0; cc < this->TestResults.size(); cc++) {
+    cmCTestTestResult* result = &this->TestResults[cc];
     std::string testPath = result->Path + "/" + result->Name;
     xml.Element("Test", this->CTest->GetShortPathToFile(testPath.c_str()));
-    }
+  }
   xml.EndElement(); // TestList
-  for ( cc = 0; cc < this->TestResults.size(); cc ++ )
-    {
-    cmCTestTestResult *result = &this->TestResults[cc];
+  for (cc = 0; cc < this->TestResults.size(); cc++) {
+    cmCTestTestResult* result = &this->TestResults[cc];
     this->WriteTestResultHeader(xml, result);
     xml.StartElement("Results");
-    if ( result->Status != cmCTestTestHandler::NOT_RUN )
-      {
-      if ( result->Status != cmCTestTestHandler::COMPLETED ||
-        result->ReturnValue )
-        {
+    if (result->Status != cmCTestTestHandler::NOT_RUN) {
+      if (result->Status != cmCTestTestHandler::COMPLETED ||
+          result->ReturnValue) {
         xml.StartElement("NamedMeasurement");
         xml.Attribute("type", "text/string");
         xml.Attribute("name", "Exit Code");
@@ -1180,56 +1025,51 @@ void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
         xml.Attribute("name", "Exit Value");
         xml.Element("Value", result->ReturnValue);
         xml.EndElement(); // NamedMeasurement
-        }
+      }
       this->GenerateRegressionImages(xml, result->DartString);
       xml.StartElement("NamedMeasurement");
       xml.Attribute("type", "numeric/double");
       xml.Attribute("name", "Execution Time");
       xml.Element("Value", result->ExecutionTime);
       xml.EndElement(); // NamedMeasurement
-      if(!result->Reason.empty())
-        {
+      if (!result->Reason.empty()) {
         const char* reasonType = "Pass Reason";
-        if(result->Status != cmCTestTestHandler::COMPLETED &&
-           result->Status != cmCTestTestHandler::NOT_RUN)
-          {
+        if (result->Status != cmCTestTestHandler::COMPLETED &&
+            result->Status != cmCTestTestHandler::NOT_RUN) {
           reasonType = "Fail Reason";
-          }
+        }
         xml.StartElement("NamedMeasurement");
         xml.Attribute("type", "text/string");
         xml.Attribute("name", reasonType);
         xml.Element("Value", result->Reason);
         xml.EndElement(); // NamedMeasurement
-        }
+      }
       xml.StartElement("NamedMeasurement");
       xml.Attribute("type", "text/string");
       xml.Attribute("name", "Completion Status");
       xml.Element("Value", result->CompletionStatus);
       xml.EndElement(); // NamedMeasurement
-      }
+    }
     xml.StartElement("NamedMeasurement");
     xml.Attribute("type", "text/string");
     xml.Attribute("name", "Command Line");
     xml.Element("Value", result->FullCommandLine);
     xml.EndElement(); // NamedMeasurement
-    std::map<std::string,std::string>::iterator measureIt;
-    for ( measureIt = result->Properties->Measurements.begin();
-      measureIt != result->Properties->Measurements.end();
-      ++ measureIt )
-      {
+    std::map<std::string, std::string>::iterator measureIt;
+    for (measureIt = result->Properties->Measurements.begin();
+         measureIt != result->Properties->Measurements.end(); ++measureIt) {
       xml.StartElement("NamedMeasurement");
       xml.Attribute("type", "text/string");
       xml.Attribute("name", measureIt->first);
       xml.Element("Value", measureIt->second);
       xml.EndElement(); // NamedMeasurement
-      }
+    }
     xml.StartElement("Measurement");
     xml.StartElement("Value");
-    if (result->CompressOutput)
-      {
+    if (result->CompressOutput) {
       xml.Attribute("encoding", "base64");
       xml.Attribute("compression", "gzip");
-      }
+    }
     xml.Content(result->Output);
     xml.EndElement(); // Value
     xml.EndElement(); // Measurement
@@ -1237,12 +1077,12 @@ void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml)
 
     this->AttachFiles(xml, result);
     this->WriteTestResultFooter(xml, result);
-    }
+  }
 
   xml.Element("EndDateTime", this->EndTest);
   xml.Element("EndTestTime", this->EndTestTime);
   xml.Element("ElapsedMinutes",
-    static_cast<int>(this->ElapsedTestingTime/6)/10.0);
+              static_cast<int>(this->ElapsedTestingTime / 6) / 10.0);
   xml.EndElement(); // Testing
   this->CTest->EndXML(xml);
 }
@@ -1251,18 +1091,13 @@ void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml,
                                                cmCTestTestResult* result)
 {
   xml.StartElement("Test");
-  if ( result->Status == cmCTestTestHandler::COMPLETED )
-    {
+  if (result->Status == cmCTestTestHandler::COMPLETED) {
     xml.Attribute("Status", "passed");
-    }
-  else if ( result->Status == cmCTestTestHandler::NOT_RUN )
-    {
+  } else if (result->Status == cmCTestTestHandler::NOT_RUN) {
     xml.Attribute("Status", "notrun");
-    }
-  else
-    {
+  } else {
     xml.Attribute("Status", "failed");
-    }
+  }
   std::string testPath = result->Path + "/" + result->Name;
   xml.Element("Name", result->Name);
   xml.Element("Path", this->CTest->GetShortPathToFile(result->Path.c_str()));
@@ -1273,17 +1108,15 @@ void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml,
 void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml,
                                                cmCTestTestResult* result)
 {
-  if(!result->Properties->Labels.empty())
-    {
+  if (!result->Properties->Labels.empty()) {
     xml.StartElement("Labels");
     std::vector<std::string> const& labels = result->Properties->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) {
       xml.Element("Label", *li);
-      }
-    xml.EndElement(); // Labels
     }
+    xml.EndElement(); // Labels
+  }
 
   xml.EndElement(); // Test
 }
@@ -1291,19 +1124,17 @@ void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml,
 void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml,
                                      cmCTestTestResult* result)
 {
-  if(result->Status != cmCTestTestHandler::COMPLETED
-     && result->Properties->AttachOnFail.size())
-    {
+  if (result->Status != cmCTestTestHandler::COMPLETED &&
+      result->Properties->AttachOnFail.size()) {
     result->Properties->AttachedFiles.insert(
       result->Properties->AttachedFiles.end(),
       result->Properties->AttachOnFail.begin(),
       result->Properties->AttachOnFail.end());
-    }
-  for(std::vector<std::string>::const_iterator file =
-      result->Properties->AttachedFiles.begin();
-      file != result->Properties->AttachedFiles.end(); ++file)
-    {
-    const std::string &base64 = this->CTest->Base64GzipEncodeFile(*file);
+  }
+  for (std::vector<std::string>::const_iterator file =
+         result->Properties->AttachedFiles.begin();
+       file != result->Properties->AttachedFiles.end(); ++file) {
+    const std::string& base64 = this->CTest->Base64GzipEncodeFile(*file);
     std::string fname = cmSystemTools::GetFilenameName(*file);
     xml.StartElement("NamedMeasurement");
     xml.Attribute("name", "Attached File");
@@ -1313,67 +1144,57 @@ void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml,
     xml.Attribute("type", "file");
     xml.Element("Value", base64);
     xml.EndElement(); // NamedMeasurement
-    }
+  }
 }
 
 int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec)
 {
   std::vector<std::string>::iterator it;
-  for ( it = vec.begin(); it != vec.end(); ++it )
-    {
+  for (it = vec.begin(); it != vec.end(); ++it) {
     int retVal = 0;
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " <<
-      *it << std::endl, this->Quiet);
-    if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, 0, &retVal, 0,
-                                          cmSystemTools::OUTPUT_MERGE
-        /*this->Verbose*/) || retVal != 0 )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem running command: "
-        << *it << std::endl);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Run command: " << *it << std::endl, this->Quiet);
+    if (!cmSystemTools::RunSingleCommand(it->c_str(), 0, 0, &retVal, 0,
+                                         cmSystemTools::OUTPUT_MERGE
+                                         /*this->Verbose*/) ||
+        retVal != 0) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Problem running command: " << *it << std::endl);
       return 0;
-      }
     }
+  }
   return 1;
 }
 
-
 // Find the appropriate executable to run for a test
-std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
+std::string cmCTestTestHandler::FindTheExecutable(const char* exe)
 {
   std::string resConfig;
   std::vector<std::string> extraPaths;
   std::vector<std::string> failedPaths;
-  if(strcmp(exe, "NOT_AVAILABLE") == 0)
-    {
+  if (strcmp(exe, "NOT_AVAILABLE") == 0) {
     return exe;
-    }
-  return cmCTestTestHandler::FindExecutable(this->CTest,
-                                            exe, resConfig,
-                                            extraPaths,
-                                            failedPaths);
+  }
+  return cmCTestTestHandler::FindExecutable(this->CTest, exe, resConfig,
+                                            extraPaths, failedPaths);
 }
 
 // add additional configurations to the search path
-void cmCTestTestHandler
-::AddConfigurations(cmCTest *ctest,
-                    std::vector<std::string> &attempted,
-                    std::vector<std::string> &attemptedConfigs,
-                    std::string filepath,
-                    std::string &filename)
+void cmCTestTestHandler::AddConfigurations(
+  cmCTest* ctest, std::vector<std::string>& attempted,
+  std::vector<std::string>& attemptedConfigs, std::string filepath,
+  std::string& filename)
 {
   std::string tempPath;
 
-  if (!filepath.empty() &&
-      filepath[filepath.size()-1] != '/')
-    {
+  if (!filepath.empty() && filepath[filepath.size() - 1] != '/') {
     filepath += "/";
-    }
+  }
   tempPath = filepath + filename;
   attempted.push_back(tempPath);
   attemptedConfigs.push_back("");
 
-  if(!ctest->GetConfigType().empty())
-    {
+  if (!ctest->GetConfigType().empty()) {
     tempPath = filepath;
     tempPath += ctest->GetConfigType();
     tempPath += "/";
@@ -1388,9 +1209,7 @@ void cmCTestTestHandler
     tempPath += filename;
     attempted.push_back(tempPath);
     attemptedConfigs.push_back(ctest->GetConfigType());
-    }
-  else
-    {
+  } else {
     // no config specified - try some options...
     tempPath = filepath;
     tempPath += "Release/";
@@ -1422,141 +1241,111 @@ void cmCTestTestHandler
     tempPath += filename;
     attempted.push_back(tempPath);
     attemptedConfigs.push_back("Deployment");
-    }
+  }
 }
 
-
 // Find the appropriate executable to run for a test
-std::string cmCTestTestHandler
-::FindExecutable(cmCTest *ctest,
-                 const char *testCommand,
-                 std::string &resultingConfig,
-                 std::vector<std::string> &extraPaths,
-                 std::vector<std::string> &failed)
+std::string cmCTestTestHandler::FindExecutable(
+  cmCTest* ctest, const char* testCommand, std::string& resultingConfig,
+  std::vector<std::string>& extraPaths, std::vector<std::string>& failed)
 {
   // now run the compiled test if we can find it
   std::vector<std::string> attempted;
   std::vector<std::string> attemptedConfigs;
   std::string tempPath;
-  std::string filepath =
-    cmSystemTools::GetFilenamePath(testCommand);
-  std::string filename =
-    cmSystemTools::GetFilenameName(testCommand);
+  std::string filepath = cmSystemTools::GetFilenamePath(testCommand);
+  std::string filename = cmSystemTools::GetFilenameName(testCommand);
 
-  cmCTestTestHandler::AddConfigurations(ctest, attempted,
-                                        attemptedConfigs,
-                                        filepath,filename);
+  cmCTestTestHandler::AddConfigurations(ctest, attempted, attemptedConfigs,
+                                        filepath, filename);
 
   // even if a fullpath was specified also try it relative to the current
   // directory
-  if (!filepath.empty() && filepath[0] == '/')
-    {
-    std::string localfilepath = filepath.substr(1,filepath.size()-1);
-    cmCTestTestHandler::AddConfigurations(ctest, attempted,
-                                          attemptedConfigs,
-                                          localfilepath,filename);
-    }
-
+  if (!filepath.empty() && filepath[0] == '/') {
+    std::string localfilepath = filepath.substr(1, filepath.size() - 1);
+    cmCTestTestHandler::AddConfigurations(ctest, attempted, attemptedConfigs,
+                                          localfilepath, filename);
+  }
 
   // if extraPaths are provided and we were not passed a full path, try them,
   // try any extra paths
-  if (filepath.empty())
-    {
-    for (unsigned int i = 0; i < extraPaths.size(); ++i)
-      {
+  if (filepath.empty()) {
+    for (unsigned int i = 0; i < extraPaths.size(); ++i) {
       std::string filepathExtra =
         cmSystemTools::GetFilenamePath(extraPaths[i]);
       std::string filenameExtra =
         cmSystemTools::GetFilenameName(extraPaths[i]);
-      cmCTestTestHandler::AddConfigurations(ctest,attempted,
-                                            attemptedConfigs,
-                                            filepathExtra,
-                                            filenameExtra);
-      }
+      cmCTestTestHandler::AddConfigurations(ctest, attempted, attemptedConfigs,
+                                            filepathExtra, filenameExtra);
     }
+  }
 
   // store the final location in fullPath
   std::string fullPath;
 
   // now look in the paths we specified above
-  for(unsigned int ai=0;
-      ai < attempted.size() && fullPath.empty(); ++ai)
-    {
+  for (unsigned int ai = 0; ai < attempted.size() && fullPath.empty(); ++ai) {
     // first check without exe extension
-    if(cmSystemTools::FileExists(attempted[ai].c_str())
-       && !cmSystemTools::FileIsDirectory(attempted[ai]))
-      {
+    if (cmSystemTools::FileExists(attempted[ai].c_str()) &&
+        !cmSystemTools::FileIsDirectory(attempted[ai])) {
       fullPath = cmSystemTools::CollapseFullPath(attempted[ai]);
       resultingConfig = attemptedConfigs[ai];
-      }
+    }
     // then try with the exe extension
-    else
-      {
+    else {
       failed.push_back(attempted[ai]);
       tempPath = attempted[ai];
       tempPath += cmSystemTools::GetExecutableExtension();
-      if(cmSystemTools::FileExists(tempPath.c_str())
-         && !cmSystemTools::FileIsDirectory(tempPath))
-        {
+      if (cmSystemTools::FileExists(tempPath.c_str()) &&
+          !cmSystemTools::FileIsDirectory(tempPath)) {
         fullPath = cmSystemTools::CollapseFullPath(tempPath);
         resultingConfig = attemptedConfigs[ai];
-        }
-      else
-        {
+      } else {
         failed.push_back(tempPath);
-        }
       }
     }
+  }
 
   // if everything else failed, check the users path, but only if a full path
   // wasn't specified
-  if (fullPath.empty() && filepath.empty())
-    {
+  if (fullPath.empty() && filepath.empty()) {
     std::string path = cmSystemTools::FindProgram(filename.c_str());
-    if (path != "")
-      {
+    if (path != "") {
       resultingConfig = "";
       return path;
-      }
     }
-  if(fullPath.empty())
-    {
-    cmCTestLog(ctest, HANDLER_OUTPUT,
-               "Could not find executable " << testCommand << "\n"
-               << "Looked in the following places:\n");
-    for(std::vector<std::string>::iterator i = failed.begin();
-        i != failed.end(); ++i)
-      {
+  }
+  if (fullPath.empty()) {
+    cmCTestLog(ctest, HANDLER_OUTPUT, "Could not find executable "
+                 << testCommand << "\n"
+                 << "Looked in the following places:\n");
+    for (std::vector<std::string>::iterator i = failed.begin();
+         i != failed.end(); ++i) {
       cmCTestLog(ctest, HANDLER_OUTPUT, i->c_str() << "\n");
-      }
     }
+  }
 
   return fullPath;
 }
 
-
 void cmCTestTestHandler::GetListOfTests()
 {
-  if ( !this->IncludeLabelRegExp.empty() )
-    {
-    this->IncludeLabelRegularExpression.
-      compile(this->IncludeLabelRegExp.c_str());
-    }
-  if ( !this->ExcludeLabelRegExp.empty() )
-    {
-    this->ExcludeLabelRegularExpression.
-      compile(this->ExcludeLabelRegExp.c_str());
-    }
-  if ( !this->IncludeRegExp.empty() )
-    {
+  if (!this->IncludeLabelRegExp.empty()) {
+    this->IncludeLabelRegularExpression.compile(
+      this->IncludeLabelRegExp.c_str());
+  }
+  if (!this->ExcludeLabelRegExp.empty()) {
+    this->ExcludeLabelRegularExpression.compile(
+      this->ExcludeLabelRegExp.c_str());
+  }
+  if (!this->IncludeRegExp.empty()) {
     this->IncludeTestsRegularExpression.compile(this->IncludeRegExp.c_str());
-    }
-  if ( !this->ExcludeRegExp.empty() )
-    {
+  }
+  if (!this->ExcludeRegExp.empty()) {
     this->ExcludeTestsRegularExpression.compile(this->ExcludeRegExp.c_str());
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Constructing a list of tests" << std::endl, this->Quiet);
+                     "Constructing a list of tests" << std::endl, this->Quiet);
   cmake cm;
   cm.SetHomeDirectory("");
   cm.SetHomeOutputDirectory("");
@@ -1564,7 +1353,7 @@ void cmCTestTestHandler::GetListOfTests()
   cmGlobalGenerator gg(&cm);
   cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
   mf->AddDefinition("CTEST_CONFIGURATION_TYPE",
-    this->CTest->GetConfigType().c_str());
+                    this->CTest->GetConfigType().c_str());
 
   // Add handler for ADD_TEST
   cmCTestAddTestCommand* newCom1 = new cmCTestAddTestCommand;
@@ -1572,49 +1361,41 @@ void cmCTestTestHandler::GetListOfTests()
   cm.GetState()->AddCommand(newCom1);
 
   // Add handler for SUBDIRS
-  cmCTestSubdirCommand* newCom2 =
-    new cmCTestSubdirCommand;
+  cmCTestSubdirCommand* newCom2 = new cmCTestSubdirCommand;
   newCom2->TestHandler = this;
   cm.GetState()->AddCommand(newCom2);
 
   // Add handler for ADD_SUBDIRECTORY
-  cmCTestAddSubdirectoryCommand* newCom3 =
-    new cmCTestAddSubdirectoryCommand;
+  cmCTestAddSubdirectoryCommand* newCom3 = new cmCTestAddSubdirectoryCommand;
   newCom3->TestHandler = this;
   cm.GetState()->AddCommand(newCom3);
 
   // Add handler for SET_SOURCE_FILES_PROPERTIES
-  cmCTestSetTestsPropertiesCommand* newCom4
-    = new cmCTestSetTestsPropertiesCommand;
+  cmCTestSetTestsPropertiesCommand* newCom4 =
+    new cmCTestSetTestsPropertiesCommand;
   newCom4->TestHandler = this;
   cm.GetState()->AddCommand(newCom4);
 
   const char* testFilename;
-  if( cmSystemTools::FileExists("CTestTestfile.cmake") )
-    {
+  if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
     // does the CTestTestfile.cmake exist ?
     testFilename = "CTestTestfile.cmake";
-    }
-  else if( cmSystemTools::FileExists("DartTestfile.txt") )
-    {
+  } else if (cmSystemTools::FileExists("DartTestfile.txt")) {
     // does the DartTestfile.txt exist ?
     testFilename = "DartTestfile.txt";
-    }
-  else
-    {
+  } else {
     return;
-    }
+  }
 
-  if ( !mf->ReadListFile(testFilename) )
-    {
+  if (!mf->ReadListFile(testFilename)) {
     return;
-    }
-  if ( cmSystemTools::GetErrorOccuredFlag() )
-    {
+  }
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return;
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Done constructing a list of tests" << std::endl, this->Quiet);
+                     "Done constructing a list of tests" << std::endl,
+                     this->Quiet);
 }
 
 void cmCTestTestHandler::UseIncludeRegExp()
@@ -1631,32 +1412,22 @@ void cmCTestTestHandler::UseExcludeRegExp()
 const char* cmCTestTestHandler::GetTestStatus(int status)
 {
   static const char statuses[][100] = {
-    "Not Run",
-    "Timeout",
-    "SEGFAULT",
-    "ILLEGAL",
-    "INTERRUPT",
-    "NUMERICAL",
-    "OTHER_FAULT",
-    "Failed",
-    "BAD_COMMAND",
-    "Completed"
+    "Not Run",   "Timeout",     "SEGFAULT", "ILLEGAL",     "INTERRUPT",
+    "NUMERICAL", "OTHER_FAULT", "Failed",   "BAD_COMMAND", "Completed"
   };
 
-  if ( status < cmCTestTestHandler::NOT_RUN ||
-       status > cmCTestTestHandler::COMPLETED )
-    {
+  if (status < cmCTestTestHandler::NOT_RUN ||
+      status > cmCTestTestHandler::COMPLETED) {
     return "No Status";
-    }
+  }
   return statuses[status];
 }
 
 void cmCTestTestHandler::ExpandTestsToRunInformation(size_t numTests)
 {
-  if (this->TestsToRunString.empty())
-    {
+  if (this->TestsToRunString.empty()) {
     return;
-    }
+  }
 
   int start;
   int end = -1;
@@ -1664,57 +1435,48 @@ void cmCTestTestHandler::ExpandTestsToRunInformation(size_t numTests)
   std::string::size_type pos = 0;
   std::string::size_type pos2;
   // read start
-  if(GetNextNumber(this->TestsToRunString, start, pos, pos2))
-    {
+  if (GetNextNumber(this->TestsToRunString, start, pos, pos2)) {
     // read end
-    if(GetNextNumber(this->TestsToRunString, end, pos, pos2))
-      {
+    if (GetNextNumber(this->TestsToRunString, end, pos, pos2)) {
       // read stride
-      if(GetNextRealNumber(this->TestsToRunString, stride, pos, pos2))
-        {
-        int val =0;
+      if (GetNextRealNumber(this->TestsToRunString, stride, pos, pos2)) {
+        int val = 0;
         // now read specific numbers
-        while(GetNextNumber(this->TestsToRunString, val, pos, pos2))
-          {
+        while (GetNextNumber(this->TestsToRunString, val, pos, pos2)) {
           this->TestsToRun.push_back(val);
-          }
-        this->TestsToRun.push_back(val);
         }
+        this->TestsToRun.push_back(val);
       }
     }
+  }
 
   // if start is not specified then we assume we start at 1
-  if(start == -1)
-    {
+  if (start == -1) {
     start = 1;
-    }
+  }
 
   // if end isnot specified then we assume we end with the last test
-  if(end == -1)
-    {
+  if (end == -1) {
     end = static_cast<int>(numTests);
-    }
+  }
 
   // if the stride wasn't specified then it defaults to 1
-  if(stride == -1)
-    {
+  if (stride == -1) {
     stride = 1;
-    }
+  }
 
   // if we have a range then add it
-  if(end != -1 && start != -1 && stride > 0)
-    {
+  if (end != -1 && start != -1 && stride > 0) {
     int i = 0;
-    while (i*stride + start <= end)
-      {
-      this->TestsToRun.push_back(static_cast<int>(i*stride+start));
+    while (i * stride + start <= end) {
+      this->TestsToRun.push_back(static_cast<int>(i * stride + start));
       ++i;
-      }
     }
+  }
 
   // sort the array
   std::sort(this->TestsToRun.begin(), this->TestsToRun.end(),
-    std::less<int>());
+            std::less<int>());
   // remove duplicates
   std::vector<int>::iterator new_end =
     std::unique(this->TestsToRun.begin(), this->TestsToRun.end());
@@ -1727,141 +1489,120 @@ void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed()
   std::string dirName = this->CTest->GetBinaryDir() + "/Testing/Temporary";
 
   cmsys::Directory directory;
-  if (directory.Load(dirName) == 0)
-    {
+  if (directory.Load(dirName) == 0) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to read the contents of "
-      << dirName << std::endl);
+                 << dirName << std::endl);
     return;
-    }
+  }
 
-  int numFiles = static_cast<int>
-    (cmsys::Directory::GetNumberOfFilesInDirectory(dirName));
+  int numFiles =
+    static_cast<int>(cmsys::Directory::GetNumberOfFilesInDirectory(dirName));
   std::string pattern = "LastTestsFailed";
   std::string logName = "";
 
-  for (int i = 0; i < numFiles; ++i)
-    {
+  for (int i = 0; i < numFiles; ++i) {
     std::string fileName = directory.GetFile(i);
     // bcc crashes if we attempt a normal substring comparison,
     // hence the following workaround
     std::string fileNameSubstring = fileName.substr(0, pattern.length());
-    if (fileNameSubstring.compare(pattern) != 0)
-      {
+    if (fileNameSubstring.compare(pattern) != 0) {
       continue;
-      }
-    if (logName == "")
-      {
+    }
+    if (logName == "") {
       logName = fileName;
-      }
-    else
-      {
+    } else {
       // if multiple matching logs were found we use the most recently
       // modified one.
       int res;
       cmSystemTools::FileTimeCompare(logName, fileName, &res);
-      if (res == -1)
-        {
+      if (res == -1) {
         logName = fileName;
-        }
       }
     }
+  }
 
-  std::string lastTestsFailedLog = this->CTest->GetBinaryDir()
-    + "/Testing/Temporary/" + logName;
+  std::string lastTestsFailedLog =
+    this->CTest->GetBinaryDir() + "/Testing/Temporary/" + logName;
 
-  if ( !cmSystemTools::FileExists(lastTestsFailedLog.c_str()) )
-    {
-    if ( !this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels() )
-      {
+  if (!cmSystemTools::FileExists(lastTestsFailedLog.c_str())) {
+    if (!this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels()) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, lastTestsFailedLog
-        << " does not exist!" << std::endl);
-      }
-    return;
+                   << " does not exist!" << std::endl);
     }
+    return;
+  }
 
   // parse the list of tests to rerun from LastTestsFailed.log
   cmsys::ifstream ifs(lastTestsFailedLog.c_str());
-  if ( ifs )
-    {
+  if (ifs) {
     std::string line;
     std::string::size_type pos;
-    while ( cmSystemTools::GetLineFromStream(ifs, line) )
-      {
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
       pos = line.find(':', 0);
-      if (pos == line.npos)
-        {
+      if (pos == line.npos) {
         continue;
-        }
+      }
 
       int val = atoi(line.substr(0, pos).c_str());
       this->TestsToRun.push_back(val);
-      }
-    ifs.close();
     }
-  else if ( !this->CTest->GetShowOnly() && !this->CTest->ShouldPrintLabels() )
-    {
+    ifs.close();
+  } else if (!this->CTest->GetShowOnly() &&
+             !this->CTest->ShouldPrintLabels()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem reading file: "
-      << lastTestsFailedLog <<
-      " while generating list of previously failed tests." << std::endl);
-    }
+                 << lastTestsFailedLog
+                 << " while generating list of previously failed tests."
+                 << std::endl);
+  }
 }
 
 // Just for convenience
 #define SPACE_REGEX "[ \t\r\n]"
-void cmCTestTestHandler::GenerateRegressionImages(
-  cmXMLWriter& xml, const std::string& dart)
+void cmCTestTestHandler::GenerateRegressionImages(cmXMLWriter& xml,
+                                                  const std::string& dart)
 {
   cmsys::RegularExpression twoattributes(
-    "<DartMeasurement"
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*>([^<]*)</DartMeasurement>");
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurement>");
   cmsys::RegularExpression threeattributes(
-    "<DartMeasurement"
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*>([^<]*)</DartMeasurement>");
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurement>");
   cmsys::RegularExpression fourattributes(
-    "<DartMeasurement"
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*>([^<]*)</DartMeasurement>");
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurement>");
   cmsys::RegularExpression cdatastart(
-    "<DartMeasurement"
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*>"
-    SPACE_REGEX "*<!\\[CDATA\\[");
-  cmsys::RegularExpression cdataend(
-    "]]>"
-    SPACE_REGEX "*</DartMeasurement>");
+    "<DartMeasurement" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>" SPACE_REGEX "*<!\\[CDATA\\[");
+  cmsys::RegularExpression cdataend("]]>" SPACE_REGEX "*</DartMeasurement>");
   cmsys::RegularExpression measurementfile(
-    "<DartMeasurementFile"
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
-    SPACE_REGEX "*>([^<]*)</DartMeasurementFile>");
+    "<DartMeasurementFile" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*(name|type|encoding|compression)=\"([^\"]*)\"" SPACE_REGEX
+    "*>([^<]*)</DartMeasurementFile>");
 
   bool done = false;
   std::string cxml = dart;
-  while ( ! done )
-    {
-    if ( twoattributes.find(cxml) )
-      {
+  while (!done) {
+    if (twoattributes.find(cxml)) {
       xml.StartElement("NamedMeasurement");
-      xml.Attribute(twoattributes.match(1).c_str(),
-                    twoattributes.match(2));
-      xml.Attribute(twoattributes.match(3).c_str(),
-                    twoattributes.match(4));
+      xml.Attribute(twoattributes.match(1).c_str(), twoattributes.match(2));
+      xml.Attribute(twoattributes.match(3).c_str(), twoattributes.match(4));
       xml.Element("Value", twoattributes.match(5));
       xml.EndElement();
       cxml.erase(twoattributes.start(),
-        twoattributes.end() - twoattributes.start());
-      }
-    else if ( threeattributes.find(cxml) )
-      {
+                 twoattributes.end() - twoattributes.start());
+    } else if (threeattributes.find(cxml)) {
       xml.StartElement("NamedMeasurement");
       xml.Attribute(threeattributes.match(1).c_str(),
                     threeattributes.match(2));
@@ -1872,58 +1613,43 @@ void cmCTestTestHandler::GenerateRegressionImages(
       xml.Element("Value", twoattributes.match(7));
       xml.EndElement();
       cxml.erase(threeattributes.start(),
-        threeattributes.end() - threeattributes.start());
-      }
-    else if ( fourattributes.find(cxml) )
-      {
+                 threeattributes.end() - threeattributes.start());
+    } else if (fourattributes.find(cxml)) {
       xml.StartElement("NamedMeasurement");
-      xml.Attribute(fourattributes.match(1).c_str(),
-                    fourattributes.match(2));
-      xml.Attribute(fourattributes.match(3).c_str(),
-                    fourattributes.match(4));
-      xml.Attribute(fourattributes.match(5).c_str(),
-                    fourattributes.match(6));
-      xml.Attribute(fourattributes.match(7).c_str(),
-                    fourattributes.match(8));
+      xml.Attribute(fourattributes.match(1).c_str(), fourattributes.match(2));
+      xml.Attribute(fourattributes.match(3).c_str(), fourattributes.match(4));
+      xml.Attribute(fourattributes.match(5).c_str(), fourattributes.match(6));
+      xml.Attribute(fourattributes.match(7).c_str(), fourattributes.match(8));
       xml.Element("Value", twoattributes.match(9));
       xml.EndElement();
       cxml.erase(fourattributes.start(),
-        fourattributes.end() - fourattributes.start());
-      }
-    else if ( cdatastart.find(cxml) && cdataend.find(cxml) )
-      {
+                 fourattributes.end() - fourattributes.start());
+    } else if (cdatastart.find(cxml) && cdataend.find(cxml)) {
       xml.StartElement("NamedMeasurement");
       xml.Attribute(cdatastart.match(1).c_str(), cdatastart.match(2));
       xml.Attribute(cdatastart.match(3).c_str(), cdatastart.match(4));
       xml.StartElement("Value");
       xml.CData(
-          cxml.substr(cdatastart.end(), cdataend.start() - cdatastart.end()));
+        cxml.substr(cdatastart.end(), cdataend.start() - cdatastart.end()));
       xml.EndElement(); // Value
       xml.EndElement(); // NamedMeasurement
-      cxml.erase(cdatastart.start(),
-        cdataend.end() - cdatastart.start());
-      }
-    else if ( measurementfile.find(cxml) )
-      {
+      cxml.erase(cdatastart.start(), cdataend.end() - cdatastart.start());
+    } else if (measurementfile.find(cxml)) {
       const std::string& filename =
         cmCTest::CleanString(measurementfile.match(5));
-      if ( cmSystemTools::FileExists(filename.c_str()) )
-        {
+      if (cmSystemTools::FileExists(filename.c_str())) {
         long len = cmSystemTools::FileLength(filename);
-        if ( len == 0 )
-          {
+        if (len == 0) {
           std::string k1 = measurementfile.match(1);
           std::string v1 = measurementfile.match(2);
           std::string k2 = measurementfile.match(3);
           std::string v2 = measurementfile.match(4);
-          if ( cmSystemTools::LowerCase(k1) == "type" )
-            {
+          if (cmSystemTools::LowerCase(k1) == "type") {
             v1 = "text/string";
-            }
-          if ( cmSystemTools::LowerCase(k2) == "type" )
-            {
+          }
+          if (cmSystemTools::LowerCase(k2) == "type") {
             v2 = "text/string";
-            }
+          }
 
           xml.StartElement("NamedMeasurement");
           xml.Attribute(k1.c_str(), v1);
@@ -1931,22 +1657,19 @@ void cmCTestTestHandler::GenerateRegressionImages(
           xml.Attribute("encoding", "none");
           xml.Element("Value", "Image " + filename + " is empty");
           xml.EndElement();
-          }
-        else
-          {
+        } else {
           cmsys::ifstream ifs(filename.c_str(), std::ios::in
 #ifdef _WIN32
-                            | std::ios::binary
+                                | std::ios::binary
 #endif
-            );
-          unsigned char *file_buffer = new unsigned char [ len + 1 ];
+                              );
+          unsigned char* file_buffer = new unsigned char[len + 1];
           ifs.read(reinterpret_cast<char*>(file_buffer), len);
-          unsigned char *encoded_buffer
-            = new unsigned char [ static_cast<int>(
-                static_cast<double>(len) * 1.5 + 5.0) ];
+          unsigned char* encoded_buffer = new unsigned char[static_cast<int>(
+            static_cast<double>(len) * 1.5 + 5.0)];
 
-          size_t rlen
-            = cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
+          size_t rlen =
+            cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
 
           xml.StartElement("NamedMeasurement");
           xml.Attribute(measurementfile.match(1).c_str(),
@@ -1955,83 +1678,74 @@ void cmCTestTestHandler::GenerateRegressionImages(
                         measurementfile.match(4));
           xml.Attribute("encoding", "base64");
           std::stringstream ostr;
-          for (size_t cc = 0; cc < rlen; cc ++ )
-            {
+          for (size_t cc = 0; cc < rlen; cc++) {
             ostr << encoded_buffer[cc];
-            if ( cc % 60 == 0 && cc )
-              {
+            if (cc % 60 == 0 && cc) {
               ostr << std::endl;
-              }
             }
+          }
           xml.Element("Value", ostr.str());
           xml.EndElement(); // NamedMeasurement
-          delete [] file_buffer;
-          delete [] encoded_buffer;
-          }
+          delete[] file_buffer;
+          delete[] encoded_buffer;
         }
-      else
-        {
+      } else {
         int idx = 4;
-        if ( measurementfile.match(1) == "name" )
-          {
+        if (measurementfile.match(1) == "name") {
           idx = 2;
-          }
+        }
         xml.StartElement("NamedMeasurement");
         xml.Attribute("name", measurementfile.match(idx));
         xml.Attribute("text", "text/string");
         xml.Element("Value", "File " + filename + " not found");
         xml.EndElement();
-        cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "File \"" << filename
-          << "\" not found." << std::endl, this->Quiet);
-        }
-      cxml.erase(measurementfile.start(),
-        measurementfile.end() - measurementfile.start());
+        cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "File \""
+                             << filename << "\" not found." << std::endl,
+                           this->Quiet);
       }
-    else
-      {
+      cxml.erase(measurementfile.start(),
+                 measurementfile.end() - measurementfile.start());
+    } else {
       done = true;
-      }
     }
+  }
 }
 
-void cmCTestTestHandler::SetIncludeRegExp(const char *arg)
+void cmCTestTestHandler::SetIncludeRegExp(const char* arg)
 {
   this->IncludeRegExp = arg;
 }
 
-void cmCTestTestHandler::SetExcludeRegExp(const char *arg)
+void cmCTestTestHandler::SetExcludeRegExp(const char* arg)
 {
   this->ExcludeRegExp = arg;
 }
 
 void cmCTestTestHandler::SetTestsToRunInformation(const char* in)
 {
-  if ( !in )
-    {
+  if (!in) {
     return;
-    }
+  }
   this->TestsToRunString = in;
   // if the argument is a file, then read it and use the contents as the
   // string
-  if(cmSystemTools::FileExists(in))
-    {
+  if (cmSystemTools::FileExists(in)) {
     cmsys::ifstream fin(in);
     unsigned long filelen = cmSystemTools::FileLength(in);
-    char* buff = new char[filelen+1];
+    char* buff = new char[filelen + 1];
     fin.getline(buff, filelen);
     buff[fin.gcount()] = 0;
     this->TestsToRunString = buff;
-    delete [] buff;
-    }
+    delete[] buff;
+  }
 }
 
 bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length)
 {
-  if(!length || length >= output.size() ||
-     output.find("CTEST_FULL_OUTPUT") != output.npos)
-    {
+  if (!length || length >= output.size() ||
+      output.find("CTEST_FULL_OUTPUT") != output.npos) {
     return true;
-    }
+  }
 
   // Truncate at given length but do not break in the middle of a multi-byte
   // UTF-8 encoding.
@@ -2039,29 +1753,27 @@ bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length)
   char const* const end = begin + output.size();
   char const* const truncate = begin + length;
   char const* current = begin;
-  while(current < truncate)
-    {
+  while (current < truncate) {
     unsigned int ch;
-    if(const char* next = cm_utf8_decode_character(current, end, &ch))
-      {
-      if(next > truncate)
-        {
+    if (const char* next = cm_utf8_decode_character(current, end, &ch)) {
+      if (next > truncate) {
         break;
-        }
-      current = next;
       }
-    else // Bad byte will be handled by cmXMLWriter.
-      {
+      current = next;
+    } else // Bad byte will be handled by cmXMLWriter.
+    {
       ++current;
-      }
     }
+  }
   output = output.substr(0, current - begin);
 
   // Append truncation message.
   std::ostringstream msg;
   msg << "...\n"
-    "The rest of the test output was removed since it exceeds the threshold "
-    "of " << length << " bytes.\n";
+         "The rest of the test output was removed since it exceeds the "
+         "threshold "
+         "of "
+      << length << " bytes.\n";
   output += msg.str();
   return true;
 }
@@ -2072,176 +1784,138 @@ bool cmCTestTestHandler::SetTestsProperties(
   std::vector<std::string>::const_iterator it;
   std::vector<std::string> tests;
   bool found = false;
-  for ( it = args.begin(); it != args.end(); ++ it )
-    {
-    if ( *it == "PROPERTIES" )
-      {
+  for (it = args.begin(); it != args.end(); ++it) {
+    if (*it == "PROPERTIES") {
       found = true;
       break;
-      }
-    tests.push_back(*it);
     }
-  if ( !found )
-    {
+    tests.push_back(*it);
+  }
+  if (!found) {
     return false;
-    }
-  ++ it; // skip PROPERTIES
-  for ( ; it != args.end(); ++ it )
-    {
+  }
+  ++it; // skip PROPERTIES
+  for (; it != args.end(); ++it) {
     std::string key = *it;
-    ++ it;
-    if ( it == args.end() )
-      {
+    ++it;
+    if (it == args.end()) {
       break;
-      }
+    }
     std::string val = *it;
     std::vector<std::string>::const_iterator tit;
-    for ( tit = tests.begin(); tit != tests.end(); ++ tit )
-      {
+    for (tit = tests.begin(); tit != tests.end(); ++tit) {
       cmCTestTestHandler::ListOfTests::iterator rtit;
-      for ( rtit = this->TestList.begin();
-        rtit != this->TestList.end();
-        ++ rtit )
-        {
-        if ( *tit == rtit->Name )
-          {
-          if ( key == "WILL_FAIL" )
-            {
+      for (rtit = this->TestList.begin(); rtit != this->TestList.end();
+           ++rtit) {
+        if (*tit == rtit->Name) {
+          if (key == "WILL_FAIL") {
             rtit->WillFail = cmSystemTools::IsOn(val.c_str());
-            }
-          if ( key == "ATTACHED_FILES" )
-            {
+          }
+          if (key == "ATTACHED_FILES") {
             cmSystemTools::ExpandListArgument(val, rtit->AttachedFiles);
-            }
-          if ( key == "ATTACHED_FILES_ON_FAIL" )
-            {
+          }
+          if (key == "ATTACHED_FILES_ON_FAIL") {
             cmSystemTools::ExpandListArgument(val, rtit->AttachOnFail);
-            }
-          if ( key == "RESOURCE_LOCK" )
-            {
+          }
+          if (key == "RESOURCE_LOCK") {
             std::vector<std::string> lval;
             cmSystemTools::ExpandListArgument(val, lval);
 
             rtit->LockedResources.insert(lval.begin(), lval.end());
-            }
-          if ( key == "TIMEOUT" )
-            {
+          }
+          if (key == "TIMEOUT") {
             rtit->Timeout = atof(val.c_str());
             rtit->ExplicitTimeout = true;
-            }
-          if ( key == "COST" )
-            {
+          }
+          if (key == "COST") {
             rtit->Cost = static_cast<float>(atof(val.c_str()));
-            }
-          if ( key == "REQUIRED_FILES" )
-            {
+          }
+          if (key == "REQUIRED_FILES") {
             cmSystemTools::ExpandListArgument(val, rtit->RequiredFiles);
-            }
-          if ( key == "RUN_SERIAL" )
-            {
+          }
+          if (key == "RUN_SERIAL") {
             rtit->RunSerial = cmSystemTools::IsOn(val.c_str());
-            }
-          if ( key == "FAIL_REGULAR_EXPRESSION" )
-            {
+          }
+          if (key == "FAIL_REGULAR_EXPRESSION") {
             std::vector<std::string> lval;
             cmSystemTools::ExpandListArgument(val, lval);
             std::vector<std::string>::iterator crit;
-            for ( crit = lval.begin(); crit != lval.end(); ++ crit )
-              {
+            for (crit = lval.begin(); crit != lval.end(); ++crit) {
               rtit->ErrorRegularExpressions.push_back(
                 std::pair<cmsys::RegularExpression, std::string>(
                   cmsys::RegularExpression(crit->c_str()),
                   std::string(*crit)));
-              }
             }
-          if ( key == "PROCESSORS" )
-            {
+          }
+          if (key == "PROCESSORS") {
             rtit->Processors = atoi(val.c_str());
-            if(rtit->Processors < 1)
-              {
+            if (rtit->Processors < 1) {
               rtit->Processors = 1;
-              }
             }
-          if ( key == "SKIP_RETURN_CODE" )
-            {
+          }
+          if (key == "SKIP_RETURN_CODE") {
             rtit->SkipReturnCode = atoi(val.c_str());
-            if(rtit->SkipReturnCode < 0 || rtit->SkipReturnCode > 255)
-              {
+            if (rtit->SkipReturnCode < 0 || rtit->SkipReturnCode > 255) {
               rtit->SkipReturnCode = -1;
-              }
             }
-          if ( key == "DEPENDS" )
-            {
+          }
+          if (key == "DEPENDS") {
             cmSystemTools::ExpandListArgument(val, rtit->Depends);
-            }
-          if ( key == "ENVIRONMENT" )
-            {
+          }
+          if (key == "ENVIRONMENT") {
             cmSystemTools::ExpandListArgument(val, rtit->Environment);
-            }
-          if ( key == "LABELS" )
-            {
+          }
+          if (key == "LABELS") {
             cmSystemTools::ExpandListArgument(val, rtit->Labels);
-            }
-          if ( key == "MEASUREMENT" )
-            {
+          }
+          if (key == "MEASUREMENT") {
             size_t pos = val.find_first_of("=");
-            if ( pos != val.npos )
-              {
+            if (pos != val.npos) {
               std::string mKey = val.substr(0, pos);
               const char* mVal = val.c_str() + pos + 1;
               rtit->Measurements[mKey] = mVal;
-              }
-            else
-              {
+            } else {
               rtit->Measurements[val] = "1";
-              }
             }
-          if ( key == "PASS_REGULAR_EXPRESSION" )
-            {
+          }
+          if (key == "PASS_REGULAR_EXPRESSION") {
             std::vector<std::string> lval;
             cmSystemTools::ExpandListArgument(val, lval);
             std::vector<std::string>::iterator crit;
-            for ( crit = lval.begin(); crit != lval.end(); ++ crit )
-              {
+            for (crit = lval.begin(); crit != lval.end(); ++crit) {
               rtit->RequiredRegularExpressions.push_back(
                 std::pair<cmsys::RegularExpression, std::string>(
                   cmsys::RegularExpression(crit->c_str()),
                   std::string(*crit)));
-              }
             }
-          if ( key == "WORKING_DIRECTORY" )
-            {
+          }
+          if (key == "WORKING_DIRECTORY") {
             rtit->Directory = val;
-            }
-          if ( key == "TIMEOUT_AFTER_MATCH" )
-            {
+          }
+          if (key == "TIMEOUT_AFTER_MATCH") {
             std::vector<std::string> propArgs;
             cmSystemTools::ExpandListArgument(val, propArgs);
-            if (propArgs.size() != 2)
-              {
+            if (propArgs.size() != 2) {
               cmCTestLog(this->CTest, WARNING,
-                "TIMEOUT_AFTER_MATCH expects two arguments, found " <<
-                propArgs.size() << std::endl);
-              }
-            else
-              {
+                         "TIMEOUT_AFTER_MATCH expects two arguments, found "
+                           << propArgs.size() << std::endl);
+            } else {
               rtit->AlternateTimeout = atof(propArgs[0].c_str());
               std::vector<std::string> lval;
               cmSystemTools::ExpandListArgument(propArgs[1], lval);
               std::vector<std::string>::iterator crit;
-              for ( crit = lval.begin(); crit != lval.end(); ++ crit )
-                {
+              for (crit = lval.begin(); crit != lval.end(); ++crit) {
                 rtit->TimeoutRegularExpressions.push_back(
                   std::pair<cmsys::RegularExpression, std::string>(
                     cmsys::RegularExpression(crit->c_str()),
                     std::string(*crit)));
-                }
               }
             }
           }
         }
       }
     }
+  }
   return true;
 }
 
@@ -2249,61 +1923,51 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
 {
   const std::string& testname = args[0];
   cmCTestOptionalLog(this->CTest, DEBUG, "Add test: " << args[0] << std::endl,
-    this->Quiet);
+                     this->Quiet);
 
-  if (this->UseExcludeRegExpFlag &&
-    this->UseExcludeRegExpFirst &&
-    this->ExcludeTestsRegularExpression.find(testname.c_str()))
-    {
+  if (this->UseExcludeRegExpFlag && this->UseExcludeRegExpFirst &&
+      this->ExcludeTestsRegularExpression.find(testname.c_str())) {
     return true;
-    }
-  if ( this->MemCheck )
-    {
+  }
+  if (this->MemCheck) {
     std::vector<std::string>::iterator it;
     bool found = false;
-    for ( it = this->CustomTestsIgnore.begin();
-      it != this->CustomTestsIgnore.end(); ++ it )
-      {
-      if ( *it == testname )
-        {
+    for (it = this->CustomTestsIgnore.begin();
+         it != this->CustomTestsIgnore.end(); ++it) {
+      if (*it == testname) {
         found = true;
         break;
-        }
       }
-    if ( found )
-      {
+    }
+    if (found) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "Ignore memcheck: " << *it << std::endl, this->Quiet);
+                         "Ignore memcheck: " << *it << std::endl, this->Quiet);
       return true;
-      }
     }
-  else
-    {
+  } else {
     std::vector<std::string>::iterator it;
     bool found = false;
-    for ( it = this->CustomTestsIgnore.begin();
-      it != this->CustomTestsIgnore.end(); ++ it )
-      {
-      if ( *it == testname )
-        {
+    for (it = this->CustomTestsIgnore.begin();
+         it != this->CustomTestsIgnore.end(); ++it) {
+      if (*it == testname) {
         found = true;
         break;
-        }
       }
-    if ( found )
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: "
-        << *it << std::endl, this->Quiet);
+    }
+    if (found) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Ignore test: " << *it << std::endl, this->Quiet);
       return true;
-      }
     }
+  }
 
   cmCTestTestProperties test;
   test.Name = testname;
   test.Args = args;
   test.Directory = cmSystemTools::GetCurrentWorkingDirectory();
-  cmCTestOptionalLog(this->CTest, DEBUG, "Set test directory: "
-    << test.Directory << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Set test directory: " << test.Directory << std::endl,
+                     this->Quiet);
 
   test.IsInBasedOnREOptions = true;
   test.WillFail = false;
@@ -2315,17 +1979,12 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
   test.SkipReturnCode = -1;
   test.PreviousRuns = 0;
   if (this->UseIncludeRegExpFlag &&
-    !this->IncludeTestsRegularExpression.find(testname.c_str()))
-    {
+      !this->IncludeTestsRegularExpression.find(testname.c_str())) {
     test.IsInBasedOnREOptions = false;
-    }
-  else if (this->UseExcludeRegExpFlag &&
-    !this->UseExcludeRegExpFirst &&
-    this->ExcludeTestsRegularExpression.find(testname.c_str()))
-    {
+  } else if (this->UseExcludeRegExpFlag && !this->UseExcludeRegExpFirst &&
+             this->ExcludeTestsRegularExpression.find(testname.c_str())) {
     test.IsInBasedOnREOptions = false;
-    }
+  }
   this->TestList.push_back(test);
   return true;
 }
-
diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h
index 28338dd..4b74ce0 100644
--- a/Source/CTest/cmCTestTestHandler.h
+++ b/Source/CTest/cmCTestTestHandler.h
@@ -29,6 +29,7 @@ class cmCTestTestHandler : public cmCTestGenericHandler
   friend class cmCTestRunTest;
   friend class cmCTestMultiProcessHandler;
   friend class cmCTestBatchTestHandler;
+
 public:
   cmTypeMacro(cmCTestTestHandler, cmCTestGenericHandler);
 
@@ -53,22 +54,26 @@ public:
   /**
    * This method is called when reading CTest custom file
    */
-  void PopulateCustomVectors(cmMakefile *mf);
+  void PopulateCustomVectors(cmMakefile* mf);
 
   ///! Control the use of the regular expresisons, call these methods to turn
-  ///them on
+  /// them on
   void UseIncludeRegExp();
   void UseExcludeRegExp();
-  void SetIncludeRegExp(const char *);
-  void SetExcludeRegExp(const char *);
+  void SetIncludeRegExp(const char*);
+  void SetExcludeRegExp(const char*);
 
-  void SetMaxIndex(int n) {this->MaxIndex = n;}
-  int GetMaxIndex() {return this->MaxIndex;}
+  void SetMaxIndex(int n) { this->MaxIndex = n; }
+  int GetMaxIndex() { return this->MaxIndex; }
 
   void SetTestOutputSizePassed(int n)
-    { this->CustomMaximumPassedTestOutputSize = n; }
+  {
+    this->CustomMaximumPassedTestOutputSize = n;
+  }
   void SetTestOutputSizeFailed(int n)
-    { this->CustomMaximumFailedTestOutputSize = n; }
+  {
+    this->CustomMaximumFailedTestOutputSize = n;
+  }
 
   ///! pass the -I argument down
   void SetTestsToRunInformation(const char*);
@@ -100,12 +105,12 @@ public:
     std::vector<std::string> Depends;
     std::vector<std::string> AttachedFiles;
     std::vector<std::string> AttachOnFail;
-    std::vector<std::pair<cmsys::RegularExpression,
-                          std::string> > ErrorRegularExpressions;
-    std::vector<std::pair<cmsys::RegularExpression,
-                          std::string> > RequiredRegularExpressions;
-    std::vector<std::pair<cmsys::RegularExpression,
-                          std::string> > TimeoutRegularExpressions;
+    std::vector<std::pair<cmsys::RegularExpression, std::string> >
+      ErrorRegularExpressions;
+    std::vector<std::pair<cmsys::RegularExpression, std::string> >
+      RequiredRegularExpressions;
+    std::vector<std::pair<cmsys::RegularExpression, std::string> >
+      TimeoutRegularExpressions;
     std::map<std::string, std::string> Measurements;
     bool IsInBasedOnREOptions;
     bool WillFail;
@@ -116,7 +121,7 @@ public:
     bool ExplicitTimeout;
     double AlternateTimeout;
     int Index;
-    //Requested number of process slots
+    // Requested number of process slots
     int Processors;
     // return code of test which will mark test as "not run"
     int SkipReturnCode;
@@ -131,41 +136,40 @@ public:
     std::string Path;
     std::string Reason;
     std::string FullCommandLine;
-    double      ExecutionTime;
-    int         ReturnValue;
-    int         Status;
-    bool        CompressOutput;
+    double ExecutionTime;
+    int ReturnValue;
+    int Status;
+    bool CompressOutput;
     std::string CompletionStatus;
     std::string Output;
     std::string DartString;
-    int         TestCount;
+    int TestCount;
     cmCTestTestProperties* Properties;
   };
 
   struct cmCTestTestResultLess
   {
-    bool operator() (const cmCTestTestResult &lhs,
-                     const cmCTestTestResult &rhs) const
+    bool operator()(const cmCTestTestResult& lhs,
+                    const cmCTestTestResult& rhs) const
     {
-    return lhs.TestCount < rhs.TestCount;
+      return lhs.TestCount < rhs.TestCount;
     }
   };
 
   // add configurations to a search path for an executable
-  static void AddConfigurations(cmCTest *ctest,
-                                std::vector<std::string> &attempted,
-                                std::vector<std::string> &attemptedConfigs,
-                                std::string filepath,
-                                std::string &filename);
+  static void AddConfigurations(cmCTest* ctest,
+                                std::vector<std::string>& attempted,
+                                std::vector<std::string>& attemptedConfigs,
+                                std::string filepath, std::string& filename);
 
   // full signature static method to find an executable
-  static std::string FindExecutable(cmCTest *ctest,
-                                    const char *testCommand,
-                                    std::string &resultingConfig,
-                                    std::vector<std::string> &extraPaths,
-                                    std::vector<std::string> &failed);
+  static std::string FindExecutable(cmCTest* ctest, const char* testCommand,
+                                    std::string& resultingConfig,
+                                    std::vector<std::string>& extraPaths,
+                                    std::vector<std::string>& failed);
 
   typedef std::vector<cmCTestTestProperties> ListOfTests;
+
 protected:
   // compute a final test list
   virtual int PreProcessHandler();
@@ -181,22 +185,24 @@ protected:
   //! Clean test output to specified length
   bool CleanTestOutput(std::string& output, size_t length);
 
-  double                  ElapsedTestingTime;
+  double ElapsedTestingTime;
 
   typedef std::vector<cmCTestTestResult> TestResultsVector;
-  TestResultsVector    TestResults;
+  TestResultsVector TestResults;
 
   std::vector<std::string> CustomTestsIgnore;
-  std::string             StartTest;
-  std::string             EndTest;
-  unsigned int            StartTestTime;
-  unsigned int            EndTestTime;
+  std::string StartTest;
+  std::string EndTest;
+  unsigned int StartTestTime;
+  unsigned int EndTestTime;
   bool MemCheck;
   int CustomMaximumPassedTestOutputSize;
   int CustomMaximumFailedTestOutputSize;
   int MaxIndex;
+
 public:
-  enum { // Program statuses
+  enum
+  { // Program statuses
     NOT_RUN = 0,
     TIMEOUT,
     SEGFAULT,
@@ -219,8 +225,8 @@ private:
   /**
    * Run the tests for a directory and any subdirectories
    */
-  void ProcessDirectory(std::vector<std::string> &passed,
-                        std::vector<std::string> &failed);
+  void ProcessDirectory(std::vector<std::string>& passed,
+                        std::vector<std::string>& failed);
 
   /**
    * Get the list of tests in directory and subdirectories.
@@ -236,25 +242,15 @@ private:
 
   void UpdateMaxTestNameWidth();
 
-  bool GetValue(const char* tag,
-                std::string& value,
-                std::istream& fin);
-  bool GetValue(const char* tag,
-                int& value,
-                std::istream& fin);
-  bool GetValue(const char* tag,
-                size_t& value,
-                std::istream& fin);
-  bool GetValue(const char* tag,
-                bool& value,
-                std::istream& fin);
-  bool GetValue(const char* tag,
-                double& value,
-                std::istream& fin);
+  bool GetValue(const char* tag, std::string& value, std::istream& fin);
+  bool GetValue(const char* tag, int& value, std::istream& fin);
+  bool GetValue(const char* tag, size_t& value, std::istream& fin);
+  bool GetValue(const char* tag, bool& value, std::istream& fin);
+  bool GetValue(const char* tag, double& value, std::istream& fin);
   /**
    * Find the executable for a test
    */
-  std::string FindTheExecutable(const char *exe);
+  std::string FindTheExecutable(const char* exe);
 
   const char* GetTestStatus(int status);
   void ExpandTestsToRunInformation(size_t numPossibleTests);
@@ -263,7 +259,7 @@ private:
   std::vector<std::string> CustomPreTest;
   std::vector<std::string> CustomPostTest;
 
-  std::vector<int>        TestsToRun;
+  std::vector<int> TestsToRun;
 
   bool UseIncludeLabelRegExpFlag;
   bool UseExcludeLabelRegExpFlag;
diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx
index 1bf60fc..f1bae5d 100644
--- a/Source/CTest/cmCTestUpdateCommand.cxx
+++ b/Source/CTest/cmCTestUpdateCommand.cxx
@@ -16,79 +16,81 @@
 
 cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
 {
-  if ( this->Values[ct_SOURCE] )
-    {
-    this->CTest->SetCTestConfiguration("SourceDirectory",
-      cmSystemTools::CollapseFullPath(
-        this->Values[ct_SOURCE]).c_str(), this->Quiet);
-    }
-  else
-    {
-    this->CTest->SetCTestConfiguration("SourceDirectory",
+  if (this->Values[ct_SOURCE]) {
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
+      cmSystemTools::CollapseFullPath(this->Values[ct_SOURCE]).c_str(),
+      this->Quiet);
+  } else {
+    this->CTest->SetCTestConfiguration(
+      "SourceDirectory",
       cmSystemTools::CollapseFullPath(
-        this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY")).c_str(),
+        this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY"))
+        .c_str(),
       this->Quiet);
-    }
-  std::string source_dir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
+  }
+  std::string source_dir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
 
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "UpdateCommand", "CTEST_UPDATE_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "UpdateOptions", "CTEST_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "CVSCommand", "CTEST_CVS_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "CVSUpdateOptions", "CTEST_CVS_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "SVNCommand", "CTEST_SVN_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "SVNUpdateOptions", "CTEST_SVN_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "SVNOptions", "CTEST_SVN_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "BZRCommand", "CTEST_BZR_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "BZRUpdateOptions", "CTEST_BZR_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "GITCommand", "CTEST_GIT_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "GITUpdateOptions", "CTEST_GIT_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "GITInitSubmodules", "CTEST_GIT_INIT_SUBMODULES", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "GITUpdateCustom", "CTEST_GIT_UPDATE_CUSTOM", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "UpdateVersionOnly", "CTEST_UPDATE_VERSION_ONLY", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "HGCommand", "CTEST_HG_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "HGUpdateOptions", "CTEST_HG_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "P4Command", "CTEST_P4_COMMAND", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "P4UpdateOptions", "CTEST_P4_UPDATE_OPTIONS", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "P4Client", "CTEST_P4_CLIENT", this->Quiet);
-  this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile,
-    "P4Options", "CTEST_P4_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "UpdateCommand", "CTEST_UPDATE_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "UpdateOptions", "CTEST_UPDATE_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CVSCommand", "CTEST_CVS_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "CVSUpdateOptions", "CTEST_CVS_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "SVNCommand", "CTEST_SVN_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "SVNUpdateOptions", "CTEST_SVN_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "SVNOptions", "CTEST_SVN_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "BZRCommand", "CTEST_BZR_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "BZRUpdateOptions", "CTEST_BZR_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITCommand", "CTEST_GIT_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITUpdateOptions", "CTEST_GIT_UPDATE_OPTIONS",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITInitSubmodules", "CTEST_GIT_INIT_SUBMODULES",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "GITUpdateCustom", "CTEST_GIT_UPDATE_CUSTOM", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "UpdateVersionOnly", "CTEST_UPDATE_VERSION_ONLY",
+    this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "HGCommand", "CTEST_HG_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "HGUpdateOptions", "CTEST_HG_UPDATE_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4Command", "CTEST_P4_COMMAND", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4UpdateOptions", "CTEST_P4_UPDATE_OPTIONS", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4Client", "CTEST_P4_CLIENT", this->Quiet);
+  this->CTest->SetCTestConfigurationFromCMakeVariable(
+    this->Makefile, "P4Options", "CTEST_P4_OPTIONS", this->Quiet);
 
-  cmCTestGenericHandler* handler
-    = this->CTest->GetInitializedHandler("update");
-  if ( !handler )
-    {
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("update");
+  if (!handler) {
     this->SetError("internal CTest error. Cannot instantiate update handler");
     return 0;
-    }
+  }
   handler->SetCommand(this);
-  if ( source_dir.empty() )
-    {
+  if (source_dir.empty()) {
     this->SetError("source directory not specified. Please use SOURCE tag");
     return 0;
-    }
+  }
   handler->SetOption("SourceDirectory", source_dir.c_str());
   handler->SetQuiet(this->Quiet);
   return handler;
 }
-
-
diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h
index fb80333..e807193 100644
--- a/Source/CTest/cmCTestUpdateCommand.h
+++ b/Source/CTest/cmCTestUpdateCommand.h
@@ -22,24 +22,23 @@
 class cmCTestUpdateCommand : public cmCTestHandlerCommand
 {
 public:
-
   cmCTestUpdateCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestUpdateCommand* ni = new cmCTestUpdateCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_update";}
+  virtual std::string GetName() const { return "ctest_update"; }
 
   cmTypeMacro(cmCTestUpdateCommand, cmCTestHandlerCommand);
 
@@ -47,5 +46,4 @@ protected:
   cmCTestGenericHandler* InitializeHandler();
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
index 85624e0..4eaa16b 100644
--- a/Source/CTest/cmCTestUpdateHandler.cxx
+++ b/Source/CTest/cmCTestUpdateHandler.cxx
@@ -44,24 +44,16 @@
 #include <math.h>
 #include <stdlib.h>
 
-static const char* cmCTestUpdateHandlerUpdateStrings[] =
-{
-  "Unknown",
-  "CVS",
-  "SVN",
-  "BZR",
-  "GIT",
-  "HG",
-  "P4"
+static const char* cmCTestUpdateHandlerUpdateStrings[] = {
+  "Unknown", "CVS", "SVN", "BZR", "GIT", "HG", "P4"
 };
 
 static const char* cmCTestUpdateHandlerUpdateToString(int type)
 {
-  if ( type < cmCTestUpdateHandler::e_UNKNOWN ||
-    type >= cmCTestUpdateHandler::e_LAST )
-    {
+  if (type < cmCTestUpdateHandler::e_UNKNOWN ||
+      type >= cmCTestUpdateHandler::e_LAST) {
     return cmCTestUpdateHandlerUpdateStrings[cmCTestUpdateHandler::e_UNKNOWN];
-    }
+  }
   return cmCTestUpdateHandlerUpdateStrings[type];
 }
 
@@ -78,74 +70,60 @@ void cmCTestUpdateHandler::Initialize()
 
 int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type)
 {
-  cmCTestOptionalLog(this->CTest, DEBUG,
-    "Determine update type from command: " << cmd << " and type: " << type <<
-    std::endl, this->Quiet);
-  if ( type && *type )
-    {
-    cmCTestOptionalLog(this->CTest, DEBUG, "Type specified: " << type <<
-      std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG, "Determine update type from command: "
+                       << cmd << " and type: " << type << std::endl,
+                     this->Quiet);
+  if (type && *type) {
+    cmCTestOptionalLog(this->CTest, DEBUG,
+                       "Type specified: " << type << std::endl, this->Quiet);
     std::string stype = cmSystemTools::LowerCase(type);
-    if ( stype.find("cvs") != std::string::npos )
-      {
+    if (stype.find("cvs") != std::string::npos) {
       return cmCTestUpdateHandler::e_CVS;
-      }
-    if ( stype.find("svn") != std::string::npos )
-      {
+    }
+    if (stype.find("svn") != std::string::npos) {
       return cmCTestUpdateHandler::e_SVN;
-      }
-    if ( stype.find("bzr") != std::string::npos )
-      {
+    }
+    if (stype.find("bzr") != std::string::npos) {
       return cmCTestUpdateHandler::e_BZR;
-      }
-    if ( stype.find("git") != std::string::npos )
-      {
+    }
+    if (stype.find("git") != std::string::npos) {
       return cmCTestUpdateHandler::e_GIT;
-      }
-    if ( stype.find("hg") != std::string::npos )
-      {
+    }
+    if (stype.find("hg") != std::string::npos) {
       return cmCTestUpdateHandler::e_HG;
-      }
-    if ( stype.find("p4") != std::string::npos )
-      {
+    }
+    if (stype.find("p4") != std::string::npos) {
       return cmCTestUpdateHandler::e_P4;
-      }
     }
-  else
-    {
-    cmCTestOptionalLog(this->CTest, DEBUG,
+  } else {
+    cmCTestOptionalLog(
+      this->CTest, DEBUG,
       "Type not specified, check command: " << cmd << std::endl, this->Quiet);
     std::string stype = cmSystemTools::LowerCase(cmd);
-    if ( stype.find("cvs") != std::string::npos )
-      {
+    if (stype.find("cvs") != std::string::npos) {
       return cmCTestUpdateHandler::e_CVS;
-      }
-    if ( stype.find("svn") != std::string::npos )
-      {
+    }
+    if (stype.find("svn") != std::string::npos) {
       return cmCTestUpdateHandler::e_SVN;
-      }
-    if ( stype.find("bzr") != std::string::npos )
-      {
+    }
+    if (stype.find("bzr") != std::string::npos) {
       return cmCTestUpdateHandler::e_BZR;
-      }
-    if ( stype.find("git") != std::string::npos )
-      {
+    }
+    if (stype.find("git") != std::string::npos) {
       return cmCTestUpdateHandler::e_GIT;
-      }
-    if ( stype.find("hg") != std::string::npos )
-      {
+    }
+    if (stype.find("hg") != std::string::npos) {
       return cmCTestUpdateHandler::e_HG;
-      }
-    if ( stype.find("p4") != std::string::npos )
-      {
+    }
+    if (stype.find("p4") != std::string::npos) {
       return cmCTestUpdateHandler::e_P4;
-      }
     }
+  }
   return cmCTestUpdateHandler::e_UNKNOWN;
 }
 
-//clearly it would be nice if this were broken up into a few smaller
-//functions and commented...
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
 int cmCTestUpdateHandler::ProcessHandler()
 {
   // Make sure VCS tool messages are in English so we can parse them.
@@ -154,46 +132,57 @@ int cmCTestUpdateHandler::ProcessHandler()
 
   // Get source dir
   const char* sourceDirectory = this->GetOption("SourceDirectory");
-  if ( !sourceDirectory )
-    {
+  if (!sourceDirectory) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot find SourceDirectory  key in the DartConfiguration.tcl"
-      << std::endl);
+               "Cannot find SourceDirectory  key in the DartConfiguration.tcl"
+                 << std::endl);
     return -1;
-    }
+  }
 
   cmGeneratedFileStream ofs;
-  if ( !this->CTest->GetShowOnly() )
-    {
+  if (!this->CTest->GetShowOnly()) {
     this->StartLogFile("Update", ofs);
-    }
+  }
 
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-    "   Updating the repository: " << sourceDirectory << std::endl,
-    this->Quiet);
+                     "   Updating the repository: " << sourceDirectory
+                                                    << std::endl,
+                     this->Quiet);
 
-  if(!this->SelectVCS())
-    {
+  if (!this->SelectVCS()) {
     return -1;
-    }
+  }
 
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Use "
-    << cmCTestUpdateHandlerUpdateToString(this->UpdateType)
-    << " repository type"
-    << std::endl;, this->Quiet);
+                       << cmCTestUpdateHandlerUpdateToString(this->UpdateType)
+                       << " repository type" << std::endl;
+                     , this->Quiet);
 
   // Create an object to interact with the VCS tool.
   cmsys::auto_ptr<cmCTestVC> vc;
-  switch (this->UpdateType)
-    {
-    case e_CVS: vc.reset(new cmCTestCVS(this->CTest, ofs)); break;
-    case e_SVN: vc.reset(new cmCTestSVN(this->CTest, ofs)); break;
-    case e_BZR: vc.reset(new cmCTestBZR(this->CTest, ofs)); break;
-    case e_GIT: vc.reset(new cmCTestGIT(this->CTest, ofs)); break;
-    case e_HG:  vc.reset(new cmCTestHG(this->CTest, ofs)); break;
-    case e_P4:  vc.reset(new cmCTestP4(this->CTest, ofs)); break;
-    default:    vc.reset(new cmCTestVC(this->CTest, ofs));  break;
-    }
+  switch (this->UpdateType) {
+    case e_CVS:
+      vc.reset(new cmCTestCVS(this->CTest, ofs));
+      break;
+    case e_SVN:
+      vc.reset(new cmCTestSVN(this->CTest, ofs));
+      break;
+    case e_BZR:
+      vc.reset(new cmCTestBZR(this->CTest, ofs));
+      break;
+    case e_GIT:
+      vc.reset(new cmCTestGIT(this->CTest, ofs));
+      break;
+    case e_HG:
+      vc.reset(new cmCTestHG(this->CTest, ofs));
+      break;
+    case e_P4:
+      vc.reset(new cmCTestP4(this->CTest, ofs));
+      break;
+    default:
+      vc.reset(new cmCTestVC(this->CTest, ofs));
+      break;
+  }
   vc->SetCommandLineTool(this->UpdateCommand);
   vc->SetSourceDirectory(sourceDirectory);
 
@@ -204,134 +193,127 @@ int cmCTestUpdateHandler::ProcessHandler()
   // Now update repository and remember what files were updated
   //
   cmGeneratedFileStream os;
-  if(!this->StartResultingXML(cmCTest::PartUpdate, "Update", os))
-    {
+  if (!this->StartResultingXML(cmCTest::PartUpdate, "Update", os)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file"
-      << std::endl);
+                 << std::endl);
     return -1;
-    }
+  }
   std::string start_time = this->CTest->CurrentTime();
   unsigned int start_time_time =
     static_cast<unsigned int>(cmSystemTools::GetTime());
   double elapsed_time_start = cmSystemTools::GetTime();
 
   bool updated = vc->Update();
-  std::string buildname = cmCTest::SafeBuildIdField(
-    this->CTest->GetCTestConfiguration("BuildName"));
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->CTest->GetCTestConfiguration("BuildName"));
 
   cmXMLWriter xml(os);
   xml.StartDocument();
   xml.StartElement("Update");
   xml.Attribute("mode", "Client");
   xml.Attribute("Generator",
-    std::string("ctest-") + cmVersion::GetCMakeVersion());
+                std::string("ctest-") + cmVersion::GetCMakeVersion());
   xml.Element("Site", this->CTest->GetCTestConfiguration("Site"));
   xml.Element("BuildName", buildname);
   xml.Element("BuildStamp", this->CTest->GetCurrentTag() + "-" +
-    this->CTest->GetTestModelString());
+                this->CTest->GetTestModelString());
   xml.Element("StartDateTime", start_time);
   xml.Element("StartTime", start_time_time);
   xml.Element("UpdateCommand", vc->GetUpdateCommandLine());
   xml.Element("UpdateType",
-    cmCTestUpdateHandlerUpdateToString(this->UpdateType));
+              cmCTestUpdateHandlerUpdateToString(this->UpdateType));
 
   vc->WriteXML(xml);
 
   int localModifications = 0;
   int numUpdated = vc->GetPathCount(cmCTestVC::PathUpdated);
-  if(numUpdated)
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "   Found " << numUpdated << " updated files\n", this->Quiet);
-    }
-  if(int numModified = vc->GetPathCount(cmCTestVC::PathModified))
-    {
+  if (numUpdated) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-      "   Found " << numModified << " locally modified files\n", this->Quiet);
+                       "   Found " << numUpdated << " updated files\n",
+                       this->Quiet);
+  }
+  if (int numModified = vc->GetPathCount(cmCTestVC::PathModified)) {
+    cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "   Found "
+                         << numModified << " locally modified files\n",
+                       this->Quiet);
     localModifications += numModified;
-    }
-  if(int numConflicting = vc->GetPathCount(cmCTestVC::PathConflicting))
-    {
+  }
+  if (int numConflicting = vc->GetPathCount(cmCTestVC::PathConflicting)) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-    "   Found " << numConflicting << " conflicting files\n", this->Quiet);
+                       "   Found " << numConflicting << " conflicting files\n",
+                       this->Quiet);
     localModifications += numConflicting;
-    }
+  }
 
   cmCTestOptionalLog(this->CTest, DEBUG, "End" << std::endl, this->Quiet);
   std::string end_time = this->CTest->CurrentTime();
   xml.Element("EndDateTime", end_time);
   xml.Element("EndTime", static_cast<unsigned int>(cmSystemTools::GetTime()));
-  xml.Element("ElapsedMinutes",
-    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
+  xml.Element(
+    "ElapsedMinutes",
+    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
+      10.0);
 
   xml.StartElement("UpdateReturnStatus");
-  if(localModifications)
-    {
+  if (localModifications) {
     xml.Content("Update error: "
-      "There are modified or conflicting files in the repository");
+                "There are modified or conflicting files in the repository");
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "   There are modified or conflicting files in the repository"
-      << std::endl);
-    }
-  if(!updated)
-    {
+               "   There are modified or conflicting files in the repository"
+                 << std::endl);
+  }
+  if (!updated) {
     xml.Content("Update command failed:\n");
     xml.Content(vc->GetUpdateCommandLine());
     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Update command failed: "
-               << vc->GetUpdateCommandLine() << "\n");
-    }
+                 << vc->GetUpdateCommandLine() << "\n");
+  }
   xml.EndElement(); // UpdateReturnStatus
   xml.EndElement(); // Update
   xml.EndDocument();
-  return updated? numUpdated : -1;
+  return updated ? numUpdated : -1;
 }
 
 int cmCTestUpdateHandler::DetectVCS(const char* dir)
 {
   std::string sourceDirectory = dir;
-  cmCTestOptionalLog(this->CTest, DEBUG, "Check directory: "
-    << sourceDirectory << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "Check directory: " << sourceDirectory << std::endl,
+                     this->Quiet);
   sourceDirectory += "/.svn";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_SVN;
-    }
+  }
   sourceDirectory = dir;
   sourceDirectory += "/CVS";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_CVS;
-    }
+  }
   sourceDirectory = dir;
   sourceDirectory += "/.bzr";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_BZR;
-    }
+  }
   sourceDirectory = dir;
   sourceDirectory += "/.git";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_GIT;
-    }
+  }
   sourceDirectory = dir;
   sourceDirectory += "/.hg";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_HG;
-    }
+  }
   sourceDirectory = dir;
   sourceDirectory += "/.p4";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_P4;
-    }
+  }
   sourceDirectory = dir;
   sourceDirectory += "/.p4config";
-  if ( cmSystemTools::FileExists(sourceDirectory.c_str()) )
-    {
+  if (cmSystemTools::FileExists(sourceDirectory.c_str())) {
     return cmCTestUpdateHandler::e_P4;
-    }
+  }
   return cmCTestUpdateHandler::e_UNKNOWN;
 }
 
@@ -342,45 +324,53 @@ bool cmCTestUpdateHandler::SelectVCS()
 
   // Detect the VCS managing the source tree.
   this->UpdateType = this->DetectVCS(this->GetOption("SourceDirectory"));
-  if (this->UpdateType == e_UNKNOWN)
-    {
+  if (this->UpdateType == e_UNKNOWN) {
     // The source tree does not have a recognized VCS.  Check the
     // configuration value or command name.
-    this->UpdateType = this->DetermineType(this->UpdateCommand.c_str(),
+    this->UpdateType = this->DetermineType(
+      this->UpdateCommand.c_str(),
       this->CTest->GetCTestConfiguration("UpdateType").c_str());
-    }
+  }
 
   // If no update command was specified, lookup one for this VCS tool.
-  if (this->UpdateCommand.empty())
-    {
+  if (this->UpdateCommand.empty()) {
     const char* key = 0;
-    switch (this->UpdateType)
-      {
-      case e_CVS: key = "CVSCommand"; break;
-      case e_SVN: key = "SVNCommand"; break;
-      case e_BZR: key = "BZRCommand"; break;
-      case e_GIT: key = "GITCommand"; break;
-      case e_HG:  key = "HGCommand";  break;
-      case e_P4:  key = "P4Command";  break;
-      default: break;
-      }
-    if (key)
-      {
+    switch (this->UpdateType) {
+      case e_CVS:
+        key = "CVSCommand";
+        break;
+      case e_SVN:
+        key = "SVNCommand";
+        break;
+      case e_BZR:
+        key = "BZRCommand";
+        break;
+      case e_GIT:
+        key = "GITCommand";
+        break;
+      case e_HG:
+        key = "HGCommand";
+        break;
+      case e_P4:
+        key = "P4Command";
+        break;
+      default:
+        break;
+    }
+    if (key) {
       this->UpdateCommand = this->CTest->GetCTestConfiguration(key);
-      }
-    if (this->UpdateCommand.empty())
-      {
+    }
+    if (this->UpdateCommand.empty()) {
       std::ostringstream e;
       e << "Cannot find UpdateCommand ";
-      if (key)
-        {
+      if (key) {
         e << "or " << key;
-        }
+      }
       e << " configuration key.";
       cmCTestLog(this->CTest, ERROR_MESSAGE, e.str() << std::endl);
       return false;
-      }
     }
+  }
 
   return true;
 }
diff --git a/Source/CTest/cmCTestUpdateHandler.h b/Source/CTest/cmCTestUpdateHandler.h
index 463703c..d44e619 100644
--- a/Source/CTest/cmCTestUpdateHandler.h
+++ b/Source/CTest/cmCTestUpdateHandler.h
@@ -33,7 +33,8 @@ public:
 
   cmCTestUpdateHandler();
 
-  enum {
+  enum
+  {
     e_UNKNOWN = 0,
     e_CVS,
     e_SVN,
@@ -51,9 +52,12 @@ public:
 
 private:
   // Some structures needed for update
-  struct StringPair :
-    public std::pair<std::string, std::string>{};
-  struct UpdateFiles : public std::vector<StringPair>{};
+  struct StringPair : public std::pair<std::string, std::string>
+  {
+  };
+  struct UpdateFiles : public std::vector<StringPair>
+  {
+  };
 
   // Determine the type of version control
   int DetermineType(const char* cmd, const char* type);
diff --git a/Source/CTest/cmCTestUploadCommand.cxx b/Source/CTest/cmCTestUploadCommand.cxx
index 7c24e62..6813cbc 100644
--- a/Source/CTest/cmCTestUploadCommand.cxx
+++ b/Source/CTest/cmCTestUploadCommand.cxx
@@ -17,57 +17,48 @@
 
 cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler()
 {
-  cmCTestGenericHandler* handler
-    = this->CTest->GetInitializedHandler("upload");
-  if ( !handler )
-    {
+  cmCTestGenericHandler* handler =
+    this->CTest->GetInitializedHandler("upload");
+  if (!handler) {
     this->SetError("internal CTest error. Cannot instantiate upload handler");
     return 0;
-    }
+  }
   static_cast<cmCTestUploadHandler*>(handler)->SetFiles(this->Files);
 
   handler->SetQuiet(this->Quiet);
   return handler;
 }
 
-
 bool cmCTestUploadCommand::CheckArgumentKeyword(std::string const& arg)
 {
-  if(arg == "FILES")
-    {
+  if (arg == "FILES") {
     this->ArgumentDoing = ArgumentDoingFiles;
     return true;
-    }
-  if(arg == "QUIET")
-    {
+  }
+  if (arg == "QUIET") {
     this->ArgumentDoing = ArgumentDoingNone;
     this->Quiet = true;
     return true;
-    }
+  }
   return false;
 }
 
-
 bool cmCTestUploadCommand::CheckArgumentValue(std::string const& arg)
 {
-  if(this->ArgumentDoing == ArgumentDoingFiles)
-    {
+  if (this->ArgumentDoing == ArgumentDoingFiles) {
     std::string filename(arg);
-    if(cmSystemTools::FileExists(filename.c_str()))
-      {
+    if (cmSystemTools::FileExists(filename.c_str())) {
       this->Files.insert(filename);
       return true;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "File \"" << filename << "\" does not exist. Cannot submit "
-          << "a non-existent file.";
+        << "a non-existent file.";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       this->ArgumentDoing = ArgumentDoingError;
       return false;
-      }
     }
+  }
 
   // Look for other arguments.
   return this->Superclass::CheckArgumentValue(arg);
diff --git a/Source/CTest/cmCTestUploadCommand.h b/Source/CTest/cmCTestUploadCommand.h
index 1802254..551be2b 100644
--- a/Source/CTest/cmCTestUploadCommand.h
+++ b/Source/CTest/cmCTestUploadCommand.h
@@ -25,26 +25,23 @@
 class cmCTestUploadCommand : public cmCTestHandlerCommand
 {
 public:
-
-  cmCTestUploadCommand()
-    {
-    }
+  cmCTestUploadCommand() {}
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     cmCTestUploadCommand* ni = new cmCTestUploadCommand;
     ni->CTest = this->CTest;
     ni->CTestScriptHandler = this->CTestScriptHandler;
     return ni;
-    }
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "ctest_upload";}
+  virtual std::string GetName() const { return "ctest_upload"; }
 
   cmTypeMacro(cmCTestUploadCommand, cmCTestHandlerCommand);
 
@@ -63,5 +60,4 @@ protected:
   cmCTest::SetOfStrings Files;
 };
 
-
 #endif
diff --git a/Source/CTest/cmCTestUploadHandler.cxx b/Source/CTest/cmCTestUploadHandler.cxx
index 6f0a024..6a3b830 100644
--- a/Source/CTest/cmCTestUploadHandler.cxx
+++ b/Source/CTest/cmCTestUploadHandler.cxx
@@ -34,36 +34,35 @@ void cmCTestUploadHandler::SetFiles(const cmCTest::SetOfStrings& files)
 int cmCTestUploadHandler::ProcessHandler()
 {
   cmGeneratedFileStream ofs;
-  if ( !this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(),
-                                    "Upload.xml", ofs))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot open Upload.xml file" << std::endl);
+  if (!this->CTest->OpenOutputFile(this->CTest->GetCurrentTag(), "Upload.xml",
+                                   ofs)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open Upload.xml file"
+                 << std::endl);
     return -1;
-    }
-  std::string buildname = cmCTest::SafeBuildIdField(
-    this->CTest->GetCTestConfiguration("BuildName"));
+  }
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->CTest->GetCTestConfiguration("BuildName"));
   cmCTest::SetOfStrings::const_iterator it;
 
   cmXMLWriter xml(ofs);
   xml.StartDocument();
-  xml.ProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" "
-    "href=\"Dart/Source/Server/XSL/Build.xsl "
-    "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
+  xml.ProcessingInstruction("xml-stylesheet",
+                            "type=\"text/xsl\" "
+                            "href=\"Dart/Source/Server/XSL/Build.xsl "
+                            "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
   xml.StartElement("Site");
   xml.Attribute("BuildName", buildname);
-  xml.Attribute("BuildStamp",
-    this->CTest->GetCurrentTag() + "-" + this->CTest->GetTestModelString());
+  xml.Attribute("BuildStamp", this->CTest->GetCurrentTag() + "-" +
+                  this->CTest->GetTestModelString());
   xml.Attribute("Name", this->CTest->GetCTestConfiguration("Site"));
   xml.Attribute("Generator",
-    std::string("ctest") + cmVersion::GetCMakeVersion());
+                std::string("ctest") + cmVersion::GetCMakeVersion());
   this->CTest->AddSiteProperties(xml);
   xml.StartElement("Upload");
 
-  for ( it = this->Files.begin(); it != this->Files.end(); it ++ )
-    {
+  for (it = this->Files.begin(); it != this->Files.end(); it++) {
     cmCTestOptionalLog(this->CTest, OUTPUT,
-      "\tUpload file: " << *it << std::endl, this->Quiet);
+                       "\tUpload file: " << *it << std::endl, this->Quiet);
     xml.StartElement("File");
     xml.Attribute("filename", *it);
     xml.StartElement("Content");
@@ -71,7 +70,7 @@ int cmCTestUploadHandler::ProcessHandler()
     xml.Content(this->CTest->Base64EncodeFile(*it));
     xml.EndElement(); // Content
     xml.EndElement(); // File
-    }
+  }
   xml.EndElement(); // Upload
   xml.EndElement(); // Site
   xml.EndDocument();
diff --git a/Source/CTest/cmCTestVC.cxx b/Source/CTest/cmCTestVC.cxx
index f3d699b..e9934e5 100644
--- a/Source/CTest/cmCTestVC.cxx
+++ b/Source/CTest/cmCTestVC.cxx
@@ -17,7 +17,9 @@
 
 #include <cmsys/Process.h>
 
-cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log): CTest(ct), Log(log)
+cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log)
+  : CTest(ct)
+  , Log(log)
 {
   this->PathCount[PathUpdated] = 0;
   this->PathCount[PathModified] = 0;
@@ -50,21 +52,19 @@ bool cmCTestVC::InitialCheckout(const char* command)
   std::string parent = cmSystemTools::GetFilenamePath(this->SourceDirectory);
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              "   Perform checkout in directory: " << parent << "\n");
-  if(!cmSystemTools::MakeDirectory(parent.c_str()))
-    {
+  if (!cmSystemTools::MakeDirectory(parent.c_str())) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Cannot create directory: " << parent << std::endl);
     return false;
-    }
+  }
 
   // Construct the initial checkout command line.
   std::vector<std::string> args = cmSystemTools::ParseArguments(command);
   std::vector<char const*> vc_co;
-  for(std::vector<std::string>::const_iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::const_iterator ai = args.begin();
+       ai != args.end(); ++ai) {
     vc_co.push_back(ai->c_str());
-    }
+  }
   vc_co.push_back(0);
 
   // Run the initial checkout command and log its output.
@@ -73,11 +73,10 @@ bool cmCTestVC::InitialCheckout(const char* command)
   OutputLogger err(this->Log, "co-err> ");
   bool result = this->RunChild(&vc_co[0], &out, &err, parent.c_str());
   this->Log << "--- End Initial Checkout ---\n";
-  if(!result)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Initial checkout failed!" << std::endl);
-    }
+  if (!result) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Initial checkout failed!"
+                 << std::endl);
+  }
   return result;
 }
 
@@ -88,7 +87,7 @@ bool cmCTestVC::RunChild(char const* const* cmd, OutputParser* out,
 
   cmsysProcess* cp = cmsysProcess_New();
   cmsysProcess_SetCommand(cp, cmd);
-  workDir = workDir? workDir : this->SourceDirectory.c_str();
+  workDir = workDir ? workDir : this->SourceDirectory.c_str();
   cmsysProcess_SetWorkingDirectory(cp, workDir);
   this->RunProcess(cp, out, err);
   int result = cmsysProcess_GetExitValue(cp);
@@ -100,24 +99,22 @@ std::string cmCTestVC::ComputeCommandLine(char const* const* cmd)
 {
   std::ostringstream line;
   const char* sep = "";
-  for(const char* const* arg = cmd; *arg; ++arg)
-    {
+  for (const char* const* arg = cmd; *arg; ++arg) {
     line << sep << "\"" << *arg << "\"";
     sep = " ";
-    }
+  }
   return line.str();
 }
 
-bool cmCTestVC::RunUpdateCommand(char const* const* cmd,
-                                 OutputParser* out, OutputParser* err)
+bool cmCTestVC::RunUpdateCommand(char const* const* cmd, OutputParser* out,
+                                 OutputParser* err)
 {
   // Report the command line.
   this->UpdateCommandLine = this->ComputeCommandLine(cmd);
-  if(this->CTest->GetShowOnly())
-    {
+  if (this->CTest->GetShowOnly()) {
     this->Log << this->UpdateCommandLine << "\n";
     return true;
-    }
+  }
 
   // Run the command.
   return this->RunChild(cmd, out, err);
@@ -130,13 +127,8 @@ std::string cmCTestVC::GetNightlyTime()
     this->CTest->GetCTestConfiguration("NightlyStartTime"),
     this->CTest->GetTomorrowTag());
   char current_time[1024];
-  sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d",
-          t->tm_year + 1900,
-          t->tm_mon + 1,
-          t->tm_mday,
-          t->tm_hour,
-          t->tm_min,
-          t->tm_sec);
+  sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d", t->tm_year + 1900,
+          t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
   return std::string(current_time);
 }
 
@@ -157,14 +149,13 @@ bool cmCTestVC::Update()
   bool result = true;
   // if update version only is on then do not actually update,
   // just note the current version and finish
-  if(!cmSystemTools::IsOn(
-       this->CTest->GetCTestConfiguration("UpdateVersionOnly").c_str()))
-    {
+  if (!cmSystemTools::IsOn(
+        this->CTest->GetCTestConfiguration("UpdateVersionOnly").c_str())) {
     this->NoteOldRevision();
     this->Log << "--- Begin Update ---\n";
     result = this->UpdateImpl();
     this->Log << "--- End Update ---\n";
-    }
+  }
   this->NoteNewRevision();
   return result;
 }
@@ -201,15 +192,13 @@ bool cmCTestVC::WriteXMLUpdates(cmXMLWriter&)
   return true;
 }
 
-void cmCTestVC::WriteXMLEntry(cmXMLWriter& xml,
-                              std::string const& path,
-                              std::string const& name,
-                              std::string const& full,
+void cmCTestVC::WriteXMLEntry(cmXMLWriter& xml, std::string const& path,
+                              std::string const& name, std::string const& full,
                               File const& f)
 {
-  static const char* desc[3] = { "Updated", "Modified", "Conflicting"};
-  Revision const& rev = f.Rev? *f.Rev : this->Unknown;
-  std::string prior = f.PriorRev? f.PriorRev->Rev : std::string("Unknown");
+  static const char* desc[3] = { "Updated", "Modified", "Conflicting" };
+  Revision const& rev = f.Rev ? *f.Rev : this->Unknown;
+  std::string prior = f.PriorRev ? f.PriorRev->Rev : std::string("Unknown");
   xml.StartElement(desc[f.Status]);
   xml.Element("File", name);
   xml.Element("Directory", path);
diff --git a/Source/CTest/cmCTestVC.h b/Source/CTest/cmCTestVC.h
index 1caa850..4ae38eb 100644
--- a/Source/CTest/cmCTestVC.h
+++ b/Source/CTest/cmCTestVC.h
@@ -21,7 +21,7 @@ class cmXMLWriter;
  * \brief Base class for version control system handlers
  *
  */
-class cmCTestVC: public cmProcessTools
+class cmCTestVC : public cmProcessTools
 {
 public:
   /** Construct with a CTest instance and update log stream.  */
@@ -49,13 +49,20 @@ public:
 
   /** Get the command line used by the Update method.  */
   std::string const& GetUpdateCommandLine() const
-    { return this->UpdateCommandLine; }
+  {
+    return this->UpdateCommandLine;
+  }
 
   /** Write Update.xml entries for the updates found.  */
   bool WriteXML(cmXMLWriter& xml);
 
   /** Enumerate non-trivial working tree states during update.  */
-  enum PathStatus { PathUpdated, PathModified, PathConflicting };
+  enum PathStatus
+  {
+    PathUpdated,
+    PathModified,
+    PathConflicting
+  };
 
   /** Get the number of working tree paths in each state after update.  */
   int GetPathCount(PathStatus s) const { return this->PathCount[s]; }
@@ -95,21 +102,30 @@ protected:
     PathStatus Status;
     Revision const* Rev;
     Revision const* PriorRev;
-    File(): Status(PathUpdated), Rev(0), PriorRev(0) {}
-    File(PathStatus status, Revision const* rev, Revision const* priorRev):
-      Status(status), Rev(rev), PriorRev(priorRev) {}
+    File()
+      : Status(PathUpdated)
+      , Rev(0)
+      , PriorRev(0)
+    {
+    }
+    File(PathStatus status, Revision const* rev, Revision const* priorRev)
+      : Status(status)
+      , Rev(rev)
+      , PriorRev(priorRev)
+    {
+    }
   };
 
   /** Convert a list of arguments to a human-readable command line.  */
   static std::string ComputeCommandLine(char const* const* cmd);
 
   /** Run a command line and send output to given parsers.  */
-  bool RunChild(char const* const* cmd, OutputParser* out,
-                OutputParser* err, const char* workDir = 0);
+  bool RunChild(char const* const* cmd, OutputParser* out, OutputParser* err,
+                const char* workDir = 0);
 
   /** Run VC update command line and send output to given parsers.  */
-  bool RunUpdateCommand(char const* const* cmd,
-                        OutputParser* out, OutputParser* err = 0);
+  bool RunUpdateCommand(char const* const* cmd, OutputParser* out,
+                        OutputParser* err = 0);
 
   /** Write xml element for one file.  */
   void WriteXMLEntry(cmXMLWriter& xml, std::string const& path,
diff --git a/Source/CTest/cmParseBlanketJSCoverage.cxx b/Source/CTest/cmParseBlanketJSCoverage.cxx
index 1f1db3e..1e42847 100644
--- a/Source/CTest/cmParseBlanketJSCoverage.cxx
+++ b/Source/CTest/cmParseBlanketJSCoverage.cxx
@@ -18,76 +18,65 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
 class cmParseBlanketJSCoverage::JSONParser
-  {
+{
 public:
-  typedef cmCTestCoverageHandlerContainer::
-      SingleFileCoverageVector FileLinesType;
+  typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
+    FileLinesType;
   JSONParser(cmCTestCoverageHandlerContainer& cont)
-      : Coverage(cont)
-    {
-    }
+    : Coverage(cont)
+  {
+  }
 
-  virtual ~JSONParser()
-    {
-    }
+  virtual ~JSONParser() {}
 
   std::string getValue(std::string line, int type)
-    {
+  {
     size_t begIndex;
     size_t endIndex;
     endIndex = line.rfind(',');
     begIndex = line.find_first_of(':');
-    if(type == 0)
-      {
+    if (type == 0) {
       //  A unique substring to remove the extra characters
       //  around the files name in the JSON (extra " and ,)
       std::string foundFileName =
-          line.substr(begIndex+3,endIndex-(begIndex+4));
+        line.substr(begIndex + 3, endIndex - (begIndex + 4));
       return foundFileName;
-      }
-    else
-      {
-      return line.substr(begIndex,line.npos);
-      }
+    } else {
+      return line.substr(begIndex, line.npos);
     }
+  }
   bool ParseFile(std::string file)
-    {
+  {
     FileLinesType localCoverageVector;
     std::string filename;
     bool foundFile = false;
-    bool inSource  = false;
+    bool inSource = false;
     std::string covResult;
     std::string line;
 
     cmsys::ifstream in(file.c_str());
-    if(!in)
-      {
+    if (!in) {
       return false;
-      }
-    while(  cmSystemTools::GetLineFromStream(in, line))
-      {
-      if(line.find("filename") != line.npos)
-        {
-        if(foundFile)
-          {
+    }
+    while (cmSystemTools::GetLineFromStream(in, line)) {
+      if (line.find("filename") != line.npos) {
+        if (foundFile) {
           /*
           * Upon finding a second file name, generate a
           * vector within the total coverage to capture the
           * information in the local vector
           */
           FileLinesType& CoverageVector =
-              this->Coverage.TotalCoverage[filename];
+            this->Coverage.TotalCoverage[filename];
           CoverageVector = localCoverageVector;
           localCoverageVector.clear();
-          }
-        foundFile= true;
-        inSource = false;
-        filename = getValue(line,0).c_str();
         }
-      else if((line.find("coverage") != line.npos) && foundFile && inSource )
-        {
+        foundFile = true;
+        inSource = false;
+        filename = getValue(line, 0).c_str();
+      } else if ((line.find("coverage") != line.npos) && foundFile &&
+                 inSource) {
         /*
         *  two types of "coverage" in the JSON structure
         *
@@ -97,68 +86,63 @@ public:
         *  FoundFile and foundSource ensure that
         *  only the value of the line coverage is captured
         */
-        std::string result = getValue(line,1);
-        result = result.substr(2,result.npos);
-        if(result == "\"\"")
-          {
+        std::string result = getValue(line, 1);
+        result = result.substr(2, result.npos);
+        if (result == "\"\"") {
           // Empty quotation marks indicate that the
           // line is not executable
           localCoverageVector.push_back(-1);
-          }
-        else
-          {
+        } else {
           // Else, it contains the number of time executed
           localCoverageVector.push_back(atoi(result.c_str()));
-          }
-        }
-      else if(line.find("source") != line.npos)
-        {
-        inSource=true;
         }
+      } else if (line.find("source") != line.npos) {
+        inSource = true;
       }
+    }
 
     // On exit, capture end of last file covered.
-    FileLinesType& CoverageVector =
-        this->Coverage.TotalCoverage[filename];
+    FileLinesType& CoverageVector = this->Coverage.TotalCoverage[filename];
     CoverageVector = localCoverageVector;
     localCoverageVector.clear();
     return true;
-    }
+  }
+
 private:
   cmCTestCoverageHandlerContainer& Coverage;
 };
 
 cmParseBlanketJSCoverage::cmParseBlanketJSCoverage(
-  cmCTestCoverageHandlerContainer& cont,  cmCTest* ctest)
-  :Coverage(cont), CTest(ctest)
-  {
-  }
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
 
 bool cmParseBlanketJSCoverage::LoadCoverageData(std::vector<std::string> files)
-  {
-  size_t i=0;
+{
+  size_t i = 0;
   std::string path;
-      cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-       "Found " << files.size() <<" Files" << std::endl, this->Coverage.Quiet);
-  for(i=0;i<files.size();i++)
-    {
-    cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-       "Reading JSON File " << files[i]  << std::endl, this->Coverage.Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Found " << files.size() << " Files" << std::endl,
+                     this->Coverage.Quiet);
+  for (i = 0; i < files.size(); i++) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Reading JSON File " << files[i] << std::endl,
+                       this->Coverage.Quiet);
 
-    if(!this->ReadJSONFile(files[i]))
-      {
+    if (!this->ReadJSONFile(files[i])) {
       return false;
-      }
     }
-  return true;
   }
+  return true;
+}
 
 bool cmParseBlanketJSCoverage::ReadJSONFile(std::string file)
-  {
-  cmParseBlanketJSCoverage::JSONParser parser
-     (this->Coverage);
-  cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-       "Parsing " << file << std::endl, this->Coverage.Quiet);
+{
+  cmParseBlanketJSCoverage::JSONParser parser(this->Coverage);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Parsing " << file << std::endl, this->Coverage.Quiet);
   parser.ParseFile(file);
   return true;
-  }
+}
diff --git a/Source/CTest/cmParseBlanketJSCoverage.h b/Source/CTest/cmParseBlanketJSCoverage.h
index d34492d..4fc64e7 100644
--- a/Source/CTest/cmParseBlanketJSCoverage.h
+++ b/Source/CTest/cmParseBlanketJSCoverage.h
@@ -15,7 +15,6 @@
 
 #include "cmCTestCoverageHandler.h"
 
-
 /** \class cmParseBlanketJSCoverage
  * \brief Parse BlanketJS coverage information
  *
@@ -33,13 +32,12 @@ class cmParseBlanketJSCoverage
 {
 public:
   cmParseBlanketJSCoverage(cmCTestCoverageHandlerContainer& cont,
-       cmCTest* ctest);
+                           cmCTest* ctest);
   bool LoadCoverageData(std::vector<std::string> files);
   //  Read the JSON output
   bool ReadJSONFile(std::string file);
 
 protected:
-
   class JSONParser;
   cmCTestCoverageHandlerContainer& Coverage;
   cmCTest* CTest;
diff --git a/Source/CTest/cmParseCacheCoverage.cxx b/Source/CTest/cmParseCacheCoverage.cxx
index f838087..0916da2 100644
--- a/Source/CTest/cmParseCacheCoverage.cxx
+++ b/Source/CTest/cmParseCacheCoverage.cxx
@@ -7,44 +7,35 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
 cmParseCacheCoverage::cmParseCacheCoverage(
-  cmCTestCoverageHandlerContainer& cont,
-  cmCTest* ctest)
-  :cmParseMumpsCoverage(cont, ctest)
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : cmParseMumpsCoverage(cont, ctest)
 {
 }
 
-
 bool cmParseCacheCoverage::LoadCoverageData(const char* d)
 {
   // load all the .mcov files in the specified directory
   cmsys::Directory dir;
-  if(!dir.Load(d))
-    {
+  if (!dir.Load(d)) {
     return false;
-    }
+  }
   size_t numf;
   unsigned int i;
   numf = dir.GetNumberOfFiles();
-  for (i = 0; i < numf; i++)
-    {
+  for (i = 0; i < numf; i++) {
     std::string file = dir.GetFile(i);
-    if(file != "." && file != ".."
-       && !cmSystemTools::FileIsDirectory(file))
-      {
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
       std::string path = d;
       path += "/";
       path += file;
-      if(cmSystemTools::GetFilenameLastExtension(path) == ".cmcov")
-        {
-        if(!this->ReadCMCovFile(path.c_str()))
-          {
+      if (cmSystemTools::GetFilenameLastExtension(path) == ".cmcov") {
+        if (!this->ReadCMCovFile(path.c_str())) {
           return false;
-          }
         }
       }
     }
+  }
   return true;
 }
 
@@ -55,32 +46,26 @@ void cmParseCacheCoverage::RemoveUnCoveredFiles()
   // that only have -1 or 0 for the lines.
   cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator ci =
     this->Coverage.TotalCoverage.begin();
-  while(ci != this->Coverage.TotalCoverage.end())
-    {
-    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v =
-      ci->second;
+  while (ci != this->Coverage.TotalCoverage.end()) {
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v = ci->second;
     bool nothing = true;
-    for(cmCTestCoverageHandlerContainer::SingleFileCoverageVector::iterator i=
-          v.begin(); i != v.end(); ++i)
-      {
-      if(*i > 0)
-        {
+    for (cmCTestCoverageHandlerContainer::SingleFileCoverageVector::iterator
+           i = v.begin();
+         i != v.end(); ++i) {
+      if (*i > 0) {
         nothing = false;
         break;
-        }
       }
-    if(nothing)
-      {
+    }
+    if (nothing) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                 "No coverage found in: " << ci->first
-                 << std::endl, this->Coverage.Quiet);
+                         "No coverage found in: " << ci->first << std::endl,
+                         this->Coverage.Quiet);
       this->Coverage.TotalCoverage.erase(ci++);
-      }
-    else
-      {
+    } else {
       ++ci;
-      }
     }
+  }
 }
 
 bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
@@ -88,18 +73,16 @@ bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
 {
   std::string::size_type pos1 = 0;
   std::string::size_type pos2 = line.find(',', 0);
-  if(pos2 == std::string::npos)
-    {
+  if (pos2 == std::string::npos) {
     return false;
-    }
+  }
   std::string arg;
-  while(pos2 != std::string::npos)
-    {
-    arg = line.substr(pos1, pos2-pos1);
+  while (pos2 != std::string::npos) {
+    arg = line.substr(pos1, pos2 - pos1);
     args.push_back(arg);
-    pos1 = pos2+1;
-    pos2 = line.find(',',pos1);
-    }
+    pos1 = pos2 + 1;
+    pos2 = line.find(',', pos1);
+  }
   arg = line.substr(pos1);
   args.push_back(arg);
   return true;
@@ -108,126 +91,106 @@ bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
 bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
 {
   cmsys::ifstream in(file);
-  if(!in)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Can not open : "
-               << file << "\n");
+  if (!in) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not open : " << file << "\n");
     return false;
-    }
+  }
   std::string line;
   std::vector<std::string> separateLine;
-  if(!cmSystemTools::GetLineFromStream(in, line))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Empty file : "
-               << file << "  referenced in this line of cmcov data:\n"
-               "[" << line << "]\n");
+  if (!cmSystemTools::GetLineFromStream(in, line)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Empty file : "
+                 << file << "  referenced in this line of cmcov data:\n"
+                            "["
+                 << line << "]\n");
     return false;
-    }
+  }
   separateLine.clear();
   this->SplitString(separateLine, line);
-  if(separateLine.size() !=4 || separateLine[0] != "Routine"
-     || separateLine[1] != "Line" || separateLine[2] != "RtnLine"
-     || separateLine[3] != "Code")
-    {
+  if (separateLine.size() != 4 || separateLine[0] != "Routine" ||
+      separateLine[1] != "Line" || separateLine[2] != "RtnLine" ||
+      separateLine[3] != "Code") {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Bad first line of cmcov file : "
-               << file << "  line:\n"
-               "[" << line << "]\n");
-    }
+               "Bad first line of cmcov file : " << file << "  line:\n"
+                                                            "["
+                                                 << line << "]\n");
+  }
   std::string routine;
   std::string filepath;
-  while(cmSystemTools::GetLineFromStream(in, line))
-    {
+  while (cmSystemTools::GetLineFromStream(in, line)) {
     // clear out line argument vector
     separateLine.clear();
     // parse the comma separated line
     this->SplitString(separateLine, line);
     // might have more because code could have a quoted , in it
     // but we only care about the first 3 args anyway
-    if(separateLine.size() < 4)
-      {
+    if (separateLine.size() < 4) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Bad line of cmcov file expected at least 4 found: "
-                 << separateLine.size() << " "
-                 << file << "  line:\n"
-                 "[" << line << "]\n");
-      for(std::string::size_type i = 0; i < separateLine.size(); ++i)
-        {
-        cmCTestLog(this->CTest, ERROR_MESSAGE,""
-                   << separateLine[1] << " ");
-        }
+                   << separateLine.size() << " " << file << "  line:\n"
+                                                            "["
+                   << line << "]\n");
+      for (std::string::size_type i = 0; i < separateLine.size(); ++i) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "" << separateLine[1] << " ");
+      }
       cmCTestLog(this->CTest, ERROR_MESSAGE, "\n");
       return false;
-      }
+    }
     // if we do not have a routine yet, then it should be
     // the first argument in the vector
-    if(routine.empty())
-      {
+    if (routine.empty()) {
       routine = separateLine[0];
       // Find the full path to the file
-      if(!this->FindMumpsFile(routine, filepath))
-        {
+      if (!this->FindMumpsFile(routine, filepath)) {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "Could not find mumps file for routine: "
-                   << routine << "\n");
+                   "Could not find mumps file for routine: " << routine
+                                                             << "\n");
         filepath = "";
         continue; // move to next line
-        }
       }
+    }
     // if we have a routine name, check for end of routine
-    else
-      {
+    else {
       // Totals in arg 0 marks the end of a routine
-      if(separateLine[0].substr(0, 6) == "Totals")
-        {
+      if (separateLine[0].substr(0, 6) == "Totals") {
         routine = ""; // at the end of this routine
         filepath = "";
         continue; // move to next line
-        }
       }
+    }
     // if the file path was not found for the routine
     // move to next line. We should have already warned
     // after the call to FindMumpsFile that we did not find
     // it, so don't report again to cut down on output
-    if(filepath.empty())
-      {
+    if (filepath.empty()) {
       continue;
-      }
+    }
     // now we are ready to set the coverage from the line of data
-    cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
-      coverageVector = this->Coverage.TotalCoverage[filepath];
-    std::string::size_type linenumber = atoi(separateLine[1].c_str()) -1;
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+      this->Coverage.TotalCoverage[filepath];
+    std::string::size_type linenumber = atoi(separateLine[1].c_str()) - 1;
     int count = atoi(separateLine[2].c_str());
-    if(linenumber > coverageVector.size())
-      {
+    if (linenumber > coverageVector.size()) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Parse error line is greater than number of lines in file: "
-                 << linenumber << " " << filepath << "\n");
+                   << linenumber << " " << filepath << "\n");
       continue; // skip setting count to avoid crash
-      }
+    }
     // now add to count for linenumber
     // for some reason the cache coverage adds extra lines to the
     // end of the file in some cases. Since they do not exist, we will
     // mark them as non executable
-    while(linenumber >= coverageVector.size())
-      {
+    while (linenumber >= coverageVector.size()) {
       coverageVector.push_back(-1);
-      }
+    }
     // Accounts for lines that were previously marked
     // as non-executable code (-1). if the parser comes back with
     // a non-zero count, increase the count by 1 to push the line
     // into the executable code set in addition to the count found.
-    if(coverageVector[linenumber] == -1 &&
-        count > 0)
-      {
-        coverageVector[linenumber] += count+1;
-      }
-    else
-      {
-        coverageVector[linenumber] += count;
-      }
+    if (coverageVector[linenumber] == -1 && count > 0) {
+      coverageVector[linenumber] += count + 1;
+    } else {
+      coverageVector[linenumber] += count;
     }
+  }
   return true;
 }
diff --git a/Source/CTest/cmParseCacheCoverage.h b/Source/CTest/cmParseCacheCoverage.h
index 114eb92..bd331d0 100644
--- a/Source/CTest/cmParseCacheCoverage.h
+++ b/Source/CTest/cmParseCacheCoverage.h
@@ -24,8 +24,8 @@
 class cmParseCacheCoverage : public cmParseMumpsCoverage
 {
 public:
-  cmParseCacheCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest);
+  cmParseCacheCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+
 protected:
   // implement virtual from parent
   bool LoadCoverageData(const char* dir);
@@ -34,9 +34,7 @@ protected:
   // Read a single mcov file
   bool ReadCMCovFile(const char* f);
   // split a string based on ,
-  bool SplitString(std::vector<std::string>& args,
-                   std::string const& line);
+  bool SplitString(std::vector<std::string>& args, std::string const& line);
 };
 
-
 #endif
diff --git a/Source/CTest/cmParseCoberturaCoverage.cxx b/Source/CTest/cmParseCoberturaCoverage.cxx
index d3b99fb..3bdae17 100644
--- a/Source/CTest/cmParseCoberturaCoverage.cxx
+++ b/Source/CTest/cmParseCoberturaCoverage.cxx
@@ -5,117 +5,97 @@
 #include <cmsys/Directory.hxx>
 #include <cmsys/FStream.hxx>
 
-class cmParseCoberturaCoverage::XMLParser: public cmXMLParser
+class cmParseCoberturaCoverage::XMLParser : public cmXMLParser
 {
 public:
   XMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
-    : CTest(ctest), Coverage(cont)
+    : CTest(ctest)
+    , Coverage(cont)
   {
-   this->InSources     = false;
-   this->InSource      = false;
-   this->SkipThisClass = false;
-   this->FilePaths.push_back(this->Coverage.SourceDir);
-   this->FilePaths.push_back(this->Coverage.BinaryDir);
-   this->CurFileName = "";
+    this->InSources = false;
+    this->InSource = false;
+    this->SkipThisClass = false;
+    this->FilePaths.push_back(this->Coverage.SourceDir);
+    this->FilePaths.push_back(this->Coverage.BinaryDir);
+    this->CurFileName = "";
   }
 
-  virtual ~XMLParser()
-  {
-  }
+  virtual ~XMLParser() {}
 
 protected:
-
-
   virtual void EndElement(const std::string& name)
   {
-   if(name == "source")
-     {
-     this->InSource=false;
-     }
-   else if (name == "sources")
-     {
-     this->InSources=false;
-     }
-    else if(name == "class")
-      {
+    if (name == "source") {
+      this->InSource = false;
+    } else if (name == "sources") {
+      this->InSources = false;
+    } else if (name == "class") {
       this->SkipThisClass = false;
-      }
+    }
   }
 
   virtual void CharacterDataHandler(const char* data, int length)
   {
-     std::string tmp;
-     tmp.insert(0,data,length);
-     if (this->InSources && this->InSource)
-       {
-       this->FilePaths.push_back(tmp);
-       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-         "Adding Source: " << tmp << std::endl, this->Coverage.Quiet);
-       }
+    std::string tmp;
+    tmp.insert(0, data, length);
+    if (this->InSources && this->InSource) {
+      this->FilePaths.push_back(tmp);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Adding Source: " << tmp << std::endl,
+                         this->Coverage.Quiet);
+    }
   }
 
   virtual void StartElement(const std::string& name, const char** atts)
   {
     std::string FoundSource;
     std::string finalpath = "";
-    if(name == "source")
-    {
+    if (name == "source") {
       this->InSource = true;
-    }
-    else if(name == "sources")
-      {
+    } else if (name == "sources") {
       this->InSources = true;
-      }
-    else if(name == "class")
-    {
+    } else if (name == "class") {
       int tagCount = 0;
-      while(true)
-      {
-        if(strcmp(atts[tagCount], "filename") == 0)
-        {
+      while (true) {
+        if (strcmp(atts[tagCount], "filename") == 0) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "Reading file: " << atts[tagCount+1]<< std::endl,
-            this->Coverage.Quiet);
-          std::string filename = atts[tagCount+1];
+                             "Reading file: " << atts[tagCount + 1]
+                                              << std::endl,
+                             this->Coverage.Quiet);
+          std::string filename = atts[tagCount + 1];
           this->CurFileName = "";
 
           // Check if this is an absolute path that falls within our
           // source or binary directories.
-          for(size_t i=0;i < FilePaths.size();i++)
-            {
-            if (filename.find(FilePaths[i]) == 0)
-              {
+          for (size_t i = 0; i < FilePaths.size(); i++) {
+            if (filename.find(FilePaths[i]) == 0) {
               this->CurFileName = filename;
               break;
-              }
             }
+          }
 
-          if (this->CurFileName == "")
-            {
+          if (this->CurFileName == "") {
             // Check if this is a path that is relative to our source or
             // binary directories.
-            for(size_t i=0;i < FilePaths.size();i++)
-              {
+            for (size_t i = 0; i < FilePaths.size(); i++) {
               finalpath = FilePaths[i] + "/" + filename;
-              if(cmSystemTools::FileExists(finalpath.c_str()))
-                {
+              if (cmSystemTools::FileExists(finalpath.c_str())) {
                 this->CurFileName = finalpath;
                 break;
-                }
               }
             }
+          }
 
           cmsys::ifstream fin(this->CurFileName.c_str());
-          if(this->CurFileName == "" || !fin )
-          {
-            this->CurFileName = this->Coverage.BinaryDir + "/" +
-                                   atts[tagCount+1];
+          if (this->CurFileName == "" || !fin) {
+            this->CurFileName =
+              this->Coverage.BinaryDir + "/" + atts[tagCount + 1];
             fin.open(this->CurFileName.c_str());
-            if (!fin)
-            {
+            if (!fin) {
               cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                "Skipping system file " << filename << std::endl,
-                this->Coverage.Quiet);
+                                 "Skipping system file " << filename
+                                                         << std::endl,
+                                 this->Coverage.Quiet);
 
               this->SkipThisClass = true;
               break;
@@ -124,8 +104,7 @@ protected:
           std::string line;
           FileLinesType& curFileLines =
             this->Coverage.TotalCoverage[this->CurFileName];
-          while(cmSystemTools::GetLineFromStream(fin, line))
-          {
+          while (cmSystemTools::GetLineFromStream(fin, line)) {
             curFileLines.push_back(-1);
           }
 
@@ -133,34 +112,26 @@ protected:
         }
         ++tagCount;
       }
-    }
-    else if(name == "line")
-    {
+    } else if (name == "line") {
       int tagCount = 0;
       int curNumber = -1;
       int curHits = -1;
-      while(true)
-      {
-        if(this->SkipThisClass)
-          {
+      while (true) {
+        if (this->SkipThisClass) {
           break;
-          }
-        if(strcmp(atts[tagCount], "hits") == 0)
-        {
-          curHits = atoi(atts[tagCount+1]);
         }
-        else if(strcmp(atts[tagCount], "number") == 0)
-        {
-          curNumber = atoi(atts[tagCount+1]);
+        if (strcmp(atts[tagCount], "hits") == 0) {
+          curHits = atoi(atts[tagCount + 1]);
+        } else if (strcmp(atts[tagCount], "number") == 0) {
+          curNumber = atoi(atts[tagCount + 1]);
         }
 
-        if(curHits > -1 && curNumber > 0)
-        {
+        if (curHits > -1 && curNumber > 0) {
           FileLinesType& curFileLines =
             this->Coverage.TotalCoverage[this->CurFileName];
-            {
-            curFileLines[curNumber-1] = curHits;
-            }
+          {
+            curFileLines[curNumber - 1] = curHits;
+          }
           break;
         }
         ++tagCount;
@@ -169,24 +140,21 @@ protected:
   }
 
 private:
-
   bool InSources;
   bool InSource;
   bool SkipThisClass;
   std::vector<std::string> FilePaths;
   typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
-     FileLinesType;
+    FileLinesType;
   cmCTest* CTest;
   cmCTestCoverageHandlerContainer& Coverage;
   std::string CurFileName;
-
 };
 
-
 cmParseCoberturaCoverage::cmParseCoberturaCoverage(
-    cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest)
-    :Coverage(cont), CTest(ctest)
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
 {
 }
 
diff --git a/Source/CTest/cmParseCoberturaCoverage.h b/Source/CTest/cmParseCoberturaCoverage.h
index c3e3ec9..4fa6d10 100644
--- a/Source/CTest/cmParseCoberturaCoverage.h
+++ b/Source/CTest/cmParseCoberturaCoverage.h
@@ -27,11 +27,10 @@
 class cmParseCoberturaCoverage
 {
 public:
-
   //! Create the coverage parser by passing in the coverage handler
   //! container and the cmCTest object
   cmParseCoberturaCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest);
+                           cmCTest* ctest);
 
   bool inSources;
   bool inSource;
@@ -40,7 +39,6 @@ public:
   bool ReadCoverageXML(const char* xmlFile);
 
 private:
-
   class XMLParser;
   cmCTestCoverageHandlerContainer& Coverage;
   cmCTest* CTest;
diff --git a/Source/CTest/cmParseDelphiCoverage.cxx b/Source/CTest/cmParseDelphiCoverage.cxx
index 09c4f02..d20b16a 100644
--- a/Source/CTest/cmParseDelphiCoverage.cxx
+++ b/Source/CTest/cmParseDelphiCoverage.cxx
@@ -8,93 +8,76 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
 class cmParseDelphiCoverage::HTMLParser
 {
 public:
   typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
-  FileLinesType;
+    FileLinesType;
   HTMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
-     : CTest(ctest), Coverage(cont)
-    {
-    }
+    : CTest(ctest)
+    , Coverage(cont)
+  {
+  }
 
-  virtual ~HTMLParser()
-    {
-    }
+  virtual ~HTMLParser() {}
 
-  bool initializeDelphiFile(const std::string filename,
-     cmParseDelphiCoverage::HTMLParser::FileLinesType &coverageVector)
-    {
+  bool initializeDelphiFile(
+    const std::string filename,
+    cmParseDelphiCoverage::HTMLParser::FileLinesType& coverageVector)
+  {
     std::string line;
     size_t comPos;
     size_t semiPos;
-    bool blockComFlag= false;
-    bool lineComFlag= false;
+    bool blockComFlag = false;
+    bool lineComFlag = false;
     std::vector<std::string> beginSet;
     cmsys::ifstream in(filename.c_str());
-    if(!in)
-      {
+    if (!in) {
       return false;
-      }
-    while(cmSystemTools::GetLineFromStream(in, line))
-      {
-      lineComFlag=false;
+    }
+    while (cmSystemTools::GetLineFromStream(in, line)) {
+      lineComFlag = false;
       // Unique cases found in lines.
       size_t beginPos = line.find("begin");
 
-      //Check that the begin is the first non-space string on the line
-      if( (beginPos == line.find_first_not_of(' ')) && beginPos != line.npos )
-        {
+      // Check that the begin is the first non-space string on the line
+      if ((beginPos == line.find_first_not_of(' ')) && beginPos != line.npos) {
         beginSet.push_back("begin");
         coverageVector.push_back(-1);
         continue;
-        }
-      else if(line.find('{') != line.npos)
-        {
-        blockComFlag=true;
-        }
-      else if(line.find('}') != line.npos)
-        {
-        blockComFlag=false;
+      } else if (line.find('{') != line.npos) {
+        blockComFlag = true;
+      } else if (line.find('}') != line.npos) {
+        blockComFlag = false;
         coverageVector.push_back(-1);
         continue;
-        }
-      else if((line.find("end;") != line.npos)
-         && !beginSet.empty())
-        {
+      } else if ((line.find("end;") != line.npos) && !beginSet.empty()) {
         beginSet.pop_back();
         coverageVector.push_back(-1);
         continue;
-        }
+      }
 
       //  This checks for comments after lines of code, finding the
       //  comment symbol after the ending semicolon.
       comPos = line.find("//");
-      if(comPos != line.npos)
-        {
-        semiPos= line.find(';');
-        if(comPos < semiPos)
-          {
-          lineComFlag=true;
-          }
+      if (comPos != line.npos) {
+        semiPos = line.find(';');
+        if (comPos < semiPos) {
+          lineComFlag = true;
         }
-      //Based up what was found, add a line to the coverageVector
-      if(!beginSet.empty() && line != ""  && !blockComFlag
-         && !lineComFlag)
-        {
+      }
+      // Based up what was found, add a line to the coverageVector
+      if (!beginSet.empty() && line != "" && !blockComFlag && !lineComFlag) {
         coverageVector.push_back(0);
-        }
-      else
-        {
+      } else {
         coverageVector.push_back(-1);
-        }
       }
-      return true;
     }
+    return true;
+  }
   bool ParseFile(const char* file)
-    {
-    std::string line=file;
+  {
+    std::string line = file;
     std::string lineresult;
     std::string lastroutine;
     std::string filename;
@@ -117,28 +100,25 @@ public:
     *   to see if it ends in '.pas'.  If it can't be found,
     *   exit the function.
     */
-    while(true)
-      {
-      lastoffset = line.find('(',pos);
-      if(lastoffset==line.npos)
-        {
-        cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-           endnamepos << "File not found  " << lastoffset  << std::endl,
-           this->Coverage.Quiet);
+    while (true) {
+      lastoffset = line.find('(', pos);
+      if (lastoffset == line.npos) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, endnamepos
+                             << "File not found  " << lastoffset << std::endl,
+                           this->Coverage.Quiet);
         return false;
-        }
-      endnamepos = line.find(')',lastoffset);
-      filename = line.substr(lastoffset+1,
-         (endnamepos-1)-lastoffset);
-      if(filename.find(".pas") != filename.npos)
-        {
-        cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-           "Coverage found for file:  " << filename  << std::endl,
-           this->Coverage.Quiet);
+      }
+      endnamepos = line.find(')', lastoffset);
+      filename = line.substr(lastoffset + 1, (endnamepos - 1) - lastoffset);
+      if (filename.find(".pas") != filename.npos) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "Coverage found for file:  " << filename
+                                                        << std::endl,
+                           this->Coverage.Quiet);
         break;
-        }
-      pos = lastoffset+1;
       }
+      pos = lastoffset + 1;
+    }
     /*
     *  Glob through the source directory for the
     *  file found above
@@ -149,32 +129,29 @@ public:
     std::string glob = Coverage.SourceDir + "*/" + filename;
     gl.FindFiles(glob);
     std::vector<std::string> const& files = gl.GetFiles();
-    if(files.empty())
-      {
+    if (files.empty()) {
       /*
       *  If that doesn't find any matching files
       *  return a failure.
       */
-      cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-         "Unable to find file matching" << glob << std::endl,
-         this->Coverage.Quiet);
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Unable to find file matching" << glob << std::endl,
+                         this->Coverage.Quiet);
       return false;
-      }
-    FileLinesType&  coverageVector =
-       this->Coverage.TotalCoverage[files[0]];
+    }
+    FileLinesType& coverageVector = this->Coverage.TotalCoverage[files[0]];
 
     /*
     *  Initialize the file to have all code between 'begin' and
     *  'end' tags marked as executable
     */
 
-    this->initializeDelphiFile(files[0],coverageVector);
+    this->initializeDelphiFile(files[0], coverageVector);
 
     cmsys::ifstream in(file);
-    if(!in)
-      {
+    if (!in) {
       return false;
-      }
+    }
 
     /*
     *  Now read the HTML file, looking for the lines that have an
@@ -188,67 +165,61 @@ public:
     *
     */
 
-    while(  cmSystemTools::GetLineFromStream(in, line))
-      {
-      if(line.find("inline") == line.npos)
-        {
+    while (cmSystemTools::GetLineFromStream(in, line)) {
+      if (line.find("inline") == line.npos) {
         continue;
-        }
+      }
 
       lastoffset = line.find("class=");
-      endcovpos = line.find(">",lastoffset);
-      lineresult = line.substr(lastoffset+7,(endcovpos-8)-lastoffset);
-
-      if(lineresult == "covered")
-        {
-        afterLineNum = line.find('<',endcovpos+5);
-        filelineoffset= line.substr(endcovpos+5,
-        afterLineNum-(endcovpos+5));
-        coverageVector[atoi(filelineoffset.c_str())-1] = 1;
-        }
+      endcovpos = line.find(">", lastoffset);
+      lineresult = line.substr(lastoffset + 7, (endcovpos - 8) - lastoffset);
+
+      if (lineresult == "covered") {
+        afterLineNum = line.find('<', endcovpos + 5);
+        filelineoffset =
+          line.substr(endcovpos + 5, afterLineNum - (endcovpos + 5));
+        coverageVector[atoi(filelineoffset.c_str()) - 1] = 1;
       }
-      return true;
     }
+    return true;
+  }
 
-
-  private:
-    cmCTest* CTest;
-    cmCTestCoverageHandlerContainer& Coverage;
+private:
+  cmCTest* CTest;
+  cmCTestCoverageHandlerContainer& Coverage;
 };
 
 cmParseDelphiCoverage::cmParseDelphiCoverage(
-   cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
-   :Coverage(cont), CTest(ctest)
-  {
-  }
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
 
 bool cmParseDelphiCoverage::LoadCoverageData(
   const std::vector<std::string> files)
-  {
+{
   size_t i;
   std::string path;
   size_t numf = files.size();
-  for (i = 0; i < numf; i++)
-    {
+  for (i = 0; i < numf; i++) {
     path = files[i];
 
-    cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-       "Reading HTML File " << path  << std::endl, this->Coverage.Quiet);
-    if(cmSystemTools::GetFilenameLastExtension(path) == ".html")
-      {
-      if(!this->ReadDelphiHTML(path.c_str()))
-        {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Reading HTML File " << path << std::endl,
+                       this->Coverage.Quiet);
+    if (cmSystemTools::GetFilenameLastExtension(path) == ".html") {
+      if (!this->ReadDelphiHTML(path.c_str())) {
         return false;
-        }
       }
     }
-  return true;
   }
+  return true;
+}
 
 bool cmParseDelphiCoverage::ReadDelphiHTML(const char* file)
-  {
-  cmParseDelphiCoverage::HTMLParser
-     parser(this->CTest, this->Coverage);
+{
+  cmParseDelphiCoverage::HTMLParser parser(this->CTest, this->Coverage);
   parser.ParseFile(file);
   return true;
-  }
+}
diff --git a/Source/CTest/cmParseDelphiCoverage.h b/Source/CTest/cmParseDelphiCoverage.h
index 2c3f3b3..06dea2b 100644
--- a/Source/CTest/cmParseDelphiCoverage.h
+++ b/Source/CTest/cmParseDelphiCoverage.h
@@ -15,7 +15,6 @@
 
 #include "cmCTestCoverageHandler.h"
 
-
 /** \class cmParseDelphiCoverage
  * \brief Parse Delphi coverage information
  *
@@ -26,20 +25,17 @@
  */
 
 class cmParseDelphiCoverage
-  {
-  public:
-    cmParseDelphiCoverage(cmCTestCoverageHandlerContainer& cont,
-        cmCTest* ctest);
-    bool LoadCoverageData(const std::vector<std::string> files);
-    bool ReadDelphiHTML(const char* file);
-    // Read a single HTML file from output
-    bool ReadHTMLFile(const char* f);
-
-
-  protected:
-
-    class HTMLParser;
-    cmCTestCoverageHandlerContainer& Coverage;
-    cmCTest* CTest;
-  };
+{
+public:
+  cmParseDelphiCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+  bool LoadCoverageData(const std::vector<std::string> files);
+  bool ReadDelphiHTML(const char* file);
+  // Read a single HTML file from output
+  bool ReadHTMLFile(const char* f);
+
+protected:
+  class HTMLParser;
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
 #endif
diff --git a/Source/CTest/cmParseGTMCoverage.cxx b/Source/CTest/cmParseGTMCoverage.cxx
index ae7dedb..a065903 100644
--- a/Source/CTest/cmParseGTMCoverage.cxx
+++ b/Source/CTest/cmParseGTMCoverage.cxx
@@ -7,65 +7,54 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
 cmParseGTMCoverage::cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
                                        cmCTest* ctest)
-  :cmParseMumpsCoverage(cont, ctest)
+  : cmParseMumpsCoverage(cont, ctest)
 {
 }
 
-
 bool cmParseGTMCoverage::LoadCoverageData(const char* d)
 {
   // load all the .mcov files in the specified directory
   cmsys::Directory dir;
-  if(!dir.Load(d))
-    {
+  if (!dir.Load(d)) {
     return false;
-    }
+  }
   size_t numf;
   unsigned int i;
   numf = dir.GetNumberOfFiles();
-  for (i = 0; i < numf; i++)
-    {
+  for (i = 0; i < numf; i++) {
     std::string file = dir.GetFile(i);
-    if(file != "." && file != ".."
-       && !cmSystemTools::FileIsDirectory(file))
-      {
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
       std::string path = d;
       path += "/";
       path += file;
-      if(cmSystemTools::GetFilenameLastExtension(path) == ".mcov")
-        {
-        if(!this->ReadMCovFile(path.c_str()))
-          {
+      if (cmSystemTools::GetFilenameLastExtension(path) == ".mcov") {
+        if (!this->ReadMCovFile(path.c_str())) {
           return false;
-          }
         }
       }
     }
+  }
   return true;
 }
 
 bool cmParseGTMCoverage::ReadMCovFile(const char* file)
 {
   cmsys::ifstream in(file);
-  if(!in)
-    {
+  if (!in) {
     return false;
-    }
+  }
   std::string line;
   std::string lastfunction;
   std::string lastroutine;
   std::string lastpath;
   int lastoffset = 0;
-  while(  cmSystemTools::GetLineFromStream(in, line))
-    {
+  while (cmSystemTools::GetLineFromStream(in, line)) {
     // only look at lines that have coverage data
-    if(line.find("^ZZCOVERAGE") == line.npos)
-      {
+    if (line.find("^ZZCOVERAGE") == line.npos) {
       continue;
-      }
+    }
     std::string filepath;
     std::string function;
     std::string routine;
@@ -73,66 +62,51 @@ bool cmParseGTMCoverage::ReadMCovFile(const char* file)
     int count = 0;
     this->ParseMCOVLine(line, routine, function, linenumber, count);
     // skip this one
-    if(routine == "RSEL")
-      {
+    if (routine == "RSEL") {
       continue;
-      }
+    }
     // no need to search the file if we just did it
-    if(function == lastfunction && lastroutine == routine)
-      {
-      if(!lastpath.empty())
-        {
-        this->Coverage.TotalCoverage[lastpath][lastoffset + linenumber]
-          += count;
-        }
-      else
-        {
-        cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "Can not find mumps file : "
-                   << lastroutine <<
-                   "  referenced in this line of mcov data:\n"
-                   "[" << line << "]\n");
-        }
-      continue;
+    if (function == lastfunction && lastroutine == routine) {
+      if (!lastpath.empty()) {
+        this->Coverage.TotalCoverage[lastpath][lastoffset + linenumber] +=
+          count;
+      } else {
+        cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not find mumps file : "
+                     << lastroutine
+                     << "  referenced in this line of mcov data:\n"
+                        "["
+                     << line << "]\n");
       }
+      continue;
+    }
     // Find the full path to the file
     bool found = this->FindMumpsFile(routine, filepath);
-    if(found)
-      {
+    if (found) {
       int lineoffset = 0;
-      if(this->FindFunctionInMumpsFile(filepath,
-                                       function,
-                                       lineoffset))
-        {
+      if (this->FindFunctionInMumpsFile(filepath, function, lineoffset)) {
         cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
           coverageVector = this->Coverage.TotalCoverage[filepath];
         // This section accounts for lines that were previously marked
         // as non-executable code (-1), if the parser comes back with
         // a non-zero count, increase the count by 1 to push the line
         // into the executable code set in addtion to the count found.
-        if(coverageVector[lineoffset + linenumber] == -1 &&
-           count > 0)
-          {
-          coverageVector[lineoffset + linenumber] += count+1;
-          }
-        else
-          {
+        if (coverageVector[lineoffset + linenumber] == -1 && count > 0) {
+          coverageVector[lineoffset + linenumber] += count + 1;
+        } else {
           coverageVector[lineoffset + linenumber] += count;
-          }
-        lastoffset = lineoffset;
         }
+        lastoffset = lineoffset;
       }
-    else
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Can not find mumps file : "
-               << routine << "  referenced in this line of mcov data:\n"
-                 "[" << line << "]\n");
-      }
+    } else {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Can not find mumps file : "
+                   << routine << "  referenced in this line of mcov data:\n"
+                                 "["
+                   << line << "]\n");
+    }
     lastfunction = function;
     lastroutine = routine;
     lastpath = filepath;
-    }
+  }
   return true;
 }
 
@@ -141,47 +115,39 @@ bool cmParseGTMCoverage::FindFunctionInMumpsFile(std::string const& filepath,
                                                  int& lineoffset)
 {
   cmsys::ifstream in(filepath.c_str());
-  if(!in)
-    {
+  if (!in) {
     return false;
-    }
+  }
   std::string line;
   int linenum = 0;
-  while(  cmSystemTools::GetLineFromStream(in, line))
-    {
+  while (cmSystemTools::GetLineFromStream(in, line)) {
     std::string::size_type pos = line.find(function.c_str());
-    if(pos == 0)
-      {
+    if (pos == 0) {
       char nextchar = line[function.size()];
-      if(nextchar == ' ' || nextchar == '('|| nextchar == '\t')
-        {
+      if (nextchar == ' ' || nextchar == '(' || nextchar == '\t') {
         lineoffset = linenum;
         return true;
-        }
       }
-    if(pos == 1)
-      {
+    }
+    if (pos == 1) {
       char prevchar = line[0];
-      char nextchar = line[function.size()+1];
-      if(prevchar == '%' && (nextchar == ' ' || nextchar == '('))
-        {
+      char nextchar = line[function.size() + 1];
+      if (prevchar == '%' && (nextchar == ' ' || nextchar == '(')) {
         lineoffset = linenum;
         return true;
-        }
       }
-    linenum++; // move to next line count
     }
+    linenum++; // move to next line count
+  }
   lineoffset = 0;
-  cmCTestLog(this->CTest, ERROR_MESSAGE,
-             "Could not find entry point : "
-             << function << " in " << filepath << "\n");
+  cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not find entry point : "
+               << function << " in " << filepath << "\n");
   return false;
 }
 
 bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
                                        std::string& routine,
-                                       std::string& function,
-                                       int& linenumber,
+                                       std::string& function, int& linenumber,
                                        int& count)
 {
   // this method parses lines from the .mcov file
@@ -197,60 +163,49 @@ bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
   std::vector<std::string> args;
   std::string::size_type pos = line.find('(', 0);
   // if no ( is found, then return line has no coverage
-  if(pos == std::string::npos)
-    {
+  if (pos == std::string::npos) {
     return false;
-    }
+  }
   std::string arg;
   bool done = false;
   // separate out all of the comma separated arguments found
   // in the COVERAGE(...) line
-  while(line[pos] && !done)
-    {
+  while (line[pos] && !done) {
     // save the char we are looking at
     char cur = line[pos];
     // , or ) means end of argument
-    if(cur == ',' || cur == ')')
-      {
+    if (cur == ',' || cur == ')') {
       // save the argument into the argument vector
       args.push_back(arg);
       // start on a new argument
       arg = "";
       // if we are at the end of the ), then finish while loop
-      if(cur == ')')
-        {
+      if (cur == ')') {
         done = true;
-        }
       }
-    else
-      {
+    } else {
       // all chars except ", (, and % get stored in the arg string
-      if(cur != '\"' && cur != '(' && cur != '%')
-        {
+      if (cur != '\"' && cur != '(' && cur != '%') {
         arg.append(1, line[pos]);
-        }
       }
+    }
     // move to next char
     pos++;
-    }
+  }
   // now parse the right hand side of the =
   pos = line.find('=');
   // no = found, this is an error
-  if(pos == line.npos)
-    {
+  if (pos == line.npos) {
     return false;
-    }
+  }
   pos++; // move past =
 
   // if the next positing is not a ", then this is a
   // COVERAGE(..)=count line and turn the rest of the string
   // past the = into an integer and set it to count
-  if(line[pos] != '\"')
-    {
+  if (line[pos] != '\"') {
     count = atoi(line.substr(pos).c_str());
-    }
-  else
-    {
+  } else {
     // this means line[pos] is a ", and we have a
     // COVERAGE(...)="1:0:0:0" type of line
     pos++; // move past "
@@ -258,32 +213,28 @@ bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
     std::string::size_type pos2 = line.find(':', pos);
     // turn the string between the " and the first : into an integer
     // and set it to count
-    count = atoi(line.substr(pos, pos2-pos).c_str());
-    }
+    count = atoi(line.substr(pos, pos2 - pos).c_str());
+  }
   // less then two arguments is an error
-  if(args.size() < 2)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Error parsing mcov line: [" << line << "]\n");
+  if (args.size() < 2) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing mcov line: ["
+                 << line << "]\n");
     return false;
-    }
-  routine = args[0]; // the routine is the first argument
+  }
+  routine = args[0];  // the routine is the first argument
   function = args[1]; // the function in the routine is the second
   // in the two argument only format
   // ^COVERAGE("%RSEL","SRC"), the line offset is 0
-  if(args.size() == 2)
-    {
+  if (args.size() == 2) {
     // To avoid double counting of line 0 of each entry point,
     // Don't count the lines that do not give an explicit line
     // number.
-    routine="";
-    function="";
-    }
-  else
-    {
+    routine = "";
+    function = "";
+  } else {
     // this is the format for this line
     // ^COVERAGE("%RSEL","SRC",count)
     linenumber = atoi(args[2].c_str());
-    }
+  }
   return true;
 }
diff --git a/Source/CTest/cmParseGTMCoverage.h b/Source/CTest/cmParseGTMCoverage.h
index c6d7ef9..bc2f2ec 100644
--- a/Source/CTest/cmParseGTMCoverage.h
+++ b/Source/CTest/cmParseGTMCoverage.h
@@ -24,8 +24,8 @@
 class cmParseGTMCoverage : public cmParseMumpsCoverage
 {
 public:
-  cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest);
+  cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
+
 protected:
   // implement virtual from parent
   bool LoadCoverageData(const char* dir);
@@ -34,16 +34,11 @@ protected:
   // find out what line in a mumps file (filepath) the given entry point
   // or function is.  lineoffset is set by this method.
   bool FindFunctionInMumpsFile(std::string const& filepath,
-                               std::string const& function,
-                               int& lineoffset);
+                               std::string const& function, int& lineoffset);
   // parse a line from a .mcov file, and fill in the
   // routine, function, linenumber and coverage count
-  bool ParseMCOVLine(std::string const& line,
-                 std::string& routine,
-                 std::string& function,
-                 int& linenumber,
-                 int& count);
+  bool ParseMCOVLine(std::string const& line, std::string& routine,
+                     std::string& function, int& linenumber, int& count);
 };
 
-
 #endif
diff --git a/Source/CTest/cmParseJacocoCoverage.cxx b/Source/CTest/cmParseJacocoCoverage.cxx
index d9c4ffb..6afaca6 100644
--- a/Source/CTest/cmParseJacocoCoverage.cxx
+++ b/Source/CTest/cmParseJacocoCoverage.cxx
@@ -8,172 +8,145 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
-class cmParseJacocoCoverage::XMLParser: public cmXMLParser
+class cmParseJacocoCoverage::XMLParser : public cmXMLParser
 {
-  public:
-    XMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
-      : CTest(ctest), Coverage(cont)
-      {
-      this->FilePath = "";
-      this->PackagePath = "";
-      this->PackageName = "";
-      }
+public:
+  XMLParser(cmCTest* ctest, cmCTestCoverageHandlerContainer& cont)
+    : CTest(ctest)
+    , Coverage(cont)
+  {
+    this->FilePath = "";
+    this->PackagePath = "";
+    this->PackageName = "";
+  }
 
-    virtual ~XMLParser()
-      {
-      }
+  virtual ~XMLParser() {}
 
-  protected:
+protected:
+  virtual void EndElement(const std::string&) {}
 
-    virtual void EndElement(const std::string&)
-      {
+  virtual void StartElement(const std::string& name, const char** atts)
+  {
+    if (name == "package") {
+      this->PackageName = atts[1];
+      this->PackagePath = "";
+    } else if (name == "sourcefile") {
+      std::string fileName = atts[1];
+
+      if (this->PackagePath == "") {
+        if (!this->FindPackagePath(fileName)) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
+                       << this->PackageName << "/" << fileName << std::endl);
+          this->Coverage.Error++;
+          return;
+        }
       }
 
-    virtual void StartElement(const std::string& name,
-      const char** atts)
-      {
-      if(name == "package")
-        {
-        this->PackageName = atts[1];
-        this->PackagePath = "";
-        }
-      else if(name == "sourcefile")
-        {
-        std::string fileName = atts[1];
-
-        if (this->PackagePath == "")
-          {
-          if(!this->FindPackagePath(fileName))
-            {
-            cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
-              << this->PackageName << "/" << fileName << std::endl);
-            this->Coverage.Error++;
-            return;
-            }
-          }
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                         "Reading file: " << fileName << std::endl,
+                         this->Coverage.Quiet);
 
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "Reading file: " << fileName << std::endl,
-          this->Coverage.Quiet);
-
-        this->FilePath = this->PackagePath + "/" + fileName;
-        cmsys::ifstream fin(this->FilePath.c_str());
-        if (!fin)
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE,
-                     "Jacoco Coverage: Error opening " << this->FilePath
-                     << std::endl);
-          }
-        std::string line;
-        FileLinesType& curFileLines =
-          this->Coverage.TotalCoverage[this->FilePath];
-        if(fin)
-          {
-          curFileLines.push_back(-1);
-          }
-        while(cmSystemTools::GetLineFromStream(fin, line))
-          {
-          curFileLines.push_back(-1);
-          }
+      this->FilePath = this->PackagePath + "/" + fileName;
+      cmsys::ifstream fin(this->FilePath.c_str());
+      if (!fin) {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Jacoco Coverage: Error opening " << this->FilePath
+                                                     << std::endl);
+      }
+      std::string line;
+      FileLinesType& curFileLines =
+        this->Coverage.TotalCoverage[this->FilePath];
+      if (fin) {
+        curFileLines.push_back(-1);
+      }
+      while (cmSystemTools::GetLineFromStream(fin, line)) {
+        curFileLines.push_back(-1);
+      }
+    } else if (name == "line") {
+      int tagCount = 0;
+      int nr = -1;
+      int ci = -1;
+      while (true) {
+        if (strcmp(atts[tagCount], "ci") == 0) {
+          ci = atoi(atts[tagCount + 1]);
+        } else if (strcmp(atts[tagCount], "nr") == 0) {
+          nr = atoi(atts[tagCount + 1]);
         }
-      else if(name == "line")
-        {
-        int tagCount = 0;
-        int nr = -1;
-        int ci = -1;
-        while(true)
-          {
-          if(strcmp(atts[tagCount],"ci") == 0)
-            {
-            ci = atoi(atts[tagCount+1]);
-            }
-          else if (strcmp(atts[tagCount],"nr") == 0)
-            {
-            nr = atoi(atts[tagCount+1]);
-            }
-          if (ci > -1 && nr > 0)
-            {
-            FileLinesType& curFileLines=
-              this->Coverage.TotalCoverage[this->FilePath];
-            if(!curFileLines.empty())
-               {
-               curFileLines[nr-1] = ci;
-               }
-            break;
-            }
-          ++tagCount;
+        if (ci > -1 && nr > 0) {
+          FileLinesType& curFileLines =
+            this->Coverage.TotalCoverage[this->FilePath];
+          if (!curFileLines.empty()) {
+            curFileLines[nr - 1] = ci;
           }
+          break;
         }
+        ++tagCount;
       }
+    }
+  }
 
-    virtual bool FindPackagePath(const std::string fileName)
-      {
-      // Search for the source file in the source directory.
-      if (this->PackagePathFound(fileName, this->Coverage.SourceDir))
-        {
-        return true;
-        }
-
-      // If not found there, check the binary directory.
-      if (this->PackagePathFound(fileName, this->Coverage.BinaryDir))
-        {
-        return true;
-        }
-      return false;
-      }
+  virtual bool FindPackagePath(const std::string fileName)
+  {
+    // Search for the source file in the source directory.
+    if (this->PackagePathFound(fileName, this->Coverage.SourceDir)) {
+      return true;
+    }
 
-    virtual bool PackagePathFound(const std::string fileName,
-                                  const std::string baseDir)
-      {
-      // Search for the file in the baseDir and its subdirectories.
-      std::string packageGlob = baseDir;
-      packageGlob += "/";
-      packageGlob += fileName;
-      cmsys::Glob gl;
-      gl.RecurseOn();
-      gl.RecurseThroughSymlinksOn();
-      gl.FindFiles(packageGlob);
-      std::vector<std::string> const& files = gl.GetFiles();
-      if (files.size() == 0)
-        {
-        return false;
-        }
+    // If not found there, check the binary directory.
+    if (this->PackagePathFound(fileName, this->Coverage.BinaryDir)) {
+      return true;
+    }
+    return false;
+  }
 
-      // Check if any of the locations found match our package.
-      for(std::vector<std::string>::const_iterator fi = files.begin();
-          fi != files.end(); ++fi)
-        {
-        std::string dir = cmsys::SystemTools::GetParentDirectory(*fi);
-        if (cmsys::SystemTools::StringEndsWith(dir, this->PackageName.c_str()))
-          {
-          cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-                             "Found package directory for " << fileName <<
-                             ": " << dir << std::endl,
-                             this->Coverage.Quiet);
-          this->PackagePath = dir;
-          return true;
-          }
-        }
+  virtual bool PackagePathFound(const std::string fileName,
+                                const std::string baseDir)
+  {
+    // Search for the file in the baseDir and its subdirectories.
+    std::string packageGlob = baseDir;
+    packageGlob += "/";
+    packageGlob += fileName;
+    cmsys::Glob gl;
+    gl.RecurseOn();
+    gl.RecurseThroughSymlinksOn();
+    gl.FindFiles(packageGlob);
+    std::vector<std::string> const& files = gl.GetFiles();
+    if (files.size() == 0) {
       return false;
+    }
+
+    // Check if any of the locations found match our package.
+    for (std::vector<std::string>::const_iterator fi = files.begin();
+         fi != files.end(); ++fi) {
+      std::string dir = cmsys::SystemTools::GetParentDirectory(*fi);
+      if (cmsys::SystemTools::StringEndsWith(dir, this->PackageName.c_str())) {
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "Found package directory for " << fileName << ": "
+                                                          << dir << std::endl,
+                           this->Coverage.Quiet);
+        this->PackagePath = dir;
+        return true;
       }
+    }
+    return false;
+  }
 
-  private:
-    std::string FilePath;
-    std::string PackagePath;
-    std::string PackageName;
-    typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
-     FileLinesType;
-    cmCTest* CTest;
-    cmCTestCoverageHandlerContainer& Coverage;
+private:
+  std::string FilePath;
+  std::string PackagePath;
+  std::string PackageName;
+  typedef cmCTestCoverageHandlerContainer::SingleFileCoverageVector
+    FileLinesType;
+  cmCTest* CTest;
+  cmCTestCoverageHandlerContainer& Coverage;
 };
 
 cmParseJacocoCoverage::cmParseJacocoCoverage(
-  cmCTestCoverageHandlerContainer& cont,
-  cmCTest* ctest)
-  :Coverage(cont), CTest(ctest)
-  {
-  }
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
+{
+}
 
 bool cmParseJacocoCoverage::LoadCoverageData(
   const std::vector<std::string> files)
@@ -183,27 +156,24 @@ bool cmParseJacocoCoverage::LoadCoverageData(
   size_t i;
   std::string path;
   size_t numf = files.size();
-  for (i = 0; i < numf; i++)
-    {
+  for (i = 0; i < numf; i++) {
     path = files[i];
 
-    cmCTestOptionalLog(this->CTest,HANDLER_VERBOSE_OUTPUT,
-      "Reading XML File " << path  << std::endl, this->Coverage.Quiet);
-    if(cmSystemTools::GetFilenameLastExtension(path) == ".xml")
-      {
-      if(!this->ReadJacocoXML(path.c_str()))
-        {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Reading XML File " << path << std::endl,
+                       this->Coverage.Quiet);
+    if (cmSystemTools::GetFilenameLastExtension(path) == ".xml") {
+      if (!this->ReadJacocoXML(path.c_str())) {
         return false;
-        }
       }
     }
+  }
   return true;
 }
 
 bool cmParseJacocoCoverage::ReadJacocoXML(const char* file)
 {
-  cmParseJacocoCoverage::XMLParser
-    parser(this->CTest, this->Coverage);
+  cmParseJacocoCoverage::XMLParser parser(this->CTest, this->Coverage);
   parser.ParseFile(file);
   return true;
 }
diff --git a/Source/CTest/cmParseJacocoCoverage.h b/Source/CTest/cmParseJacocoCoverage.h
index cf86508..fa31d47 100644
--- a/Source/CTest/cmParseJacocoCoverage.h
+++ b/Source/CTest/cmParseJacocoCoverage.h
@@ -15,7 +15,6 @@
 
 #include "cmCTestCoverageHandler.h"
 
-
 /** \class cmParseJacocoCoverage
  * \brief Parse JaCoCO coverage information
  *
@@ -27,14 +26,14 @@
 class cmParseJacocoCoverage
 {
 public:
-  cmParseJacocoCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest);
+  cmParseJacocoCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
   bool LoadCoverageData(const std::vector<std::string> files);
 
   std::string PackageName;
   std::string FileName;
   std::string ModuleName;
   std::string CurFileName;
+
 private:
   // implement virtual from parent
   // remove files with no coverage
@@ -42,10 +41,8 @@ private:
   // Read a single mcov file
   bool ReadJacocoXML(const char* f);
   // split a string based on ,
-  bool SplitString(std::vector<std::string>& args,
-    std::string const& line);
-  bool FindJavaFile(std::string const& routine,
-    std::string& filepath);
+  bool SplitString(std::vector<std::string>& args, std::string const& line);
+  bool FindJavaFile(std::string const& routine, std::string& filepath);
   void InitializeJavaFile(std::string& file);
   bool LoadSource(std::string d);
 
diff --git a/Source/CTest/cmParseMumpsCoverage.cxx b/Source/CTest/cmParseMumpsCoverage.cxx
index d0c7599..e5dd74a 100644
--- a/Source/CTest/cmParseMumpsCoverage.cxx
+++ b/Source/CTest/cmParseMumpsCoverage.cxx
@@ -7,11 +7,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-
 cmParseMumpsCoverage::cmParseMumpsCoverage(
-  cmCTestCoverageHandlerContainer& cont,
-  cmCTest* ctest)
-  :Coverage(cont), CTest(ctest)
+  cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
 {
 }
 
@@ -25,37 +24,30 @@ bool cmParseMumpsCoverage::ReadCoverageFile(const char* file)
   // packages:/full/path/to/Vista/Packages
   // coverage_dir:/full/path/to/dir/with/*.mcov
   cmsys::ifstream in(file);
-  if(!in)
-    {
+  if (!in) {
     return false;
-    }
+  }
   std::string line;
-  while(cmSystemTools::GetLineFromStream(in, line))
-    {
+  while (cmSystemTools::GetLineFromStream(in, line)) {
     std::string::size_type pos = line.find(':', 0);
     std::string packages;
-    if(pos != std::string::npos)
-      {
+    if (pos != std::string::npos) {
       std::string type = line.substr(0, pos);
-      std::string path = line.substr(pos+1);
-      if(type == "packages")
-        {
+      std::string path = line.substr(pos + 1);
+      if (type == "packages") {
         this->LoadPackages(path.c_str());
-        }
-      else if(type == "coverage_dir")
-        {
+      } else if (type == "coverage_dir") {
         this->LoadCoverageData(path.c_str());
-        }
-      else
-        {
+      } else {
         cmCTestLog(this->CTest, ERROR_MESSAGE,
                    "Parse Error in Mumps coverage file :\n"
-                   << file <<
-                   "\ntype: [" << type << "]\npath:[" << path << "]\n"
-                   "input line: [" << line << "]\n");
-        }
+                     << file << "\ntype: [" << type << "]\npath:[" << path
+                     << "]\n"
+                        "input line: ["
+                     << line << "]\n");
       }
     }
+  }
   return true;
 }
 
@@ -63,59 +55,50 @@ void cmParseMumpsCoverage::InitializeMumpsFile(std::string& file)
 {
   // initialize the coverage information for a given mumps file
   cmsys::ifstream in(file.c_str());
-  if(!in)
-    {
+  if (!in) {
     return;
-    }
+  }
   std::string line;
-  cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
-    coverageVector = this->Coverage.TotalCoverage[file];
-  if(!cmSystemTools::GetLineFromStream(in, line))
-    {
+  cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+    this->Coverage.TotalCoverage[file];
+  if (!cmSystemTools::GetLineFromStream(in, line)) {
     return;
-    }
+  }
   // first line of a .m file can never be run
   coverageVector.push_back(-1);
-  while( cmSystemTools::GetLineFromStream(in, line) )
-    {
+  while (cmSystemTools::GetLineFromStream(in, line)) {
     // putting in a 0 for a line means it is executable code
     // putting in a -1 for a line means it is not executable code
     int val = -1; // assume line is not executable
     bool found = false;
     std::string::size_type i = 0;
     // (1) Search for the first whitespace or semicolon character on a line.
-    //This will skip over labels if the line starts with one, or will simply
-    //be the first character on the line for non-label lines.
-    for(; i < line.size(); ++i)
-      {
-      if(line[i] == ' ' || line[i] == '\t' || line[i] == ';')
-        {
+    // This will skip over labels if the line starts with one, or will simply
+    // be the first character on the line for non-label lines.
+    for (; i < line.size(); ++i) {
+      if (line[i] == ' ' || line[i] == '\t' || line[i] == ';') {
         found = true;
         break;
-        }
       }
-    if(found)
-      {
+    }
+    if (found) {
       // (2) If the first character found above is whitespace or a period
       // then continue the search for the first following non-whitespace
       // character.
-      if(line[i] == ' ' || line[i] == '\t')
-        {
-        while(i < line.size() && (line[i] == ' ' || line[i] == '\t'
-          || line[i] == '.'))
-          {
+      if (line[i] == ' ' || line[i] == '\t') {
+        while (i < line.size() &&
+               (line[i] == ' ' || line[i] == '\t' || line[i] == '.')) {
           i++;
-          }
         }
+      }
       // (3) If the character found is not a semicolon then the line counts for
       // coverage.
-      if(i < line.size() && line[i] != ';')
-        {
+      if (i < line.size() && line[i] != ';') {
         val = 0;
-        }
       }
-    coverageVector.push_back(val);
     }
+    coverageVector.push_back(val);
+  }
 }
 
 bool cmParseMumpsCoverage::LoadPackages(const char* d)
@@ -127,15 +110,13 @@ bool cmParseMumpsCoverage::LoadPackages(const char* d)
   glob.FindFiles(pat);
   std::vector<std::string>& files = glob.GetFiles();
   std::vector<std::string>::iterator fileIt;
-  for ( fileIt = files.begin(); fileIt != files.end();
-        ++ fileIt )
-    {
+  for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
     std::string name = cmSystemTools::GetFilenameName(*fileIt);
-    this->RoutineToDirectory[name.substr(0, name.size()-2)] = *fileIt;
+    this->RoutineToDirectory[name.substr(0, name.size() - 2)] = *fileIt;
     // initialze each file, this is left out until CDash is fixed
     // to handle large numbers of files
     this->InitializeMumpsFile(*fileIt);
-    }
+  }
   return true;
 }
 
@@ -144,25 +125,20 @@ bool cmParseMumpsCoverage::FindMumpsFile(std::string const& routine,
 {
   std::map<std::string, std::string>::iterator i =
     this->RoutineToDirectory.find(routine);
-  if(i != this->RoutineToDirectory.end())
-    {
+  if (i != this->RoutineToDirectory.end()) {
     filepath = i->second;
     return true;
-    }
-  else
-    {
+  } else {
     // try some alternate names
-    const char* tryname[] = {"GUX", "GTM", "ONT", 0};
-    for(int k=0; tryname[k] != 0; k++)
-      {
+    const char* tryname[] = { "GUX", "GTM", "ONT", 0 };
+    for (int k = 0; tryname[k] != 0; k++) {
       std::string routine2 = routine + tryname[k];
       i = this->RoutineToDirectory.find(routine2);
-      if(i != this->RoutineToDirectory.end())
-        {
+      if (i != this->RoutineToDirectory.end()) {
         filepath = i->second;
         return true;
-        }
       }
     }
+  }
   return false;
 }
diff --git a/Source/CTest/cmParseMumpsCoverage.h b/Source/CTest/cmParseMumpsCoverage.h
index ab957b8..3761ba6 100644
--- a/Source/CTest/cmParseMumpsCoverage.h
+++ b/Source/CTest/cmParseMumpsCoverage.h
@@ -24,12 +24,12 @@
 class cmParseMumpsCoverage
 {
 public:
-  cmParseMumpsCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest);
+  cmParseMumpsCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
   virtual ~cmParseMumpsCoverage();
   // This is the toplevel coverage file locating the coverage files
   // and the mumps source code package tree.
   bool ReadCoverageFile(const char* file);
+
 protected:
   // sub classes will use this to
   // load all coverage files found in the given directory
@@ -40,8 +40,8 @@ protected:
   // initialize the coverage information for a single mumps file
   void InitializeMumpsFile(std::string& file);
   // Find mumps file for routine
-  bool FindMumpsFile(std::string const& routine,
-                     std::string& filepath);
+  bool FindMumpsFile(std::string const& routine, std::string& filepath);
+
 protected:
   std::map<std::string, std::string> RoutineToDirectory;
   cmCTestCoverageHandlerContainer& Coverage;
diff --git a/Source/CTest/cmParsePHPCoverage.cxx b/Source/CTest/cmParsePHPCoverage.cxx
index 7c2901e..eb0d962 100644
--- a/Source/CTest/cmParsePHPCoverage.cxx
+++ b/Source/CTest/cmParsePHPCoverage.cxx
@@ -16,55 +16,48 @@
 */
 
 cmParsePHPCoverage::cmParsePHPCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest)
-    :Coverage(cont), CTest(ctest)
+                                       cmCTest* ctest)
+  : Coverage(cont)
+  , CTest(ctest)
 {
 }
 
 bool cmParsePHPCoverage::ReadUntil(std::istream& in, char until)
 {
   char c = 0;
-  while(in.get(c) && c != until)
-    {
-    }
-  if(c != until)
-    {
+  while (in.get(c) && c != until) {
+  }
+  if (c != until) {
     return false;
-    }
+  }
   return true;
 }
 bool cmParsePHPCoverage::ReadCoverageArray(std::istream& in,
                                            std::string const& fileName)
 {
-  cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector
-    = this->Coverage.TotalCoverage[fileName];
+  cmCTestCoverageHandlerContainer::SingleFileCoverageVector& coverageVector =
+    this->Coverage.TotalCoverage[fileName];
 
   char c;
   char buf[4];
   in.read(buf, 3);
   buf[3] = 0;
-  if(strcmp(buf, ";a:") != 0)
-    {
+  if (strcmp(buf, ";a:") != 0) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "failed to read start of coverage array, found : "
-               << buf << "\n");
+               "failed to read start of coverage array, found : " << buf
+                                                                  << "\n");
     return false;
-    }
+  }
   int size = 0;
-  if(!this->ReadInt(in, size))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "failed to read size ");
+  if (!this->ReadInt(in, size)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read size ");
     return false;
-    }
-  if(!in.get(c) && c == '{')
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "failed to read open {\n");
+  }
+  if (!in.get(c) && c == '{') {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read open {\n");
     return false;
-    }
-  for(int i =0; i < size; i++)
-    {
+  }
+  for (int i = 0; i < size; i++) {
     this->ReadUntil(in, ':');
     int line = 0;
     this->ReadInt(in, line);
@@ -72,19 +65,17 @@ bool cmParsePHPCoverage::ReadCoverageArray(std::istream& in,
     // it seems to be 1 based but often times
     // seems to have a 0'th line.
     line--;
-    if(line < 0)
-      {
+    if (line < 0) {
       line = 0;
-      }
+    }
     this->ReadUntil(in, ':');
     int value = 0;
     this->ReadInt(in, value);
     // make sure the vector is the right size and is
     // initialized with -1 for each line
-    while(coverageVector.size() <= static_cast<size_t>(line) )
-      {
+    while (coverageVector.size() <= static_cast<size_t>(line)) {
       coverageVector.push_back(-1);
-      }
+    }
     // if value is less than 0, set it to zero
     // TODO figure out the difference between
     // -1 and -2 in xdebug coverage??  For now
@@ -92,21 +83,18 @@ bool cmParsePHPCoverage::ReadCoverageArray(std::istream& in,
     // CDash expects -1 for non executable code (like comments)
     // and 0 for uncovered code, and a positive value
     // for number of times a line was executed
-    if(value < 0)
-      {
+    if (value < 0) {
       value = 0;
-      }
+    }
     // if unset then set it to value
-    if(coverageVector[line] == -1)
-      {
+    if (coverageVector[line] == -1) {
       coverageVector[line] = value;
-      }
+    }
     // otherwise increment by value
-    else
-      {
+    else {
       coverageVector[line] += value;
-      }
     }
+  }
   return true;
 }
 
@@ -114,10 +102,9 @@ bool cmParsePHPCoverage::ReadInt(std::istream& in, int& v)
 {
   std::string s;
   char c = 0;
-  while(in.get(c) && c != ':' && c != ';')
-    {
+  while (in.get(c) && c != ':' && c != ';') {
     s += c;
-    }
+  }
   v = atoi(s.c_str());
   return true;
 }
@@ -126,17 +113,14 @@ bool cmParsePHPCoverage::ReadArraySize(std::istream& in, int& size)
 {
   char c = 0;
   in.get(c);
-  if(c != 'a')
-    {
+  if (c != 'a') {
     return false;
-    }
-  if(in.get(c) && c == ':')
-    {
-    if(this->ReadInt(in, size))
-      {
+  }
+  if (in.get(c) && c == ':') {
+    if (this->ReadInt(in, size)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -145,110 +129,91 @@ bool cmParsePHPCoverage::ReadFileInformation(std::istream& in)
   char buf[4];
   in.read(buf, 2);
   buf[2] = 0;
-  if(strcmp(buf, "s:") != 0)
-    {
+  if (strcmp(buf, "s:") != 0) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "failed to read start of file info found: [" << buf << "]\n");
     return false;
-    }
+  }
   char c;
   int size = 0;
-  if(this->ReadInt(in, size))
-    {
+  if (this->ReadInt(in, size)) {
     size++; // add one for null termination
-    char* s = new char[size+1];
+    char* s = new char[size + 1];
     // read open quote
-    if(in.get(c) && c != '"')
-      {
+    if (in.get(c) && c != '"') {
       delete[] s;
       return false;
-      }
+    }
     // read the string data
-    in.read(s, size-1);
-    s[size-1] = 0;
+    in.read(s, size - 1);
+    s[size - 1] = 0;
     std::string fileName = s;
-    delete [] s;
+    delete[] s;
     // read close quote
-    if(in.get(c) && c != '"')
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-                 "failed to read close quote\n"
-                 << "read [" << c << "]\n");
+    if (in.get(c) && c != '"') {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read close quote\n"
+                   << "read [" << c << "]\n");
       return false;
-      }
-    if(!this->ReadCoverageArray(in, fileName) )
-      {
+    }
+    if (!this->ReadCoverageArray(in, fileName)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-                 "failed to read coverage array for file: "
-                 << fileName << "\n");
+                 "failed to read coverage array for file: " << fileName
+                                                            << "\n");
       return false;
-      }
-    return true;
     }
+    return true;
+  }
   return false;
 }
 
-
 bool cmParsePHPCoverage::ReadPHPData(const char* file)
 {
   cmsys::ifstream in(file);
-  if(!in)
-    {
+  if (!in) {
     return false;
-    }
+  }
   int size = 0;
   this->ReadArraySize(in, size);
   char c = 0;
   in.get(c);
-  if(c != '{')
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "failed to read open array\n");
+  if (c != '{') {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read open array\n");
     return false;
-    }
-  for(int i =0; i < size; i++)
-    {
-    if(!this->ReadFileInformation(in))
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-                 "Failed to read file #" << i << "\n");
+  }
+  for (int i = 0; i < size; i++) {
+    if (!this->ReadFileInformation(in)) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "Failed to read file #" << i
+                                                                     << "\n");
       return false;
-      }
+    }
     in.get(c);
-    if(c != '}')
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-                 "failed to read close array\n");
+    if (c != '}') {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "failed to read close array\n");
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmParsePHPCoverage::ReadPHPCoverageDirectory(const char* d)
 {
   cmsys::Directory dir;
-  if(!dir.Load(d))
-    {
+  if (!dir.Load(d)) {
     return false;
-    }
+  }
   size_t numf;
   unsigned int i;
   numf = dir.GetNumberOfFiles();
-  for (i = 0; i < numf; i++)
-    {
+  for (i = 0; i < numf; i++) {
     std::string file = dir.GetFile(i);
-    if(file != "." && file != ".."
-       && !cmSystemTools::FileIsDirectory(file))
-      {
+    if (file != "." && file != ".." && !cmSystemTools::FileIsDirectory(file)) {
       std::string path = d;
       path += "/";
       path += file;
-      if(!this->ReadPHPData(path.c_str()))
-        {
+      if (!this->ReadPHPData(path.c_str())) {
         return false;
-        }
       }
     }
+  }
   return true;
 }
diff --git a/Source/CTest/cmParsePHPCoverage.h b/Source/CTest/cmParsePHPCoverage.h
index 706d036..72f9129 100644
--- a/Source/CTest/cmParsePHPCoverage.h
+++ b/Source/CTest/cmParsePHPCoverage.h
@@ -25,10 +25,10 @@
 class cmParsePHPCoverage
 {
 public:
-  cmParsePHPCoverage(cmCTestCoverageHandlerContainer& cont,
-    cmCTest* ctest);
+  cmParsePHPCoverage(cmCTestCoverageHandlerContainer& cont, cmCTest* ctest);
   bool ReadPHPCoverageDirectory(const char* dir);
   void PrintCoverage();
+
 private:
   bool ReadPHPData(const char* file);
   bool ReadArraySize(std::istream& in, int& size);
@@ -40,5 +40,4 @@ private:
   cmCTest* CTest;
 };
 
-
 #endif
diff --git a/Source/CTest/cmProcess.cxx b/Source/CTest/cmProcess.cxx
index d385677..db5151c 100644
--- a/Source/CTest/cmProcess.cxx
+++ b/Source/CTest/cmProcess.cxx
@@ -40,49 +40,43 @@ void cmProcess::SetCommandArguments(std::vector<std::string> const& args)
 
 bool cmProcess::StartProcess()
 {
-  if(this->Command.empty())
-    {
+  if (this->Command.empty()) {
     return false;
-    }
+  }
   this->StartTime = cmSystemTools::GetTime();
   this->ProcessArgs.clear();
   // put the command as arg0
   this->ProcessArgs.push_back(this->Command.c_str());
   // now put the command arguments in
-  for(std::vector<std::string>::iterator i = this->Arguments.begin();
-      i != this->Arguments.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->Arguments.begin();
+       i != this->Arguments.end(); ++i) {
     this->ProcessArgs.push_back(i->c_str());
-    }
+  }
   this->ProcessArgs.push_back(0); // null terminate the list
   this->Process = cmsysProcess_New();
   cmsysProcess_SetCommand(this->Process, &*this->ProcessArgs.begin());
-  if(!this->WorkingDirectory.empty())
-    {
+  if (!this->WorkingDirectory.empty()) {
     cmsysProcess_SetWorkingDirectory(this->Process,
                                      this->WorkingDirectory.c_str());
-    }
+  }
   cmsysProcess_SetTimeout(this->Process, this->Timeout);
   cmsysProcess_SetOption(this->Process, cmsysProcess_Option_MergeOutput, 1);
   cmsysProcess_Execute(this->Process);
-  return (cmsysProcess_GetState(this->Process)
-          == cmsysProcess_State_Executing);
+  return (cmsysProcess_GetState(this->Process) ==
+          cmsysProcess_State_Executing);
 }
 
 bool cmProcess::Buffer::GetLine(std::string& line)
 {
   // Scan for the next newline.
-  for(size_type sz = this->size(); this->Last != sz; ++this->Last)
-    {
-    if((*this)[this->Last] == '\n' || (*this)[this->Last] == '\0')
-      {
+  for (size_type sz = this->size(); this->Last != sz; ++this->Last) {
+    if ((*this)[this->Last] == '\n' || (*this)[this->Last] == '\0') {
       // Extract the range first..last as a line.
       const char* text = &*this->begin() + this->First;
       size_type length = this->Last - this->First;
-      while(length && text[length-1] == '\r')
-        {
-        length --;
-        }
+      while (length && text[length - 1] == '\r') {
+        length--;
+      }
       line.assign(text, length);
 
       // Start a new range for the next line.
@@ -91,73 +85,63 @@ bool cmProcess::Buffer::GetLine(std::string& line)
 
       // Return the line extracted.
       return true;
-      }
     }
+  }
 
   // Available data have been exhausted without a newline.
-  if(this->First != 0)
-    {
+  if (this->First != 0) {
     // Move the partial line to the beginning of the buffer.
     this->erase(this->begin(), this->begin() + this->First);
     this->First = 0;
     this->Last = this->size();
-    }
+  }
   return false;
 }
 
 bool cmProcess::Buffer::GetLast(std::string& line)
 {
   // Return the partial last line, if any.
-  if(!this->empty())
-    {
+  if (!this->empty()) {
     line.assign(&*this->begin(), this->size());
     this->First = this->Last = 0;
     this->clear();
     return true;
-    }
+  }
   return false;
 }
 
 int cmProcess::GetNextOutputLine(std::string& line, double timeout)
 {
-  for(;;)
-    {
+  for (;;) {
     // Look for lines already buffered.
-    if(this->Output.GetLine(line))
-      {
+    if (this->Output.GetLine(line)) {
       return cmsysProcess_Pipe_STDOUT;
-      }
+    }
 
     // Check for more data from the process.
     char* data;
     int length;
     int p = cmsysProcess_WaitForData(this->Process, &data, &length, &timeout);
-    if(p == cmsysProcess_Pipe_Timeout)
-      {
+    if (p == cmsysProcess_Pipe_Timeout) {
       return cmsysProcess_Pipe_Timeout;
-      }
-    else if(p == cmsysProcess_Pipe_STDOUT)
-      {
-      this->Output.insert(this->Output.end(), data, data+length);
-      }
-    else // p == cmsysProcess_Pipe_None
-      {
+    } else if (p == cmsysProcess_Pipe_STDOUT) {
+      this->Output.insert(this->Output.end(), data, data + length);
+    } else // p == cmsysProcess_Pipe_None
+    {
       // The process will provide no more data.
       break;
-      }
     }
+  }
 
   // Look for partial last lines.
-  if(this->Output.GetLast(line))
-    {
+  if (this->Output.GetLast(line)) {
     return cmsysProcess_Pipe_STDOUT;
-    }
+  }
 
   // No more data.  Wait for process exit.
-  if(!cmsysProcess_WaitForExit(this->Process, &timeout))
-    {
+  if (!cmsysProcess_WaitForExit(this->Process, &timeout)) {
     return cmsysProcess_Pipe_Timeout;
-    }
+  }
 
   // Record exit information.
   this->ExitValue = cmsysProcess_GetExitValue(this->Process);
@@ -166,10 +150,9 @@ int cmProcess::GetNextOutputLine(std::string& line, double timeout)
   // negative. If someone changed the system clock while the process was
   // running this may be even more. Make sure not to report a negative
   // duration here.
-  if (this->TotalTime <= 0.0)
-    {
+  if (this->TotalTime <= 0.0) {
     this->TotalTime = 0.0;
-    }
+  }
   //  std::cerr << "Time to run: " << this->TotalTime << "\n";
   return cmsysProcess_Pipe_None;
 }
@@ -177,87 +160,68 @@ int cmProcess::GetNextOutputLine(std::string& line, double timeout)
 // return the process status
 int cmProcess::GetProcessStatus()
 {
-  if(!this->Process)
-    {
+  if (!this->Process) {
     return cmsysProcess_State_Exited;
-    }
+  }
   return cmsysProcess_GetState(this->Process);
 }
 
 int cmProcess::ReportStatus()
 {
   int result = 1;
-  switch(cmsysProcess_GetState(this->Process))
-    {
-    case cmsysProcess_State_Starting:
-      {
-      std::cerr << "cmProcess: Never started "
-           << this->Command << " process.\n";
-      } break;
-    case cmsysProcess_State_Error:
-      {
+  switch (cmsysProcess_GetState(this->Process)) {
+    case cmsysProcess_State_Starting: {
+      std::cerr << "cmProcess: Never started " << this->Command
+                << " process.\n";
+    } break;
+    case cmsysProcess_State_Error: {
       std::cerr << "cmProcess: Error executing " << this->Command
-                << " process: "
-                << cmsysProcess_GetErrorString(this->Process)
+                << " process: " << cmsysProcess_GetErrorString(this->Process)
                 << "\n";
-      } break;
-    case cmsysProcess_State_Exception:
-      {
+    } break;
+    case cmsysProcess_State_Exception: {
       std::cerr << "cmProcess: " << this->Command
-                      << " process exited with an exception: ";
-      switch(cmsysProcess_GetExitException(this->Process))
-        {
-        case cmsysProcess_Exception_None:
-          {
+                << " process exited with an exception: ";
+      switch (cmsysProcess_GetExitException(this->Process)) {
+        case cmsysProcess_Exception_None: {
           std::cerr << "None";
-          } break;
-        case cmsysProcess_Exception_Fault:
-          {
+        } break;
+        case cmsysProcess_Exception_Fault: {
           std::cerr << "Segmentation fault";
-          } break;
-        case cmsysProcess_Exception_Illegal:
-          {
+        } break;
+        case cmsysProcess_Exception_Illegal: {
           std::cerr << "Illegal instruction";
-          } break;
-        case cmsysProcess_Exception_Interrupt:
-          {
+        } break;
+        case cmsysProcess_Exception_Interrupt: {
           std::cerr << "Interrupted by user";
-          } break;
-        case cmsysProcess_Exception_Numerical:
-          {
+        } break;
+        case cmsysProcess_Exception_Numerical: {
           std::cerr << "Numerical exception";
-          } break;
-        case cmsysProcess_Exception_Other:
-          {
+        } break;
+        case cmsysProcess_Exception_Other: {
           std::cerr << "Unknown";
-          } break;
-        }
+        } break;
+      }
       std::cerr << "\n";
-      } break;
-    case cmsysProcess_State_Executing:
-      {
-      std::cerr << "cmProcess: Never terminated " <<
-        this->Command << " process.\n";
-      } break;
-    case cmsysProcess_State_Exited:
-      {
+    } break;
+    case cmsysProcess_State_Executing: {
+      std::cerr << "cmProcess: Never terminated " << this->Command
+                << " process.\n";
+    } break;
+    case cmsysProcess_State_Exited: {
       result = cmsysProcess_GetExitValue(this->Process);
       std::cerr << "cmProcess: " << this->Command
-                << " process exited with code "
-                << result << "\n";
-      } break;
-    case cmsysProcess_State_Expired:
-      {
+                << " process exited with code " << result << "\n";
+    } break;
+    case cmsysProcess_State_Expired: {
       std::cerr << "cmProcess: killed " << this->Command
                 << " process due to timeout.\n";
-      } break;
-    case cmsysProcess_State_Killed:
-      {
+    } break;
+    case cmsysProcess_State_Killed: {
       std::cerr << "cmProcess: killed " << this->Command << " process.\n";
-      } break;
-    }
+    } break;
+  }
   return result;
-
 }
 
 void cmProcess::ChangeTimeout(double t)
diff --git a/Source/CTest/cmProcess.h b/Source/CTest/cmProcess.h
index 326456e..d5e2721 100644
--- a/Source/CTest/cmProcess.h
+++ b/Source/CTest/cmProcess.h
@@ -16,7 +16,6 @@
 
 #include <cmsys/Process.h>
 
-
 /** \class cmProcess
  * \brief run a process with c++
  *
@@ -27,11 +26,11 @@ class cmProcess
 public:
   cmProcess();
   ~cmProcess();
-  const char* GetCommand() { return this->Command.c_str();}
+  const char* GetCommand() { return this->Command.c_str(); }
   void SetCommand(const char* command);
   void SetCommandArguments(std::vector<std::string> const& arg);
-  void SetWorkingDirectory(const char* dir) { this->WorkingDirectory = dir;}
-  void SetTimeout(double t) { this->Timeout = t;}
+  void SetWorkingDirectory(const char* dir) { this->WorkingDirectory = dir; }
+  void SetTimeout(double t) { this->Timeout = t; }
   void ChangeTimeout(double t);
   void ResetStartTime();
   // Return true if the process starts
@@ -42,9 +41,9 @@ public:
   // Report the status of the program
   int ReportStatus();
   int GetId() { return this->Id; }
-  void SetId(int id) { this->Id = id;}
-  int GetExitValue() { return this->ExitValue;}
-  double GetTotalTime() { return this->TotalTime;}
+  void SetId(int id) { this->Id = id; }
+  int GetExitValue() { return this->ExitValue; }
+  double GetTotalTime() { return this->TotalTime; }
   int GetExitException();
   /**
    * Read one line of output but block for no more than timeout.
@@ -54,18 +53,24 @@ public:
    *   cmsysProcess_Pipe_Timeout = Timeout expired while waiting
    */
   int GetNextOutputLine(std::string& line, double timeout);
+
 private:
   double Timeout;
   double StartTime;
   double TotalTime;
   cmsysProcess* Process;
-  class Buffer: public std::vector<char>
+  class Buffer : public std::vector<char>
   {
     // Half-open index range of partial line already scanned.
     size_type First;
     size_type Last;
+
   public:
-    Buffer(): First(0), Last(0) {}
+    Buffer()
+      : First(0)
+      , Last(0)
+    {
+    }
     bool GetLine(std::string& line);
     bool GetLast(std::string& line);
   };
diff --git a/Source/Checks/cm_c11_thread_local.c b/Source/Checks/cm_c11_thread_local.c
index ab780f2..bdf91aa 100644
--- a/Source/Checks/cm_c11_thread_local.c
+++ b/Source/Checks/cm_c11_thread_local.c
@@ -1,2 +1,5 @@
 _Thread_local int i = 42;
-int main(void) { return 0; }
+int main(void)
+{
+  return 0;
+}
diff --git a/Source/Checks/cm_cxx11_unordered_map.cpp b/Source/Checks/cm_cxx11_unordered_map.cpp
index beeb31b..be3de25 100644
--- a/Source/Checks/cm_cxx11_unordered_map.cpp
+++ b/Source/Checks/cm_cxx11_unordered_map.cpp
@@ -1,5 +1,6 @@
 #include <unordered_map>
-int main() {
+int main()
+{
   std::unordered_map<int, int> map;
   map[0] = 0;
   return 0;
diff --git a/Source/Checks/cm_cxx14_cstdio.cpp b/Source/Checks/cm_cxx14_cstdio.cpp
index 3a6a699..f5806a9 100644
--- a/Source/Checks/cm_cxx14_cstdio.cpp
+++ b/Source/Checks/cm_cxx14_cstdio.cpp
@@ -1,2 +1,5 @@
 #include <cstdio>
-int main() { return 0; }
+int main()
+{
+  return 0;
+}
diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx
index 6eccf54..be8751c 100644
--- a/Source/CursesDialog/ccmake.cxx
+++ b/Source/CursesDialog/ccmake.cxx
@@ -23,68 +23,56 @@
 
 #include <form.h>
 
-static const char * cmDocumentationName[][2] =
-{
-  {0,
-   "  ccmake - Curses Interface for CMake."},
-  {0,0}
+static const char* cmDocumentationName[][2] = {
+  { 0, "  ccmake - Curses Interface for CMake." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationUsage[][2] =
-{
-  {0,
-   "  ccmake <path-to-source>\n"
-   "  ccmake <path-to-existing-build>"},
-  {0,
-   "Specify a source directory to (re-)generate a build system for "
-   "it in the current working directory.  Specify an existing build "
-   "directory to re-generate its build system."},
-  {0,0}
+static const char* cmDocumentationUsage[][2] = {
+  { 0, "  ccmake <path-to-source>\n"
+       "  ccmake <path-to-existing-build>" },
+  { 0, "Specify a source directory to (re-)generate a build system for "
+       "it in the current working directory.  Specify an existing build "
+       "directory to re-generate its build system." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationUsageNote[][2] =
-{
-  {0,
-   "Run 'ccmake --help' for more information."},
-  {0,0}
+static const char* cmDocumentationUsageNote[][2] = {
+  { 0, "Run 'ccmake --help' for more information." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationOptions[][2] =
-{
-  CMAKE_STANDARD_OPTIONS_TABLE,
-  {0,0}
-};
+static const char* cmDocumentationOptions[]
+                                         [2] = { CMAKE_STANDARD_OPTIONS_TABLE,
+                                                 { 0, 0 } };
 
-cmCursesForm* cmCursesForm::CurrentForm=0;
+cmCursesForm* cmCursesForm::CurrentForm = 0;
 
-extern "C"
-{
+extern "C" {
 
 void onsig(int)
 {
-  if (cmCursesForm::CurrentForm)
-    {
+  if (cmCursesForm::CurrentForm) {
     endwin();
-    initscr(); /* Initialization */
-    noecho(); /* Echo off */
-    cbreak(); /* nl- or cr not needed */
-    keypad(stdscr,TRUE); /* Use key symbols as
-                            KEY_DOWN*/
+    initscr();            /* Initialization */
+    noecho();             /* Echo off */
+    cbreak();             /* nl- or cr not needed */
+    keypad(stdscr, TRUE); /* Use key symbols as
+                             KEY_DOWN*/
     refresh();
-    int x,y;
+    int x, y;
     getmaxyx(stdscr, y, x);
-    cmCursesForm::CurrentForm->Render(1,1,x,y);
+    cmCursesForm::CurrentForm->Render(1, 1, x, y);
     cmCursesForm::CurrentForm->UpdateStatusBar();
-    }
+  }
   signal(SIGWINCH, onsig);
 }
-
 }
 
 void CMakeMessageHandler(const char* message, const char* title, bool&,
                          void* clientData)
 {
-  cmCursesForm* self = static_cast<cmCursesForm*>( clientData );
+  cmCursesForm* self = static_cast<cmCursesForm*>(clientData);
   self->AddError(message, title);
 }
 
@@ -98,8 +86,7 @@ int main(int argc, char const* const* argv)
   cmSystemTools::FindCMakeResources(argv[0]);
   cmDocumentation doc;
   doc.addCMakeStandardDocSections();
-  if(doc.CheckOptions(argc, argv))
-    {
+  if (doc.CheckOptions(argc, argv)) {
     cmake hcm;
     hcm.SetHomeDirectory("");
     hcm.SetHomeOutputDirectory("");
@@ -107,95 +94,82 @@ int main(int argc, char const* const* argv)
     std::vector<cmDocumentationEntry> generators;
     hcm.GetGeneratorDocumentation(generators);
     doc.SetName("ccmake");
-    doc.SetSection("Name",cmDocumentationName);
-    doc.SetSection("Usage",cmDocumentationUsage);
-    if ( argc == 1 )
-      {
-      doc.AppendSection("Usage",cmDocumentationUsageNote);
-      }
-    doc.SetSection("Generators",generators);
-    doc.PrependSection("Options",cmDocumentationOptions);
-    return doc.PrintRequestedDocumentation(std::cout)? 0:1;
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    if (argc == 1) {
+      doc.AppendSection("Usage", cmDocumentationUsageNote);
     }
+    doc.SetSection("Generators", generators);
+    doc.PrependSection("Options", cmDocumentationOptions);
+    return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
+  }
 
   bool debug = false;
   unsigned int i;
   int j;
   std::vector<std::string> args;
-  for(j =0; j < argc; ++j)
-    {
-    if(strcmp(argv[j], "-debug") == 0)
-      {
+  for (j = 0; j < argc; ++j) {
+    if (strcmp(argv[j], "-debug") == 0) {
       debug = true;
-      }
-    else
-      {
+    } else {
       args.push_back(argv[j]);
-      }
     }
+  }
 
   std::string cacheDir = cmSystemTools::GetCurrentWorkingDirectory();
-  for(i=1; i < args.size(); ++i)
-    {
+  for (i = 1; i < args.size(); ++i) {
     std::string arg = args[i];
-    if(arg.find("-B",0) == 0)
-      {
+    if (arg.find("-B", 0) == 0) {
       cacheDir = arg.substr(2);
-      }
     }
+  }
 
   cmSystemTools::DisableRunCommandOutput();
 
-  if (debug)
-    {
+  if (debug) {
     cmCursesForm::DebugStart();
-    }
+  }
 
-  initscr(); /* Initialization */
-  noecho(); /* Echo off */
-  cbreak(); /* nl- or cr not needed */
-  keypad(stdscr,TRUE); /* Use key symbols as
-                          KEY_DOWN*/
+  initscr();            /* Initialization */
+  noecho();             /* Echo off */
+  cbreak();             /* nl- or cr not needed */
+  keypad(stdscr, TRUE); /* Use key symbols as
+                           KEY_DOWN*/
 
   signal(SIGWINCH, onsig);
 
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
-  if ( x < cmCursesMainForm::MIN_WIDTH  ||
-       y < cmCursesMainForm::MIN_HEIGHT )
-    {
+  if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
     endwin();
     std::cerr << "Window is too small. A size of at least "
               << cmCursesMainForm::MIN_WIDTH << " x "
-              <<  cmCursesMainForm::MIN_HEIGHT
-              << " is required to run ccmake." <<  std::endl;
+              << cmCursesMainForm::MIN_HEIGHT << " is required to run ccmake."
+              << std::endl;
     return 1;
-    }
-
+  }
 
   cmCursesMainForm* myform;
 
   myform = new cmCursesMainForm(args, x);
-  if(myform->LoadCache(cacheDir.c_str()))
-    {
+  if (myform->LoadCache(cacheDir.c_str())) {
     curses_clear();
     touchwin(stdscr);
     endwin();
     delete myform;
     std::cerr << "Error running cmake::LoadCache().  Aborting.\n";
     return 1;
-    }
+  }
 
   cmSystemTools::SetMessageCallback(CMakeMessageHandler, myform);
 
   cmCursesForm::CurrentForm = myform;
 
   myform->InitializeUI();
-  if ( myform->Configure(1) == 0 )
-    {
+  if (myform->Configure(1) == 0) {
     myform->Render(1, 1, x, y);
     myform->HandleInput();
-    }
+  }
 
   // Need to clean-up better
   curses_clear();
@@ -207,5 +181,4 @@ int main(int argc, char const* const* argv)
   std::cout << std::endl << std::endl;
 
   return 0;
-
 }
diff --git a/Source/CursesDialog/cmCursesBoolWidget.cxx b/Source/CursesDialog/cmCursesBoolWidget.cxx
index 0529b78..0055e88 100644
--- a/Source/CursesDialog/cmCursesBoolWidget.cxx
+++ b/Source/CursesDialog/cmCursesBoolWidget.cxx
@@ -13,14 +13,14 @@
 
 #include "cmCursesMainForm.h"
 
-cmCursesBoolWidget::cmCursesBoolWidget(int width, int height,
-                                       int left, int top) :
-  cmCursesWidget(width, height, left, top)
+cmCursesBoolWidget::cmCursesBoolWidget(int width, int height, int left,
+                                       int top)
+  : cmCursesWidget(width, height, left, top)
 {
   this->Type = cmState::BOOL;
-  set_field_fore(this->Field,  A_NORMAL);
-  set_field_back(this->Field,  A_STANDOUT);
-  field_opts_off(this->Field,  O_STATIC);
+  set_field_fore(this->Field, A_NORMAL);
+  set_field_back(this->Field, A_STANDOUT);
+  field_opts_off(this->Field, O_STATIC);
   this->SetValueAsBool(false);
 }
 
@@ -28,48 +28,35 @@ bool cmCursesBoolWidget::HandleInput(int& key, cmCursesMainForm*, WINDOW* w)
 {
 
   // 10 == enter
-  if (key == 10 || key == KEY_ENTER)
-    {
-    if (this->GetValueAsBool())
-      {
+  if (key == 10 || key == KEY_ENTER) {
+    if (this->GetValueAsBool()) {
       this->SetValueAsBool(false);
-      }
-    else
-      {
+    } else {
       this->SetValueAsBool(true);
-      }
+    }
 
     touchwin(w);
     wrefresh(w);
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
-
+  }
 }
 
 void cmCursesBoolWidget::SetValueAsBool(bool value)
 {
-  if (value)
-    {
+  if (value) {
     this->SetValue("ON");
-    }
-  else
-    {
+  } else {
     this->SetValue("OFF");
-    }
+  }
 }
 
 bool cmCursesBoolWidget::GetValueAsBool()
 {
-  if (this->Value == "ON")
-    {
+  if (this->Value == "ON") {
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
diff --git a/Source/CursesDialog/cmCursesBoolWidget.h b/Source/CursesDialog/cmCursesBoolWidget.h
index 65a8ddb..49be45a 100644
--- a/Source/CursesDialog/cmCursesBoolWidget.h
+++ b/Source/CursesDialog/cmCursesBoolWidget.h
@@ -35,7 +35,6 @@ public:
 protected:
   cmCursesBoolWidget(const cmCursesBoolWidget& from);
   void operator=(const cmCursesBoolWidget&);
-
 };
 
 #endif // cmCursesBoolWidget_h
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
index 40c0eb6..bdfc8e9 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -25,10 +25,10 @@
 #include <assert.h>
 
 cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
-                                                        const std::string& key,
-                                                        int labelwidth,
-                                                        int entrywidth) :
-  Key(key), LabelWidth(labelwidth), EntryWidth(entrywidth)
+  const std::string& key, int labelwidth, int entrywidth)
+  : Key(key)
+  , LabelWidth(labelwidth)
+  , EntryWidth(entrywidth)
 {
   this->Label = new cmCursesLabelWidget(this->LabelWidth, 1, 1, 1, key);
   this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, " ");
@@ -37,35 +37,30 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
 }
 
 cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
-  const std::string& key, cmake *cm, bool isNew,
-  int labelwidth, int entrywidth)
-  : Key(key), LabelWidth(labelwidth), EntryWidth(entrywidth)
+  const std::string& key, cmake* cm, bool isNew, int labelwidth,
+  int entrywidth)
+  : Key(key)
+  , LabelWidth(labelwidth)
+  , EntryWidth(entrywidth)
 {
   this->Label = new cmCursesLabelWidget(this->LabelWidth, 1, 1, 1, key);
-  if (isNew)
-    {
+  if (isNew) {
     this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, "*");
-    }
-  else
-    {
+  } else {
     this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, " ");
-    }
+  }
 
   this->Entry = 0;
   const char* value = cm->GetState()->GetCacheEntryValue(key);
   assert(value);
-  switch (cm->GetState()->GetCacheEntryType(key))
-    {
+  switch (cm->GetState()->GetCacheEntryType(key)) {
     case cmState::BOOL:
       this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
-      if (cmSystemTools::IsOn(value))
-        {
+      if (cmSystemTools::IsOn(value)) {
         static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(true);
-        }
-      else
-        {
+      } else {
         static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(false);
-        }
+      }
       break;
     case cmState::PATH:
       this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
@@ -75,40 +70,33 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
       this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
       static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
       break;
-    case cmState::STRING:
-      {
-      const char* stringsProp = cm->GetState()
-                                  ->GetCacheEntryProperty(key, "STRINGS");
-      if(stringsProp)
-        {
+    case cmState::STRING: {
+      const char* stringsProp =
+        cm->GetState()->GetCacheEntryProperty(key, "STRINGS");
+      if (stringsProp) {
         cmCursesOptionsWidget* ow =
           new cmCursesOptionsWidget(this->EntryWidth, 1, 1, 1);
         this->Entry = ow;
         std::vector<std::string> options;
         cmSystemTools::ExpandListArgument(stringsProp, options);
-        for(std::vector<std::string>::iterator
-              si = options.begin(); si != options.end(); ++si)
-          {
+        for (std::vector<std::string>::iterator si = options.begin();
+             si != options.end(); ++si) {
           ow->AddOption(*si);
-          }
-        ow->SetOption(value);
         }
-      else
-        {
+        ow->SetOption(value);
+      } else {
         this->Entry = new cmCursesStringWidget(this->EntryWidth, 1, 1, 1);
         static_cast<cmCursesStringWidget*>(this->Entry)->SetString(value);
-        }
-      break;
       }
+      break;
+    }
     case cmState::UNINITIALIZED:
-      cmSystemTools::Error("Found an undefined variable: ",
-                           key.c_str());
+      cmSystemTools::Error("Found an undefined variable: ", key.c_str());
       break;
     default:
       // TODO : put warning message here
       break;
-    }
-
+  }
 }
 
 cmCursesCacheEntryComposite::~cmCursesCacheEntryComposite()
@@ -120,12 +108,9 @@ cmCursesCacheEntryComposite::~cmCursesCacheEntryComposite()
 
 const char* cmCursesCacheEntryComposite::GetValue()
 {
-  if (this->Label)
-    {
+  if (this->Label) {
     return this->Label->GetValue();
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h
index f280897..8ed3902 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.h
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h
@@ -19,9 +19,8 @@ class cmCursesCacheEntryComposite
 public:
   cmCursesCacheEntryComposite(const std::string& key, int labelwidth,
                               int entrywidth);
-  cmCursesCacheEntryComposite(const std::string& key,
-                              cmake *cm,
-                              bool isNew, int labelwidth, int entrywidth);
+  cmCursesCacheEntryComposite(const std::string& key, cmake* cm, bool isNew,
+                              int labelwidth, int entrywidth);
   ~cmCursesCacheEntryComposite();
   const char* GetValue();
 
diff --git a/Source/CursesDialog/cmCursesDummyWidget.cxx b/Source/CursesDialog/cmCursesDummyWidget.cxx
index 9801e4d..3cd36af 100644
--- a/Source/CursesDialog/cmCursesDummyWidget.cxx
+++ b/Source/CursesDialog/cmCursesDummyWidget.cxx
@@ -11,16 +11,14 @@
 ============================================================================*/
 #include "cmCursesDummyWidget.h"
 
-cmCursesDummyWidget::cmCursesDummyWidget(int width, int height,
-                                           int left, int top) :
-  cmCursesWidget(width, height, left, top)
+cmCursesDummyWidget::cmCursesDummyWidget(int width, int height, int left,
+                                         int top)
+  : cmCursesWidget(width, height, left, top)
 {
   this->Type = cmState::INTERNAL;
 }
 
-
-bool cmCursesDummyWidget::HandleInput(int&, cmCursesMainForm*, WINDOW* )
+bool cmCursesDummyWidget::HandleInput(int&, cmCursesMainForm*, WINDOW*)
 {
   return false;
 }
-
diff --git a/Source/CursesDialog/cmCursesDummyWidget.h b/Source/CursesDialog/cmCursesDummyWidget.h
index 2b3b9b5..9a3df29 100644
--- a/Source/CursesDialog/cmCursesDummyWidget.h
+++ b/Source/CursesDialog/cmCursesDummyWidget.h
@@ -30,7 +30,6 @@ public:
 protected:
   cmCursesDummyWidget(const cmCursesDummyWidget& from);
   void operator=(const cmCursesDummyWidget&);
-
 };
 
 #endif // cmCursesDummyWidget_h
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.cxx b/Source/CursesDialog/cmCursesFilePathWidget.cxx
index 51ed670..28a74a9 100644
--- a/Source/CursesDialog/cmCursesFilePathWidget.cxx
+++ b/Source/CursesDialog/cmCursesFilePathWidget.cxx
@@ -11,10 +11,9 @@
 ============================================================================*/
 #include "cmCursesFilePathWidget.h"
 
-cmCursesFilePathWidget::cmCursesFilePathWidget(int width, int height,
-                                           int left, int top) :
-  cmCursesPathWidget(width, height, left, top)
+cmCursesFilePathWidget::cmCursesFilePathWidget(int width, int height, int left,
+                                               int top)
+  : cmCursesPathWidget(width, height, left, top)
 {
   this->Type = cmState::FILEPATH;
 }
-
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.h b/Source/CursesDialog/cmCursesFilePathWidget.h
index 6c50dd4..72adc77 100644
--- a/Source/CursesDialog/cmCursesFilePathWidget.h
+++ b/Source/CursesDialog/cmCursesFilePathWidget.h
@@ -22,7 +22,6 @@ public:
 protected:
   cmCursesFilePathWidget(const cmCursesFilePathWidget& from);
   void operator=(const cmCursesFilePathWidget&);
-
 };
 
 #endif // cmCursesFilePathWidget_h
diff --git a/Source/CursesDialog/cmCursesForm.cxx b/Source/CursesDialog/cmCursesForm.cxx
index d1b470c..aa4710f 100644
--- a/Source/CursesDialog/cmCursesForm.cxx
+++ b/Source/CursesDialog/cmCursesForm.cxx
@@ -21,12 +21,11 @@ cmCursesForm::cmCursesForm()
 
 cmCursesForm::~cmCursesForm()
 {
-  if (this->Form)
-    {
+  if (this->Form) {
     unpost_form(this->Form);
     free_form(this->Form);
     this->Form = 0;
-    }
+  }
 }
 
 void cmCursesForm::DebugStart()
@@ -37,10 +36,9 @@ void cmCursesForm::DebugStart()
 
 void cmCursesForm::DebugEnd()
 {
-  if (!cmCursesForm::Debug)
-    {
+  if (!cmCursesForm::Debug) {
     return;
-    }
+  }
 
   cmCursesForm::Debug = false;
   cmCursesForm::DebugFile.close();
@@ -48,10 +46,9 @@ void cmCursesForm::DebugEnd()
 
 void cmCursesForm::LogMessage(const char* msg)
 {
-  if (!cmCursesForm::Debug)
-    {
+  if (!cmCursesForm::Debug) {
     return;
-    }
+  }
 
   cmCursesForm::DebugFile << msg << std::endl;
 }
diff --git a/Source/CursesDialog/cmCursesForm.h b/Source/CursesDialog/cmCursesForm.h
index 2c45494..c0192fc 100644
--- a/Source/CursesDialog/cmCursesForm.h
+++ b/Source/CursesDialog/cmCursesForm.h
@@ -54,16 +54,11 @@ public:
 
   // Description:
   // Return the FORM. Should be only used by low-level methods.
-  FORM* GetForm()
-    {
-      return this->Form;
-    }
+  FORM* GetForm() { return this->Form; }
 
   static cmCursesForm* CurrentForm;
 
-
 protected:
-
   static cmsys::ofstream DebugFile;
   static bool Debug;
 
diff --git a/Source/CursesDialog/cmCursesLabelWidget.cxx b/Source/CursesDialog/cmCursesLabelWidget.cxx
index b50eb64..e9da71e 100644
--- a/Source/CursesDialog/cmCursesLabelWidget.cxx
+++ b/Source/CursesDialog/cmCursesLabelWidget.cxx
@@ -11,14 +11,13 @@
 ============================================================================*/
 #include "cmCursesLabelWidget.h"
 
-cmCursesLabelWidget::cmCursesLabelWidget(int width, int height,
-                                         int left, int top,
-                                         const std::string& name) :
-  cmCursesWidget(width, height, left, top)
+cmCursesLabelWidget::cmCursesLabelWidget(int width, int height, int left,
+                                         int top, const std::string& name)
+  : cmCursesWidget(width, height, left, top)
 {
-  field_opts_off(this->Field,  O_EDIT);
-  field_opts_off(this->Field,  O_ACTIVE);
-  field_opts_off(this->Field,  O_STATIC);
+  field_opts_off(this->Field, O_EDIT);
+  field_opts_off(this->Field, O_ACTIVE);
+  field_opts_off(this->Field, O_STATIC);
   this->SetValue(name);
 }
 
@@ -26,7 +25,7 @@ cmCursesLabelWidget::~cmCursesLabelWidget()
 {
 }
 
-bool cmCursesLabelWidget::HandleInput(int&, cmCursesMainForm*, WINDOW* )
+bool cmCursesLabelWidget::HandleInput(int&, cmCursesMainForm*, WINDOW*)
 {
   // Static text. No input is handled here.
   return false;
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.cxx b/Source/CursesDialog/cmCursesLongMessageForm.cxx
index 776d828..84672ae 100644
--- a/Source/CursesDialog/cmCursesLongMessageForm.cxx
+++ b/Source/CursesDialog/cmCursesLongMessageForm.cxx
@@ -18,21 +18,19 @@
 
 inline int ctrl(int z)
 {
-    return (z&037);
+  return (z & 037);
 }
 
-cmCursesLongMessageForm::cmCursesLongMessageForm(std::vector<std::string>
-                                                 const& messages, const char*
-                                                 title)
+cmCursesLongMessageForm::cmCursesLongMessageForm(
+  std::vector<std::string> const& messages, const char* title)
 {
   // Append all messages into on big string
   std::vector<std::string>::const_iterator it;
-  for(it=messages.begin(); it != messages.end(); it++)
-    {
+  for (it = messages.begin(); it != messages.end(); it++) {
     this->Messages += (*it);
     // Add one blank line after each message
     this->Messages += "\n\n";
-    }
+  }
   this->Title = title;
   this->Fields[0] = 0;
   this->Fields[1] = 0;
@@ -40,170 +38,145 @@ cmCursesLongMessageForm::cmCursesLongMessageForm(std::vector<std::string>
 
 cmCursesLongMessageForm::~cmCursesLongMessageForm()
 {
-  if (this->Fields[0])
-    {
+  if (this->Fields[0]) {
     free_field(this->Fields[0]);
-    }
+  }
 }
 
-
 void cmCursesLongMessageForm::UpdateStatusBar()
 {
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
 
   char bar[cmCursesMainForm::MAX_WIDTH];
   size_t size = strlen(this->Title.c_str());
-  if ( size >= cmCursesMainForm::MAX_WIDTH )
-    {
-    size = cmCursesMainForm::MAX_WIDTH-1;
-    }
+  if (size >= cmCursesMainForm::MAX_WIDTH) {
+    size = cmCursesMainForm::MAX_WIDTH - 1;
+  }
   strncpy(bar, this->Title.c_str(), size);
-  for(size_t i=size-1; i<cmCursesMainForm::MAX_WIDTH; i++) bar[i] = ' ';
+  for (size_t i = size - 1; i < cmCursesMainForm::MAX_WIDTH; i++)
+    bar[i] = ' ';
 
   int width;
-  if (x < cmCursesMainForm::MAX_WIDTH )
-    {
+  if (x < cmCursesMainForm::MAX_WIDTH) {
     width = x;
-    }
-  else
-    {
-    width = cmCursesMainForm::MAX_WIDTH-1;
-    }
+  } else {
+    width = cmCursesMainForm::MAX_WIDTH - 1;
+  }
 
   bar[width] = '\0';
 
   char version[cmCursesMainForm::MAX_WIDTH];
   char vertmp[128];
-  sprintf(vertmp,"CMake Version %s", cmVersion::GetCMakeVersion());
-  size_t sideSpace = (width-strlen(vertmp));
-  for(size_t i=0; i<sideSpace; i++) { version[i] = ' '; }
-  sprintf(version+sideSpace, "%s", vertmp);
+  sprintf(vertmp, "CMake Version %s", cmVersion::GetCMakeVersion());
+  size_t sideSpace = (width - strlen(vertmp));
+  for (size_t i = 0; i < sideSpace; i++) {
+    version[i] = ' ';
+  }
+  sprintf(version + sideSpace, "%s", vertmp);
   version[width] = '\0';
 
   char fmt_s[] = "%s";
-  curses_move(y-4,0);
+  curses_move(y - 4, 0);
   attron(A_STANDOUT);
   printw(fmt_s, bar);
   attroff(A_STANDOUT);
-  curses_move(y-3,0);
+  curses_move(y - 3, 0);
   printw(fmt_s, version);
   pos_form_cursor(this->Form);
 }
 
 void cmCursesLongMessageForm::PrintKeys()
 {
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
-  if ( x < cmCursesMainForm::MIN_WIDTH  ||
-       y < cmCursesMainForm::MIN_HEIGHT )
-    {
+  if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
     return;
-    }
+  }
   char firstLine[512];
-  sprintf(firstLine,  "Press [e] to exit help");
+  sprintf(firstLine, "Press [e] to exit help");
 
   char fmt_s[] = "%s";
-  curses_move(y-2,0);
+  curses_move(y - 2, 0);
   printw(fmt_s, firstLine);
   pos_form_cursor(this->Form);
-
 }
 
 void cmCursesLongMessageForm::Render(int, int, int, int)
 {
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
 
-  if (this->Form)
-    {
+  if (this->Form) {
     unpost_form(this->Form);
     free_form(this->Form);
     this->Form = 0;
-    }
+  }
 
   const char* msg = this->Messages.c_str();
 
   curses_clear();
 
-  if (this->Fields[0])
-    {
+  if (this->Fields[0]) {
     free_field(this->Fields[0]);
     this->Fields[0] = 0;
-    }
+  }
 
-  this->Fields[0] = new_field(y-6, x-2, 1, 1, 0, 0);
+  this->Fields[0] = new_field(y - 6, x - 2, 1, 1, 0, 0);
 
-  field_opts_off(this->Fields[0],  O_STATIC);
+  field_opts_off(this->Fields[0], O_STATIC);
 
   this->Form = new_form(this->Fields);
   post_form(this->Form);
 
-  int i=0;
+  int i = 0;
   form_driver(this->Form, REQ_BEG_FIELD);
-  while(msg[i] != '\0' && i < 60000)
-    {
-    if (msg[i] == '\n' && msg[i+1] != '\0')
-      {
+  while (msg[i] != '\0' && i < 60000) {
+    if (msg[i] == '\n' && msg[i + 1] != '\0') {
       form_driver(this->Form, REQ_NEW_LINE);
-      }
-    else
-      {
+    } else {
       form_driver(this->Form, msg[i]);
-      }
-    i++;
     }
+    i++;
+  }
   form_driver(this->Form, REQ_BEG_FIELD);
 
   this->UpdateStatusBar();
   this->PrintKeys();
   touchwin(stdscr);
   refresh();
-
 }
 
 void cmCursesLongMessageForm::HandleInput()
 {
-  if (!this->Form)
-    {
+  if (!this->Form) {
     return;
-    }
+  }
 
   char debugMessage[128];
 
-  for(;;)
-    {
+  for (;;) {
     int key = getch();
 
     sprintf(debugMessage, "Message widget handling input, key: %d", key);
     cmCursesForm::LogMessage(debugMessage);
 
     // quit
-    if ( key == 'o' || key == 'e' )
-      {
+    if (key == 'o' || key == 'e') {
       break;
-      }
-    else if ( key == KEY_DOWN || key == ctrl('n') )
-      {
+    } else if (key == KEY_DOWN || key == ctrl('n')) {
       form_driver(this->Form, REQ_SCR_FLINE);
-      }
-    else if ( key == KEY_UP  || key == ctrl('p') )
-      {
+    } else if (key == KEY_UP || key == ctrl('p')) {
       form_driver(this->Form, REQ_SCR_BLINE);
-      }
-    else if ( key == KEY_NPAGE || key == ctrl('d') )
-      {
+    } else if (key == KEY_NPAGE || key == ctrl('d')) {
       form_driver(this->Form, REQ_SCR_FPAGE);
-      }
-    else if ( key == KEY_PPAGE || key == ctrl('u') )
-      {
+    } else if (key == KEY_PPAGE || key == ctrl('u')) {
       form_driver(this->Form, REQ_SCR_BPAGE);
-      }
+    }
 
     this->UpdateStatusBar();
     this->PrintKeys();
     touchwin(stdscr);
     wrefresh(stdscr);
-    }
-
+  }
 }
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.h b/Source/CursesDialog/cmCursesLongMessageForm.h
index e9bd542..73ccfc4 100644
--- a/Source/CursesDialog/cmCursesLongMessageForm.h
+++ b/Source/CursesDialog/cmCursesLongMessageForm.h
@@ -52,7 +52,6 @@ protected:
   std::string Title;
 
   FIELD* Fields[2];
-
 };
 
 #endif // cmCursesLongMessageForm_h
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 2aafc8b..7368560 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -25,15 +25,15 @@
 #include "cmCursesStringWidget.h"
 #include "cmState.h"
 
-
 inline int ctrl(int z)
 {
-    return (z&037);
+  return (z & 037);
 }
 
 cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args,
-                                   int initWidth) :
-  Args(args), InitialWidth(initWidth)
+                                   int initWidth)
+  : Args(args)
+  , InitialWidth(initWidth)
 {
   this->NumberOfPages = 0;
   this->Fields = 0;
@@ -41,7 +41,8 @@ cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args,
   this->AdvancedMode = false;
   this->NumberOfVisibleEntries = 0;
   this->OkToGenerate = false;
-  this->HelpMessage.push_back("Welcome to ccmake, curses based user interface for CMake.");
+  this->HelpMessage.push_back(
+    "Welcome to ccmake, curses based user interface for CMake.");
   this->HelpMessage.push_back("");
   this->HelpMessage.push_back(s_ConstHelpMessage);
   this->CMakeInstance = new cmake;
@@ -60,43 +61,37 @@ cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args,
 
 cmCursesMainForm::~cmCursesMainForm()
 {
-  if (this->Form)
-    {
+  if (this->Form) {
     unpost_form(this->Form);
     free_form(this->Form);
     this->Form = 0;
-    }
+  }
   delete[] this->Fields;
 
   // Clean-up composites
-  if (this->Entries)
-    {
+  if (this->Entries) {
     cmDeleteAll(*this->Entries);
-    }
+  }
   delete this->Entries;
-  if (this->CMakeInstance)
-    {
+  if (this->CMakeInstance) {
     delete this->CMakeInstance;
     this->CMakeInstance = 0;
-    }
+  }
 }
 
 // See if a cache entry is in the list of entries in the ui.
 bool cmCursesMainForm::LookForCacheEntry(const std::string& key)
 {
-  if (!this->Entries)
-    {
+  if (!this->Entries) {
     return false;
-    }
+  }
 
   std::vector<cmCursesCacheEntryComposite*>::iterator it;
-  for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-    {
-    if (key == (*it)->Key)
-      {
+  for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
+    if (key == (*it)->Key) {
       return true;
-      }
     }
+  }
 
   return false;
 }
@@ -109,93 +104,74 @@ void cmCursesMainForm::InitializeUI()
   std::vector<cmCursesCacheEntryComposite*>* newEntries =
     new std::vector<cmCursesCacheEntryComposite*>;
   std::vector<std::string> cacheKeys =
-      this->CMakeInstance->GetState()->GetCacheEntryKeys();
+    this->CMakeInstance->GetState()->GetCacheEntryKeys();
   newEntries->reserve(cacheKeys.size());
 
   // Count non-internal and non-static entries
-  int count=0;
-
-  for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
-      it != cacheKeys.end(); ++it)
-    {
-    cmState::CacheEntryType t = this->CMakeInstance->GetState()
-        ->GetCacheEntryType(*it);
-    if (t != cmState::INTERNAL &&
-        t != cmState::STATIC &&
-        t != cmState::UNINITIALIZED)
-      {
+  int count = 0;
+
+  for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+       it != cacheKeys.end(); ++it) {
+    cmState::CacheEntryType t =
+      this->CMakeInstance->GetState()->GetCacheEntryType(*it);
+    if (t != cmState::INTERNAL && t != cmState::STATIC &&
+        t != cmState::UNINITIALIZED) {
       ++count;
-      }
     }
+  }
 
   int entrywidth = this->InitialWidth - 35;
 
   cmCursesCacheEntryComposite* comp;
-  if ( count == 0 )
-    {
+  if (count == 0) {
     // If cache is empty, display a label saying so and a
     // dummy entry widget (does not respond to input)
     comp = new cmCursesCacheEntryComposite("EMPTY CACHE", 30, 30);
     comp->Entry = new cmCursesDummyWidget(1, 1, 1, 1);
     newEntries->push_back(comp);
-    }
-  else
-    {
+  } else {
     // Create the composites.
 
     // First add entries which are new
-    for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
-        it != cacheKeys.end(); ++it)
-      {
+    for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+         it != cacheKeys.end(); ++it) {
       std::string key = *it;
-      cmState::CacheEntryType t = this->CMakeInstance->GetState()
-          ->GetCacheEntryType(*it);
-      if (t == cmState::INTERNAL ||
-          t == cmState::STATIC ||
-          t == cmState::UNINITIALIZED )
-        {
+      cmState::CacheEntryType t =
+        this->CMakeInstance->GetState()->GetCacheEntryType(*it);
+      if (t == cmState::INTERNAL || t == cmState::STATIC ||
+          t == cmState::UNINITIALIZED) {
         continue;
-        }
+      }
 
-      if (!this->LookForCacheEntry(key))
-        {
-        newEntries->push_back(new cmCursesCacheEntryComposite(key,
-                                                          this->CMakeInstance,
-                                                          true, 30,
-                                                          entrywidth));
+      if (!this->LookForCacheEntry(key)) {
+        newEntries->push_back(new cmCursesCacheEntryComposite(
+          key, this->CMakeInstance, true, 30, entrywidth));
         this->OkToGenerate = false;
-        }
       }
+    }
 
     // then add entries which are old
-    for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
-        it != cacheKeys.end(); ++it)
-      {
+    for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+         it != cacheKeys.end(); ++it) {
       std::string key = *it;
-      cmState::CacheEntryType t = this->CMakeInstance->GetState()
-          ->GetCacheEntryType(*it);
-      if (t == cmState::INTERNAL ||
-          t == cmState::STATIC ||
-          t == cmState::UNINITIALIZED )
-        {
+      cmState::CacheEntryType t =
+        this->CMakeInstance->GetState()->GetCacheEntryType(*it);
+      if (t == cmState::INTERNAL || t == cmState::STATIC ||
+          t == cmState::UNINITIALIZED) {
         continue;
-        }
+      }
 
-      if (this->LookForCacheEntry(key))
-        {
-        newEntries->push_back(new cmCursesCacheEntryComposite(key,
-                                                          this->CMakeInstance,
-                                                          false, 30,
-                                                          entrywidth));
-        }
+      if (this->LookForCacheEntry(key)) {
+        newEntries->push_back(new cmCursesCacheEntryComposite(
+          key, this->CMakeInstance, false, 30, entrywidth));
       }
     }
+  }
 
   // Clean old entries
-  if (this->Entries)
-    {
+  if (this->Entries) {
     cmDeleteAll(*this->Entries);
-    }
+  }
   delete this->Entries;
   this->Entries = newEntries;
 
@@ -203,180 +179,150 @@ void cmCursesMainForm::InitializeUI()
   this->RePost();
 }
 
-
 void cmCursesMainForm::RePost()
 {
   // Create the fields to be passed to the form.
-  if (this->Form)
-    {
+  if (this->Form) {
     unpost_form(this->Form);
     free_form(this->Form);
     this->Form = 0;
-    }
+  }
   delete[] this->Fields;
-  if (this->AdvancedMode)
-    {
+  if (this->AdvancedMode) {
     this->NumberOfVisibleEntries = this->Entries->size();
-    }
-  else
-    {
+  } else {
     // If normal mode, count only non-advanced entries
     this->NumberOfVisibleEntries = 0;
     std::vector<cmCursesCacheEntryComposite*>::iterator it;
-    for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-      {
+    for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
       const char* existingValue =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryValue((*it)->GetValue());
+        this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
       bool advanced =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
-      if (!existingValue || (!this->AdvancedMode && advanced))
-        {
+        this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+          (*it)->GetValue(), "ADVANCED");
+      if (!existingValue || (!this->AdvancedMode && advanced)) {
         continue;
-        }
-      this->NumberOfVisibleEntries++;
       }
+      this->NumberOfVisibleEntries++;
     }
+  }
   // there is always one even if it is the dummy one
-  if(this->NumberOfVisibleEntries == 0)
-    {
+  if (this->NumberOfVisibleEntries == 0) {
     this->NumberOfVisibleEntries = 1;
-    }
+  }
   // Assign the fields: 3 for each entry: label, new entry marker
   // ('*' or ' ') and entry widget
-  this->Fields = new FIELD*[3*this->NumberOfVisibleEntries+1];
+  this->Fields = new FIELD*[3 * this->NumberOfVisibleEntries + 1];
   size_t cc;
-  for ( cc = 0; cc < 3 * this->NumberOfVisibleEntries+1; cc ++ )
-    {
+  for (cc = 0; cc < 3 * this->NumberOfVisibleEntries + 1; cc++) {
     this->Fields[cc] = 0;
-    }
+  }
 
   // Assign fields
-  int j=0;
+  int j = 0;
   std::vector<cmCursesCacheEntryComposite*>::iterator it;
-  for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-    {
+  for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
     const char* existingValue =
-        this->CMakeInstance->GetState()
-            ->GetCacheEntryValue((*it)->GetValue());
+      this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
     bool advanced =
-        this->CMakeInstance->GetState()
-            ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
-    if (!existingValue || (!this->AdvancedMode && advanced))
-      {
+      this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+        (*it)->GetValue(), "ADVANCED");
+    if (!existingValue || (!this->AdvancedMode && advanced)) {
       continue;
-      }
-    this->Fields[3*j]    = (*it)->Label->Field;
-    this->Fields[3*j+1]  = (*it)->IsNewLabel->Field;
-    this->Fields[3*j+2]  = (*it)->Entry->Field;
-    j++;
     }
+    this->Fields[3 * j] = (*it)->Label->Field;
+    this->Fields[3 * j + 1] = (*it)->IsNewLabel->Field;
+    this->Fields[3 * j + 2] = (*it)->Entry->Field;
+    j++;
+  }
   // if no cache entries there should still be one dummy field
-  if(j == 0)
-    {
+  if (j == 0) {
     it = this->Entries->begin();
-    this->Fields[0]    = (*it)->Label->Field;
-    this->Fields[1]  = (*it)->IsNewLabel->Field;
-    this->Fields[2]  = (*it)->Entry->Field;
+    this->Fields[0] = (*it)->Label->Field;
+    this->Fields[1] = (*it)->IsNewLabel->Field;
+    this->Fields[2] = (*it)->Entry->Field;
     this->NumberOfVisibleEntries = 1;
-    }
+  }
   // Has to be null terminated.
-  this->Fields[3*this->NumberOfVisibleEntries] = 0;
+  this->Fields[3 * this->NumberOfVisibleEntries] = 0;
 }
 
 void cmCursesMainForm::Render(int left, int top, int width, int height)
 {
 
-  if (this->Form)
-    {
+  if (this->Form) {
     FIELD* currentField = current_field(this->Form);
-    cmCursesWidget* cw = reinterpret_cast<cmCursesWidget*>
-      (field_userptr(currentField));
+    cmCursesWidget* cw =
+      reinterpret_cast<cmCursesWidget*>(field_userptr(currentField));
     // If in edit mode, get out of it
-    if ( cw->GetType() == cmState::STRING ||
-         cw->GetType() == cmState::PATH   ||
-         cw->GetType() == cmState::FILEPATH )
-      {
+    if (cw->GetType() == cmState::STRING || cw->GetType() == cmState::PATH ||
+        cw->GetType() == cmState::FILEPATH) {
       cmCursesStringWidget* sw = static_cast<cmCursesStringWidget*>(cw);
       sw->SetInEdit(false);
-      }
+    }
     // Delete the previous form
     unpost_form(this->Form);
     free_form(this->Form);
     this->Form = 0;
-    }
+  }
 
   // Wrong window size
-  if ( width < cmCursesMainForm::MIN_WIDTH  ||
-       width < this->InitialWidth               ||
-       height < cmCursesMainForm::MIN_HEIGHT )
-    {
+  if (width < cmCursesMainForm::MIN_WIDTH || width < this->InitialWidth ||
+      height < cmCursesMainForm::MIN_HEIGHT) {
     return;
-    }
+  }
 
   // Leave room for toolbar
   height -= 7;
 
-  if (this->AdvancedMode)
-    {
+  if (this->AdvancedMode) {
     this->NumberOfVisibleEntries = this->Entries->size();
-    }
-  else
-    {
+  } else {
     // If normal, display only non-advanced entries
     this->NumberOfVisibleEntries = 0;
     std::vector<cmCursesCacheEntryComposite*>::iterator it;
-    for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-      {
+    for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
       const char* existingValue =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryValue((*it)->GetValue());
+        this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
       bool advanced =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
-      if (!existingValue || (!this->AdvancedMode && advanced))
-        {
+        this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+          (*it)->GetValue(), "ADVANCED");
+      if (!existingValue || (!this->AdvancedMode && advanced)) {
         continue;
-        }
-      this->NumberOfVisibleEntries++;
       }
+      this->NumberOfVisibleEntries++;
     }
+  }
 
   // Re-adjust the fields according to their place
   this->NumberOfPages = 1;
-  if (height > 0)
-    {
+  if (height > 0) {
     bool isNewPage;
-    int i=0;
+    int i = 0;
     std::vector<cmCursesCacheEntryComposite*>::iterator it;
-    for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-      {
+    for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
       const char* existingValue =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryValue((*it)->GetValue());
+        this->CMakeInstance->GetState()->GetCacheEntryValue((*it)->GetValue());
       bool advanced =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
-      if (!existingValue || (!this->AdvancedMode && advanced))
-        {
+        this->CMakeInstance->GetState()->GetCacheEntryPropertyAsBool(
+          (*it)->GetValue(), "ADVANCED");
+      if (!existingValue || (!this->AdvancedMode && advanced)) {
         continue;
-        }
+      }
       int row = (i % height) + 1;
       int page = (i / height) + 1;
-      isNewPage = ( page > 1 ) && ( row == 1 );
+      isNewPage = (page > 1) && (row == 1);
 
-      if (isNewPage)
-        {
+      if (isNewPage) {
         this->NumberOfPages++;
-        }
-      (*it)->Label->Move(left, top+row-1, isNewPage);
-      (*it)->IsNewLabel->Move(left+32, top+row-1, false);
-      (*it)->Entry->Move(left+33, top+row-1, false);
+      }
+      (*it)->Label->Move(left, top + row - 1, isNewPage);
+      (*it)->IsNewLabel->Move(left + 32, top + row - 1, false);
+      (*it)->Entry->Move(left + 33, top + row - 1, false);
       (*it)->Entry->SetPage(this->NumberOfPages);
       i++;
-      }
     }
+  }
 
   // Post the form
   this->Form = new_form(this->Fields);
@@ -391,153 +337,130 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
 
 void cmCursesMainForm::PrintKeys(int process /* = 0 */)
 {
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
-  if ( x < cmCursesMainForm::MIN_WIDTH  ||
-       x < this->InitialWidth               ||
-       y < cmCursesMainForm::MIN_HEIGHT )
-    {
+  if (x < cmCursesMainForm::MIN_WIDTH || x < this->InitialWidth ||
+      y < cmCursesMainForm::MIN_HEIGHT) {
     return;
-    }
+  }
 
   // Give the current widget (if it exists), a chance to print keys
   cmCursesWidget* cw = 0;
-  if (this->Form)
-    {
+  if (this->Form) {
     FIELD* currentField = current_field(this->Form);
     cw = reinterpret_cast<cmCursesWidget*>(field_userptr(currentField));
-    }
+  }
 
-  if (cw)
-    {
+  if (cw) {
     cw->PrintKeys();
-    }
-
-//    {
-//    }
-//  else
-//    {
-  char firstLine[512]="";
-  char secondLine[512]="";
-  char thirdLine[512]="";
-  if (process)
-    {
+  }
+
+  //    {
+  //    }
+  //  else
+  //    {
+  char firstLine[512] = "";
+  char secondLine[512] = "";
+  char thirdLine[512] = "";
+  if (process) {
     const char* clearLine =
       "                                                                    ";
     strcpy(firstLine, clearLine);
     strcpy(secondLine, clearLine);
     strcpy(thirdLine, clearLine);
-    }
-  else
-    {
-    if (this->OkToGenerate)
-      {
+  } else {
+    if (this->OkToGenerate) {
       sprintf(firstLine,
               "Press [c] to configure       Press [g] to generate and exit");
-      }
-    else
-      {
-      sprintf(firstLine,  "Press [c] to configure                                   ");
-      }
+    } else {
+      sprintf(firstLine,
+              "Press [c] to configure                                   ");
+    }
     {
       const char* toggleKeyInstruction =
         "Press [t] to toggle advanced mode (Currently %s)";
-      sprintf(thirdLine,
-              toggleKeyInstruction,
+      sprintf(thirdLine, toggleKeyInstruction,
               this->AdvancedMode ? "On" : "Off");
     }
-    sprintf(secondLine,
-            "Press [h] for help           "
-            "Press [q] to quit without generating");
-    }
+    sprintf(secondLine, "Press [h] for help           "
+                        "Press [q] to quit without generating");
+  }
 
-  curses_move(y-4,0);
+  curses_move(y - 4, 0);
   char fmt_s[] = "%s";
   char fmt[512] = "Press [enter] to edit option";
-  if ( process )
-    {
+  if (process) {
     strcpy(fmt, "                           ");
-    }
+  }
   printw(fmt_s, fmt);
-  curses_move(y-3,0);
+  curses_move(y - 3, 0);
   printw(fmt_s, firstLine);
-  curses_move(y-2,0);
+  curses_move(y - 2, 0);
   printw(fmt_s, secondLine);
-  curses_move(y-1,0);
+  curses_move(y - 1, 0);
   printw(fmt_s, thirdLine);
 
-  if (cw)
-    {
+  if (cw) {
     sprintf(firstLine, "Page %d of %d", cw->GetPage(), this->NumberOfPages);
-    curses_move(0,65-static_cast<unsigned int>(strlen(firstLine))-1);
+    curses_move(0, 65 - static_cast<unsigned int>(strlen(firstLine)) - 1);
     printw(fmt_s, firstLine);
-    }
-//    }
+  }
+  //    }
 
   pos_form_cursor(this->Form);
-
 }
 
 // Print the key of the current entry and the CMake version
 // on the status bar. Designed for a width of 80 chars.
 void cmCursesMainForm::UpdateStatusBar(const char* message)
 {
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
   // If window size is too small, display error and return
-  if ( x < cmCursesMainForm::MIN_WIDTH  ||
-       x < this->InitialWidth               ||
-       y < cmCursesMainForm::MIN_HEIGHT )
-    {
+  if (x < cmCursesMainForm::MIN_WIDTH || x < this->InitialWidth ||
+      y < cmCursesMainForm::MIN_HEIGHT) {
     curses_clear();
-    curses_move(0,0);
+    curses_move(0, 0);
     char fmt[] = "Window is too small. A size of at least %dx%d is required.";
-    printw(fmt,
-           (cmCursesMainForm::MIN_WIDTH < this->InitialWidth ?
-            this->InitialWidth : cmCursesMainForm::MIN_WIDTH),
+    printw(fmt, (cmCursesMainForm::MIN_WIDTH < this->InitialWidth
+                   ? this->InitialWidth
+                   : cmCursesMainForm::MIN_WIDTH),
            cmCursesMainForm::MIN_HEIGHT);
     touchwin(stdscr);
     wrefresh(stdscr);
     return;
-    }
+  }
 
   // Get the key of the current entry
   FIELD* cur = current_field(this->Form);
   int findex = field_index(cur);
   cmCursesWidget* lbl = 0;
-  if ( findex >= 0 )
-    {
-    lbl = reinterpret_cast<cmCursesWidget*>(field_userptr(this->Fields[findex-2]));
-    }
+  if (findex >= 0) {
+    lbl = reinterpret_cast<cmCursesWidget*>(
+      field_userptr(this->Fields[findex - 2]));
+  }
   char help[128] = "";
   const char* curField = "";
-  if ( lbl )
-    {
+  if (lbl) {
     curField = lbl->GetValue();
 
     // Get the help string of the current entry
     // and add it to the help string
     const char* existingValue =
-        this->CMakeInstance->GetState()->GetCacheEntryValue(curField);
-    if (existingValue)
-      {
-      const char* hs = this->CMakeInstance->GetState()
-                           ->GetCacheEntryProperty(curField, "HELPSTRING");
-      if ( hs )
-        {
+      this->CMakeInstance->GetState()->GetCacheEntryValue(curField);
+    if (existingValue) {
+      const char* hs = this->CMakeInstance->GetState()->GetCacheEntryProperty(
+        curField, "HELPSTRING");
+      if (hs) {
         strncpy(help, hs, 127);
         help[127] = '\0';
-        }
-      else
-        {
+      } else {
         help[0] = 0;
-        }
-      }
-    else
-      {
-      sprintf(help," ");
       }
+    } else {
+      sprintf(help, " ");
     }
+  }
 
   // Join the key, help string and pad with spaces
   // (or truncate) as necessary
@@ -546,119 +469,98 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
   size_t helpLen = strlen(help);
 
   size_t width;
-  if (x < cmCursesMainForm::MAX_WIDTH )
-    {
+  if (x < cmCursesMainForm::MAX_WIDTH) {
     width = x;
-    }
-  else
-    {
+  } else {
     width = cmCursesMainForm::MAX_WIDTH;
-    }
+  }
 
-  if ( message )
-    {
+  if (message) {
     curField = message;
     curFieldLen = strlen(message);
-    if ( curFieldLen < width )
-      {
+    if (curFieldLen < width) {
       strcpy(bar, curField);
-      for(i=curFieldLen; i < width; ++i)
-        {
+      for (i = curFieldLen; i < width; ++i) {
         bar[i] = ' ';
-        }
       }
-    else
-      {
+    } else {
       strncpy(bar, curField, width);
-      }
-   }
-  else
-    {
-    if (curFieldLen >= width)
-      {
+    }
+  } else {
+    if (curFieldLen >= width) {
       strncpy(bar, curField, width);
-      }
-    else
-      {
+    } else {
       strcpy(bar, curField);
       bar[curFieldLen] = ':';
-      bar[curFieldLen+1] = ' ';
-      if (curFieldLen + helpLen + 2 >= width)
-        {
-        strncpy(bar+curFieldLen+2, help, width
-                - curFieldLen - 2);
-        }
-      else
-        {
-        strcpy(bar+curFieldLen+2, help);
-        for(i=curFieldLen+helpLen+2; i < width; ++i)
-          {
+      bar[curFieldLen + 1] = ' ';
+      if (curFieldLen + helpLen + 2 >= width) {
+        strncpy(bar + curFieldLen + 2, help, width - curFieldLen - 2);
+      } else {
+        strcpy(bar + curFieldLen + 2, help);
+        for (i = curFieldLen + helpLen + 2; i < width; ++i) {
           bar[i] = ' ';
-          }
         }
       }
     }
-
+  }
 
   bar[width] = '\0';
 
-
   // Display CMake version info on the next line
   // We want to display this on the right
   char version[cmCursesMainForm::MAX_WIDTH];
   char vertmp[128];
-  sprintf(vertmp,"CMake Version %s", cmVersion::GetCMakeVersion());
-  size_t sideSpace = (width-strlen(vertmp));
-  for(i=0; i<sideSpace; i++) { version[i] = ' '; }
-  sprintf(version+sideSpace, "%s", vertmp);
+  sprintf(vertmp, "CMake Version %s", cmVersion::GetCMakeVersion());
+  size_t sideSpace = (width - strlen(vertmp));
+  for (i = 0; i < sideSpace; i++) {
+    version[i] = ' ';
+  }
+  sprintf(version + sideSpace, "%s", vertmp);
   version[width] = '\0';
 
   // Now print both lines
   char fmt_s[] = "%s";
-  curses_move(y-5,0);
+  curses_move(y - 5, 0);
   attron(A_STANDOUT);
   printw(fmt_s, bar);
   attroff(A_STANDOUT);
-  curses_move(y-4,0);
+  curses_move(y - 4, 0);
   printw(fmt_s, version);
   pos_form_cursor(this->Form);
 }
 
-void cmCursesMainForm::UpdateProgress(const char *msg, float prog, void* vp)
+void cmCursesMainForm::UpdateProgress(const char* msg, float prog, void* vp)
 {
   cmCursesMainForm* cm = static_cast<cmCursesMainForm*>(vp);
-  if ( !cm )
-    {
+  if (!cm) {
     return;
-    }
+  }
   char tmp[1024];
-  const char *cmsg = tmp;
-  if ( prog >= 0 )
-    {
-    sprintf(tmp, "%s %i%%",msg,(int)(100*prog));
-    }
-  else
-    {
+  const char* cmsg = tmp;
+  if (prog >= 0) {
+    sprintf(tmp, "%s %i%%", msg, (int)(100 * prog));
+  } else {
     cmsg = msg;
-    }
+  }
   cm->UpdateStatusBar(cmsg);
   cm->PrintKeys(1);
-  curses_move(1,1);
+  curses_move(1, 1);
   touchwin(stdscr);
   refresh();
 }
 
 int cmCursesMainForm::Configure(int noconfigure)
 {
-  int xi,yi;
+  int xi, yi;
   getmaxyx(stdscr, yi, xi);
 
-  curses_move(1,1);
+  curses_move(1, 1);
   this->UpdateStatusBar("Configuring, please wait...");
   this->PrintKeys(1);
   touchwin(stdscr);
   refresh();
-  this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress, this);
+  this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress,
+                                           this);
 
   // always save the current gui values to disk
   this->FillCacheManagerFromUI();
@@ -672,52 +574,44 @@ int cmCursesMainForm::Configure(int noconfigure)
   // run the generate process
   this->OkToGenerate = true;
   int retVal;
-  if ( noconfigure )
-    {
+  if (noconfigure) {
     retVal = this->CMakeInstance->DoPreConfigureChecks();
     this->OkToGenerate = false;
-    if ( retVal > 0 )
-      {
+    if (retVal > 0) {
       retVal = 0;
-      }
     }
-  else
-    {
+  } else {
     retVal = this->CMakeInstance->Configure();
-    }
+  }
   this->CMakeInstance->SetProgressCallback(0, 0);
 
-  keypad(stdscr,TRUE); /* Use key symbols as
-                          KEY_DOWN*/
+  keypad(stdscr, TRUE); /* Use key symbols as
+                           KEY_DOWN*/
 
-  if( retVal != 0 || !this->Errors.empty())
-    {
+  if (retVal != 0 || !this->Errors.empty()) {
     // see if there was an error
-    if(cmSystemTools::GetErrorOccuredFlag())
-      {
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       this->OkToGenerate = false;
-      }
-    int xx,yy;
+    }
+    int xx, yy;
     getmaxyx(stdscr, yy, xx);
     cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(
-      this->Errors,
-      cmSystemTools::GetErrorOccuredFlag()
-      ? "Errors occurred during the last pass." :
-      "CMake produced the following output.");
+      this->Errors, cmSystemTools::GetErrorOccuredFlag()
+        ? "Errors occurred during the last pass."
+        : "CMake produced the following output.");
     // reset error condition
     cmSystemTools::ResetErrorOccuredFlag();
     CurrentForm = msgs;
-    msgs->Render(1,1,xx,yy);
+    msgs->Render(1, 1, xx, yy);
     msgs->HandleInput();
     // If they typed the wrong source directory, we report
     // an error and exit
-    if ( retVal == -2 )
-      {
+    if (retVal == -2) {
       return retVal;
-      }
-    CurrentForm = this;
-    this->Render(1,1,xx,yy);
     }
+    CurrentForm = this;
+    this->Render(1, 1, xx, yy);
+  }
 
   this->InitializeUI();
   this->Render(1, 1, xi, yi);
@@ -727,15 +621,16 @@ int cmCursesMainForm::Configure(int noconfigure)
 
 int cmCursesMainForm::Generate()
 {
-  int xi,yi;
+  int xi, yi;
   getmaxyx(stdscr, yi, xi);
 
-  curses_move(1,1);
+  curses_move(1, 1);
   this->UpdateStatusBar("Generating, please wait...");
   this->PrintKeys(1);
   touchwin(stdscr);
   refresh();
-  this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress, this);
+  this->CMakeInstance->SetProgressCallback(cmCursesMainForm::UpdateProgress,
+                                           this);
 
   // Get rid of previous errors
   this->Errors = std::vector<std::string>();
@@ -744,39 +639,35 @@ int cmCursesMainForm::Generate()
   int retVal = this->CMakeInstance->Generate();
 
   this->CMakeInstance->SetProgressCallback(0, 0);
-  keypad(stdscr,TRUE); /* Use key symbols as
-                          KEY_DOWN*/
+  keypad(stdscr, TRUE); /* Use key symbols as
+                           KEY_DOWN*/
 
-  if( retVal != 0 || !this->Errors.empty())
-    {
+  if (retVal != 0 || !this->Errors.empty()) {
     // see if there was an error
-    if(cmSystemTools::GetErrorOccuredFlag())
-      {
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       this->OkToGenerate = false;
-      }
+    }
     // reset error condition
     cmSystemTools::ResetErrorOccuredFlag();
-    int xx,yy;
+    int xx, yy;
     getmaxyx(stdscr, yy, xx);
     const char* title = "Messages during last pass.";
-    if(cmSystemTools::GetErrorOccuredFlag())
-      {
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       title = "Errors occurred during the last pass.";
-      }
-    cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(this->Errors,
-                                                                title);
+    }
+    cmCursesLongMessageForm* msgs =
+      new cmCursesLongMessageForm(this->Errors, title);
     CurrentForm = msgs;
-    msgs->Render(1,1,xx,yy);
+    msgs->Render(1, 1, xx, yy);
     msgs->HandleInput();
     // If they typed the wrong source directory, we report
     // an error and exit
-    if ( retVal == -2 )
-      {
+    if (retVal == -2) {
       return retVal;
-      }
-    CurrentForm = this;
-    this->Render(1,1,xx,yy);
     }
+    CurrentForm = this;
+    this->Render(1, 1, xx, yy);
+  }
 
   this->InitializeUI();
   this->Render(1, 1, xi, yi);
@@ -791,346 +682,286 @@ void cmCursesMainForm::AddError(const char* message, const char*)
 
 void cmCursesMainForm::RemoveEntry(const char* value)
 {
-  if (!value)
-    {
+  if (!value) {
     return;
-    }
+  }
 
   std::vector<cmCursesCacheEntryComposite*>::iterator it;
-  for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-    {
+  for (it = this->Entries->begin(); it != this->Entries->end(); ++it) {
     const char* val = (*it)->GetValue();
-    if (  val && !strcmp(value, val) )
-      {
+    if (val && !strcmp(value, val)) {
       this->CMakeInstance->UnwatchUnusedCli(value);
       this->Entries->erase(it);
       break;
-      }
     }
+  }
 }
 
 // copy from the list box to the cache manager
 void cmCursesMainForm::FillCacheManagerFromUI()
 {
   size_t size = this->Entries->size();
-  for(size_t i=0; i < size; i++)
-    {
+  for (size_t i = 0; i < size; i++) {
     std::string cacheKey = (*this->Entries)[i]->Key;
-      const char* existingValue = this->CMakeInstance->GetState()
-        ->GetCacheEntryValue(cacheKey);
-    if (existingValue)
-      {
+    const char* existingValue =
+      this->CMakeInstance->GetState()->GetCacheEntryValue(cacheKey);
+    if (existingValue) {
       std::string oldValue = existingValue;
       std::string newValue = (*this->Entries)[i]->Entry->GetValue();
       std::string fixedOldValue;
       std::string fixedNewValue;
       cmState::CacheEntryType t =
-          this->CMakeInstance->GetState()
-              ->GetCacheEntryType(cacheKey);
+        this->CMakeInstance->GetState()->GetCacheEntryType(cacheKey);
       this->FixValue(t, oldValue, fixedOldValue);
       this->FixValue(t, newValue, fixedNewValue);
 
-      if(!(fixedOldValue == fixedNewValue))
-        {
+      if (!(fixedOldValue == fixedNewValue)) {
         // The user has changed the value.  Mark it as modified.
-        this->CMakeInstance->GetState()
-            ->SetCacheEntryBoolProperty(cacheKey, "MODIFIED", true);
-        this->CMakeInstance->GetState()
-            ->SetCacheEntryValue(cacheKey, fixedNewValue);
-        }
+        this->CMakeInstance->GetState()->SetCacheEntryBoolProperty(
+          cacheKey, "MODIFIED", true);
+        this->CMakeInstance->GetState()->SetCacheEntryValue(cacheKey,
+                                                            fixedNewValue);
       }
     }
+  }
 }
 
 void cmCursesMainForm::FixValue(cmState::CacheEntryType type,
                                 const std::string& in, std::string& out) const
 {
-  out = in.substr(0,in.find_last_not_of(" ")+1);
-  if(type == cmState::PATH || type == cmState::FILEPATH)
-    {
+  out = in.substr(0, in.find_last_not_of(" ") + 1);
+  if (type == cmState::PATH || type == cmState::FILEPATH) {
     cmSystemTools::ConvertToUnixSlashes(out);
-    }
-  if(type == cmState::BOOL)
-    {
-    if(cmSystemTools::IsOff(out.c_str()))
-      {
+  }
+  if (type == cmState::BOOL) {
+    if (cmSystemTools::IsOff(out.c_str())) {
       out = "OFF";
-      }
-    else
-      {
+    } else {
       out = "ON";
-      }
     }
+  }
 }
 
 #include <unistd.h>
 
 void cmCursesMainForm::HandleInput()
 {
-  int x=0,y=0;
+  int x = 0, y = 0;
 
-  if (!this->Form)
-    {
+  if (!this->Form) {
     return;
-    }
+  }
 
   FIELD* currentField;
   cmCursesWidget* currentWidget;
 
   char debugMessage[128];
 
-  for(;;)
-    {
+  for (;;) {
     this->UpdateStatusBar();
     this->PrintKeys();
-    if ( this->SearchMode )
-      {
+    if (this->SearchMode) {
       std::string searchstr = "Search: " + this->SearchString;
-      this->UpdateStatusBar( searchstr.c_str() );
+      this->UpdateStatusBar(searchstr.c_str());
       this->PrintKeys(1);
-      curses_move(y-5,static_cast<unsigned int>(searchstr.size()));
-      //curses_move(1,1);
+      curses_move(y - 5, static_cast<unsigned int>(searchstr.size()));
+      // curses_move(1,1);
       touchwin(stdscr);
       refresh();
-      }
+    }
     int key = getch();
 
     getmaxyx(stdscr, y, x);
     // If window too small, handle 'q' only
-    if ( x < cmCursesMainForm::MIN_WIDTH  ||
-         y < cmCursesMainForm::MIN_HEIGHT )
-      {
+    if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
       // quit
-      if ( key == 'q' )
-        {
+      if (key == 'q') {
         break;
-        }
-      else
-        {
+      } else {
         continue;
-        }
       }
+    }
 
     currentField = current_field(this->Form);
-    currentWidget = reinterpret_cast<cmCursesWidget*>(field_userptr(
-      currentField));
+    currentWidget =
+      reinterpret_cast<cmCursesWidget*>(field_userptr(currentField));
 
-    bool widgetHandled=false;
+    bool widgetHandled = false;
 
-    if ( this->SearchMode )
-      {
-      if ( key == 10 || key == KEY_ENTER )
-        {
+    if (this->SearchMode) {
+      if (key == 10 || key == KEY_ENTER) {
         this->SearchMode = false;
-        if (!this->SearchString.empty())
-          {
+        if (!this->SearchString.empty()) {
           this->JumpToCacheEntry(this->SearchString.c_str());
           this->OldSearchString = this->SearchString;
-          }
-        this->SearchString = "";
         }
+        this->SearchString = "";
+      }
       /*
       else if ( key == KEY_ESCAPE )
         {
         this->SearchMode = false;
         }
       */
-      else if ((key >= 'a' && key <= 'z') ||
-               (key >= 'A' && key <= 'Z') ||
-               (key >= '0' && key <= '9') ||
-               (key == '_' ))
-        {
-        if ( this->SearchString.size() < static_cast<std::string::size_type>(x-10) )
-          {
+      else if ((key >= 'a' && key <= 'z') || (key >= 'A' && key <= 'Z') ||
+               (key >= '0' && key <= '9') || (key == '_')) {
+        if (this->SearchString.size() <
+            static_cast<std::string::size_type>(x - 10)) {
           this->SearchString += static_cast<char>(key);
-          }
         }
-      else if ( key == ctrl('h') || key == KEY_BACKSPACE || key == KEY_DC )
-        {
-        if (!this->SearchString.empty())
-          {
-          this->SearchString.resize(this->SearchString.size()-1);
-          }
+      } else if (key == ctrl('h') || key == KEY_BACKSPACE || key == KEY_DC) {
+        if (!this->SearchString.empty()) {
+          this->SearchString.resize(this->SearchString.size() - 1);
         }
       }
-    else if (currentWidget && !this->SearchMode)
-      {
+    } else if (currentWidget && !this->SearchMode) {
       // Ask the current widget if it wants to handle input
       widgetHandled = currentWidget->HandleInput(key, this, stdscr);
-      if (widgetHandled)
-        {
+      if (widgetHandled) {
         this->OkToGenerate = false;
         this->UpdateStatusBar();
         this->PrintKeys();
-        }
       }
-    if ((!currentWidget || !widgetHandled) && !this->SearchMode)
-      {
+    }
+    if ((!currentWidget || !widgetHandled) && !this->SearchMode) {
       // If the current widget does not want to handle input,
       // we handle it.
       sprintf(debugMessage, "Main form handling input, key: %d", key);
       cmCursesForm::LogMessage(debugMessage);
       // quit
-      if ( key == 'q' )
-        {
+      if (key == 'q') {
         break;
-        }
+      }
       // if not end of page, next field otherwise next page
       // each entry consists of fields: label, isnew, value
       // therefore, the label field for the prev. entry is index-5
       // and the label field for the next entry is index+1
       // (index always corresponds to the value field)
-      else if ( key == KEY_DOWN || key == ctrl('n') )
-        {
+      else if (key == KEY_DOWN || key == ctrl('n')) {
         FIELD* cur = current_field(this->Form);
         size_t findex = field_index(cur);
-        if ( findex == 3*this->NumberOfVisibleEntries-1 )
-          {
+        if (findex == 3 * this->NumberOfVisibleEntries - 1) {
           continue;
-          }
-        if (new_page(this->Fields[findex+1]))
-          {
+        }
+        if (new_page(this->Fields[findex + 1])) {
           form_driver(this->Form, REQ_NEXT_PAGE);
-          }
-        else
-          {
+        } else {
           form_driver(this->Form, REQ_NEXT_FIELD);
-          }
         }
+      }
       // if not beginning of page, previous field, otherwise previous page
       // each entry consists of fields: label, isnew, value
       // therefore, the label field for the prev. entry is index-5
       // and the label field for the next entry is index+1
       // (index always corresponds to the value field)
-      else if ( key == KEY_UP || key == ctrl('p') )
-        {
+      else if (key == KEY_UP || key == ctrl('p')) {
         FIELD* cur = current_field(this->Form);
         int findex = field_index(cur);
-        if ( findex == 2 )
-          {
+        if (findex == 2) {
           continue;
-          }
-        if ( new_page(this->Fields[findex-2]) )
-          {
+        }
+        if (new_page(this->Fields[findex - 2])) {
           form_driver(this->Form, REQ_PREV_PAGE);
-          set_current_field(this->Form, this->Fields[findex-3]);
-          }
-        else
-          {
+          set_current_field(this->Form, this->Fields[findex - 3]);
+        } else {
           form_driver(this->Form, REQ_PREV_FIELD);
-          }
         }
+      }
       // pg down
-      else if ( key == KEY_NPAGE || key == ctrl('d') )
-        {
+      else if (key == KEY_NPAGE || key == ctrl('d')) {
         form_driver(this->Form, REQ_NEXT_PAGE);
-        }
+      }
       // pg up
-      else if ( key == KEY_PPAGE || key == ctrl('u') )
-        {
+      else if (key == KEY_PPAGE || key == ctrl('u')) {
         form_driver(this->Form, REQ_PREV_PAGE);
-        }
+      }
       // configure
-      else if ( key == 'c' )
-        {
+      else if (key == 'c') {
         this->Configure();
-        }
+      }
       // display help
-      else if ( key == 'h' )
-        {
+      else if (key == 'h') {
         getmaxyx(stdscr, y, x);
 
         FIELD* cur = current_field(this->Form);
         int findex = field_index(cur);
-        cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(field_userptr(
-          this->Fields[findex-2]));
+        cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(
+          field_userptr(this->Fields[findex - 2]));
         const char* curField = lbl->GetValue();
         const char* helpString = 0;
 
         const char* existingValue =
-            this->CMakeInstance->GetState()
-                ->GetCacheEntryValue(curField);
-        if (existingValue)
-          {
-          helpString = this->CMakeInstance->GetState()
-                           ->GetCacheEntryProperty(curField, "HELPSTRING");
-          }
-        if (helpString)
-          {
-          char* message = new char[strlen(curField)+strlen(helpString)
-                                  +strlen("Current option is: \n Help string for this option is: \n")+10];
-          sprintf(message,"Current option is: %s\nHelp string for this option is: %s\n", curField, helpString);
+          this->CMakeInstance->GetState()->GetCacheEntryValue(curField);
+        if (existingValue) {
+          helpString = this->CMakeInstance->GetState()->GetCacheEntryProperty(
+            curField, "HELPSTRING");
+        }
+        if (helpString) {
+          char* message = new char
+            [strlen(curField) + strlen(helpString) +
+             strlen(
+               "Current option is: \n Help string for this option is: \n") +
+             10];
+          sprintf(
+            message,
+            "Current option is: %s\nHelp string for this option is: %s\n",
+            curField, helpString);
           this->HelpMessage[1] = message;
           delete[] message;
-          }
-        else
-          {
+        } else {
           this->HelpMessage[1] = "";
-          }
+        }
 
-        cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(this->HelpMessage,
-                                                                    "Help.");
+        cmCursesLongMessageForm* msgs =
+          new cmCursesLongMessageForm(this->HelpMessage, "Help.");
         CurrentForm = msgs;
-        msgs->Render(1,1,x,y);
+        msgs->Render(1, 1, x, y);
         msgs->HandleInput();
         CurrentForm = this;
-        this->Render(1,1,x,y);
+        this->Render(1, 1, x, y);
         set_current_field(this->Form, cur);
-        }
+      }
       // display last errors
-      else if ( key == 'l' )
-        {
+      else if (key == 'l') {
         getmaxyx(stdscr, y, x);
-        cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(this->Errors,
-                                                                    "Errors occurred during the last pass.");
+        cmCursesLongMessageForm* msgs = new cmCursesLongMessageForm(
+          this->Errors, "Errors occurred during the last pass.");
         CurrentForm = msgs;
-        msgs->Render(1,1,x,y);
+        msgs->Render(1, 1, x, y);
         msgs->HandleInput();
         CurrentForm = this;
-        this->Render(1,1,x,y);
-        }
-      else if ( key == '/' )
-        {
+        this->Render(1, 1, x, y);
+      } else if (key == '/') {
         this->SearchMode = true;
         this->UpdateStatusBar("Search");
         this->PrintKeys(1);
         touchwin(stdscr);
         refresh();
-        }
-      else if ( key == 'n' )
-        {
-        if (!this->OldSearchString.empty())
-          {
+      } else if (key == 'n') {
+        if (!this->OldSearchString.empty()) {
           this->JumpToCacheEntry(this->OldSearchString.c_str());
-          }
         }
+      }
       // switch advanced on/off
-      else if ( key == 't' )
-        {
-        if (this->AdvancedMode)
-          {
+      else if (key == 't') {
+        if (this->AdvancedMode) {
           this->AdvancedMode = false;
-          }
-        else
-          {
+        } else {
           this->AdvancedMode = true;
-          }
+        }
         getmaxyx(stdscr, y, x);
         this->RePost();
         this->Render(1, 1, x, y);
-        }
+      }
       // generate and exit
-      else if ( key == 'g' )
-        {
-        if ( this->OkToGenerate )
-          {
+      else if (key == 'g') {
+        if (this->OkToGenerate) {
           this->Generate();
           break;
-          }
         }
+      }
       // delete cache entry
-      else if ( key == 'd' && this->NumberOfVisibleEntries )
-        {
+      else if (key == 'd' && this->NumberOfVisibleEntries) {
         this->OkToGenerate = false;
         FIELD* cur = current_field(this->Form);
         size_t findex = field_index(cur);
@@ -1141,76 +972,66 @@ void cmCursesMainForm::HandleInput()
         // and the label field for the next entry is findex+1
         // (findex always corresponds to the value field)
         FIELD* nextCur;
-        if ( findex == 2 )
-          {
-          nextCur=0;
-          }
-        else if ( findex == 3*this->NumberOfVisibleEntries-1 )
-          {
-          nextCur = this->Fields[findex-5];
-          }
-        else
-          {
-          nextCur = this->Fields[findex+1];
-          }
+        if (findex == 2) {
+          nextCur = 0;
+        } else if (findex == 3 * this->NumberOfVisibleEntries - 1) {
+          nextCur = this->Fields[findex - 5];
+        } else {
+          nextCur = this->Fields[findex + 1];
+        }
 
         // Get the label widget
         // each entry consists of fields: label, isnew, value
         // therefore, the label field for the is findex-2
         // (findex always corresponds to the value field)
-        cmCursesWidget* lbl
-          = reinterpret_cast<cmCursesWidget*>(
-            field_userptr(this->Fields[findex-2]));
-        if ( lbl )
-          {
+        cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(
+          field_userptr(this->Fields[findex - 2]));
+        if (lbl) {
           this->CMakeInstance->GetState()->RemoveCacheEntry(lbl->GetValue());
 
           std::string nextVal;
-          if (nextCur)
-            {
-            nextVal = (reinterpret_cast<cmCursesWidget*>(field_userptr(nextCur))->GetValue());
-            }
+          if (nextCur) {
+            nextVal =
+              (reinterpret_cast<cmCursesWidget*>(field_userptr(nextCur))
+                 ->GetValue());
+          }
 
           getmaxyx(stdscr, y, x);
           this->RemoveEntry(lbl->GetValue());
           this->RePost();
           this->Render(1, 1, x, y);
 
-          if (nextCur)
-            {
+          if (nextCur) {
             // make the next or prev. current field after deletion
             nextCur = 0;
             std::vector<cmCursesCacheEntryComposite*>::iterator it;
-            for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
-              {
-              if (nextVal == (*it)->Key)
-                {
+            for (it = this->Entries->begin(); it != this->Entries->end();
+                 ++it) {
+              if (nextVal == (*it)->Key) {
                 nextCur = (*it)->Entry->Field;
-                }
               }
+            }
 
-            if (nextCur)
-              {
+            if (nextCur) {
               set_current_field(this->Form, nextCur);
-              }
             }
           }
         }
       }
+    }
 
     touchwin(stdscr);
     wrefresh(stdscr);
-    }
+  }
 }
 
-int cmCursesMainForm::LoadCache(const char *)
+int cmCursesMainForm::LoadCache(const char*)
 
 {
   int r = this->CMakeInstance->LoadCache();
-  if(r < 0)
-    {
+  if (r < 0) {
     return r;
-    }
+  }
   this->CMakeInstance->SetCacheArgs(this->Args);
   this->CMakeInstance->PreLoadCMakeFiles();
   return r;
@@ -1219,55 +1040,44 @@ int cmCursesMainForm::LoadCache(const char *)
 void cmCursesMainForm::JumpToCacheEntry(const char* astr)
 {
   std::string str;
-  if ( astr )
-    {
+  if (astr) {
     str = cmSystemTools::LowerCase(astr);
-    }
+  }
 
-  if(str.empty())
-    {
+  if (str.empty()) {
     return;
-    }
+  }
   FIELD* cur = current_field(this->Form);
   int start_index = field_index(cur);
   int findex = start_index;
-  for(;;)
-    {
-    if (!str.empty())
-      {
+  for (;;) {
+    if (!str.empty()) {
       cmCursesWidget* lbl = 0;
-      if ( findex >= 0 )
-        {
-        lbl = reinterpret_cast<cmCursesWidget*>(field_userptr(this->Fields[findex-2]));
-        }
-      if ( lbl )
-        {
+      if (findex >= 0) {
+        lbl = reinterpret_cast<cmCursesWidget*>(
+          field_userptr(this->Fields[findex - 2]));
+      }
+      if (lbl) {
         const char* curField = lbl->GetValue();
-        if ( curField )
-          {
+        if (curField) {
           std::string cfld = cmSystemTools::LowerCase(curField);
-          if ( cfld.find(str) != cfld.npos && findex != start_index )
-            {
+          if (cfld.find(str) != cfld.npos && findex != start_index) {
             break;
-            }
           }
         }
       }
-    if ( size_t(findex) >= 3* this->NumberOfVisibleEntries-1 )
-      {
+    }
+    if (size_t(findex) >= 3 * this->NumberOfVisibleEntries - 1) {
       set_current_field(this->Form, this->Fields[2]);
-      }
-    else if (new_page(this->Fields[findex+1]))
-      {
+    } else if (new_page(this->Fields[findex + 1])) {
       form_driver(this->Form, REQ_NEXT_PAGE);
-      }
-    else
-      {
+    } else {
       form_driver(this->Form, REQ_NEXT_FIELD);
-      }
+    }
     /*
     char buffer[1024];
-    sprintf(buffer, "Line: %d != %d / %d\n", findex, idx, this->NumberOfVisibleEntries);
+    sprintf(buffer, "Line: %d != %d / %d\n", findex, idx,
+    this->NumberOfVisibleEntries);
     touchwin(stdscr);
     refresh();
     this->UpdateStatusBar( buffer );
@@ -1275,52 +1085,70 @@ void cmCursesMainForm::JumpToCacheEntry(const char* astr)
     */
     cur = current_field(this->Form);
     findex = field_index(cur);
-    if ( findex == start_index )
-      {
+    if (findex == start_index) {
       break;
-      }
     }
+  }
 }
 
-
 const char* cmCursesMainForm::s_ConstHelpMessage =
-"CMake is used to configure and generate build files for software projects. "
-"The basic steps for configuring a project with ccmake are as follows:\n\n"
-"1. Run ccmake in the directory where you want the object and executable files to be placed (build directory). If the source directory is not the same as this build directory, you have to specify it as an argument on the command line.\n\n"
-"2. When ccmake is run, it will read the configuration files and display the current build options. "
-"If you have run CMake before and have updated the configuration files since then, any new entries will be displayed on top and will be marked with a *. "
-"On the other hand, the first time you run ccmake, all build options will be new and will be marked as such. "
-"At this point, you can modify any options (see keys below) you want to change. "
-"When you are satisfied with your changes, press 'c' to have CMake process the configuration files. "
-"Please note that changing some options may cause new ones to appear. These will be shown on top and will be marked with *. "
-"Repeat this procedure until you are satisfied with all the options and there are no new entries. "
-"At this point, a new command will appear: G)enerate and Exit. You can now hit 'g' to have CMake generate all the build files (i.e. makefiles or project files) and exit. "
-"At any point during the process, you can exit ccmake with 'q'. However, this will not generate/change any build files.\n\n"
-"ccmake KEYS:\n\n"
-"Navigation: "
-"You can use the arrow keys and page up, down to navigate the options. Alternatively, you can use the following keys: \n"
-" C-n : next option\n"
-" C-p : previous options\n"
-" C-d : down one page\n"
-" C-u : up one page\n\n"
-"Editing options: "
-"To change an option  press enter or return. If the current options is a boolean, this will toggle it's value. "
-"Otherwise, ccmake will enter edit mode. In this mode you can edit an option using arrow keys and backspace. Alternatively, you can use the following keys:\n"
-" C-b : back one character\n"
-" C-f : forward one character\n"
-" C-a : go to the beginning of the field\n"
-" C-e : go to the end of the field\n"
-" C-d : delete previous character\n"
-" C-k : kill the rest of the field\n"
-" Esc : Restore field (discard last changes)\n"
-" Enter : Leave edit mode\n"
-"You can also delete an option by pressing 'd'\n\n"
-"Commands:\n"
-" q : quit ccmake without generating build files\n"
-" h : help, shows this screen\n"
-" c : process the configuration files with the current options\n"
-" g : generate build files and exit, only available when there are no "
-"new options and no errors have been detected during last configuration.\n"
-" l : shows last errors\n"
-" t : toggles advanced mode. In normal mode, only the most important options are shown. In advanced mode, all options are shown. We recommend using normal mode unless you are an expert.\n"
-" / : search for a variable name.\n";
+  "CMake is used to configure and generate build files for software projects. "
+  "The basic steps for configuring a project with ccmake are as follows:\n\n"
+  "1. Run ccmake in the directory where you want the object and executable "
+  "files to be placed (build directory). If the source directory is not the "
+  "same as this build directory, you have to specify it as an argument on the "
+  "command line.\n\n"
+  "2. When ccmake is run, it will read the configuration files and display "
+  "the current build options. "
+  "If you have run CMake before and have updated the configuration files "
+  "since then, any new entries will be displayed on top and will be marked "
+  "with a *. "
+  "On the other hand, the first time you run ccmake, all build options will "
+  "be new and will be marked as such. "
+  "At this point, you can modify any options (see keys below) you want to "
+  "change. "
+  "When you are satisfied with your changes, press 'c' to have CMake process "
+  "the configuration files. "
+  "Please note that changing some options may cause new ones to appear. These "
+  "will be shown on top and will be marked with *. "
+  "Repeat this procedure until you are satisfied with all the options and "
+  "there are no new entries. "
+  "At this point, a new command will appear: G)enerate and Exit. You can now "
+  "hit 'g' to have CMake generate all the build files (i.e. makefiles or "
+  "project files) and exit. "
+  "At any point during the process, you can exit ccmake with 'q'. However, "
+  "this will not generate/change any build files.\n\n"
+  "ccmake KEYS:\n\n"
+  "Navigation: "
+  "You can use the arrow keys and page up, down to navigate the options. "
+  "Alternatively, you can use the following keys: \n"
+  " C-n : next option\n"
+  " C-p : previous options\n"
+  " C-d : down one page\n"
+  " C-u : up one page\n\n"
+  "Editing options: "
+  "To change an option  press enter or return. If the current options is a "
+  "boolean, this will toggle it's value. "
+  "Otherwise, ccmake will enter edit mode. In this mode you can edit an "
+  "option using arrow keys and backspace. Alternatively, you can use the "
+  "following keys:\n"
+  " C-b : back one character\n"
+  " C-f : forward one character\n"
+  " C-a : go to the beginning of the field\n"
+  " C-e : go to the end of the field\n"
+  " C-d : delete previous character\n"
+  " C-k : kill the rest of the field\n"
+  " Esc : Restore field (discard last changes)\n"
+  " Enter : Leave edit mode\n"
+  "You can also delete an option by pressing 'd'\n\n"
+  "Commands:\n"
+  " q : quit ccmake without generating build files\n"
+  " h : help, shows this screen\n"
+  " c : process the configuration files with the current options\n"
+  " g : generate build files and exit, only available when there are no "
+  "new options and no errors have been detected during last configuration.\n"
+  " l : shows last errors\n"
+  " t : toggles advanced mode. In normal mode, only the most important "
+  "options are shown. In advanced mode, all options are shown. We recommend "
+  "using normal mode unless you are an expert.\n"
+  " / : search for a variable name.\n";
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
index 9a80ba2..9aa0f67 100644
--- a/Source/CursesDialog/cmCursesMainForm.h
+++ b/Source/CursesDialog/cmCursesMainForm.h
@@ -54,7 +54,8 @@ public:
    */
   bool LookForCacheEntry(const std::string& key);
 
-  enum {
+  enum
+  {
     MIN_WIDTH = 65,
     MIN_HEIGHT = 6,
     IDEAL_WIDTH = 80,
@@ -88,7 +89,7 @@ public:
    * Used to do a configure. If argument is specified, it does only the check
    * and not configure.
    */
-  int Configure(int noconfigure=0);
+  int Configure(int noconfigure = 0);
 
   /**
    * Used to generate
@@ -98,13 +99,13 @@ public:
   /**
    * Used by main program
    */
-  int LoadCache(const char *dir);
+  int LoadCache(const char* dir);
 
   /**
    * Progress callback
    */
-  static void UpdateProgressOld(const char *msg, float prog, void*);
-  static void UpdateProgress(const char *msg, float prog, void*);
+  static void UpdateProgressOld(const char* msg, float prog, void*);
+  static void UpdateProgress(const char* msg, float prog, void*);
 
 protected:
   cmCursesMainForm(const cmCursesMainForm& from);
@@ -114,8 +115,8 @@ protected:
   // cache.
   void FillCacheManagerFromUI();
   // Fix formatting of values to a consistent form.
-  void FixValue(cmState::CacheEntryType type,
-                const std::string& in, std::string& out) const;
+  void FixValue(cmState::CacheEntryType type, const std::string& in,
+                std::string& out) const;
   // Re-post the existing fields. Used to toggle between
   // normal and advanced modes. Render() should be called
   // afterwards.
@@ -155,7 +156,7 @@ protected:
   int NumberOfPages;
 
   int InitialWidth;
-  cmake *CMakeInstance;
+  cmake* CMakeInstance;
 
   std::string SearchString;
   std::string OldSearchString;
diff --git a/Source/CursesDialog/cmCursesOptionsWidget.cxx b/Source/CursesDialog/cmCursesOptionsWidget.cxx
index 05aeab1..1a3a8c2 100644
--- a/Source/CursesDialog/cmCursesOptionsWidget.cxx
+++ b/Source/CursesDialog/cmCursesOptionsWidget.cxx
@@ -15,54 +15,47 @@
 
 inline int ctrl(int z)
 {
-    return (z&037);
+  return (z & 037);
 }
 
-cmCursesOptionsWidget::cmCursesOptionsWidget(int width, int height,
-                                       int left, int top) :
-  cmCursesWidget(width, height, left, top)
+cmCursesOptionsWidget::cmCursesOptionsWidget(int width, int height, int left,
+                                             int top)
+  : cmCursesWidget(width, height, left, top)
 {
   this->Type = cmState::BOOL; // this is a bit of a hack
   // there is no option type, and string type causes ccmake to cast
   // the widget into a string widget at some point.  BOOL is safe for
   // now.
-  set_field_fore(this->Field,  A_NORMAL);
-  set_field_back(this->Field,  A_STANDOUT);
-  field_opts_off(this->Field,  O_STATIC);
+  set_field_fore(this->Field, A_NORMAL);
+  set_field_back(this->Field, A_STANDOUT);
+  field_opts_off(this->Field, O_STATIC);
 }
 
 bool cmCursesOptionsWidget::HandleInput(int& key, cmCursesMainForm*, WINDOW* w)
 {
 
   // 10 == enter
-  if (key == 10 || key == KEY_ENTER)
-    {
+  if (key == 10 || key == KEY_ENTER) {
     this->NextOption();
     touchwin(w);
     wrefresh(w);
     return true;
-    }
-  else if (key == KEY_LEFT || key == ctrl('b'))
-    {
+  } else if (key == KEY_LEFT || key == ctrl('b')) {
     touchwin(w);
     wrefresh(w);
     this->PreviousOption();
     return true;
-    }
-  else if (key == KEY_RIGHT || key == ctrl('f'))
-    {
+  } else if (key == KEY_RIGHT || key == ctrl('f')) {
     this->NextOption();
     touchwin(w);
     wrefresh(w);
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
 
-void cmCursesOptionsWidget::AddOption(std::string const & option )
+void cmCursesOptionsWidget::AddOption(std::string const& option)
 {
   this->Options.push_back(option);
 }
@@ -70,22 +63,18 @@ void cmCursesOptionsWidget::AddOption(std::string const & option )
 void cmCursesOptionsWidget::NextOption()
 {
   this->CurrentOption++;
-  if(this->CurrentOption > this->Options.size()-1)
-    {
+  if (this->CurrentOption > this->Options.size() - 1) {
     this->CurrentOption = 0;
-    }
+  }
   this->SetValue(this->Options[this->CurrentOption]);
 }
 void cmCursesOptionsWidget::PreviousOption()
 {
-  if(this->CurrentOption == 0)
-    {
-    this->CurrentOption = this->Options.size()-1;
-    }
-  else
-    {
+  if (this->CurrentOption == 0) {
+    this->CurrentOption = this->Options.size() - 1;
+  } else {
     this->CurrentOption--;
-    }
+  }
   this->SetValue(this->Options[this->CurrentOption]);
 }
 
@@ -94,13 +83,11 @@ void cmCursesOptionsWidget::SetOption(const std::string& value)
   this->CurrentOption = 0; // default to 0 index
   this->SetValue(value);
   int index = 0;
-  for(std::vector<std::string>::iterator i = this->Options.begin();
-      i != this->Options.end(); ++i)
-    {
-    if(*i == value)
-      {
+  for (std::vector<std::string>::iterator i = this->Options.begin();
+       i != this->Options.end(); ++i) {
+    if (*i == value) {
       this->CurrentOption = index;
-      }
-    index++;
     }
+    index++;
+  }
 }
diff --git a/Source/CursesDialog/cmCursesOptionsWidget.h b/Source/CursesDialog/cmCursesOptionsWidget.h
index ba359d3..a17f2d5 100644
--- a/Source/CursesDialog/cmCursesOptionsWidget.h
+++ b/Source/CursesDialog/cmCursesOptionsWidget.h
@@ -27,9 +27,10 @@ public:
   // handled.
   virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w);
   void SetOption(const std::string&);
-  void AddOption(std::string const &);
+  void AddOption(std::string const&);
   void NextOption();
   void PreviousOption();
+
 protected:
   cmCursesOptionsWidget(const cmCursesOptionsWidget& from);
   void operator=(const cmCursesOptionsWidget&);
diff --git a/Source/CursesDialog/cmCursesPathWidget.cxx b/Source/CursesDialog/cmCursesPathWidget.cxx
index 6116823..33fffd1 100644
--- a/Source/CursesDialog/cmCursesPathWidget.cxx
+++ b/Source/CursesDialog/cmCursesPathWidget.cxx
@@ -14,9 +14,9 @@
 #include "cmCursesMainForm.h"
 #include "cmSystemTools.h"
 
-cmCursesPathWidget::cmCursesPathWidget(int width, int height,
-                                           int left, int top) :
-  cmCursesStringWidget(width, height, left, top)
+cmCursesPathWidget::cmCursesPathWidget(int width, int height, int left,
+                                       int top)
+  : cmCursesStringWidget(width, height, left, top)
 {
   this->Type = cmState::PATH;
   this->Cycle = false;
@@ -33,46 +33,39 @@ void cmCursesPathWidget::OnType(int& key, cmCursesMainForm* fm, WINDOW* w)
 
 void cmCursesPathWidget::OnTab(cmCursesMainForm* fm, WINDOW* w)
 {
-  if ( !this->GetString() )
-    {
+  if (!this->GetString()) {
     return;
-    }
+  }
   FORM* form = fm->GetForm();
   form_driver(form, REQ_NEXT_FIELD);
   form_driver(form, REQ_PREV_FIELD);
   std::string cstr = this->GetString();
-  cstr = cstr.substr(0, cstr.find_last_not_of(" \t\n\r")+1);
-  if ( this->LastString != cstr )
-    {
+  cstr = cstr.substr(0, cstr.find_last_not_of(" \t\n\r") + 1);
+  if (this->LastString != cstr) {
     this->Cycle = false;
     this->CurrentIndex = 0;
     this->LastGlob = "";
-    }
+  }
   std::string glob;
-  if ( this->Cycle )
-    {
+  if (this->Cycle) {
     glob = this->LastGlob;
-    }
-  else
-    {
+  } else {
     glob = cstr + "*";
-    }
+  }
   std::vector<std::string> dirs;
 
-  cmSystemTools::SimpleGlob(glob, dirs, (this->Type == cmState::PATH?-1:0));
-  if ( this->CurrentIndex < dirs.size() )
-    {
+  cmSystemTools::SimpleGlob(glob, dirs,
+                            (this->Type == cmState::PATH ? -1 : 0));
+  if (this->CurrentIndex < dirs.size()) {
     cstr = dirs[this->CurrentIndex];
-    }
-  if ( cstr[cstr.size()-1] == '*' )
-    {
-    cstr = cstr.substr(0, cstr.size()-1);
-    }
+  }
+  if (cstr[cstr.size() - 1] == '*') {
+    cstr = cstr.substr(0, cstr.size() - 1);
+  }
 
-  if ( cmSystemTools::FileIsDirectory(cstr) )
-    {
+  if (cmSystemTools::FileIsDirectory(cstr)) {
     cstr += "/";
-    }
+  }
 
   this->SetString(cstr);
   touchwin(w);
@@ -81,11 +74,10 @@ void cmCursesPathWidget::OnTab(cmCursesMainForm* fm, WINDOW* w)
   this->LastGlob = glob;
   this->LastString = cstr;
   this->Cycle = true;
-  this->CurrentIndex ++;
-  if ( this->CurrentIndex >= dirs.size() )
-    {
+  this->CurrentIndex++;
+  if (this->CurrentIndex >= dirs.size()) {
     this->CurrentIndex = 0;
-    }
+  }
 }
 
 void cmCursesPathWidget::OnReturn(cmCursesMainForm* fm, WINDOW* w)
diff --git a/Source/CursesDialog/cmCursesStandardIncludes.h b/Source/CursesDialog/cmCursesStandardIncludes.h
index 69a05b2..7b44df9 100644
--- a/Source/CursesDialog/cmCursesStandardIncludes.h
+++ b/Source/CursesDialog/cmCursesStandardIncludes.h
@@ -15,12 +15,12 @@
 #include "../cmStandardIncludes.h"
 
 #if defined(__sun__) && defined(__GNUC__)
- #define _MSE_INT_H
+#define _MSE_INT_H
 #endif
 
 #if defined(__hpux)
-# define _BOOL_DEFINED
-# include <sys/time.h>
+#define _BOOL_DEFINED
+#include <sys/time.h>
 #endif
 
 #include <form.h>
@@ -29,7 +29,7 @@
 // so remove them from the namespace
 inline void curses_move(unsigned int x, unsigned int y)
 {
-  move(x,y);
+  move(x, y);
 }
 
 inline void curses_clear()
@@ -42,5 +42,4 @@ inline void curses_clear()
 #undef erase
 #undef clear
 
-
 #endif // cmCursesStandardIncludes_h
diff --git a/Source/CursesDialog/cmCursesStringWidget.cxx b/Source/CursesDialog/cmCursesStringWidget.cxx
index 6bd7b45..3707d0d 100644
--- a/Source/CursesDialog/cmCursesStringWidget.cxx
+++ b/Source/CursesDialog/cmCursesStringWidget.cxx
@@ -15,30 +15,29 @@
 
 inline int ctrl(int z)
 {
-    return (z&037);
+  return (z & 037);
 }
 
-cmCursesStringWidget::cmCursesStringWidget(int width, int height,
-                                           int left, int top) :
-  cmCursesWidget(width, height, left, top)
+cmCursesStringWidget::cmCursesStringWidget(int width, int height, int left,
+                                           int top)
+  : cmCursesWidget(width, height, left, top)
 {
   this->InEdit = false;
   this->Type = cmState::STRING;
-  set_field_fore(this->Field,  A_NORMAL);
-  set_field_back(this->Field,  A_STANDOUT);
-  field_opts_off(this->Field,  O_STATIC);
+  set_field_fore(this->Field, A_NORMAL);
+  set_field_back(this->Field, A_STANDOUT);
+  field_opts_off(this->Field, O_STATIC);
 }
 
 void cmCursesStringWidget::OnTab(cmCursesMainForm*, WINDOW*)
 {
-  //FORM* form = fm->GetForm();
+  // FORM* form = fm->GetForm();
 }
 
 void cmCursesStringWidget::OnReturn(cmCursesMainForm* fm, WINDOW*)
 {
   FORM* form = fm->GetForm();
-  if (this->InEdit)
-    {
+  if (this->InEdit) {
     cmCursesForm::LogMessage("String widget leaving edit.");
     this->InEdit = false;
     fm->PrintKeys();
@@ -47,16 +46,14 @@ void cmCursesStringWidget::OnReturn(cmCursesMainForm* fm, WINDOW*)
     form_driver(form, REQ_NEXT_FIELD);
     form_driver(form, REQ_PREV_FIELD);
     this->Done = true;
-    }
-  else
-    {
+  } else {
     cmCursesForm::LogMessage("String widget entering edit.");
     this->InEdit = true;
     fm->PrintKeys();
     char* buf = field_buffer(this->Field, 0);
-    this->OriginalString = new char[strlen(buf)+1];
+    this->OriginalString = new char[strlen(buf) + 1];
     strcpy(this->OriginalString, buf);
-    }
+  }
 }
 
 void cmCursesStringWidget::OnType(int& key, cmCursesMainForm* fm, WINDOW*)
@@ -67,23 +64,21 @@ void cmCursesStringWidget::OnType(int& key, cmCursesMainForm* fm, WINDOW*)
 bool cmCursesStringWidget::HandleInput(int& key, cmCursesMainForm* fm,
                                        WINDOW* w)
 {
-  int x,y;
+  int x, y;
 
   FORM* form = fm->GetForm();
   // 10 == enter
-  if (!this->InEdit && ( key != 10 && key != KEY_ENTER ) )
-    {
+  if (!this->InEdit && (key != 10 && key != KEY_ENTER)) {
     return false;
-    }
+  }
 
-  this->OriginalString=0;
+  this->OriginalString = 0;
   this->Done = false;
 
   char debugMessage[128];
 
   // <Enter> is used to change edit mode (like <Esc> in vi).
-  while(!this->Done)
-    {
+  while (!this->Done) {
     sprintf(debugMessage, "String widget handling input, key: %d", key);
     cmCursesForm::LogMessage(debugMessage);
 
@@ -91,48 +86,36 @@ bool cmCursesStringWidget::HandleInput(int& key, cmCursesMainForm* fm,
 
     getmaxyx(stdscr, y, x);
     // If window too small, handle 'q' only
-    if ( x < cmCursesMainForm::MIN_WIDTH  ||
-         y < cmCursesMainForm::MIN_HEIGHT )
-      {
+    if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
       // quit
-      if ( key == 'q' )
-        {
+      if (key == 'q') {
         return false;
-        }
-      else
-        {
-        key=getch();
+      } else {
+        key = getch();
         continue;
-        }
       }
+    }
 
     // If resize occurred during edit, move out of edit mode
-    if (!this->InEdit && ( key != 10 && key != KEY_ENTER ) )
-      {
+    if (!this->InEdit && (key != 10 && key != KEY_ENTER)) {
       return false;
-      }
+    }
     // 10 == enter
-    if (key == 10 || key == KEY_ENTER)
-      {
+    if (key == 10 || key == KEY_ENTER) {
       this->OnReturn(fm, w);
-      }
-    else if ( key == KEY_DOWN || key == ctrl('n') ||
-              key == KEY_UP || key == ctrl('p') ||
-              key == KEY_NPAGE || key == ctrl('d') ||
-              key == KEY_PPAGE || key == ctrl('u'))
-      {
+    } else if (key == KEY_DOWN || key == ctrl('n') || key == KEY_UP ||
+               key == ctrl('p') || key == KEY_NPAGE || key == ctrl('d') ||
+               key == KEY_PPAGE || key == ctrl('u')) {
       this->InEdit = false;
       delete[] this->OriginalString;
       // trick to force forms to update the field buffer
       form_driver(form, REQ_NEXT_FIELD);
       form_driver(form, REQ_PREV_FIELD);
       return false;
-      }
+    }
     // esc
-    else if (key == 27)
-      {
-      if (this->InEdit)
-        {
+    else if (key == 27) {
+      if (this->InEdit) {
         this->InEdit = false;
         fm->PrintKeys();
         this->SetString(this->OriginalString);
@@ -140,58 +123,37 @@ bool cmCursesStringWidget::HandleInput(int& key, cmCursesMainForm* fm,
         touchwin(w);
         wrefresh(w);
         return true;
-        }
       }
-    else if ( key == 9 )
-      {
+    } else if (key == 9) {
       this->OnTab(fm, w);
-      }
-    else if ( key == KEY_LEFT || key == ctrl('b') )
-      {
+    } else if (key == KEY_LEFT || key == ctrl('b')) {
       form_driver(form, REQ_PREV_CHAR);
-      }
-    else if ( key == KEY_RIGHT || key == ctrl('f') )
-      {
+    } else if (key == KEY_RIGHT || key == ctrl('f')) {
       form_driver(form, REQ_NEXT_CHAR);
-      }
-    else if ( key == ctrl('k') )
-      {
+    } else if (key == ctrl('k')) {
       form_driver(form, REQ_CLR_EOL);
-      }
-    else if ( key == ctrl('a') || key == KEY_HOME )
-      {
+    } else if (key == ctrl('a') || key == KEY_HOME) {
       form_driver(form, REQ_BEG_FIELD);
-      }
-    else if ( key == ctrl('e') || key == KEY_END )
-      {
+    } else if (key == ctrl('e') || key == KEY_END) {
       form_driver(form, REQ_END_FIELD);
+    } else if (key == 127 || key == KEY_BACKSPACE) {
+      FIELD* cur = current_field(form);
+      form_driver(form, REQ_DEL_PREV);
+      if (current_field(form) != cur) {
+        set_current_field(form, cur);
       }
-    else if ( key == 127 ||
-              key == KEY_BACKSPACE )
-      {
-        FIELD *cur = current_field(form);
-        form_driver(form, REQ_DEL_PREV);
-        if (current_field(form) != cur)
-          {
-          set_current_field(form, cur);
-          }
-      }
-    else if ( key == ctrl('d') ||key == KEY_DC )
-      {
+    } else if (key == ctrl('d') || key == KEY_DC) {
       form_driver(form, REQ_DEL_CHAR);
-      }
-    else
-      {
+    } else {
       this->OnType(key, fm, w);
-      }
-    if ( !this->Done )
-      {
+    }
+    if (!this->Done) {
       touchwin(w);
       wrefresh(w);
 
-      key=getch();
-      }
+      key = getch();
     }
+  }
   return true;
 }
 
@@ -212,38 +174,32 @@ const char* cmCursesStringWidget::GetValue()
 
 bool cmCursesStringWidget::PrintKeys()
 {
-  int x,y;
+  int x, y;
   getmaxyx(stdscr, y, x);
-  if ( x < cmCursesMainForm::MIN_WIDTH  ||
-       y < cmCursesMainForm::MIN_HEIGHT )
-    {
+  if (x < cmCursesMainForm::MIN_WIDTH || y < cmCursesMainForm::MIN_HEIGHT) {
     return false;
-    }
-  if (this->InEdit)
-    {
+  }
+  if (this->InEdit) {
     char fmt_s[] = "%s";
     char firstLine[512];
     // Clean the toolbar
-    for(int i=0; i<512; i++)
-      {
+    for (int i = 0; i < 512; i++) {
       firstLine[i] = ' ';
-      }
+    }
     firstLine[511] = '\0';
-    curses_move(y-4,0);
+    curses_move(y - 4, 0);
     printw(fmt_s, firstLine);
-    curses_move(y-3,0);
+    curses_move(y - 3, 0);
     printw(fmt_s, firstLine);
-    curses_move(y-2,0);
+    curses_move(y - 2, 0);
     printw(fmt_s, firstLine);
-    curses_move(y-1,0);
+    curses_move(y - 1, 0);
     printw(fmt_s, firstLine);
 
-    curses_move(y-3,0);
+    curses_move(y - 3, 0);
     printw(fmt_s, "Editing option, press [enter] to leave edit.");
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
diff --git a/Source/CursesDialog/cmCursesWidget.cxx b/Source/CursesDialog/cmCursesWidget.cxx
index a12e4c2..100ed1d 100644
--- a/Source/CursesDialog/cmCursesWidget.cxx
+++ b/Source/CursesDialog/cmCursesWidget.cxx
@@ -15,41 +15,36 @@ cmCursesWidget::cmCursesWidget(int width, int height, int left, int top)
 {
   this->Field = new_field(height, width, top, left, 0, 0);
   set_field_userptr(this->Field, reinterpret_cast<char*>(this));
-  field_opts_off(this->Field,  O_AUTOSKIP);
+  field_opts_off(this->Field, O_AUTOSKIP);
   this->Page = 0;
 }
 
 cmCursesWidget::~cmCursesWidget()
 {
-  if (this->Field)
-    {
+  if (this->Field) {
     free_field(this->Field);
     this->Field = 0;
-    }
+  }
 }
 
 void cmCursesWidget::Move(int x, int y, bool isNewPage)
 {
-  if (!this->Field)
-    {
+  if (!this->Field) {
     return;
-    }
+  }
 
   move_field(this->Field, y, x);
-  if (isNewPage)
-    {
+  if (isNewPage) {
     set_new_page(this->Field, TRUE);
-    }
-  else
-    {
+  } else {
     set_new_page(this->Field, FALSE);
-    }
+  }
 }
 
 void cmCursesWidget::SetValue(const std::string& value)
 {
   this->Value = value;
-  set_field_buffer(this->Field, 0, const_cast<char *>(value.c_str()));
+  set_field_buffer(this->Field, 0, const_cast<char*>(value.c_str()));
 }
 
 const char* cmCursesWidget::GetValue()
diff --git a/Source/CursesDialog/cmCursesWidget.h b/Source/CursesDialog/cmCursesWidget.h
index 1f53786..2ac5bb8 100644
--- a/Source/CursesDialog/cmCursesWidget.h
+++ b/Source/CursesDialog/cmCursesWidget.h
@@ -47,30 +47,20 @@ public:
   /**
    * Get the type of the widget (STRING, PATH etc...)
    */
-  cmState::CacheEntryType GetType()
-    { return this->Type; }
+  cmState::CacheEntryType GetType() { return this->Type; }
 
   /**
    * If there are any, print the widget specific commands
    * in the toolbar and return true. Otherwise, return false
    * and the parent widget will print.
    */
-  virtual bool PrintKeys()
-    {
-      return false;
-    }
+  virtual bool PrintKeys() { return false; }
 
   /**
    * Set/Get the page this widget is in.
    */
-  void SetPage(int page)
-    {
-      this->Page = page;
-    }
-  int GetPage()
-    {
-      return this->Page;
-    }
+  void SetPage(int page) { this->Page = page; }
+  int GetPage() { return this->Page; }
 
   friend class cmCursesMainForm;
 
diff --git a/Source/QtDialog/AddCacheEntry.cxx b/Source/QtDialog/AddCacheEntry.cxx
index efb2b65..dc7a4b0 100644
--- a/Source/QtDialog/AddCacheEntry.cxx
+++ b/Source/QtDialog/AddCacheEntry.cxx
@@ -17,21 +17,23 @@
 
 static const int NumTypes = 4;
 static const int DefaultTypeIndex = 0;
-static const QByteArray TypeStrings[NumTypes] =
-  { "BOOL", "PATH", "FILEPATH", "STRING" };
-static const QCMakeProperty::PropertyType Types[NumTypes] =
-  { QCMakeProperty::BOOL, QCMakeProperty::PATH,
-    QCMakeProperty::FILEPATH, QCMakeProperty::STRING};
+static const QByteArray TypeStrings[NumTypes] = { "BOOL", "PATH", "FILEPATH",
+                                                  "STRING" };
+static const QCMakeProperty::PropertyType Types[NumTypes] = {
+  QCMakeProperty::BOOL, QCMakeProperty::PATH, QCMakeProperty::FILEPATH,
+  QCMakeProperty::STRING
+};
 
 AddCacheEntry::AddCacheEntry(QWidget* p, const QStringList& varNames,
-                                         const QStringList& varTypes)
-  : QWidget(p), VarNames(varNames), VarTypes(varTypes)
+                             const QStringList& varTypes)
+  : QWidget(p)
+  , VarNames(varNames)
+  , VarTypes(varTypes)
 {
   this->setupUi(this);
-  for(int i=0; i<NumTypes; i++)
-    {
+  for (int i = 0; i < NumTypes; i++) {
     this->Type->addItem(TypeStrings[i]);
-    }
+  }
   QWidget* cb = new QCheckBox();
   QWidget* path = new QCMakePathEditor();
   QWidget* filepath = new QCMakeFilePathEditor();
@@ -46,10 +48,10 @@ AddCacheEntry::AddCacheEntry(QWidget* p, const QStringList& varNames,
   this->setTabOrder(path, filepath);
   this->setTabOrder(filepath, string);
   this->setTabOrder(string, this->Description);
-  QCompleter *completer = new QCompleter(this->VarNames, this);
+  QCompleter* completer = new QCompleter(this->VarNames, this);
   this->Name->setCompleter(completer);
-  connect(completer, SIGNAL(activated(const QString&)),
-          this, SLOT(onCompletionActivated(const QString&)));
+  connect(completer, SIGNAL(activated(const QString&)), this,
+          SLOT(onCompletionActivated(const QString&)));
 }
 
 QString AddCacheEntry::name() const
@@ -60,14 +62,11 @@ QString AddCacheEntry::name() const
 QVariant AddCacheEntry::value() const
 {
   QWidget* w = this->StackedWidget->currentWidget();
-  if(qobject_cast<QLineEdit*>(w))
-    {
+  if (qobject_cast<QLineEdit*>(w)) {
     return static_cast<QLineEdit*>(w)->text();
-    }
-  else if(qobject_cast<QCheckBox*>(w))
-    {
+  } else if (qobject_cast<QCheckBox*>(w)) {
     return static_cast<QCheckBox*>(w)->isChecked();
-    }
+  }
   return QVariant();
 }
 
@@ -79,36 +78,31 @@ QString AddCacheEntry::description() const
 QCMakeProperty::PropertyType AddCacheEntry::type() const
 {
   int idx = this->Type->currentIndex();
-  if(idx >= 0 && idx < NumTypes)
-    {
+  if (idx >= 0 && idx < NumTypes) {
     return Types[idx];
-    }
+  }
   return Types[DefaultTypeIndex];
 }
 
 QString AddCacheEntry::typeString() const
 {
   int idx = this->Type->currentIndex();
-  if(idx >= 0 && idx < NumTypes)
-    {
+  if (idx >= 0 && idx < NumTypes) {
     return TypeStrings[idx];
-    }
+  }
   return TypeStrings[DefaultTypeIndex];
 }
 
-void AddCacheEntry::onCompletionActivated(const QString &text)
+void AddCacheEntry::onCompletionActivated(const QString& text)
 {
   int idx = this->VarNames.indexOf(text);
-  if (idx != -1)
-    {
+  if (idx != -1) {
     QString vartype = this->VarTypes[idx];
-    for (int i = 0; i < NumTypes; i++)
-      {
-        if (TypeStrings[i] == vartype)
-          {
-          this->Type->setCurrentIndex(i);
-          break;
-          }
+    for (int i = 0; i < NumTypes; i++) {
+      if (TypeStrings[i] == vartype) {
+        this->Type->setCurrentIndex(i);
+        break;
       }
     }
+  }
 }
diff --git a/Source/QtDialog/AddCacheEntry.h b/Source/QtDialog/AddCacheEntry.h
index 7c08af6..05469af 100644
--- a/Source/QtDialog/AddCacheEntry.h
+++ b/Source/QtDialog/AddCacheEntry.h
@@ -26,7 +26,7 @@ class AddCacheEntry : public QWidget, public Ui::AddCacheEntry
   Q_OBJECT
 public:
   AddCacheEntry(QWidget* p, const QStringList& varNames,
-                            const QStringList& varTypes);
+                const QStringList& varTypes);
 
   QString name() const;
   QVariant value() const;
@@ -35,7 +35,7 @@ public:
   QString typeString() const;
 
 private slots:
-  void onCompletionActivated(const QString &text);
+  void onCompletionActivated(const QString& text);
 
 private:
   const QStringList& VarNames;
@@ -43,4 +43,3 @@ private:
 };
 
 #endif
-
diff --git a/Source/QtDialog/CMakeSetup.cxx b/Source/QtDialog/CMakeSetup.cxx
index 1e1f040..c3c1468 100644
--- a/Source/QtDialog/CMakeSetup.cxx
+++ b/Source/QtDialog/CMakeSetup.cxx
@@ -9,7 +9,7 @@
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the License for more information.
 ============================================================================*/
-#include "QCMake.h"  // include to disable MS warnings
+#include "QCMake.h" // include to disable MS warnings
 
 #include "CMakeSetupDialog.h"
 #include "cmAlgorithms.h"
@@ -25,26 +25,18 @@
 #include <cmsys/Encoding.hxx>
 #include <cmsys/SystemTools.hxx>
 
-static const char * cmDocumentationName[][2] =
-{
-  {0,
-   "  cmake-gui - CMake GUI."},
-  {0,0}
-};
+static const char* cmDocumentationName[][2] = { { 0,
+                                                  "  cmake-gui - CMake GUI." },
+                                                { 0, 0 } };
 
-static const char * cmDocumentationUsage[][2] =
-{
-  {0,
-   "  cmake-gui [options]\n"
-   "  cmake-gui [options] <path-to-source>\n"
-   "  cmake-gui [options] <path-to-existing-build>"},
-  {0,0}
+static const char* cmDocumentationUsage[][2] = {
+  { 0, "  cmake-gui [options]\n"
+       "  cmake-gui [options] <path-to-source>\n"
+       "  cmake-gui [options] <path-to-existing-build>" },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationOptions[][2] =
-{
-  {0,0}
-};
+static const char* cmDocumentationOptions[][2] = { { 0, 0 } };
 
 #if defined(Q_OS_MAC)
 static int cmOSXInstall(std::string dir);
@@ -62,8 +54,7 @@ int main(int argc, char** argv)
   // do docs, if args were given
   cmDocumentation doc;
   doc.addCMakeStandardDocSections();
-  if(argc2 >1 && doc.CheckOptions(argc2, argv2))
-    {
+  if (argc2 > 1 && doc.CheckOptions(argc2, argv2)) {
     // Construct and print requested documentation.
     cmake hcm;
     hcm.SetHomeDirectory("");
@@ -73,23 +64,21 @@ int main(int argc, char** argv)
     std::vector<cmDocumentationEntry> generators;
     hcm.GetGeneratorDocumentation(generators);
     doc.SetName("cmake");
-    doc.SetSection("Name",cmDocumentationName);
-    doc.SetSection("Usage",cmDocumentationUsage);
-    doc.AppendSection("Generators",generators);
-    doc.PrependSection("Options",cmDocumentationOptions);
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    doc.AppendSection("Generators", generators);
+    doc.PrependSection("Options", cmDocumentationOptions);
 
-    return (doc.PrintRequestedDocumentation(std::cout)? 0:1);
-    }
+    return (doc.PrintRequestedDocumentation(std::cout) ? 0 : 1);
+  }
 
 #if defined(Q_OS_MAC)
-  if (argc2 == 2 && strcmp(argv2[1], "--install") == 0)
-    {
+  if (argc2 == 2 && strcmp(argv2[1], "--install") == 0) {
     return cmOSXInstall("/usr/local/bin");
-    }
-  if (argc2 == 2 && cmHasLiteralPrefix(argv2[1], "--install="))
-    {
-    return cmOSXInstall(argv2[1]+10);
-    }
+  }
+  if (argc2 == 2 && cmHasLiteralPrefix(argv2[1], "--install=")) {
+    return cmOSXInstall(argv2[1] + 10);
+  }
 #endif
 
   QApplication app(argc, argv);
@@ -103,10 +92,9 @@ int main(int argc, char** argv)
 
   // clean out standard Qt paths for plugins, which we don't use anyway
   // when creating Mac bundles, it potentially causes problems
-  foreach(QString p, QApplication::libraryPaths())
-    {
+  foreach (QString p, QApplication::libraryPaths()) {
     QApplication::removeLibraryPath(p);
-    }
+  }
 
   // tell the cmake library where cmake is
   QDir cmExecDir(QApplication::applicationDirPath());
@@ -139,110 +127,92 @@ int main(int argc, char** argv)
   std::string binaryDirectory;
   std::string sourceDirectory;
   typedef cmsys::CommandLineArguments argT;
-  arg.AddArgument("-B", argT::CONCAT_ARGUMENT,
-                  &binaryDirectory, "Binary Directory");
-  arg.AddArgument("-H", argT::CONCAT_ARGUMENT,
-                  &sourceDirectory, "Source Directory");
+  arg.AddArgument("-B", argT::CONCAT_ARGUMENT, &binaryDirectory,
+                  "Binary Directory");
+  arg.AddArgument("-H", argT::CONCAT_ARGUMENT, &sourceDirectory,
+                  "Source Directory");
   // do not complain about unknown options
   arg.StoreUnusedArguments(true);
   arg.Parse();
-  if(!sourceDirectory.empty() && !binaryDirectory.empty())
-    {
+  if (!sourceDirectory.empty() && !binaryDirectory.empty()) {
     dialog.setSourceDirectory(QString::fromLocal8Bit(sourceDirectory.c_str()));
     dialog.setBinaryDirectory(QString::fromLocal8Bit(binaryDirectory.c_str()));
-    }
-  else
-    {
+  } else {
     QStringList args = app.arguments();
-    if(args.count() == 2)
-      {
-      std::string filePath = cmSystemTools::CollapseFullPath(args[1].toLocal8Bit().data());
+    if (args.count() == 2) {
+      std::string filePath =
+        cmSystemTools::CollapseFullPath(args[1].toLocal8Bit().data());
 
       // check if argument is a directory containing CMakeCache.txt
       std::string buildFilePath =
         cmSystemTools::CollapseFullPath("CMakeCache.txt", filePath.c_str());
 
       // check if argument is a CMakeCache.txt file
-      if(cmSystemTools::GetFilenameName(filePath) == "CMakeCache.txt" &&
-         cmSystemTools::FileExists(filePath.c_str()))
-        {
+      if (cmSystemTools::GetFilenameName(filePath) == "CMakeCache.txt" &&
+          cmSystemTools::FileExists(filePath.c_str())) {
         buildFilePath = filePath;
-        }
+      }
 
       // check if argument is a directory containing CMakeLists.txt
       std::string srcFilePath =
         cmSystemTools::CollapseFullPath("CMakeLists.txt", filePath.c_str());
 
-      if(cmSystemTools::FileExists(buildFilePath.c_str()))
-        {
-        dialog.setBinaryDirectory(
-          QString::fromLocal8Bit(
-            cmSystemTools::GetFilenamePath(buildFilePath).c_str()
-            )
-          );
-        }
-      else if(cmSystemTools::FileExists(srcFilePath.c_str()))
-        {
+      if (cmSystemTools::FileExists(buildFilePath.c_str())) {
+        dialog.setBinaryDirectory(QString::fromLocal8Bit(
+          cmSystemTools::GetFilenamePath(buildFilePath).c_str()));
+      } else if (cmSystemTools::FileExists(srcFilePath.c_str())) {
         dialog.setSourceDirectory(QString::fromLocal8Bit(filePath.c_str()));
-        dialog.setBinaryDirectory(
-          QString::fromLocal8Bit(cmSystemTools::CollapseFullPath(".").c_str())
-          );
-        }
+        dialog.setBinaryDirectory(QString::fromLocal8Bit(
+          cmSystemTools::CollapseFullPath(".").c_str()));
       }
     }
+  }
 
   return app.exec();
 }
 
 #if defined(Q_OS_MAC)
-# include <errno.h>
-# include <string.h>
-# include <sys/stat.h>
-# include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
 static bool cmOSXInstall(std::string const& dir, std::string const& tool)
 {
-  if (tool.empty())
-    {
+  if (tool.empty()) {
     return true;
-    }
+  }
   std::string link = dir + cmSystemTools::GetFilenameName(tool);
   struct stat st;
-  if (lstat(link.c_str(), &st) == 0 && S_ISLNK(st.st_mode))
-    {
+  if (lstat(link.c_str(), &st) == 0 && S_ISLNK(st.st_mode)) {
     char buf[4096];
-    ssize_t s = readlink(link.c_str(), buf, sizeof(buf)-1);
-    if (s >= 0 && std::string(buf, s) == tool)
-      {
+    ssize_t s = readlink(link.c_str(), buf, sizeof(buf) - 1);
+    if (s >= 0 && std::string(buf, s) == tool) {
       std::cerr << "Exists: '" << link << "' -> '" << tool << "'\n";
       return true;
-      }
     }
+  }
   cmSystemTools::MakeDirectory(dir);
-  if (symlink(tool.c_str(), link.c_str()) == 0)
-    {
+  if (symlink(tool.c_str(), link.c_str()) == 0) {
     std::cerr << "Linked: '" << link << "' -> '" << tool << "'\n";
     return true;
-    }
-  else
-    {
+  } else {
     int err = errno;
-    std::cerr << "Failed: '" << link << "' -> '" << tool << "': "
-              << strerror(err) << "\n";
+    std::cerr << "Failed: '" << link << "' -> '" << tool
+              << "': " << strerror(err) << "\n";
     return false;
-    }
+  }
 }
 static int cmOSXInstall(std::string dir)
 {
-  if (!cmHasLiteralSuffix(dir, "/"))
-    {
+  if (!cmHasLiteralSuffix(dir, "/")) {
     dir += "/";
-    }
-  return (
-    cmOSXInstall(dir, cmSystemTools::GetCMakeCommand()) &&
-    cmOSXInstall(dir, cmSystemTools::GetCTestCommand()) &&
-    cmOSXInstall(dir, cmSystemTools::GetCPackCommand()) &&
-    cmOSXInstall(dir, cmSystemTools::GetCMakeGUICommand()) &&
-    cmOSXInstall(dir, cmSystemTools::GetCMakeCursesCommand())
-    ) ? 0 : 1;
+  }
+  return (cmOSXInstall(dir, cmSystemTools::GetCMakeCommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCTestCommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCPackCommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCMakeGUICommand()) &&
+          cmOSXInstall(dir, cmSystemTools::GetCMakeCursesCommand()))
+    ? 0
+    : 1;
 }
 #endif
diff --git a/Source/QtDialog/CMakeSetupDialog.cxx b/Source/QtDialog/CMakeSetupDialog.cxx
index 945739d..712611d 100644
--- a/Source/QtDialog/CMakeSetupDialog.cxx
+++ b/Source/QtDialog/CMakeSetupDialog.cxx
@@ -40,7 +40,8 @@
 #include "cmVersion.h"
 
 QCMakeThread::QCMakeThread(QObject* p)
-  : QThread(p), CMakeInstance(NULL)
+  : QThread(p)
+  , CMakeInstance(NULL)
 {
 }
 
@@ -60,7 +61,10 @@ void QCMakeThread::run()
 }
 
 CMakeSetupDialog::CMakeSetupDialog()
-  : ExitAfterGenerate(true), CacheModified(false), ConfigureNeeded(true), CurrentState(Interrupting)
+  : ExitAfterGenerate(true)
+  , CacheModified(false)
+  , ConfigureNeeded(true)
+  , CurrentState(Interrupting)
 {
   QString title = QString(tr("CMake %1"));
   title = title.arg(cmVersion::GetCMakeVersion());
@@ -72,10 +76,11 @@ CMakeSetupDialog::CMakeSetupDialog()
   restoreGeometry(settings.value("geometry").toByteArray());
   restoreState(settings.value("windowState").toByteArray());
 
-  this->AddVariableNames = settings.value("AddVariableNames",
-                           QStringList("CMAKE_INSTALL_PREFIX")).toStringList();
-  this->AddVariableTypes = settings.value("AddVariableTypes",
-                                           QStringList("PATH")).toStringList();
+  this->AddVariableNames =
+    settings.value("AddVariableNames", QStringList("CMAKE_INSTALL_PREFIX"))
+      .toStringList();
+  this->AddVariableTypes =
+    settings.value("AddVariableTypes", QStringList("PATH")).toStringList();
 
   QWidget* cont = new QWidget(this);
   this->setupUi(cont);
@@ -95,60 +100,57 @@ CMakeSetupDialog::CMakeSetupDialog()
 
   bool advancedView = settings.value("AdvancedView", false).toBool();
   this->setAdvancedView(advancedView);
-  this->advancedCheck->setCheckState(advancedView?Qt::Checked : Qt::Unchecked);
+  this->advancedCheck->setCheckState(advancedView ? Qt::Checked
+                                                  : Qt::Unchecked);
 
   QMenu* FileMenu = this->menuBar()->addMenu(tr("&File"));
   this->ReloadCacheAction = FileMenu->addAction(tr("&Reload Cache"));
-  QObject::connect(this->ReloadCacheAction, SIGNAL(triggered(bool)),
-                   this, SLOT(doReloadCache()));
+  QObject::connect(this->ReloadCacheAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doReloadCache()));
   this->DeleteCacheAction = FileMenu->addAction(tr("&Delete Cache"));
-  QObject::connect(this->DeleteCacheAction, SIGNAL(triggered(bool)),
-                   this, SLOT(doDeleteCache()));
+  QObject::connect(this->DeleteCacheAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doDeleteCache()));
   this->ExitAction = FileMenu->addAction(tr("E&xit"));
   this->ExitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
-  QObject::connect(this->ExitAction, SIGNAL(triggered(bool)),
-                   this, SLOT(close()));
+  QObject::connect(this->ExitAction, SIGNAL(triggered(bool)), this,
+                   SLOT(close()));
 
   QMenu* ToolsMenu = this->menuBar()->addMenu(tr("&Tools"));
   this->ConfigureAction = ToolsMenu->addAction(tr("&Configure"));
   // prevent merging with Preferences menu item on Mac OS X
   this->ConfigureAction->setMenuRole(QAction::NoRole);
-  QObject::connect(this->ConfigureAction, SIGNAL(triggered(bool)),
-                   this, SLOT(doConfigure()));
+  QObject::connect(this->ConfigureAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doConfigure()));
   this->GenerateAction = ToolsMenu->addAction(tr("&Generate"));
-  QObject::connect(this->GenerateAction, SIGNAL(triggered(bool)),
-                   this, SLOT(doGenerate()));
+  QObject::connect(this->GenerateAction, SIGNAL(triggered(bool)), this,
+                   SLOT(doGenerate()));
   QAction* showChangesAction = ToolsMenu->addAction(tr("&Show My Changes"));
-  QObject::connect(showChangesAction, SIGNAL(triggered(bool)),
-                   this, SLOT(showUserChanges()));
+  QObject::connect(showChangesAction, SIGNAL(triggered(bool)), this,
+                   SLOT(showUserChanges()));
 #if defined(Q_WS_MAC) || defined(Q_OS_MAC)
-  this->InstallForCommandLineAction
-    = ToolsMenu->addAction(tr("&How to Install For Command Line Use"));
+  this->InstallForCommandLineAction =
+    ToolsMenu->addAction(tr("&How to Install For Command Line Use"));
   QObject::connect(this->InstallForCommandLineAction, SIGNAL(triggered(bool)),
                    this, SLOT(doInstallForCommandLine()));
 #endif
   ToolsMenu->addSeparator();
-  ToolsMenu->addAction(tr("Regular Expression Explorer..."),
-                       this, SLOT(doRegexExplorerDialog()));
+  ToolsMenu->addAction(tr("Regular Expression Explorer..."), this,
+                       SLOT(doRegexExplorerDialog()));
   ToolsMenu->addSeparator();
-  ToolsMenu->addAction(tr("&Find in Output..."),
-                       this, SLOT(doOutputFindDialog()),
-                       QKeySequence::Find);
-  ToolsMenu->addAction(tr("Find Next"),
-                       this, SLOT(doOutputFindNext()),
+  ToolsMenu->addAction(tr("&Find in Output..."), this,
+                       SLOT(doOutputFindDialog()), QKeySequence::Find);
+  ToolsMenu->addAction(tr("Find Next"), this, SLOT(doOutputFindNext()),
                        QKeySequence::FindNext);
-  ToolsMenu->addAction(tr("Find Previous"),
-                       this, SLOT(doOutputFindPrev()),
+  ToolsMenu->addAction(tr("Find Previous"), this, SLOT(doOutputFindPrev()),
                        QKeySequence::FindPrevious);
-  ToolsMenu->addAction(tr("Goto Next Error"),
-                       this, SLOT(doOutputErrorNext()),
-                       QKeySequence(Qt::Key_F8));  // in Visual Studio
-  new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Period),
-                       this, SLOT(doOutputErrorNext()));  // in Eclipse
+  ToolsMenu->addAction(tr("Goto Next Error"), this, SLOT(doOutputErrorNext()),
+                       QKeySequence(Qt::Key_F8)); // in Visual Studio
+  new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_Period), this,
+                SLOT(doOutputErrorNext())); // in Eclipse
 
   QMenu* OptionsMenu = this->menuBar()->addMenu(tr("&Options"));
-  OptionsMenu->addAction(tr("Warning Messages..."),
-                         this, SLOT(doWarningMessagesDialog()));
+  OptionsMenu->addAction(tr("Warning Messages..."), this,
+                         SLOT(doWarningMessagesDialog()));
   this->WarnUninitializedAction =
     OptionsMenu->addAction(tr("&Warn Uninitialized (--warn-uninitialized)"));
   this->WarnUninitializedAction->setCheckable(true);
@@ -158,24 +160,24 @@ CMakeSetupDialog::CMakeSetupDialog()
 
   QAction* debugAction = OptionsMenu->addAction(tr("&Debug Output"));
   debugAction->setCheckable(true);
-  QObject::connect(debugAction, SIGNAL(toggled(bool)),
-                   this, SLOT(setDebugOutput(bool)));
+  QObject::connect(debugAction, SIGNAL(toggled(bool)), this,
+                   SLOT(setDebugOutput(bool)));
 
   OptionsMenu->addSeparator();
-  QAction* expandAction = OptionsMenu->addAction(tr("&Expand Grouped Entries"));
-  QObject::connect(expandAction, SIGNAL(triggered(bool)),
-                   this->CacheValues, SLOT(expandAll()));
-  QAction* collapseAction = OptionsMenu->addAction(tr("&Collapse Grouped Entries"));
-  QObject::connect(collapseAction, SIGNAL(triggered(bool)),
-                   this->CacheValues, SLOT(collapseAll()));
+  QAction* expandAction =
+    OptionsMenu->addAction(tr("&Expand Grouped Entries"));
+  QObject::connect(expandAction, SIGNAL(triggered(bool)), this->CacheValues,
+                   SLOT(expandAll()));
+  QAction* collapseAction =
+    OptionsMenu->addAction(tr("&Collapse Grouped Entries"));
+  QObject::connect(collapseAction, SIGNAL(triggered(bool)), this->CacheValues,
+                   SLOT(collapseAll()));
 
   QMenu* HelpMenu = this->menuBar()->addMenu(tr("&Help"));
   QAction* a = HelpMenu->addAction(tr("About"));
-  QObject::connect(a, SIGNAL(triggered(bool)),
-                   this, SLOT(doAbout()));
+  QObject::connect(a, SIGNAL(triggered(bool)), this, SLOT(doAbout()));
   a = HelpMenu->addAction(tr("Help"));
-  QObject::connect(a, SIGNAL(triggered(bool)),
-                   this, SLOT(doHelp()));
+  QObject::connect(a, SIGNAL(triggered(bool)), this, SLOT(doHelp()));
 
   this->setAcceptDrops(true);
 
@@ -193,12 +195,12 @@ CMakeSetupDialog::CMakeSetupDialog()
 
   this->Output->setContextMenuPolicy(Qt::CustomContextMenu);
   connect(this->Output, SIGNAL(customContextMenuRequested(const QPoint&)),
-          this, SLOT(doOutputContextMenu(const QPoint &)));
+          this, SLOT(doOutputContextMenu(const QPoint&)));
 
   // start the cmake worker thread
   this->CMakeThread = new QCMakeThread(this);
-  QObject::connect(this->CMakeThread, SIGNAL(cmakeInitialized()),
-                   this, SLOT(initialize()), Qt::QueuedConnection);
+  QObject::connect(this->CMakeThread, SIGNAL(cmakeInitialized()), this,
+                   SLOT(initialize()), Qt::QueuedConnection);
   this->CMakeThread->start();
 
   this->enterState(ReadyConfigure);
@@ -211,20 +213,20 @@ void CMakeSetupDialog::initialize()
 {
   // now the cmake worker thread is running, lets make our connections to it
   QObject::connect(this->CMakeThread->cmakeInstance(),
-      SIGNAL(propertiesChanged(const QCMakePropertyList&)),
-      this->CacheValues->cacheModel(),
-      SLOT(setProperties(const QCMakePropertyList&)));
+                   SIGNAL(propertiesChanged(const QCMakePropertyList&)),
+                   this->CacheValues->cacheModel(),
+                   SLOT(setProperties(const QCMakePropertyList&)));
 
-  QObject::connect(this->ConfigureButton, SIGNAL(clicked(bool)),
-                   this, SLOT(doConfigure()));
+  QObject::connect(this->ConfigureButton, SIGNAL(clicked(bool)), this,
+                   SLOT(doConfigure()));
 
-  QObject::connect(this->CMakeThread->cmakeInstance(), SIGNAL(configureDone(int)),
-                   this, SLOT(exitLoop(int)));
-  QObject::connect(this->CMakeThread->cmakeInstance(), SIGNAL(generateDone(int)),
-                   this, SLOT(exitLoop(int)));
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(configureDone(int)), this, SLOT(exitLoop(int)));
+  QObject::connect(this->CMakeThread->cmakeInstance(),
+                   SIGNAL(generateDone(int)), this, SLOT(exitLoop(int)));
 
-  QObject::connect(this->GenerateButton, SIGNAL(clicked(bool)),
-                   this, SLOT(doGenerate()));
+  QObject::connect(this->GenerateButton, SIGNAL(clicked(bool)), this,
+                   SLOT(doGenerate()));
 
   QObject::connect(this->BrowseSourceDirectoryButton, SIGNAL(clicked(bool)),
                    this, SLOT(doSourceBrowse()));
@@ -233,51 +235,50 @@ void CMakeSetupDialog::initialize()
 
   QObject::connect(this->BinaryDirectory, SIGNAL(editTextChanged(QString)),
                    this, SLOT(onBinaryDirectoryChanged(QString)));
-  QObject::connect(this->SourceDirectory, SIGNAL(textChanged(QString)),
-                   this, SLOT(onSourceDirectoryChanged(QString)));
+  QObject::connect(this->SourceDirectory, SIGNAL(textChanged(QString)), this,
+                   SLOT(onSourceDirectoryChanged(QString)));
 
   QObject::connect(this->CMakeThread->cmakeInstance(),
-                   SIGNAL(sourceDirChanged(QString)),
-                   this, SLOT(updateSourceDirectory(QString)));
+                   SIGNAL(sourceDirChanged(QString)), this,
+                   SLOT(updateSourceDirectory(QString)));
   QObject::connect(this->CMakeThread->cmakeInstance(),
-                   SIGNAL(binaryDirChanged(QString)),
-                   this, SLOT(updateBinaryDirectory(QString)));
+                   SIGNAL(binaryDirChanged(QString)), this,
+                   SLOT(updateBinaryDirectory(QString)));
 
   QObject::connect(this->CMakeThread->cmakeInstance(),
-                   SIGNAL(progressChanged(QString, float)),
-                   this, SLOT(showProgress(QString,float)));
+                   SIGNAL(progressChanged(QString, float)), this,
+                   SLOT(showProgress(QString, float)));
 
   QObject::connect(this->CMakeThread->cmakeInstance(),
-                   SIGNAL(errorMessage(QString)),
-                   this, SLOT(error(QString)));
+                   SIGNAL(errorMessage(QString)), this, SLOT(error(QString)));
 
   QObject::connect(this->CMakeThread->cmakeInstance(),
-                   SIGNAL(outputMessage(QString)),
-                   this, SLOT(message(QString)));
+                   SIGNAL(outputMessage(QString)), this,
+                   SLOT(message(QString)));
 
-  QObject::connect(this->groupedCheck, SIGNAL(toggled(bool)),
-                   this, SLOT(setGroupedView(bool)));
-  QObject::connect(this->advancedCheck, SIGNAL(toggled(bool)),
-                   this, SLOT(setAdvancedView(bool)));
-  QObject::connect(this->Search, SIGNAL(textChanged(QString)),
-                   this, SLOT(setSearchFilter(QString)));
+  QObject::connect(this->groupedCheck, SIGNAL(toggled(bool)), this,
+                   SLOT(setGroupedView(bool)));
+  QObject::connect(this->advancedCheck, SIGNAL(toggled(bool)), this,
+                   SLOT(setAdvancedView(bool)));
+  QObject::connect(this->Search, SIGNAL(textChanged(QString)), this,
+                   SLOT(setSearchFilter(QString)));
 
   QObject::connect(this->CMakeThread->cmakeInstance(),
-                   SIGNAL(generatorChanged(QString)),
-                   this, SLOT(updateGeneratorLabel(QString)));
+                   SIGNAL(generatorChanged(QString)), this,
+                   SLOT(updateGeneratorLabel(QString)));
   this->updateGeneratorLabel(QString());
 
   QObject::connect(this->CacheValues->cacheModel(),
-                   SIGNAL(dataChanged(QModelIndex,QModelIndex)),
-                   this, SLOT(setCacheModified()));
+                   SIGNAL(dataChanged(QModelIndex, QModelIndex)), this,
+                   SLOT(setCacheModified()));
 
   QObject::connect(this->CacheValues->selectionModel(),
-                   SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
+                   SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
                    this, SLOT(selectionChanged()));
-  QObject::connect(this->RemoveEntry, SIGNAL(clicked(bool)),
-                   this, SLOT(removeSelectedCacheEntries()));
-  QObject::connect(this->AddEntry, SIGNAL(clicked(bool)),
-                   this, SLOT(addCacheEntry()));
+  QObject::connect(this->RemoveEntry, SIGNAL(clicked(bool)), this,
+                   SLOT(removeSelectedCacheEntries()));
+  QObject::connect(this->AddEntry, SIGNAL(clicked(bool)), this,
+                   SLOT(addCacheEntry()));
 
   QObject::connect(this->WarnUninitializedAction, SIGNAL(triggered(bool)),
                    this->CMakeThread->cmakeInstance(),
@@ -286,16 +287,13 @@ void CMakeSetupDialog::initialize()
                    this->CMakeThread->cmakeInstance(),
                    SLOT(setWarnUnusedMode(bool)));
 
-  if(!this->SourceDirectory->text().isEmpty() ||
-     !this->BinaryDirectory->lineEdit()->text().isEmpty())
-    {
+  if (!this->SourceDirectory->text().isEmpty() ||
+      !this->BinaryDirectory->lineEdit()->text().isEmpty()) {
     this->onSourceDirectoryChanged(this->SourceDirectory->text());
     this->onBinaryDirectoryChanged(this->BinaryDirectory->lineEdit()->text());
-    }
-  else
-    {
+  } else {
     this->onBinaryDirectoryChanged(this->BinaryDirectory->lineEdit()->text());
-    }
+  }
 }
 
 CMakeSetupDialog::~CMakeSetupDialog()
@@ -316,38 +314,34 @@ bool CMakeSetupDialog::prepareConfigure()
   // make sure build directory exists
   QString bindir = this->CMakeThread->cmakeInstance()->binaryDirectory();
   QDir dir(bindir);
-  if(!dir.exists())
-    {
+  if (!dir.exists()) {
     QString msg = tr("Build directory does not exist, "
-                         "should I create it?\n\n"
-                      "Directory: ");
+                     "should I create it?\n\n"
+                     "Directory: ");
     msg += bindir;
     QString title = tr("Create Directory");
     QMessageBox::StandardButton btn;
     btn = QMessageBox::information(this, title, msg,
                                    QMessageBox::Yes | QMessageBox::No);
-    if(btn == QMessageBox::No)
-      {
+    if (btn == QMessageBox::No) {
       return false;
-      }
-    if(!dir.mkpath("."))
-      {
-      QMessageBox::information(this, tr("Create Directory Failed"),
+    }
+    if (!dir.mkpath(".")) {
+      QMessageBox::information(
+        this, tr("Create Directory Failed"),
         QString(tr("Failed to create directory %1")).arg(dir.path()),
         QMessageBox::Ok);
 
       return false;
-      }
     }
+  }
 
   // if no generator, prompt for it and other setup stuff
-  if(this->CMakeThread->cmakeInstance()->generator().isEmpty())
-    {
-    if(!this->setupFirstConfigure())
-      {
+  if (this->CMakeThread->cmakeInstance()->generator().isEmpty()) {
+    if (!this->setupFirstConfigure()) {
       return false;
-      }
     }
+  }
 
   // remember path
   this->addBinaryPath(dir.absolutePath());
@@ -362,36 +356,30 @@ void CMakeSetupDialog::exitLoop(int err)
 
 void CMakeSetupDialog::doConfigure()
 {
-  if(this->CurrentState == Configuring)
-    {
+  if (this->CurrentState == Configuring) {
     // stop configure
     doInterrupt();
     return;
-    }
+  }
 
-  if(!prepareConfigure())
-    {
+  if (!prepareConfigure()) {
     return;
-    }
+  }
 
   this->enterState(Configuring);
 
   bool ret = doConfigureInternal();
 
-  if(ret)
-    {
+  if (ret) {
     this->ConfigureNeeded = false;
-    }
+  }
 
-  if(ret && !this->CacheValues->cacheModel()->newPropertyCount())
-    {
+  if (ret && !this->CacheValues->cacheModel()->newPropertyCount()) {
     this->enterState(ReadyGenerate);
-    }
-  else
-    {
+  } else {
     this->enterState(ReadyConfigure);
     this->CacheValues->scrollToTop();
-    }
+  }
   this->ProgressBar->reset();
 }
 
@@ -400,21 +388,20 @@ bool CMakeSetupDialog::doConfigureInternal()
   this->Output->clear();
   this->CacheValues->selectionModel()->clear();
 
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "setProperties", Qt::QueuedConnection,
-    Q_ARG(QCMakePropertyList,
-      this->CacheValues->cacheModel()->properties()));
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "configure", Qt::QueuedConnection);
+  QMetaObject::invokeMethod(
+    this->CMakeThread->cmakeInstance(), "setProperties", Qt::QueuedConnection,
+    Q_ARG(QCMakePropertyList, this->CacheValues->cacheModel()->properties()));
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "configure",
+                            Qt::QueuedConnection);
 
   int err = this->LocalLoop.exec();
 
-  if(err != 0)
-    {
-    QMessageBox::critical(this, tr("Error"),
+  if (err != 0) {
+    QMessageBox::critical(
+      this, tr("Error"),
       tr("Error in configuration process, project files may be invalid"),
       QMessageBox::Ok);
-    }
+  }
 
   return 0 == err;
 }
@@ -422,21 +409,19 @@ bool CMakeSetupDialog::doConfigureInternal()
 void CMakeSetupDialog::doInstallForCommandLine()
 {
   QString title = tr("How to Install For Command Line Use");
-  QString msg = tr(
-    "One may add CMake to the PATH:\n"
-    "\n"
-    " PATH=\"%1\":\"$PATH\"\n"
-    "\n"
-    "Or, to install symlinks to '/usr/local/bin', run:\n"
-    "\n"
-    " sudo \"%2\" --install\n"
-    "\n"
-    "Or, to install symlinks to another directory, run:\n"
-    "\n"
-    " sudo \"%3\" --install=/path/to/bin\n"
-    );
-  msg = msg.arg(cmSystemTools::GetFilenamePath(
-                  cmSystemTools::GetCMakeCommand()).c_str());
+  QString msg = tr("One may add CMake to the PATH:\n"
+                   "\n"
+                   " PATH=\"%1\":\"$PATH\"\n"
+                   "\n"
+                   "Or, to install symlinks to '/usr/local/bin', run:\n"
+                   "\n"
+                   " sudo \"%2\" --install\n"
+                   "\n"
+                   "Or, to install symlinks to another directory, run:\n"
+                   "\n"
+                   " sudo \"%3\" --install=/path/to/bin\n");
+  msg = msg.arg(
+    cmSystemTools::GetFilenamePath(cmSystemTools::GetCMakeCommand()).c_str());
   msg = msg.arg(cmSystemTools::GetCMakeGUICommand().c_str());
   msg = msg.arg(cmSystemTools::GetCMakeGUICommand().c_str());
 
@@ -448,8 +433,8 @@ void CMakeSetupDialog::doInstallForCommandLine()
   lab->setText(msg);
   lab->setWordWrap(false);
   lab->setTextInteractionFlags(Qt::TextSelectableByMouse);
-  QDialogButtonBox* btns = new QDialogButtonBox(QDialogButtonBox::Ok,
-                                                Qt::Horizontal, &dialog);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, &dialog);
   QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
   l->addWidget(btns);
   dialog.exec();
@@ -457,57 +442,52 @@ void CMakeSetupDialog::doInstallForCommandLine()
 
 bool CMakeSetupDialog::doGenerateInternal()
 {
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "generate", Qt::QueuedConnection);
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "generate",
+                            Qt::QueuedConnection);
 
   int err = this->LocalLoop.exec();
 
-  if(err != 0)
-    {
-    QMessageBox::critical(this, tr("Error"),
+  if (err != 0) {
+    QMessageBox::critical(
+      this, tr("Error"),
       tr("Error in generation process, project files may be invalid"),
       QMessageBox::Ok);
-    }
+  }
 
   return 0 == err;
 }
 
 void CMakeSetupDialog::doGenerate()
 {
-  if(this->CurrentState == Generating)
-    {
+  if (this->CurrentState == Generating) {
     // stop generate
     doInterrupt();
     return;
-    }
+  }
 
   // see if we need to configure
   // we'll need to configure if:
   //   the configure step hasn't been done yet
   //   generate was the last step done
-  if(this->ConfigureNeeded)
-    {
-    if(!prepareConfigure())
-      {
+  if (this->ConfigureNeeded) {
+    if (!prepareConfigure()) {
       return;
-      }
     }
+  }
 
   this->enterState(Generating);
 
   bool config_passed = true;
-  if(this->ConfigureNeeded)
-    {
+  if (this->ConfigureNeeded) {
     this->CacheValues->cacheModel()->setShowNewProperties(false);
     this->ProgressFactor = 0.5;
     config_passed = doConfigureInternal();
     this->ProgressOffset = 0.5;
-    }
+  }
 
-  if(config_passed)
-    {
+  if (config_passed) {
     doGenerateInternal();
-    }
+  }
 
   this->ProgressOffset = 0.0;
   this->ProgressFactor = 1.0;
@@ -522,78 +502,83 @@ void CMakeSetupDialog::doGenerate()
 void CMakeSetupDialog::closeEvent(QCloseEvent* e)
 {
   // prompt for close if there are unsaved changes, and we're not busy
-  if(this->CacheModified)
-    {
+  if (this->CacheModified) {
     QString msg = tr("You have changed options but not rebuilt, "
-                    "are you sure you want to exit?");
+                     "are you sure you want to exit?");
     QString title = tr("Confirm Exit");
     QMessageBox::StandardButton btn;
     btn = QMessageBox::critical(this, title, msg,
                                 QMessageBox::Yes | QMessageBox::No);
-    if(btn == QMessageBox::No)
-      {
+    if (btn == QMessageBox::No) {
       e->ignore();
-      }
     }
+  }
 
   // don't close if we're busy, unless the user really wants to
-  if(this->CurrentState == Configuring)
-    {
-    QString msg = tr("You are in the middle of a Configure.\n"
-                   "If you Exit now the configure information will be lost.\n"
-                   "Are you sure you want to Exit?");
+  if (this->CurrentState == Configuring) {
+    QString msg =
+      tr("You are in the middle of a Configure.\n"
+         "If you Exit now the configure information will be lost.\n"
+         "Are you sure you want to Exit?");
     QString title = tr("Confirm Exit");
     QMessageBox::StandardButton btn;
     btn = QMessageBox::critical(this, title, msg,
                                 QMessageBox::Yes | QMessageBox::No);
-    if(btn == QMessageBox::No)
-      {
+    if (btn == QMessageBox::No) {
       e->ignore();
-      }
-    else
-      {
+    } else {
       this->doInterrupt();
-      }
     }
+  }
 
   // let the generate finish
-  if(this->CurrentState == Generating)
-    {
+  if (this->CurrentState == Generating) {
     e->ignore();
-    }
+  }
 }
 
 void CMakeSetupDialog::doHelp()
 {
-  QString msg = tr("CMake is used to configure and generate build files for "
+  QString msg = tr(
+    "CMake is used to configure and generate build files for "
     "software projects.   The basic steps for configuring a project are as "
-    "follows:\r\n\r\n1. Select the source directory for the project.  This should "
-    "contain the CMakeLists.txt files for the project.\r\n\r\n2. Select the build "
-    "directory for the project.   This is the directory where the project will be "
+    "follows:\r\n\r\n1. Select the source directory for the project.  This "
+    "should "
+    "contain the CMakeLists.txt files for the project.\r\n\r\n2. Select the "
+    "build "
+    "directory for the project.   This is the directory where the project "
+    "will be "
     "built.  It can be the same or a different directory than the source "
-    "directory.   For easy clean up, a separate build directory is recommended. "
+    "directory.   For easy clean up, a separate build directory is "
+    "recommended. "
     "CMake will create the directory if it does not exist.\r\n\r\n3. Once the "
     "source and binary directories are selected, it is time to press the "
-    "Configure button.  This will cause CMake to read all of the input files and "
-    "discover all the variables used by the project.   The first time a variable "
-    "is displayed it will be in Red.   Users should inspect red variables making "
-    "sure the values are correct.   For some projects the Configure process can "
-    "be iterative, so continue to press the Configure button until there are no "
+    "Configure button.  This will cause CMake to read all of the input files "
+    "and "
+    "discover all the variables used by the project.   The first time a "
+    "variable "
+    "is displayed it will be in Red.   Users should inspect red variables "
+    "making "
+    "sure the values are correct.   For some projects the Configure process "
+    "can "
+    "be iterative, so continue to press the Configure button until there are "
+    "no "
     "longer red entries.\r\n\r\n4. Once there are no longer red entries, you "
-    "should click the Generate button.  This will write the build files to the build "
+    "should click the Generate button.  This will write the build files to "
+    "the build "
     "directory.");
 
   QDialog dialog;
   QFontMetrics met(this->font());
   int msgWidth = met.width(msg);
-  dialog.setMinimumSize(msgWidth/15,20);
+  dialog.setMinimumSize(msgWidth / 15, 20);
   dialog.setWindowTitle(tr("Help"));
   QVBoxLayout* l = new QVBoxLayout(&dialog);
   QLabel* lab = new QLabel(&dialog);
   lab->setText(msg);
   lab->setWordWrap(true);
-  QDialogButtonBox* btns = new QDialogButtonBox(QDialogButtonBox::Ok,
-                                                Qt::Horizontal, &dialog);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, &dialog);
   QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
   l->addWidget(lab);
   l->addWidget(btns);
@@ -608,44 +593,40 @@ void CMakeSetupDialog::doInterrupt()
 
 void CMakeSetupDialog::doSourceBrowse()
 {
-  QString dir = QFileDialog::getExistingDirectory(this,
-    tr("Enter Path to Source"), this->SourceDirectory->text(),
+  QString dir = QFileDialog::getExistingDirectory(
+    this, tr("Enter Path to Source"), this->SourceDirectory->text(),
     QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
-  if(!dir.isEmpty())
-    {
+  if (!dir.isEmpty()) {
     this->setSourceDirectory(dir);
-    }
+  }
 }
 
 void CMakeSetupDialog::updateSourceDirectory(const QString& dir)
 {
-  if(this->SourceDirectory->text() != dir)
-    {
+  if (this->SourceDirectory->text() != dir) {
     this->SourceDirectory->blockSignals(true);
     this->SourceDirectory->setText(dir);
     this->SourceDirectory->blockSignals(false);
-    }
+  }
 }
 
 void CMakeSetupDialog::updateBinaryDirectory(const QString& dir)
 {
-  if(this->BinaryDirectory->currentText() != dir)
-    {
+  if (this->BinaryDirectory->currentText() != dir) {
     this->BinaryDirectory->blockSignals(true);
     this->BinaryDirectory->setEditText(dir);
     this->BinaryDirectory->blockSignals(false);
-    }
+  }
 }
 
 void CMakeSetupDialog::doBinaryBrowse()
 {
-  QString dir = QFileDialog::getExistingDirectory(this,
-    tr("Enter Path to Build"), this->BinaryDirectory->currentText(),
+  QString dir = QFileDialog::getExistingDirectory(
+    this, tr("Enter Path to Build"), this->BinaryDirectory->currentText(),
     QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
-  if(!dir.isEmpty() && dir != this->BinaryDirectory->currentText())
-    {
+  if (!dir.isEmpty() && dir != this->BinaryDirectory->currentText()) {
     this->setBinaryDirectory(dir);
-    }
+  }
 }
 
 void CMakeSetupDialog::setBinaryDirectory(const QString& dir)
@@ -657,7 +638,8 @@ void CMakeSetupDialog::onSourceDirectoryChanged(const QString& dir)
 {
   this->Output->clear();
   QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "setSourceDirectory", Qt::QueuedConnection, Q_ARG(QString, dir));
+                            "setSourceDirectory", Qt::QueuedConnection,
+                            Q_ARG(QString, dir));
 }
 
 void CMakeSetupDialog::onBinaryDirectoryChanged(const QString& dir)
@@ -669,10 +651,12 @@ void CMakeSetupDialog::onBinaryDirectoryChanged(const QString& dir)
 
   this->CacheModified = false;
   this->CacheValues->cacheModel()->clear();
-  qobject_cast<QCMakeCacheModelDelegate*>(this->CacheValues->itemDelegate())->clearChanges();
+  qobject_cast<QCMakeCacheModelDelegate*>(this->CacheValues->itemDelegate())
+    ->clearChanges();
   this->Output->clear();
   QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "setBinaryDirectory", Qt::QueuedConnection, Q_ARG(QString, dir));
+                            "setBinaryDirectory", Qt::QueuedConnection,
+                            Q_ARG(QString, dir));
 }
 
 void CMakeSetupDialog::setSourceDirectory(const QString& dir)
@@ -689,13 +673,14 @@ void CMakeSetupDialog::showProgress(const QString& /*msg*/, float percent)
 void CMakeSetupDialog::error(const QString& msg)
 {
   this->Output->setCurrentCharFormat(this->ErrorFormat);
-  //QTextEdit will terminate the msg with a ParagraphSeparator, but it also replaces
-  //all newlines with ParagraphSeparators. By replacing the newlines by ourself, one
-  //error msg will be one paragraph.
+  // QTextEdit will terminate the msg with a ParagraphSeparator, but it also
+  // replaces
+  // all newlines with ParagraphSeparators. By replacing the newlines by
+  // ourself, one
+  // error msg will be one paragraph.
   QString paragraph(msg);
   paragraph.replace(QLatin1Char('\n'), QChar::LineSeparator);
   this->Output->append(paragraph);
-
 }
 
 void CMakeSetupDialog::message(const QString& msg)
@@ -717,7 +702,7 @@ void CMakeSetupDialog::setEnabledState(bool enabled)
   this->ExitAction->setEnabled(enabled);
   this->ConfigureAction->setEnabled(enabled);
   this->AddEntry->setEnabled(enabled);
-  this->RemoveEntry->setEnabled(false);  // let selection re-enable it
+  this->RemoveEntry->setEnabled(false); // let selection re-enable it
 }
 
 bool CMakeSetupDialog::setupFirstConfigure()
@@ -727,58 +712,54 @@ bool CMakeSetupDialog::setupFirstConfigure()
   // initialize dialog and restore saved settings
 
   // add generators
-  dialog.setGenerators(this->CMakeThread->cmakeInstance()->availableGenerators());
+  dialog.setGenerators(
+    this->CMakeThread->cmakeInstance()->availableGenerators());
 
   // restore from settings
   dialog.loadFromSettings();
 
-  if(dialog.exec() == QDialog::Accepted)
-    {
+  if (dialog.exec() == QDialog::Accepted) {
     dialog.saveToSettings();
     this->CMakeThread->cmakeInstance()->setGenerator(dialog.getGenerator());
     this->CMakeThread->cmakeInstance()->setToolset(dialog.getToolset());
 
     QCMakeCacheModel* m = this->CacheValues->cacheModel();
 
-    if(dialog.compilerSetup())
-      {
+    if (dialog.compilerSetup()) {
       QString fortranCompiler = dialog.getFortranCompiler();
-      if(!fortranCompiler.isEmpty())
-        {
+      if (!fortranCompiler.isEmpty()) {
         m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_Fortran_COMPILER",
                           "Fortran compiler.", fortranCompiler, false);
-        }
+      }
       QString cxxCompiler = dialog.getCXXCompiler();
-      if(!cxxCompiler.isEmpty())
-        {
+      if (!cxxCompiler.isEmpty()) {
         m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_CXX_COMPILER",
                           "CXX compiler.", cxxCompiler, false);
-        }
+      }
 
       QString cCompiler = dialog.getCCompiler();
-      if(!cCompiler.isEmpty())
-        {
+      if (!cCompiler.isEmpty()) {
         m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_C_COMPILER",
                           "C compiler.", cCompiler, false);
-        }
       }
-    else if(dialog.crossCompilerSetup())
-      {
+    } else if (dialog.crossCompilerSetup()) {
       QString fortranCompiler = dialog.getFortranCompiler();
-      if(!fortranCompiler.isEmpty())
-        {
+      if (!fortranCompiler.isEmpty()) {
         m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_Fortran_COMPILER",
                           "Fortran compiler.", fortranCompiler, false);
-        }
+      }
 
       QString mode = dialog.getCrossIncludeMode();
-      m->insertProperty(QCMakeProperty::STRING, "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE",
+      m->insertProperty(QCMakeProperty::STRING,
+                        "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE",
                         tr("CMake Find Include Mode"), mode, false);
       mode = dialog.getCrossLibraryMode();
-      m->insertProperty(QCMakeProperty::STRING, "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY",
+      m->insertProperty(QCMakeProperty::STRING,
+                        "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY",
                         tr("CMake Find Library Mode"), mode, false);
       mode = dialog.getCrossProgramMode();
-      m->insertProperty(QCMakeProperty::STRING, "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM",
+      m->insertProperty(QCMakeProperty::STRING,
+                        "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM",
                         tr("CMake Find Program Mode"), mode, false);
 
       QString rootPath = dialog.getCrossRoot();
@@ -797,15 +778,14 @@ bool CMakeSetupDialog::setupFirstConfigure()
       QString cCompiler = dialog.getCCompiler();
       m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_C_COMPILER",
                         tr("C compiler."), cCompiler, false);
-      }
-    else if(dialog.crossCompilerToolChainFile())
-      {
+    } else if (dialog.crossCompilerToolChainFile()) {
       QString toolchainFile = dialog.getCrossCompilerToolChainFile();
       m->insertProperty(QCMakeProperty::FILEPATH, "CMAKE_TOOLCHAIN_FILE",
-                        tr("Cross Compile ToolChain File"), toolchainFile, false);
-      }
-    return true;
+                        tr("Cross Compile ToolChain File"), toolchainFile,
+                        false);
     }
+    return true;
+  }
 
   return false;
 }
@@ -813,21 +793,18 @@ bool CMakeSetupDialog::setupFirstConfigure()
 void CMakeSetupDialog::updateGeneratorLabel(const QString& gen)
 {
   QString str = tr("Current Generator: ");
-  if(gen.isEmpty())
-    {
+  if (gen.isEmpty()) {
     str += tr("None");
-    }
-  else
-    {
+  } else {
     str += gen;
-    }
+  }
   this->Generator->setText(str);
 }
 
 void CMakeSetupDialog::doReloadCache()
 {
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "reloadCache", Qt::QueuedConnection);
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "reloadCache",
+                            Qt::QueuedConnection);
 }
 
 void CMakeSetupDialog::doDeleteCache()
@@ -837,12 +814,11 @@ void CMakeSetupDialog::doDeleteCache()
   QMessageBox::StandardButton btn;
   btn = QMessageBox::information(this, title, msg,
                                  QMessageBox::Yes | QMessageBox::No);
-  if(btn == QMessageBox::No)
-    {
+  if (btn == QMessageBox::No) {
     return;
-    }
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-                            "deleteCache", Qt::QueuedConnection);
+  }
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(), "deleteCache",
+                            Qt::QueuedConnection);
 }
 
 void CMakeSetupDialog::doAbout()
@@ -864,7 +840,7 @@ void CMakeSetupDialog::doAbout()
   msg = msg.arg(cmVersion::GetCMakeVersion());
   msg = msg.arg(qVersion());
 #ifdef CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL
-  std::string lgpl = cmSystemTools::GetCMakeRoot()+"/Licenses/LGPLv2.1.txt";
+  std::string lgpl = cmSystemTools::GetCMakeRoot() + "/Licenses/LGPLv2.1.txt";
   msg = msg.arg(lgpl.c_str());
 #endif
 
@@ -875,8 +851,8 @@ void CMakeSetupDialog::doAbout()
   l->addWidget(lab);
   lab->setText(msg);
   lab->setWordWrap(true);
-  QDialogButtonBox* btns = new QDialogButtonBox(QDialogButtonBox::Ok,
-                                                Qt::Horizontal, &dialog);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, &dialog);
   QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
   l->addWidget(btns);
   dialog.exec();
@@ -894,10 +870,9 @@ void CMakeSetupDialog::addBinaryPath(const QString& path)
   // update UI
   this->BinaryDirectory->blockSignals(true);
   int idx = this->BinaryDirectory->findText(cleanpath);
-  if(idx != -1)
-    {
+  if (idx != -1) {
     this->BinaryDirectory->removeItem(idx);
-    }
+  }
   this->BinaryDirectory->insertItem(0, cleanpath);
   this->BinaryDirectory->setCurrentIndex(0);
   this->BinaryDirectory->blockSignals(false);
@@ -911,56 +886,48 @@ void CMakeSetupDialog::addBinaryPath(const QString& path)
 
 void CMakeSetupDialog::dragEnterEvent(QDragEnterEvent* e)
 {
-  if(!(this->CurrentState == ReadyConfigure ||
-     this->CurrentState == ReadyGenerate))
-    {
+  if (!(this->CurrentState == ReadyConfigure ||
+        this->CurrentState == ReadyGenerate)) {
     e->ignore();
     return;
-    }
+  }
 
   const QMimeData* dat = e->mimeData();
   QList<QUrl> urls = dat->urls();
   QString file = urls.count() ? urls[0].toLocalFile() : QString();
-  if(!file.isEmpty() &&
-    (file.endsWith("CMakeCache.txt", Qt::CaseInsensitive) ||
-    file.endsWith("CMakeLists.txt", Qt::CaseInsensitive) ) )
-    {
+  if (!file.isEmpty() &&
+      (file.endsWith("CMakeCache.txt", Qt::CaseInsensitive) ||
+       file.endsWith("CMakeLists.txt", Qt::CaseInsensitive))) {
     e->accept();
-    }
-  else
-    {
+  } else {
     e->ignore();
-    }
+  }
 }
 
 void CMakeSetupDialog::dropEvent(QDropEvent* e)
 {
-  if(!(this->CurrentState == ReadyConfigure ||
-     this->CurrentState == ReadyGenerate))
-    {
+  if (!(this->CurrentState == ReadyConfigure ||
+        this->CurrentState == ReadyGenerate)) {
     return;
-    }
+  }
 
   const QMimeData* dat = e->mimeData();
   QList<QUrl> urls = dat->urls();
   QString file = urls.count() ? urls[0].toLocalFile() : QString();
-  if(file.endsWith("CMakeCache.txt", Qt::CaseInsensitive))
-    {
+  if (file.endsWith("CMakeCache.txt", Qt::CaseInsensitive)) {
     QFileInfo info(file);
-    if(this->CMakeThread->cmakeInstance()->binaryDirectory() != info.absolutePath())
-      {
+    if (this->CMakeThread->cmakeInstance()->binaryDirectory() !=
+        info.absolutePath()) {
       this->setBinaryDirectory(info.absolutePath());
-      }
     }
-  else if(file.endsWith("CMakeLists.txt", Qt::CaseInsensitive))
-    {
+  } else if (file.endsWith("CMakeLists.txt", Qt::CaseInsensitive)) {
     QFileInfo info(file);
-    if(this->CMakeThread->cmakeInstance()->binaryDirectory() != info.absolutePath())
-      {
+    if (this->CMakeThread->cmakeInstance()->binaryDirectory() !=
+        info.absolutePath()) {
       this->setSourceDirectory(info.absolutePath());
       this->setBinaryDirectory(info.absolutePath());
-      }
     }
+  }
 }
 
 QStringList CMakeSetupDialog::loadBuildPaths()
@@ -969,14 +936,12 @@ QStringList CMakeSetupDialog::loadBuildPaths()
   settings.beginGroup("Settings/StartPath");
 
   QStringList buildPaths;
-  for(int i=0; i<10; i++)
-    {
-      QString p = settings.value(QString("WhereBuild%1").arg(i)).toString();
-      if(!p.isEmpty())
-        {
-        buildPaths.append(p);
-        }
+  for (int i = 0; i < 10; i++) {
+    QString p = settings.value(QString("WhereBuild%1").arg(i)).toString();
+    if (!p.isEmpty()) {
+      buildPaths.append(p);
     }
+  }
   return buildPaths;
 }
 
@@ -986,15 +951,13 @@ void CMakeSetupDialog::saveBuildPaths(const QStringList& paths)
   settings.beginGroup("Settings/StartPath");
 
   int num = paths.count();
-  if(num > 10)
-    {
+  if (num > 10) {
     num = 10;
-    }
+  }
 
-  for(int i=0; i<num; i++)
-    {
+  for (int i = 0; i < num; i++) {
     settings.setValue(QString("WhereBuild%1").arg(i), paths[i]);
-    }
+  }
 }
 
 void CMakeSetupDialog::setCacheModified()
@@ -1008,78 +971,62 @@ void CMakeSetupDialog::removeSelectedCacheEntries()
 {
   QModelIndexList idxs = this->CacheValues->selectionModel()->selectedRows();
   QList<QPersistentModelIndex> pidxs;
-  foreach(QModelIndex i, idxs)
-    {
+  foreach (QModelIndex i, idxs) {
     pidxs.append(i);
-    }
-  foreach(QPersistentModelIndex pi, pidxs)
-    {
+  }
+  foreach (QPersistentModelIndex pi, pidxs) {
     this->CacheValues->model()->removeRow(pi.row(), pi.parent());
-    }
+  }
 }
 
 void CMakeSetupDialog::selectionChanged()
 {
   QModelIndexList idxs = this->CacheValues->selectionModel()->selectedRows();
-  if(idxs.count() &&
-      (this->CurrentState == ReadyConfigure ||
-       this->CurrentState == ReadyGenerate) )
-    {
+  if (idxs.count() && (this->CurrentState == ReadyConfigure ||
+                       this->CurrentState == ReadyGenerate)) {
     this->RemoveEntry->setEnabled(true);
-    }
-  else
-    {
+  } else {
     this->RemoveEntry->setEnabled(false);
-    }
+  }
 }
 
 void CMakeSetupDialog::enterState(CMakeSetupDialog::State s)
 {
-  if(s == this->CurrentState)
-    {
+  if (s == this->CurrentState) {
     return;
-    }
+  }
 
   this->CurrentState = s;
 
-  if(s == Interrupting)
-    {
+  if (s == Interrupting) {
     this->ConfigureButton->setEnabled(false);
     this->GenerateButton->setEnabled(false);
-    }
-  else if(s == Configuring)
-    {
+  } else if (s == Configuring) {
     this->setEnabledState(false);
     this->GenerateButton->setEnabled(false);
     this->GenerateAction->setEnabled(false);
     this->ConfigureButton->setText(tr("&Stop"));
-    }
-  else if(s == Generating)
-    {
+  } else if (s == Generating) {
     this->CacheModified = false;
     this->setEnabledState(false);
     this->ConfigureButton->setEnabled(false);
     this->GenerateAction->setEnabled(false);
     this->GenerateButton->setText(tr("&Stop"));
-    }
-  else if(s == ReadyConfigure)
-    {
+  } else if (s == ReadyConfigure) {
     this->setEnabledState(true);
     this->GenerateButton->setEnabled(true);
     this->GenerateAction->setEnabled(true);
     this->ConfigureButton->setEnabled(true);
     this->ConfigureButton->setText(tr("&Configure"));
     this->GenerateButton->setText(tr("&Generate"));
-    }
-  else if(s == ReadyGenerate)
-    {
+  } else if (s == ReadyGenerate) {
     this->setEnabledState(true);
     this->GenerateButton->setEnabled(true);
     this->GenerateAction->setEnabled(true);
     this->ConfigureButton->setEnabled(true);
     this->ConfigureButton->setText(tr("&Configure"));
     this->GenerateButton->setText(tr("&Generate"));
-    }
+  }
 }
 
 void CMakeSetupDialog::addCacheEntry()
@@ -1088,44 +1035,40 @@ void CMakeSetupDialog::addCacheEntry()
   dialog.resize(400, 200);
   dialog.setWindowTitle(tr("Add Cache Entry"));
   QVBoxLayout* l = new QVBoxLayout(&dialog);
-  AddCacheEntry* w = new AddCacheEntry(&dialog, this->AddVariableNames,
-                                                this->AddVariableTypes);
+  AddCacheEntry* w =
+    new AddCacheEntry(&dialog, this->AddVariableNames, this->AddVariableTypes);
   QDialogButtonBox* btns = new QDialogButtonBox(
-      QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
-      Qt::Horizontal, &dialog);
+    QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, &dialog);
   QObject::connect(btns, SIGNAL(accepted()), &dialog, SLOT(accept()));
   QObject::connect(btns, SIGNAL(rejected()), &dialog, SLOT(reject()));
   l->addWidget(w);
   l->addStretch();
   l->addWidget(btns);
-  if(QDialog::Accepted == dialog.exec())
-    {
+  if (QDialog::Accepted == dialog.exec()) {
     QCMakeCacheModel* m = this->CacheValues->cacheModel();
-    m->insertProperty(w->type(), w->name(), w->description(), w->value(), false);
+    m->insertProperty(w->type(), w->name(), w->description(), w->value(),
+                      false);
 
     // only add variable names to the completion which are new
-    if (!this->AddVariableNames.contains(w->name()))
-      {
+    if (!this->AddVariableNames.contains(w->name())) {
       this->AddVariableNames << w->name();
       this->AddVariableTypes << w->typeString();
       // limit to at most 100 completion items
-      if (this->AddVariableNames.size() > 100)
-        {
+      if (this->AddVariableNames.size() > 100) {
         this->AddVariableNames.removeFirst();
         this->AddVariableTypes.removeFirst();
-        }
+      }
       // make sure CMAKE_INSTALL_PREFIX is always there
-      if (!this->AddVariableNames.contains("CMAKE_INSTALL_PREFIX"))
-        {
+      if (!this->AddVariableNames.contains("CMAKE_INSTALL_PREFIX")) {
         this->AddVariableNames << "CMAKE_INSTALL_PREFIX";
         this->AddVariableTypes << "PATH";
-        }
+      }
       QSettings settings;
       settings.beginGroup("Settings/StartPath");
       settings.setValue("AddVariableNames", this->AddVariableNames);
       settings.setValue("AddVariableTypes", this->AddVariableTypes);
-      }
     }
+  }
 }
 
 void CMakeSetupDialog::startSearch()
@@ -1137,18 +1080,19 @@ void CMakeSetupDialog::startSearch()
 void CMakeSetupDialog::setDebugOutput(bool flag)
 {
   QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "setDebugOutput", Qt::QueuedConnection, Q_ARG(bool, flag));
+                            "setDebugOutput", Qt::QueuedConnection,
+                            Q_ARG(bool, flag));
 }
 
 void CMakeSetupDialog::setGroupedView(bool v)
 {
-  this->CacheValues->cacheModel()->setViewType(v ? QCMakeCacheModel::GroupView : QCMakeCacheModel::FlatView);
+  this->CacheValues->cacheModel()->setViewType(v ? QCMakeCacheModel::GroupView
+                                                 : QCMakeCacheModel::FlatView);
   this->CacheValues->setRootIsDecorated(v);
 
   QSettings settings;
   settings.beginGroup("Settings/StartPath");
   settings.setValue("GroupView", v);
-
 }
 
 void CMakeSetupDialog::setAdvancedView(bool v)
@@ -1162,7 +1106,8 @@ void CMakeSetupDialog::setAdvancedView(bool v)
 void CMakeSetupDialog::showUserChanges()
 {
   QSet<QCMakeProperty> changes =
-    qobject_cast<QCMakeCacheModelDelegate*>(this->CacheValues->itemDelegate())->changes();
+    qobject_cast<QCMakeCacheModelDelegate*>(this->CacheValues->itemDelegate())
+      ->changes();
 
   QDialog dialog(this);
   dialog.setWindowTitle(tr("My Changes"));
@@ -1171,19 +1116,17 @@ void CMakeSetupDialog::showUserChanges()
   QTextEdit* textedit = new QTextEdit(&dialog);
   textedit->setReadOnly(true);
   l->addWidget(textedit);
-  QDialogButtonBox* btns = new QDialogButtonBox(QDialogButtonBox::Close,
-                                                Qt::Horizontal, &dialog);
+  QDialogButtonBox* btns =
+    new QDialogButtonBox(QDialogButtonBox::Close, Qt::Horizontal, &dialog);
   QObject::connect(btns, SIGNAL(rejected()), &dialog, SLOT(accept()));
   l->addWidget(btns);
 
   QString command;
   QString cache;
 
-  foreach(QCMakeProperty prop, changes)
-    {
+  foreach (QCMakeProperty prop, changes) {
     QString type;
-    switch(prop.Type)
-      {
+    switch (prop.Type) {
       case QCMakeProperty::BOOL:
         type = "BOOL";
         break;
@@ -1196,16 +1139,13 @@ void CMakeSetupDialog::showUserChanges()
       case QCMakeProperty::STRING:
         type = "STRING";
         break;
-      }
+    }
     QString value;
-    if(prop.Type == QCMakeProperty::BOOL)
-      {
+    if (prop.Type == QCMakeProperty::BOOL) {
       value = prop.Value.toBool() ? "1" : "0";
-      }
-    else
-      {
+    } else {
       value = prop.Value.toString();
-      }
+    }
 
     QString line("%1:%2=");
     line = line.arg(prop.Key);
@@ -1213,7 +1153,7 @@ void CMakeSetupDialog::showUserChanges()
 
     command += QString("-D%1\"%2\" ").arg(line).arg(value);
     cache += QString("%1%2\n").arg(line).arg(value);
-    }
+  }
 
   textedit->append(tr("Commandline options:"));
   textedit->append(command);
@@ -1230,20 +1170,20 @@ void CMakeSetupDialog::setSearchFilter(const QString& str)
   this->CacheValues->setSearchFilter(str);
 }
 
-void CMakeSetupDialog::doOutputContextMenu(const QPoint &pt)
+void CMakeSetupDialog::doOutputContextMenu(const QPoint& pt)
 {
-  QMenu *menu = this->Output->createStandardContextMenu();
+  QMenu* menu = this->Output->createStandardContextMenu();
 
   menu->addSeparator();
-  menu->addAction(tr("Find..."),
-                  this, SLOT(doOutputFindDialog()), QKeySequence::Find);
-  menu->addAction(tr("Find Next"),
-                  this, SLOT(doOutputFindNext()), QKeySequence::FindNext);
-  menu->addAction(tr("Find Previous"),
-                  this, SLOT(doOutputFindPrev()), QKeySequence::FindPrevious);
+  menu->addAction(tr("Find..."), this, SLOT(doOutputFindDialog()),
+                  QKeySequence::Find);
+  menu->addAction(tr("Find Next"), this, SLOT(doOutputFindNext()),
+                  QKeySequence::FindNext);
+  menu->addAction(tr("Find Previous"), this, SLOT(doOutputFindPrev()),
+                  QKeySequence::FindPrevious);
   menu->addSeparator();
-  menu->addAction(tr("Goto Next Error"),
-                  this, SLOT(doOutputErrorNext()), QKeySequence(Qt::Key_F8));
+  menu->addAction(tr("Goto Next Error"), this, SLOT(doOutputErrorNext()),
+                  QKeySequence(Qt::Key_F8));
 
   menu->exec(this->Output->mapToGlobal(pt));
   delete menu;
@@ -1254,24 +1194,20 @@ void CMakeSetupDialog::doOutputFindDialog()
   QStringList strings(this->FindHistory);
 
   QString selection = this->Output->textCursor().selectedText();
-  if (!selection.isEmpty() &&
-      !selection.contains(QChar::ParagraphSeparator) &&
-      !selection.contains(QChar::LineSeparator))
-    {
+  if (!selection.isEmpty() && !selection.contains(QChar::ParagraphSeparator) &&
+      !selection.contains(QChar::LineSeparator)) {
     strings.push_front(selection);
-    }
+  }
 
   bool ok;
   QString search = QInputDialog::getItem(this, tr("Find in Output"),
                                          tr("Find:"), strings, 0, true, &ok);
-  if (ok && !search.isEmpty())
-    {
-    if (!this->FindHistory.contains(search))
-      {
+  if (ok && !search.isEmpty()) {
+    if (!this->FindHistory.contains(search)) {
       this->FindHistory.push_front(search);
-      }
-    doOutputFindNext();
     }
+    doOutputFindNext();
+  }
 }
 
 void CMakeSetupDialog::doRegexExplorerDialog()
@@ -1287,37 +1223,33 @@ void CMakeSetupDialog::doOutputFindPrev()
 
 void CMakeSetupDialog::doOutputFindNext(bool directionForward)
 {
-  if (this->FindHistory.isEmpty())
-    {
-    doOutputFindDialog(); //will re-call this function again
+  if (this->FindHistory.isEmpty()) {
+    doOutputFindDialog(); // will re-call this function again
     return;
-    }
+  }
 
   QString search = this->FindHistory.front();
 
   QTextCursor textCursor = this->Output->textCursor();
   QTextDocument* document = this->Output->document();
   QTextDocument::FindFlags flags;
-  if (!directionForward)
-    {
+  if (!directionForward) {
     flags |= QTextDocument::FindBackward;
-    }
+  }
 
   textCursor = document->find(search, textCursor, flags);
 
-  if (textCursor.isNull())
-    {
+  if (textCursor.isNull()) {
     // first search found nothing, wrap around and search again
     textCursor = this->Output->textCursor();
     textCursor.movePosition(directionForward ? QTextCursor::Start
                                              : QTextCursor::End);
     textCursor = document->find(search, textCursor, flags);
-    }
+  }
 
-  if (textCursor.hasSelection())
-    {
+  if (textCursor.hasSelection()) {
     this->Output->setTextCursor(textCursor);
-    }
+  }
 }
 
 void CMakeSetupDialog::doOutputErrorNext()
@@ -1326,36 +1258,31 @@ void CMakeSetupDialog::doOutputErrorNext()
   bool atEnd = false;
 
   // move cursor out of current error-block
-  if (textCursor.blockCharFormat() == this->ErrorFormat)
-    {
+  if (textCursor.blockCharFormat() == this->ErrorFormat) {
     atEnd = !textCursor.movePosition(QTextCursor::NextBlock);
-    }
+  }
 
   // move cursor to next error-block
-  while (textCursor.blockCharFormat() != this->ErrorFormat && !atEnd)
-    {
+  while (textCursor.blockCharFormat() != this->ErrorFormat && !atEnd) {
     atEnd = !textCursor.movePosition(QTextCursor::NextBlock);
-    }
+  }
 
-  if (atEnd)
-    {
+  if (atEnd) {
     // first search found nothing, wrap around and search again
     atEnd = !textCursor.movePosition(QTextCursor::Start);
 
     // move cursor to next error-block
-    while (textCursor.blockCharFormat() != this->ErrorFormat && !atEnd)
-      {
+    while (textCursor.blockCharFormat() != this->ErrorFormat && !atEnd) {
       atEnd = !textCursor.movePosition(QTextCursor::NextBlock);
-      }
     }
+  }
 
-  if (!atEnd)
-    {
+  if (!atEnd) {
     textCursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
 
     QTextCharFormat selectionFormat;
     selectionFormat.setBackground(Qt::yellow);
-    QTextEdit::ExtraSelection extraSelection = {textCursor, selectionFormat};
+    QTextEdit::ExtraSelection extraSelection = { textCursor, selectionFormat };
     this->Output->setExtraSelections(QList<QTextEdit::ExtraSelection>()
                                      << extraSelection);
 
@@ -1365,7 +1292,7 @@ void CMakeSetupDialog::doOutputErrorNext()
     // remove the selection to see the extraSelection
     textCursor.setPosition(textCursor.anchor());
     this->Output->setTextCursor(textCursor);
-    }
+  }
 }
 
 void CMakeSetupDialog::doWarningMessagesDialog()
diff --git a/Source/QtDialog/CMakeSetupDialog.h b/Source/QtDialog/CMakeSetupDialog.h
index f9624d1..2a4ea7a 100644
--- a/Source/QtDialog/CMakeSetupDialog.h
+++ b/Source/QtDialog/CMakeSetupDialog.h
@@ -78,7 +78,7 @@ protected slots:
   bool doConfigureInternal();
   bool doGenerateInternal();
   void exitLoop(int);
-  void doOutputContextMenu(const QPoint &);
+  void doOutputContextMenu(const QPoint&);
   void doOutputFindDialog();
   void doOutputFindNext(bool directionForward = true);
   void doOutputFindPrev();
@@ -88,8 +88,14 @@ protected slots:
   void doWarningMessagesDialog();
 
 protected:
-
-  enum State { Interrupting, ReadyConfigure, ReadyGenerate, Configuring, Generating };
+  enum State
+  {
+    Interrupting,
+    ReadyConfigure,
+    ReadyGenerate,
+    Configuring,
+    Generating
+  };
   void enterState(State s);
 
   void closeEvent(QCloseEvent*);
diff --git a/Source/QtDialog/Compilers.h b/Source/QtDialog/Compilers.h
index ee89886..bdb1962 100644
--- a/Source/QtDialog/Compilers.h
+++ b/Source/QtDialog/Compilers.h
@@ -11,12 +11,11 @@ class Compilers : public QWidget, public Ui::Compilers
 {
   Q_OBJECT
 public:
-  Compilers(QWidget* p=NULL) :
-    QWidget(p)
+  Compilers(QWidget* p = NULL)
+    : QWidget(p)
   {
     this->setupUi(this);
   }
 };
 
 #endif
-
diff --git a/Source/QtDialog/FirstConfigure.cxx b/Source/QtDialog/FirstConfigure.cxx
index 5c0af2b..ca5e3b5 100644
--- a/Source/QtDialog/FirstConfigure.cxx
+++ b/Source/QtDialog/FirstConfigure.cxx
@@ -8,7 +8,6 @@
 #include <QSettings>
 #include <QVBoxLayout>
 
-
 StartCompilerSetup::StartCompilerSetup(QWidget* p)
   : QWizardPage(p)
 {
@@ -23,10 +22,14 @@ StartCompilerSetup::StartCompilerSetup(QWidget* p)
 
   l->addSpacing(6);
 
-  this->CompilerSetupOptions[0] = new QRadioButton(tr("Use default native compilers"), this);
-  this->CompilerSetupOptions[1] = new QRadioButton(tr("Specify native compilers"), this);
-  this->CompilerSetupOptions[2] = new QRadioButton(tr("Specify toolchain file for cross-compiling"), this);
-  this->CompilerSetupOptions[3] = new QRadioButton(tr("Specify options for cross-compiling"), this);
+  this->CompilerSetupOptions[0] =
+    new QRadioButton(tr("Use default native compilers"), this);
+  this->CompilerSetupOptions[1] =
+    new QRadioButton(tr("Specify native compilers"), this);
+  this->CompilerSetupOptions[2] =
+    new QRadioButton(tr("Specify toolchain file for cross-compiling"), this);
+  this->CompilerSetupOptions[3] =
+    new QRadioButton(tr("Specify options for cross-compiling"), this);
   l->addWidget(this->CompilerSetupOptions[0]);
   l->addWidget(this->CompilerSetupOptions[1]);
   l->addWidget(this->CompilerSetupOptions[2]);
@@ -34,17 +37,17 @@ StartCompilerSetup::StartCompilerSetup(QWidget* p)
 
   this->CompilerSetupOptions[0]->setChecked(true);
 
-  QObject::connect(this->CompilerSetupOptions[0], SIGNAL(toggled(bool)),
-                   this, SLOT(onSelectionChanged(bool)));
-  QObject::connect(this->CompilerSetupOptions[1], SIGNAL(toggled(bool)),
-                   this, SLOT(onSelectionChanged(bool)));
-  QObject::connect(this->CompilerSetupOptions[2], SIGNAL(toggled(bool)),
-                   this, SLOT(onSelectionChanged(bool)));
-  QObject::connect(this->CompilerSetupOptions[3], SIGNAL(toggled(bool)),
-                   this, SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[0], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[1], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[2], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
+  QObject::connect(this->CompilerSetupOptions[3], SIGNAL(toggled(bool)), this,
+                   SLOT(onSelectionChanged(bool)));
   QObject::connect(GeneratorOptions,
-                   SIGNAL(currentIndexChanged(QString const&)),
-                   this, SLOT(onGeneratorChanged(QString const&)));
+                   SIGNAL(currentIndexChanged(QString const&)), this,
+                   SLOT(onGeneratorChanged(QString const&)));
 }
 
 QFrame* StartCompilerSetup::CreateToolsetWidgets()
@@ -74,16 +77,14 @@ void StartCompilerSetup::setGenerators(
   QStringList generator_list;
 
   std::vector<cmake::GeneratorInfo>::const_iterator it;
-  for (it = gens.begin(); it != gens.end(); ++it)
-    {
+  for (it = gens.begin(); it != gens.end(); ++it) {
     generator_list.append(QString::fromLocal8Bit(it->name.c_str()));
 
-    if (it->supportsToolset)
-      {
+    if (it->supportsToolset) {
       this->GeneratorsSupportingToolset.append(
         QString::fromLocal8Bit(it->name.c_str()));
-      }
     }
+  }
 
   this->GeneratorOptions->addItems(generator_list);
 }
@@ -91,8 +92,7 @@ void StartCompilerSetup::setGenerators(
 void StartCompilerSetup::setCurrentGenerator(const QString& gen)
 {
   int idx = this->GeneratorOptions->findText(gen);
-  if(idx != -1)
-  {
+  if (idx != -1) {
     this->GeneratorOptions->setCurrentIndex(idx);
   }
 }
@@ -129,29 +129,26 @@ bool StartCompilerSetup::crossCompilerSetup() const
 
 void StartCompilerSetup::onSelectionChanged(bool on)
 {
-  if(on)
+  if (on)
     selectionChanged();
 }
 
 void StartCompilerSetup::onGeneratorChanged(QString const& name)
 {
-  if (GeneratorsSupportingToolset.contains(name))
-    {
+  if (GeneratorsSupportingToolset.contains(name)) {
     ToolsetFrame->show();
-    }
-  else
-    {
+  } else {
     ToolsetFrame->hide();
-    }
+  }
 }
 
 int StartCompilerSetup::nextId() const
 {
-  if(compilerSetup())
+  if (compilerSetup())
     return NativeSetup;
-  if(crossCompilerSetup())
+  if (crossCompilerSetup())
     return CrossSetup;
-  if(crossCompilerToolChainFile())
+  if (crossCompilerToolChainFile())
     return ToolchainSetup;
   return -1;
 }
@@ -199,7 +196,6 @@ void NativeCompilerSetup::setFortranCompiler(const QString& s)
   this->FortranCompiler->setText(s);
 }
 
-
 CrossCompilerSetup::CrossCompilerSetup(QWidget* p)
   : QWizardPage(p)
 {
@@ -208,7 +204,8 @@ CrossCompilerSetup::CrossCompilerSetup(QWidget* p)
   QWidget::setTabOrder(systemVersion, systemProcessor);
   QWidget::setTabOrder(systemProcessor, CrossCompilers->CCompiler);
   QWidget::setTabOrder(CrossCompilers->CCompiler, CrossCompilers->CXXCompiler);
-  QWidget::setTabOrder(CrossCompilers->CXXCompiler, CrossCompilers->FortranCompiler);
+  QWidget::setTabOrder(CrossCompilers->CXXCompiler,
+                       CrossCompilers->FortranCompiler);
   QWidget::setTabOrder(CrossCompilers->FortranCompiler, crossFindRoot);
   QWidget::setTabOrder(crossFindRoot, crossProgramMode);
   QWidget::setTabOrder(crossProgramMode, crossLibraryMode);
@@ -273,7 +270,6 @@ void CrossCompilerSetup::setSystem(const QString& t)
   this->systemName->setText(t);
 }
 
-
 QString CrossCompilerSetup::getVersion() const
 {
   return this->systemVersion->text();
@@ -284,7 +280,6 @@ void CrossCompilerSetup::setVersion(const QString& t)
   this->systemVersion->setText(t);
 }
 
-
 QString CrossCompilerSetup::getProcessor() const
 {
   return this->systemProcessor->text();
@@ -358,11 +353,9 @@ void ToolchainCompilerSetup::setToolchainFile(const QString& t)
   this->ToolchainFile->setText(t);
 }
 
-
-
 FirstConfigure::FirstConfigure()
 {
-  //this->setOption(QWizard::HaveFinishButtonOnEarlyPages, true);
+  // this->setOption(QWizard::HaveFinishButtonOnEarlyPages, true);
   this->mStartCompilerSetupPage = new StartCompilerSetup(this);
   this->setPage(Start, this->mStartCompilerSetupPage);
   QObject::connect(this->mStartCompilerSetupPage, SIGNAL(selectionChanged()),
@@ -409,24 +402,38 @@ void FirstConfigure::loadFromSettings()
 
   // restore compiler setup
   settings.beginGroup("Settings/Compiler");
-  this->mNativeCompilerSetupPage->setCCompiler(settings.value("CCompiler").toString());
-  this->mNativeCompilerSetupPage->setCXXCompiler(settings.value("CXXCompiler").toString());
-  this->mNativeCompilerSetupPage->setFortranCompiler(settings.value("FortranCompiler").toString());
+  this->mNativeCompilerSetupPage->setCCompiler(
+    settings.value("CCompiler").toString());
+  this->mNativeCompilerSetupPage->setCXXCompiler(
+    settings.value("CXXCompiler").toString());
+  this->mNativeCompilerSetupPage->setFortranCompiler(
+    settings.value("FortranCompiler").toString());
   settings.endGroup();
 
   // restore cross compiler setup
   settings.beginGroup("Settings/CrossCompiler");
-  this->mCrossCompilerSetupPage->setCCompiler(settings.value("CCompiler").toString());
-  this->mCrossCompilerSetupPage->setCXXCompiler(settings.value("CXXCompiler").toString());
-  this->mCrossCompilerSetupPage->setFortranCompiler(settings.value("FortranCompiler").toString());
-  this->mToolchainCompilerSetupPage->setToolchainFile(settings.value("ToolChainFile").toString());
-  this->mCrossCompilerSetupPage->setSystem(settings.value("SystemName").toString());
-  this->mCrossCompilerSetupPage->setVersion(settings.value("SystemVersion").toString());
-  this->mCrossCompilerSetupPage->setProcessor(settings.value("SystemProcessor").toString());
-  this->mCrossCompilerSetupPage->setFindRoot(settings.value("FindRoot").toString());
-  this->mCrossCompilerSetupPage->setProgramMode(settings.value("ProgramMode", 0).toInt());
-  this->mCrossCompilerSetupPage->setLibraryMode(settings.value("LibraryMode", 0).toInt());
-  this->mCrossCompilerSetupPage->setIncludeMode(settings.value("IncludeMode", 0).toInt());
+  this->mCrossCompilerSetupPage->setCCompiler(
+    settings.value("CCompiler").toString());
+  this->mCrossCompilerSetupPage->setCXXCompiler(
+    settings.value("CXXCompiler").toString());
+  this->mCrossCompilerSetupPage->setFortranCompiler(
+    settings.value("FortranCompiler").toString());
+  this->mToolchainCompilerSetupPage->setToolchainFile(
+    settings.value("ToolChainFile").toString());
+  this->mCrossCompilerSetupPage->setSystem(
+    settings.value("SystemName").toString());
+  this->mCrossCompilerSetupPage->setVersion(
+    settings.value("SystemVersion").toString());
+  this->mCrossCompilerSetupPage->setProcessor(
+    settings.value("SystemProcessor").toString());
+  this->mCrossCompilerSetupPage->setFindRoot(
+    settings.value("FindRoot").toString());
+  this->mCrossCompilerSetupPage->setProgramMode(
+    settings.value("ProgramMode", 0).toInt());
+  this->mCrossCompilerSetupPage->setLibraryMode(
+    settings.value("LibraryMode", 0).toInt());
+  this->mCrossCompilerSetupPage->setIncludeMode(
+    settings.value("IncludeMode", 0).toInt());
   settings.endGroup();
 }
 
@@ -442,24 +449,35 @@ void FirstConfigure::saveToSettings()
 
   // save compiler setup
   settings.beginGroup("Settings/Compiler");
-  settings.setValue("CCompiler", this->mNativeCompilerSetupPage->getCCompiler());
-  settings.setValue("CXXCompiler", this->mNativeCompilerSetupPage->getCXXCompiler());
-  settings.setValue("FortranCompiler", this->mNativeCompilerSetupPage->getFortranCompiler());
+  settings.setValue("CCompiler",
+                    this->mNativeCompilerSetupPage->getCCompiler());
+  settings.setValue("CXXCompiler",
+                    this->mNativeCompilerSetupPage->getCXXCompiler());
+  settings.setValue("FortranCompiler",
+                    this->mNativeCompilerSetupPage->getFortranCompiler());
   settings.endGroup();
 
   // save cross compiler setup
   settings.beginGroup("Settings/CrossCompiler");
-  settings.setValue("CCompiler", this->mCrossCompilerSetupPage->getCCompiler());
-  settings.setValue("CXXCompiler", this->mCrossCompilerSetupPage->getCXXCompiler());
-  settings.setValue("FortranCompiler", this->mCrossCompilerSetupPage->getFortranCompiler());
+  settings.setValue("CCompiler",
+                    this->mCrossCompilerSetupPage->getCCompiler());
+  settings.setValue("CXXCompiler",
+                    this->mCrossCompilerSetupPage->getCXXCompiler());
+  settings.setValue("FortranCompiler",
+                    this->mCrossCompilerSetupPage->getFortranCompiler());
   settings.setValue("ToolChainFile", this->getCrossCompilerToolChainFile());
   settings.setValue("SystemName", this->mCrossCompilerSetupPage->getSystem());
-  settings.setValue("SystemVersion", this->mCrossCompilerSetupPage->getVersion());
-  settings.setValue("SystemProcessor", this->mCrossCompilerSetupPage->getProcessor());
+  settings.setValue("SystemVersion",
+                    this->mCrossCompilerSetupPage->getVersion());
+  settings.setValue("SystemProcessor",
+                    this->mCrossCompilerSetupPage->getProcessor());
   settings.setValue("FindRoot", this->mCrossCompilerSetupPage->getFindRoot());
-  settings.setValue("ProgramMode", this->mCrossCompilerSetupPage->getProgramMode());
-  settings.setValue("LibraryMode", this->mCrossCompilerSetupPage->getLibraryMode());
-  settings.setValue("IncludeMode", this->mCrossCompilerSetupPage->getIncludeMode());
+  settings.setValue("ProgramMode",
+                    this->mCrossCompilerSetupPage->getProgramMode());
+  settings.setValue("LibraryMode",
+                    this->mCrossCompilerSetupPage->getLibraryMode());
+  settings.setValue("IncludeMode",
+                    this->mCrossCompilerSetupPage->getIncludeMode());
   settings.endGroup();
 }
 
@@ -495,44 +513,34 @@ QString FirstConfigure::getSystemName() const
 
 QString FirstConfigure::getCCompiler() const
 {
-  if(this->compilerSetup())
-    {
+  if (this->compilerSetup()) {
     return this->mNativeCompilerSetupPage->getCCompiler();
-    }
-  else if(this->crossCompilerSetup())
-    {
+  } else if (this->crossCompilerSetup()) {
     return this->mCrossCompilerSetupPage->getCCompiler();
-    }
+  }
   return QString();
 }
 
 QString FirstConfigure::getCXXCompiler() const
 {
-  if(this->compilerSetup())
-    {
+  if (this->compilerSetup()) {
     return this->mNativeCompilerSetupPage->getCXXCompiler();
-    }
-  else if(this->crossCompilerSetup())
-    {
+  } else if (this->crossCompilerSetup()) {
     return this->mCrossCompilerSetupPage->getCXXCompiler();
-    }
+  }
   return QString();
 }
 
 QString FirstConfigure::getFortranCompiler() const
 {
-  if(this->compilerSetup())
-    {
+  if (this->compilerSetup()) {
     return this->mNativeCompilerSetupPage->getFortranCompiler();
-    }
-  else if(this->crossCompilerSetup())
-    {
+  } else if (this->crossCompilerSetup()) {
     return this->mCrossCompilerSetupPage->getFortranCompiler();
-    }
+  }
   return QString();
 }
 
-
 QString FirstConfigure::getSystemVersion() const
 {
   return this->mCrossCompilerSetupPage->getVersion();
@@ -548,12 +556,7 @@ QString FirstConfigure::getCrossRoot() const
   return this->mCrossCompilerSetupPage->getFindRoot();
 }
 
-const QString CrossModes[] =
-{
-  "BOTH",
-  "ONLY",
-  "NEVER"
-};
+const QString CrossModes[] = { "BOTH", "ONLY", "NEVER" };
 
 QString FirstConfigure::getCrossProgramMode() const
 {
@@ -569,4 +572,3 @@ QString FirstConfigure::getCrossIncludeMode() const
 {
   return CrossModes[this->mCrossCompilerSetupPage->getIncludeMode()];
 }
-
diff --git a/Source/QtDialog/FirstConfigure.h b/Source/QtDialog/FirstConfigure.h
index 3c574d4..c467ddb 100644
--- a/Source/QtDialog/FirstConfigure.h
+++ b/Source/QtDialog/FirstConfigure.h
@@ -23,125 +23,126 @@ enum FirstConfigurePages
   Done
 };
 
-//! the first page that gives basic options for what compilers setup to choose from
+//! the first page that gives basic options for what compilers setup to choose
+//! from
 class StartCompilerSetup : public QWizardPage
 {
   Q_OBJECT
-  public:
-    StartCompilerSetup(QWidget* p);
-    ~StartCompilerSetup();
-    void setGenerators(std::vector<cmake::GeneratorInfo> const& gens);
-    void setCurrentGenerator(const QString& gen);
-    QString getGenerator() const;
-    QString getToolset() const;
-
-    bool defaultSetup() const;
-    bool compilerSetup() const;
-    bool crossCompilerSetup() const;
-    bool crossCompilerToolChainFile() const;
-
-    int nextId() const;
-
-  signals:
-    void selectionChanged();
-
-  protected slots:
-    void onSelectionChanged(bool);
-    void onGeneratorChanged(QString const& name);
-
-  protected:
-    QComboBox* GeneratorOptions;
-    QRadioButton* CompilerSetupOptions[4];
-    QFrame* ToolsetFrame;
-    QLineEdit* Toolset;
-    QLabel* ToolsetLabel;
-    QStringList GeneratorsSupportingToolset;
-
-  private:
-    QFrame* CreateToolsetWidgets();
+public:
+  StartCompilerSetup(QWidget* p);
+  ~StartCompilerSetup();
+  void setGenerators(std::vector<cmake::GeneratorInfo> const& gens);
+  void setCurrentGenerator(const QString& gen);
+  QString getGenerator() const;
+  QString getToolset() const;
+
+  bool defaultSetup() const;
+  bool compilerSetup() const;
+  bool crossCompilerSetup() const;
+  bool crossCompilerToolChainFile() const;
+
+  int nextId() const;
+
+signals:
+  void selectionChanged();
+
+protected slots:
+  void onSelectionChanged(bool);
+  void onGeneratorChanged(QString const& name);
+
+protected:
+  QComboBox* GeneratorOptions;
+  QRadioButton* CompilerSetupOptions[4];
+  QFrame* ToolsetFrame;
+  QLineEdit* Toolset;
+  QLabel* ToolsetLabel;
+  QStringList GeneratorsSupportingToolset;
+
+private:
+  QFrame* CreateToolsetWidgets();
 };
 
 //! the page that gives basic options for native compilers
 class NativeCompilerSetup : public QWizardPage, protected Ui::Compilers
 {
   Q_OBJECT
-  public:
-    NativeCompilerSetup(QWidget* p);
-    ~NativeCompilerSetup();
+public:
+  NativeCompilerSetup(QWidget* p);
+  ~NativeCompilerSetup();
 
-    QString getCCompiler() const;
-    void setCCompiler(const QString&);
+  QString getCCompiler() const;
+  void setCCompiler(const QString&);
 
-    QString getCXXCompiler() const;
-    void setCXXCompiler(const QString&);
+  QString getCXXCompiler() const;
+  void setCXXCompiler(const QString&);
 
-    QString getFortranCompiler() const;
-    void setFortranCompiler(const QString&);
+  QString getFortranCompiler() const;
+  void setFortranCompiler(const QString&);
 
-    int nextId() const { return -1; }
+  int nextId() const { return -1; }
 };
 
 //! the page that gives options for cross compilers
 class CrossCompilerSetup : public QWizardPage, protected Ui::CrossCompiler
 {
   Q_OBJECT
-  public:
-    CrossCompilerSetup(QWidget* p);
-    ~CrossCompilerSetup();
-
-    QString getSystem() const;
-    void setSystem(const QString&);
-
-    QString getVersion() const;
-    void setVersion(const QString&);
-
-    QString getProcessor() const;
-    void setProcessor(const QString&);
-
-    QString getCCompiler() const;
-    void setCCompiler(const QString&);
+public:
+  CrossCompilerSetup(QWidget* p);
+  ~CrossCompilerSetup();
 
-    QString getCXXCompiler() const;
-    void setCXXCompiler(const QString&);
+  QString getSystem() const;
+  void setSystem(const QString&);
 
-    QString getFortranCompiler() const;
-    void setFortranCompiler(const QString&);
+  QString getVersion() const;
+  void setVersion(const QString&);
 
-    QString getFindRoot() const;
-    void setFindRoot(const QString&);
+  QString getProcessor() const;
+  void setProcessor(const QString&);
 
-    enum CrossMode
-      {
-        BOTH,
-        ONLY,
-        NEVER
-      };
+  QString getCCompiler() const;
+  void setCCompiler(const QString&);
 
-    int getProgramMode() const;
-    void setProgramMode(int);
-    int getLibraryMode() const;
-    void setLibraryMode(int);
-    int getIncludeMode() const;
-    void setIncludeMode(int);
+  QString getCXXCompiler() const;
+  void setCXXCompiler(const QString&);
 
-    int nextId() const { return -1; }
+  QString getFortranCompiler() const;
+  void setFortranCompiler(const QString&);
+
+  QString getFindRoot() const;
+  void setFindRoot(const QString&);
+
+  enum CrossMode
+  {
+    BOTH,
+    ONLY,
+    NEVER
+  };
+
+  int getProgramMode() const;
+  void setProgramMode(int);
+  int getLibraryMode() const;
+  void setLibraryMode(int);
+  int getIncludeMode() const;
+  void setIncludeMode(int);
+
+  int nextId() const { return -1; }
 };
 
 //! the page that gives options for a toolchain file
 class ToolchainCompilerSetup : public QWizardPage
 {
   Q_OBJECT
-  public:
-    ToolchainCompilerSetup(QWidget* p);
-    ~ToolchainCompilerSetup();
+public:
+  ToolchainCompilerSetup(QWidget* p);
+  ~ToolchainCompilerSetup();
 
-    QString toolchainFile() const;
-    void setToolchainFile(const QString&);
+  QString toolchainFile() const;
+  void setToolchainFile(const QString&);
 
-    int nextId() const { return -1; }
+  int nextId() const { return -1; }
 
-  protected:
-    QCMakeFilePathEditor* ToolchainFile;
+protected:
+  QCMakeFilePathEditor* ToolchainFile;
 };
 
 //! the wizard with the pages
@@ -183,8 +184,6 @@ protected:
   NativeCompilerSetup* mNativeCompilerSetupPage;
   CrossCompilerSetup* mCrossCompilerSetupPage;
   ToolchainCompilerSetup* mToolchainCompilerSetupPage;
-
 };
 
 #endif // FirstConfigure_h
-
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 28be341..c84e153 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -20,7 +20,7 @@
 #include "cmSystemTools.h"
 
 #ifdef Q_OS_WIN
-#include "qt_windows.h"  // For SetErrorMode
+#include "qt_windows.h" // For SetErrorMode
 #endif
 
 QCMake::QCMake(QObject* p)
@@ -48,26 +48,24 @@ QCMake::QCMake(QObject* p)
   this->CMakeInstance->GetRegisteredGenerators(generators);
 
   std::vector<cmake::GeneratorInfo>::const_iterator it;
-  for(it = generators.begin(); it != generators.end(); ++it)
-    {
+  for (it = generators.begin(); it != generators.end(); ++it) {
     // Skip the generator "KDevelop3", since there is also
     // "KDevelop3 - Unix Makefiles", which is the full and official name.
     // The short name is actually only still there since this was the name
     // in CMake 2.4, to keep "command line argument compatibility", but
     // this is not necessary in the GUI.
-    if (it->name == "KDevelop3")
-      {
+    if (it->name == "KDevelop3") {
       continue;
-      }
+    }
 
     this->AvailableGenerators.push_back(*it);
-    }
+  }
 }
 
 QCMake::~QCMake()
 {
   delete this->CMakeInstance;
-  //cmDynamicLoader::FlushCache();
+  // cmDynamicLoader::FlushCache();
 }
 
 void QCMake::loadCache(const QString& dir)
@@ -77,80 +75,73 @@ void QCMake::loadCache(const QString& dir)
 
 void QCMake::setSourceDirectory(const QString& _dir)
 {
-  QString dir =
-    QString::fromLocal8Bit(cmSystemTools::GetActualCaseForPath(_dir.toLocal8Bit().data()).c_str());
-  if(this->SourceDirectory != dir)
-    {
+  QString dir = QString::fromLocal8Bit(
+    cmSystemTools::GetActualCaseForPath(_dir.toLocal8Bit().data()).c_str());
+  if (this->SourceDirectory != dir) {
     this->SourceDirectory = QDir::fromNativeSeparators(dir);
     emit this->sourceDirChanged(this->SourceDirectory);
-    }
+  }
 }
 
 void QCMake::setBinaryDirectory(const QString& _dir)
 {
-  QString dir =
-    QString::fromLocal8Bit(cmSystemTools::GetActualCaseForPath(_dir.toLocal8Bit().data()).c_str());
-  if(this->BinaryDirectory != dir)
-    {
+  QString dir = QString::fromLocal8Bit(
+    cmSystemTools::GetActualCaseForPath(_dir.toLocal8Bit().data()).c_str());
+  if (this->BinaryDirectory != dir) {
     this->BinaryDirectory = QDir::fromNativeSeparators(dir);
     emit this->binaryDirChanged(this->BinaryDirectory);
     cmState* state = this->CMakeInstance->GetState();
     this->setGenerator(QString());
     this->setToolset(QString());
-    if(!this->CMakeInstance->LoadCache(
-      this->BinaryDirectory.toLocal8Bit().data()))
-      {
+    if (!this->CMakeInstance->LoadCache(
+          this->BinaryDirectory.toLocal8Bit().data())) {
       QDir testDir(this->BinaryDirectory);
-      if(testDir.exists("CMakeCache.txt"))
-        {
-        cmSystemTools::Error("There is a CMakeCache.txt file for the current binary "
-            "tree but cmake does not have permission to read it.  "
-            "Please check the permissions of the directory you are trying to run CMake on.");
-        }
+      if (testDir.exists("CMakeCache.txt")) {
+        cmSystemTools::Error(
+          "There is a CMakeCache.txt file for the current binary "
+          "tree but cmake does not have permission to read it.  "
+          "Please check the permissions of the directory you are trying to "
+          "run CMake on.");
       }
+    }
 
     QCMakePropertyList props = this->properties();
     emit this->propertiesChanged(props);
     const char* homeDir = state->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
-    if (homeDir)
-      {
+    if (homeDir) {
       setSourceDirectory(QString::fromLocal8Bit(homeDir));
-      }
+    }
     const char* gen = state->GetCacheEntryValue("CMAKE_GENERATOR");
-    if (gen)
-      {
-      const char* extraGen = state
-                        ->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
-      std::string curGen = cmExternalMakefileProjectGenerator::
-        CreateFullGeneratorName(gen, extraGen? extraGen : "");
+    if (gen) {
+      const char* extraGen =
+        state->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
+      std::string curGen =
+        cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
+          gen, extraGen ? extraGen : "");
       this->setGenerator(QString::fromLocal8Bit(curGen.c_str()));
-      }
+    }
 
     const char* toolset = state->GetCacheEntryValue("CMAKE_GENERATOR_TOOLSET");
-    if (toolset)
-      {
+    if (toolset) {
       this->setToolset(QString::fromLocal8Bit(toolset));
-      }
     }
+  }
 }
 
-
 void QCMake::setGenerator(const QString& gen)
 {
-  if(this->Generator != gen)
-    {
+  if (this->Generator != gen) {
     this->Generator = gen;
     emit this->generatorChanged(this->Generator);
-    }
+  }
 }
 
 void QCMake::setToolset(const QString& toolset)
 {
-  if(this->Toolset != toolset)
-    {
+  if (this->Toolset != toolset) {
     this->Toolset = toolset;
     emit this->toolsetChanged(this->Toolset);
-    }
+  }
 }
 
 void QCMake::configure()
@@ -159,10 +150,13 @@ void QCMake::configure()
   UINT lastErrorMode = SetErrorMode(0);
 #endif
 
-  this->CMakeInstance->SetHomeDirectory(this->SourceDirectory.toLocal8Bit().data());
-  this->CMakeInstance->SetHomeOutputDirectory(this->BinaryDirectory.toLocal8Bit().data());
+  this->CMakeInstance->SetHomeDirectory(
+    this->SourceDirectory.toLocal8Bit().data());
+  this->CMakeInstance->SetHomeOutputDirectory(
+    this->BinaryDirectory.toLocal8Bit().data());
   this->CMakeInstance->SetGlobalGenerator(
-    this->CMakeInstance->CreateGlobalGenerator(this->Generator.toLocal8Bit().data()));
+    this->CMakeInstance->CreateGlobalGenerator(
+      this->Generator.toLocal8Bit().data()));
   this->CMakeInstance->SetGeneratorPlatform("");
   this->CMakeInstance->SetGeneratorToolset(this->Toolset.toLocal8Bit().data());
   this->CMakeInstance->LoadCache();
@@ -210,82 +204,59 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
   // set the value of properties
   cmState* state = this->CMakeInstance->GetState();
   std::vector<std::string> cacheKeys = state->GetCacheEntryKeys();
-  for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
-      it != cacheKeys.end(); ++it)
-    {
+  for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+       it != cacheKeys.end(); ++it) {
     cmState::CacheEntryType t = state->GetCacheEntryType(*it);
-    if(t == cmState::INTERNAL ||
-       t == cmState::STATIC)
-      {
+    if (t == cmState::INTERNAL || t == cmState::STATIC) {
       continue;
-      }
+    }
 
     QCMakeProperty prop;
     prop.Key = QString::fromLocal8Bit(it->c_str());
     int idx = props.indexOf(prop);
-    if(idx == -1)
-      {
+    if (idx == -1) {
       toremove.append(QString::fromLocal8Bit(it->c_str()));
-      }
-    else
-      {
+    } else {
       prop = props[idx];
-      if(prop.Value.type() == QVariant::Bool)
-        {
+      if (prop.Value.type() == QVariant::Bool) {
         state->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
-        }
-      else
-        {
+      } else {
         state->SetCacheEntryValue(*it,
-                                   prop.Value.toString().toLocal8Bit().data());
-        }
-      props.removeAt(idx);
+                                  prop.Value.toString().toLocal8Bit().data());
       }
-
+      props.removeAt(idx);
     }
+  }
 
   // remove some properites
-  foreach(QString s, toremove)
-    {
+  foreach (QString s, toremove) {
     this->CMakeInstance->UnwatchUnusedCli(s.toLocal8Bit().data());
 
     state->RemoveCacheEntry(s.toLocal8Bit().data());
-    }
+  }
 
   // add some new properites
-  foreach(QCMakeProperty s, props)
-    {
+  foreach (QCMakeProperty s, props) {
     this->CMakeInstance->WatchUnusedCli(s.Key.toLocal8Bit().data());
 
-    if(s.Type == QCMakeProperty::BOOL)
-      {
-      this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
-                            s.Value.toBool() ? "ON" : "OFF",
-                            s.Help.toLocal8Bit().data(),
-                            cmState::BOOL);
-      }
-    else if(s.Type == QCMakeProperty::STRING)
-      {
-      this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
-                            s.Value.toString().toLocal8Bit().data(),
-                            s.Help.toLocal8Bit().data(),
-                            cmState::STRING);
-      }
-    else if(s.Type == QCMakeProperty::PATH)
-      {
-      this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
-                            s.Value.toString().toLocal8Bit().data(),
-                            s.Help.toLocal8Bit().data(),
-                            cmState::PATH);
-      }
-    else if(s.Type == QCMakeProperty::FILEPATH)
-      {
-      this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
-                            s.Value.toString().toLocal8Bit().data(),
-                            s.Help.toLocal8Bit().data(),
-                            cmState::FILEPATH);
-      }
+    if (s.Type == QCMakeProperty::BOOL) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toBool() ? "ON" : "OFF",
+        s.Help.toLocal8Bit().data(), cmState::BOOL);
+    } else if (s.Type == QCMakeProperty::STRING) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toString().toLocal8Bit().data(),
+        s.Help.toLocal8Bit().data(), cmState::STRING);
+    } else if (s.Type == QCMakeProperty::PATH) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toString().toLocal8Bit().data(),
+        s.Help.toLocal8Bit().data(), cmState::PATH);
+    } else if (s.Type == QCMakeProperty::FILEPATH) {
+      this->CMakeInstance->AddCacheEntry(
+        s.Key.toLocal8Bit().data(), s.Value.toString().toLocal8Bit().data(),
+        s.Help.toLocal8Bit().data(), cmState::FILEPATH);
     }
+  }
 
   this->CMakeInstance->SaveCache(this->BinaryDirectory.toLocal8Bit().data());
 }
@@ -297,50 +268,39 @@ QCMakePropertyList QCMake::properties() const
   cmState* state = this->CMakeInstance->GetState();
   std::vector<std::string> cacheKeys = state->GetCacheEntryKeys();
   for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
-        i != cacheKeys.end(); ++i)
-    {
+       i != cacheKeys.end(); ++i) {
     cmState::CacheEntryType t = state->GetCacheEntryType(*i);
-    if(t == cmState::INTERNAL ||
-       t == cmState::STATIC ||
-       t == cmState::UNINITIALIZED)
-      {
+    if (t == cmState::INTERNAL || t == cmState::STATIC ||
+        t == cmState::UNINITIALIZED) {
       continue;
-      }
+    }
 
     const char* cachedValue = state->GetCacheEntryValue(*i);
 
     QCMakeProperty prop;
     prop.Key = QString::fromLocal8Bit(i->c_str());
-    prop.Help = QString::fromLocal8Bit(
-                            state->GetCacheEntryProperty(*i, "HELPSTRING"));
+    prop.Help =
+      QString::fromLocal8Bit(state->GetCacheEntryProperty(*i, "HELPSTRING"));
     prop.Value = QString::fromLocal8Bit(cachedValue);
     prop.Advanced = state->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
-    if(t == cmState::BOOL)
-      {
+    if (t == cmState::BOOL) {
       prop.Type = QCMakeProperty::BOOL;
       prop.Value = cmSystemTools::IsOn(cachedValue);
-      }
-    else if(t == cmState::PATH)
-      {
+    } else if (t == cmState::PATH) {
       prop.Type = QCMakeProperty::PATH;
-      }
-    else if(t == cmState::FILEPATH)
-      {
+    } else if (t == cmState::FILEPATH) {
       prop.Type = QCMakeProperty::FILEPATH;
-      }
-    else if(t == cmState::STRING)
-      {
+    } else if (t == cmState::STRING) {
       prop.Type = QCMakeProperty::STRING;
       const char* stringsProperty =
-                                state->GetCacheEntryProperty(*i, "STRINGS");
-      if (stringsProperty)
-        {
+        state->GetCacheEntryProperty(*i, "STRINGS");
+      if (stringsProperty) {
         prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
-        }
       }
+    }
 
     ret.append(prop);
-    }
+  }
 
   return ret;
 }
@@ -363,14 +323,11 @@ bool QCMake::interruptCallback(void* cd)
 void QCMake::progressCallback(const char* msg, float percent, void* cd)
 {
   QCMake* self = reinterpret_cast<QCMake*>(cd);
-  if(percent >= 0)
-    {
+  if (percent >= 0) {
     emit self->progressChanged(QString::fromLocal8Bit(msg), percent);
-    }
-  else
-    {
+  } else {
     emit self->outputMessage(QString::fromLocal8Bit(msg));
-    }
+  }
   QCoreApplication::processEvents();
 }
 
@@ -385,14 +342,14 @@ void QCMake::messageCallback(const char* msg, const char* /*title*/,
 void QCMake::stdoutCallback(const char* msg, size_t len, void* cd)
 {
   QCMake* self = reinterpret_cast<QCMake*>(cd);
-  emit self->outputMessage(QString::fromLocal8Bit(msg,int(len)));
+  emit self->outputMessage(QString::fromLocal8Bit(msg, int(len)));
   QCoreApplication::processEvents();
 }
 
 void QCMake::stderrCallback(const char* msg, size_t len, void* cd)
 {
   QCMake* self = reinterpret_cast<QCMake*>(cd);
-  emit self->outputMessage(QString::fromLocal8Bit(msg,int(len)));
+  emit self->outputMessage(QString::fromLocal8Bit(msg, int(len)));
   QCoreApplication::processEvents();
 }
 
@@ -443,11 +400,10 @@ void QCMake::reloadCache()
 
 void QCMake::setDebugOutput(bool flag)
 {
-  if(flag != this->CMakeInstance->GetDebugOutput())
-    {
+  if (flag != this->CMakeInstance->GetDebugOutput()) {
     this->CMakeInstance->SetDebugOutputOn(flag);
     emit this->debugOutputChanged(flag);
-    }
+  }
 }
 
 bool QCMake::getDebugOutput() const
diff --git a/Source/QtDialog/QCMake.h b/Source/QtDialog/QCMake.h
index 5cae06d..a818c6b 100644
--- a/Source/QtDialog/QCMake.h
+++ b/Source/QtDialog/QCMake.h
@@ -16,8 +16,8 @@
 #include "cmake.h"
 
 #ifdef _MSC_VER
-#pragma warning ( disable : 4127 )
-#pragma warning ( disable : 4512 )
+#pragma warning(disable : 4127)
+#pragma warning(disable : 4512)
 #endif
 
 #include <vector>
@@ -34,7 +34,13 @@
 /// Value is of type String or Bool
 struct QCMakeProperty
 {
-  enum PropertyType { BOOL, PATH, FILEPATH, STRING };
+  enum PropertyType
+  {
+    BOOL,
+    PATH,
+    FILEPATH,
+    STRING
+  };
   QString Key;
   QVariant Value;
   QStringList Strings;
@@ -42,13 +48,13 @@ struct QCMakeProperty
   PropertyType Type;
   bool Advanced;
   bool operator==(const QCMakeProperty& other) const
-    {
+  {
     return this->Key == other.Key;
-    }
+  }
   bool operator<(const QCMakeProperty& other) const
-    {
+  {
     return this->Key < other.Key;
-    }
+  }
 };
 
 // list of properties
@@ -65,7 +71,7 @@ class QCMake : public QObject
 {
   Q_OBJECT
 public:
-  QCMake(QObject* p=0);
+  QCMake(QObject* p = 0);
   ~QCMake();
 public slots:
   /// load the cache file in a directory
@@ -84,7 +90,8 @@ public slots:
   void generate();
   /// set the property values
   void setProperties(const QCMakePropertyList&);
-  /// interrupt the configure or generate process (if connecting, make a direct connection)
+  /// interrupt the configure or generate process (if connecting, make a direct
+  /// connection)
   void interrupt();
   /// delete the cache in binary directory
   void deleteCache();
@@ -128,7 +135,8 @@ public:
   bool getDebugOutput() const;
 
 signals:
-  /// signal when properties change (during read from disk or configure process)
+  /// signal when properties change (during read from disk or configure
+  /// process)
   void propertiesChanged(const QCMakePropertyList& vars);
   /// signal when the generator changes
   void generatorChanged(const QString& gen);
@@ -157,8 +165,8 @@ protected:
 
   static bool interruptCallback(void*);
   static void progressCallback(const char* msg, float percent, void* cd);
-  static void messageCallback(const char* msg, const char* title,
-                              bool&, void* cd);
+  static void messageCallback(const char* msg, const char* title, bool&,
+                              void* cd);
   static void stdoutCallback(const char* msg, size_t len, void* cd);
   static void stderrCallback(const char* msg, size_t len, void* cd);
   bool WarnUninitializedMode;
@@ -174,4 +182,3 @@ protected:
 };
 
 #endif // QCMake_h
-
diff --git a/Source/QtDialog/QCMakeCacheView.cxx b/Source/QtDialog/QCMakeCacheView.cxx
index f64a78a..cc1f4aa 100644
--- a/Source/QtDialog/QCMakeCacheView.cxx
+++ b/Source/QtDialog/QCMakeCacheView.cxx
@@ -27,46 +27,44 @@
 class QCMakeSearchFilter : public QSortFilterProxyModel
 {
 public:
-  QCMakeSearchFilter(QObject* o) : QSortFilterProxyModel(o) {}
+  QCMakeSearchFilter(QObject* o)
+    : QSortFilterProxyModel(o)
+  {
+  }
+
 protected:
   bool filterAcceptsRow(int row, const QModelIndex& p) const
-    {
+  {
     QStringList strs;
     const QAbstractItemModel* m = this->sourceModel();
     QModelIndex idx = m->index(row, 0, p);
 
     // if there are no children, get strings for column 0 and 1
-    if(!m->hasChildren(idx))
-      {
+    if (!m->hasChildren(idx)) {
       strs.append(m->data(idx).toString());
       idx = m->index(row, 1, p);
       strs.append(m->data(idx).toString());
-      }
-    else
-      {
+    } else {
       // get strings for children entries to compare with
       // instead of comparing with the parent
       int num = m->rowCount(idx);
-      for(int i=0; i<num; i++)
-        {
+      for (int i = 0; i < num; i++) {
         QModelIndex tmpidx = m->index(i, 0, idx);
         strs.append(m->data(tmpidx).toString());
         tmpidx = m->index(i, 1, idx);
         strs.append(m->data(tmpidx).toString());
-        }
       }
+    }
 
     // check all strings for a match
-    foreach(QString str, strs)
-      {
-      if(str.contains(this->filterRegExp()))
-        {
+    foreach (QString str, strs) {
+      if (str.contains(this->filterRegExp())) {
         return true;
-        }
       }
+    }
 
     return false;
-    }
+  }
 };
 
 // filter for searches
@@ -74,7 +72,10 @@ class QCMakeAdvancedFilter : public QSortFilterProxyModel
 {
 public:
   QCMakeAdvancedFilter(QObject* o)
-    : QSortFilterProxyModel(o), ShowAdvanced(false) {}
+    : QSortFilterProxyModel(o)
+    , ShowAdvanced(false)
+  {
+  }
 
   void setShowAdvanced(bool f)
   {
@@ -84,37 +85,32 @@ public:
   bool showAdvanced() const { return this->ShowAdvanced; }
 
 protected:
-
   bool ShowAdvanced;
 
   bool filterAcceptsRow(int row, const QModelIndex& p) const
-    {
+  {
     const QAbstractItemModel* m = this->sourceModel();
     QModelIndex idx = m->index(row, 0, p);
 
     // if there are no children
-    if(!m->hasChildren(idx))
-      {
+    if (!m->hasChildren(idx)) {
       bool adv = m->data(idx, QCMakeCacheModel::AdvancedRole).toBool();
-      if(!adv || (adv && this->ShowAdvanced))
-        {
+      if (!adv || (adv && this->ShowAdvanced)) {
         return true;
-        }
-      return false;
       }
+      return false;
+    }
 
     // check children
     int num = m->rowCount(idx);
-    for(int i=0; i<num; i++)
-      {
+    for (int i = 0; i < num; i++) {
       bool accept = this->filterAcceptsRow(i, idx);
-      if(accept)
-        {
+      if (accept) {
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
 };
 
 QCMakeCacheView::QCMakeCacheView(QWidget* p)
@@ -147,10 +143,9 @@ QCMakeCacheView::QCMakeCacheView(QWidget* p)
 
 bool QCMakeCacheView::event(QEvent* e)
 {
-  if(e->type() == QEvent::Show)
-    {
-    this->header()->setDefaultSectionSize(this->viewport()->width()/2);
-    }
+  if (e->type() == QEvent::Show) {
+    this->header()->setDefaultSectionSize(this->viewport()->width() / 2);
+  }
   return QTreeView::event(e);
 }
 
@@ -160,17 +155,14 @@ QCMakeCacheModel* QCMakeCacheView::cacheModel() const
 }
 
 QModelIndex QCMakeCacheView::moveCursor(CursorAction act,
-  Qt::KeyboardModifiers mod)
+                                        Qt::KeyboardModifiers mod)
 {
   // want home/end to go to begin/end of rows, not columns
-  if(act == MoveHome)
-    {
+  if (act == MoveHome) {
     return this->model()->index(0, 1);
-    }
-  else if(act == MoveEnd)
-    {
-    return this->model()->index(this->model()->rowCount()-1, 1);
-    }
+  } else if (act == MoveEnd) {
+    return this->model()->index(this->model()->rowCount() - 1, 1);
+  }
   return QTreeView::moveCursor(act, mod);
 }
 
@@ -195,10 +187,10 @@ void QCMakeCacheView::setSearchFilter(const QString& s)
 }
 
 QCMakeCacheModel::QCMakeCacheModel(QObject* p)
-  : QStandardItemModel(p),
-    EditEnabled(true),
-    NewPropertyCount(0),
-    View(FlatView)
+  : QStandardItemModel(p)
+  , EditEnabled(true)
+  , NewPropertyCount(0)
+  , View(FlatView)
 {
   this->ShowNewProperties = true;
   QStringList labels;
@@ -234,47 +226,39 @@ void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
 {
   QSet<QCMakeProperty> newProps, newProps2;
 
-  if(this->ShowNewProperties)
-    {
+  if (this->ShowNewProperties) {
     newProps = props.toSet();
     newProps2 = newProps;
     QSet<QCMakeProperty> oldProps = this->properties().toSet();
     oldProps.intersect(newProps);
     newProps.subtract(oldProps);
     newProps2.subtract(newProps);
-    }
-  else
-    {
+  } else {
     newProps2 = props.toSet();
-    }
+  }
 
   bool b = this->blockSignals(true);
 
   this->clear();
   this->NewPropertyCount = newProps.size();
 
-  if(View == FlatView)
-  {
+  if (View == FlatView) {
     QCMakePropertyList newP = newProps.toList();
     QCMakePropertyList newP2 = newProps2.toList();
     qSort(newP);
     qSort(newP2);
     int row_count = 0;
-    foreach(QCMakeProperty p, newP)
-    {
+    foreach (QCMakeProperty p, newP) {
       this->insertRow(row_count);
       this->setPropertyData(this->index(row_count, 0), p, true);
       row_count++;
     }
-    foreach(QCMakeProperty p, newP2)
-    {
+    foreach (QCMakeProperty p, newP2) {
       this->insertRow(row_count);
       this->setPropertyData(this->index(row_count, 0), p, false);
       row_count++;
     }
-  }
-  else if(this->View == GroupView)
-  {
+  } else if (this->View == GroupView) {
     QMap<QString, QCMakePropertyList> newPropsTree;
     this->breakProperties(newProps, newPropsTree);
     QMap<QString, QCMakePropertyList> newPropsTree2;
@@ -282,35 +266,33 @@ void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
 
     QStandardItem* root = this->invisibleRootItem();
 
-    foreach(QString key, newPropsTree.keys())
-      {
+    foreach (QString key, newPropsTree.keys()) {
       QCMakePropertyList props2 = newPropsTree[key];
 
       QList<QStandardItem*> parentItems;
       parentItems.append(
-        new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key)
-        );
+        new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key));
       parentItems.append(new QStandardItem());
-      parentItems[0]->setData(QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
-      parentItems[1]->setData(QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
+      parentItems[0]->setData(QBrush(QColor(255, 100, 100)),
+                              Qt::BackgroundColorRole);
+      parentItems[1]->setData(QBrush(QColor(255, 100, 100)),
+                              Qt::BackgroundColorRole);
       parentItems[0]->setData(1, GroupRole);
       parentItems[1]->setData(1, GroupRole);
       root->appendRow(parentItems);
 
       int num = props2.size();
-      for(int i=0; i<num; i++)
-        {
+      for (int i = 0; i < num; i++) {
         QCMakeProperty prop = props2[i];
         QList<QStandardItem*> items;
         items.append(new QStandardItem());
         items.append(new QStandardItem());
         parentItems[0]->appendRow(items);
         this->setPropertyData(this->indexFromItem(items[0]), prop, true);
-        }
       }
+    }
 
-    foreach(QString key, newPropsTree2.keys())
-      {
+    foreach (QString key, newPropsTree2.keys()) {
       QCMakePropertyList props2 = newPropsTree2[key];
 
       QStandardItem* parentItem =
@@ -319,16 +301,15 @@ void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
       parentItem->setData(1, GroupRole);
 
       int num = props2.size();
-      for(int i=0; i<num; i++)
-        {
+      for (int i = 0; i < num; i++) {
         QCMakeProperty prop = props2[i];
         QList<QStandardItem*> items;
         items.append(new QStandardItem());
         items.append(new QStandardItem());
         parentItem->appendRow(items);
         this->setPropertyData(this->indexFromItem(items[0]), prop, false);
-        }
       }
+    }
   }
 
   this->blockSignals(b);
@@ -348,8 +329,7 @@ void QCMakeCacheModel::setViewType(QCMakeCacheModel::ViewType t)
   QCMakePropertyList oldProps;
   int numNew = this->NewPropertyCount;
   int numTotal = props.count();
-  for(int i=numNew; i<numTotal; i++)
-  {
+  for (int i = numNew; i < numTotal; i++) {
     oldProps.append(props[i]);
   }
 
@@ -362,7 +342,7 @@ void QCMakeCacheModel::setViewType(QCMakeCacheModel::ViewType t)
 }
 
 void QCMakeCacheModel::setPropertyData(const QModelIndex& idx1,
-    const QCMakeProperty& prop, bool isNew)
+                                       const QCMakeProperty& prop, bool isNew)
 {
   QModelIndex idx2 = idx1.sibling(idx1.row(), 1);
 
@@ -371,46 +351,42 @@ void QCMakeCacheModel::setPropertyData(const QModelIndex& idx1,
   this->setData(idx1, prop.Type, QCMakeCacheModel::TypeRole);
   this->setData(idx1, prop.Advanced, QCMakeCacheModel::AdvancedRole);
 
-  if(prop.Type == QCMakeProperty::BOOL)
-  {
+  if (prop.Type == QCMakeProperty::BOOL) {
     int check = prop.Value.toBool() ? Qt::Checked : Qt::Unchecked;
     this->setData(idx2, check, Qt::CheckStateRole);
-  }
-  else
-  {
+  } else {
     this->setData(idx2, prop.Value, Qt::DisplayRole);
   }
   this->setData(idx2, prop.Help, QCMakeCacheModel::HelpRole);
 
-  if (!prop.Strings.isEmpty())
-  {
+  if (!prop.Strings.isEmpty()) {
     this->setData(idx1, prop.Strings, QCMakeCacheModel::StringsRole);
   }
 
-  if(isNew)
-  {
-    this->setData(idx1, QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
-    this->setData(idx2, QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
+  if (isNew) {
+    this->setData(idx1, QBrush(QColor(255, 100, 100)),
+                  Qt::BackgroundColorRole);
+    this->setData(idx2, QBrush(QColor(255, 100, 100)),
+                  Qt::BackgroundColorRole);
   }
 }
 
 void QCMakeCacheModel::getPropertyData(const QModelIndex& idx1,
-    QCMakeProperty& prop) const
+                                       QCMakeProperty& prop) const
 {
   QModelIndex idx2 = idx1.sibling(idx1.row(), 1);
 
   prop.Key = this->data(idx1, Qt::DisplayRole).toString();
   prop.Help = this->data(idx1, HelpRole).toString();
-  prop.Type = static_cast<QCMakeProperty::PropertyType>(this->data(idx1, TypeRole).toInt());
+  prop.Type = static_cast<QCMakeProperty::PropertyType>(
+    this->data(idx1, TypeRole).toInt());
   prop.Advanced = this->data(idx1, AdvancedRole).toBool();
-  prop.Strings = this->data(idx1, QCMakeCacheModel::StringsRole).toStringList();
-  if(prop.Type == QCMakeProperty::BOOL)
-  {
+  prop.Strings =
+    this->data(idx1, QCMakeCacheModel::StringsRole).toStringList();
+  if (prop.Type == QCMakeProperty::BOOL) {
     int check = this->data(idx2, Qt::CheckStateRole).toInt();
     prop.Value = check == Qt::Checked;
-  }
-  else
-  {
+  } else {
     prop.Value = this->data(idx2, Qt::DisplayRole).toString();
   }
 }
@@ -418,43 +394,36 @@ void QCMakeCacheModel::getPropertyData(const QModelIndex& idx1,
 QString QCMakeCacheModel::prefix(const QString& s)
 {
   QString prefix = s.section('_', 0, 0);
-  if(prefix == s)
-    {
+  if (prefix == s) {
     prefix = QString();
-    }
+  }
   return prefix;
 }
 
-void QCMakeCacheModel::breakProperties(const QSet<QCMakeProperty>& props,
-                     QMap<QString, QCMakePropertyList>& result)
+void QCMakeCacheModel::breakProperties(
+  const QSet<QCMakeProperty>& props, QMap<QString, QCMakePropertyList>& result)
 {
   QMap<QString, QCMakePropertyList> tmp;
   // return a map of properties grouped by prefixes, and sorted
-  foreach(QCMakeProperty p, props)
-    {
+  foreach (QCMakeProperty p, props) {
     QString prefix = QCMakeCacheModel::prefix(p.Key);
     tmp[prefix].append(p);
-    }
+  }
   // sort it and re-org any properties with only one sub item
   QCMakePropertyList reorgProps;
   QMap<QString, QCMakePropertyList>::iterator iter;
-  for(iter = tmp.begin(); iter != tmp.end();)
-    {
-    if(iter->count() == 1)
-      {
+  for (iter = tmp.begin(); iter != tmp.end();) {
+    if (iter->count() == 1) {
       reorgProps.append((*iter)[0]);
       iter = tmp.erase(iter);
-      }
-    else
-      {
+    } else {
       qSort(*iter);
       ++iter;
-      }
     }
-  if(reorgProps.count())
-    {
+  }
+  if (reorgProps.count()) {
     tmp[QString()] += reorgProps;
-    }
+  }
   result = tmp;
 }
 
@@ -462,27 +431,21 @@ QCMakePropertyList QCMakeCacheModel::properties() const
 {
   QCMakePropertyList props;
 
-  if(!this->rowCount())
-    {
+  if (!this->rowCount()) {
     return props;
-    }
+  }
 
   QList<QModelIndex> idxs;
-  idxs.append(this->index(0,0));
+  idxs.append(this->index(0, 0));
 
   // walk the entire model for property entries
   // this works regardless of a flat view or a tree view
-  while(!idxs.isEmpty())
-  {
+  while (!idxs.isEmpty()) {
     QModelIndex idx = idxs.last();
-    if(this->hasChildren(idx) && this->rowCount(idx))
-    {
-      idxs.append(this->index(0,0, idx));
-    }
-    else
-    {
-      if(!data(idx, GroupRole).toInt())
-      {
+    if (this->hasChildren(idx) && this->rowCount(idx)) {
+      idxs.append(this->index(0, 0, idx));
+    } else {
+      if (!data(idx, GroupRole).toInt()) {
         // get data
         QCMakeProperty prop;
         this->getPropertyData(idx, prop);
@@ -490,17 +453,17 @@ QCMakePropertyList QCMakeCacheModel::properties() const
       }
 
       // go to the next in the tree
-      while(!idxs.isEmpty() && (
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) && QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
-        (idxs.last().row()+1) >= rowCount(idxs.last().parent()) ||
+      while (!idxs.isEmpty() &&
+             (
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0) &&                                \
+  QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
+               (idxs.last().row() + 1) >= rowCount(idxs.last().parent()) ||
 #endif
-        !idxs.last().sibling(idxs.last().row()+1, 0).isValid()))
-      {
+               !idxs.last().sibling(idxs.last().row() + 1, 0).isValid())) {
         idxs.removeLast();
       }
-      if(!idxs.isEmpty())
-      {
-        idxs.last() = idxs.last().sibling(idxs.last().row()+1, 0);
+      if (!idxs.isEmpty()) {
+        idxs.last() = idxs.last().sibling(idxs.last().row() + 1, 0);
       }
     }
   }
@@ -509,8 +472,9 @@ QCMakePropertyList QCMakeCacheModel::properties() const
 }
 
 bool QCMakeCacheModel::insertProperty(QCMakeProperty::PropertyType t,
-                      const QString& name, const QString& description,
-                      const QVariant& value, bool advanced)
+                                      const QString& name,
+                                      const QString& description,
+                                      const QVariant& value, bool advanced)
 {
   QCMakeProperty prop;
   prop.Key = name;
@@ -519,9 +483,9 @@ bool QCMakeCacheModel::insertProperty(QCMakeProperty::PropertyType t,
   prop.Type = t;
   prop.Advanced = advanced;
 
-  //insert at beginning
+  // insert at beginning
   this->insertRow(0);
-  this->setPropertyData(this->index(0,0), prop, true);
+  this->setPropertyData(this->index(0, 0), prop, true);
   this->NewPropertyCount++;
   return true;
 }
@@ -541,33 +505,31 @@ int QCMakeCacheModel::newPropertyCount() const
   return this->NewPropertyCount;
 }
 
-Qt::ItemFlags QCMakeCacheModel::flags (const QModelIndex& idx) const
+Qt::ItemFlags QCMakeCacheModel::flags(const QModelIndex& idx) const
 {
   Qt::ItemFlags f = QStandardItemModel::flags(idx);
-  if(!this->EditEnabled)
-    {
+  if (!this->EditEnabled) {
     f &= ~Qt::ItemIsEditable;
     return f;
-    }
-  if(QCMakeProperty::BOOL == this->data(idx, TypeRole).toInt())
-    {
+  }
+  if (QCMakeProperty::BOOL == this->data(idx, TypeRole).toInt()) {
     f |= Qt::ItemIsUserCheckable;
-    }
+  }
   return f;
 }
 
 QModelIndex QCMakeCacheModel::buddy(const QModelIndex& idx) const
 {
-  if(!this->hasChildren(idx) &&
-     this->data(idx, TypeRole).toInt() != QCMakeProperty::BOOL)
-  {
+  if (!this->hasChildren(idx) &&
+      this->data(idx, TypeRole).toInt() != QCMakeProperty::BOOL) {
     return this->index(idx.row(), 1, idx.parent());
   }
   return idx;
 }
 
 QCMakeCacheModelDelegate::QCMakeCacheModelDelegate(QObject* p)
-  : QItemDelegate(p), FileDialogFlag(false)
+  : QItemDelegate(p)
+  , FileDialogFlag(false)
 {
 }
 
@@ -577,91 +539,77 @@ void QCMakeCacheModelDelegate::setFileDialogFlag(bool f)
 }
 
 QWidget* QCMakeCacheModelDelegate::createEditor(QWidget* p,
-    const QStyleOptionViewItem&, const QModelIndex& idx) const
+                                                const QStyleOptionViewItem&,
+                                                const QModelIndex& idx) const
 {
   QModelIndex var = idx.sibling(idx.row(), 0);
   int type = var.data(QCMakeCacheModel::TypeRole).toInt();
-  if(type == QCMakeProperty::BOOL)
-    {
+  if (type == QCMakeProperty::BOOL) {
     return NULL;
-    }
-  else if(type == QCMakeProperty::PATH)
-    {
+  } else if (type == QCMakeProperty::PATH) {
     QCMakePathEditor* editor =
-      new QCMakePathEditor(p,
-      var.data(Qt::DisplayRole).toString());
+      new QCMakePathEditor(p, var.data(Qt::DisplayRole).toString());
     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
-        SLOT(setFileDialogFlag(bool)));
+                     SLOT(setFileDialogFlag(bool)));
     return editor;
-    }
-  else if(type == QCMakeProperty::FILEPATH)
-    {
+  } else if (type == QCMakeProperty::FILEPATH) {
     QCMakeFilePathEditor* editor =
-      new QCMakeFilePathEditor(p,
-      var.data(Qt::DisplayRole).toString());
+      new QCMakeFilePathEditor(p, var.data(Qt::DisplayRole).toString());
     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
-        SLOT(setFileDialogFlag(bool)));
+                     SLOT(setFileDialogFlag(bool)));
     return editor;
-    }
-  else if(type == QCMakeProperty::STRING &&
-          var.data(QCMakeCacheModel::StringsRole).isValid())
-    {
-    QCMakeComboBox* editor =
-      new QCMakeComboBox(p, var.data(QCMakeCacheModel::StringsRole).toStringList());
+  } else if (type == QCMakeProperty::STRING &&
+             var.data(QCMakeCacheModel::StringsRole).isValid()) {
+    QCMakeComboBox* editor = new QCMakeComboBox(
+      p, var.data(QCMakeCacheModel::StringsRole).toStringList());
     editor->setFrame(false);
     return editor;
-    }
+  }
 
   QLineEdit* editor = new QLineEdit(p);
   editor->setFrame(false);
   return editor;
 }
 
-bool QCMakeCacheModelDelegate::editorEvent(QEvent* e, QAbstractItemModel* model,
-       const QStyleOptionViewItem& option, const QModelIndex& index)
+bool QCMakeCacheModelDelegate::editorEvent(QEvent* e,
+                                           QAbstractItemModel* model,
+                                           const QStyleOptionViewItem& option,
+                                           const QModelIndex& index)
 {
   Qt::ItemFlags flags = model->flags(index);
-  if (!(flags & Qt::ItemIsUserCheckable) || !(option.state & QStyle::State_Enabled)
-      || !(flags & Qt::ItemIsEnabled))
-    {
+  if (!(flags & Qt::ItemIsUserCheckable) ||
+      !(option.state & QStyle::State_Enabled) ||
+      !(flags & Qt::ItemIsEnabled)) {
     return false;
-    }
+  }
 
   QVariant value = index.data(Qt::CheckStateRole);
-  if (!value.isValid())
-    {
+  if (!value.isValid()) {
     return false;
-    }
+  }
 
-  if ((e->type() == QEvent::MouseButtonRelease)
-      || (e->type() == QEvent::MouseButtonDblClick))
-    {
+  if ((e->type() == QEvent::MouseButtonRelease) ||
+      (e->type() == QEvent::MouseButtonDblClick)) {
     // eat the double click events inside the check rect
-    if (e->type() == QEvent::MouseButtonDblClick)
-      {
+    if (e->type() == QEvent::MouseButtonDblClick) {
       return true;
-      }
     }
-  else if (e->type() == QEvent::KeyPress)
-    {
-    if(static_cast<QKeyEvent*>(e)->key() != Qt::Key_Space &&
-       static_cast<QKeyEvent*>(e)->key() != Qt::Key_Select)
-      {
+  } else if (e->type() == QEvent::KeyPress) {
+    if (static_cast<QKeyEvent*>(e)->key() != Qt::Key_Space &&
+        static_cast<QKeyEvent*>(e)->key() != Qt::Key_Select) {
       return false;
-      }
     }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 
-  Qt::CheckState state = (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked
-                          ? Qt::Unchecked : Qt::Checked);
+  Qt::CheckState state =
+    (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked ? Qt::Unchecked
+                                                               : Qt::Checked);
   bool success = model->setData(index, state, Qt::CheckStateRole);
-  if(success)
-    {
+  if (success) {
     this->recordChange(model, index);
-    }
+  }
   return success;
 }
 
@@ -673,29 +621,32 @@ bool QCMakeCacheModelDelegate::eventFilter(QObject* object, QEvent* evt)
   // where it doesn't create a QWidget wrapper for the native file dialog
   // so the Qt library ends up assuming the focus was lost to something else
 
-  if(evt->type() == QEvent::FocusOut && this->FileDialogFlag)
-    {
+  if (evt->type() == QEvent::FocusOut && this->FileDialogFlag) {
     return false;
-    }
+  }
   return QItemDelegate::eventFilter(object, evt);
 }
 
 void QCMakeCacheModelDelegate::setModelData(QWidget* editor,
-  QAbstractItemModel* model, const QModelIndex& index ) const
+                                            QAbstractItemModel* model,
+                                            const QModelIndex& index) const
 {
   QItemDelegate::setModelData(editor, model, index);
   const_cast<QCMakeCacheModelDelegate*>(this)->recordChange(model, index);
 }
 
-QSize QCMakeCacheModelDelegate::sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const
+QSize QCMakeCacheModelDelegate::sizeHint(const QStyleOptionViewItem& option,
+                                         const QModelIndex& index) const
 {
   QSize sz = QItemDelegate::sizeHint(option, index);
-  QStyle *style = QApplication::style();
+  QStyle* style = QApplication::style();
 
   // increase to checkbox size
   QStyleOptionButton opt;
   opt.QStyleOption::operator=(option);
-  sz = sz.expandedTo(style->subElementRect(QStyle::SE_ViewItemCheckIndicator, &opt, NULL).size());
+  sz = sz.expandedTo(
+    style->subElementRect(QStyle::SE_ViewItemCheckIndicator, &opt, NULL)
+      .size());
 
   return sz;
 }
@@ -710,30 +661,27 @@ void QCMakeCacheModelDelegate::clearChanges()
   mChanges.clear();
 }
 
-void QCMakeCacheModelDelegate::recordChange(QAbstractItemModel* model, const QModelIndex& index)
+void QCMakeCacheModelDelegate::recordChange(QAbstractItemModel* model,
+                                            const QModelIndex& index)
 {
   QModelIndex idx = index;
   QAbstractItemModel* mymodel = model;
-  while(qobject_cast<QAbstractProxyModel*>(mymodel))
-    {
+  while (qobject_cast<QAbstractProxyModel*>(mymodel)) {
     idx = static_cast<QAbstractProxyModel*>(mymodel)->mapToSource(idx);
     mymodel = static_cast<QAbstractProxyModel*>(mymodel)->sourceModel();
-    }
+  }
   QCMakeCacheModel* cache_model = qobject_cast<QCMakeCacheModel*>(mymodel);
-  if(cache_model && idx.isValid())
-    {
+  if (cache_model && idx.isValid()) {
     QCMakeProperty prop;
     idx = idx.sibling(idx.row(), 0);
     cache_model->getPropertyData(idx, prop);
 
     // clean out an old one
     QSet<QCMakeProperty>::iterator iter = mChanges.find(prop);
-    if(iter != mChanges.end())
-      {
+    if (iter != mChanges.end()) {
       mChanges.erase(iter);
-      }
+    }
     // now add the new item
     mChanges.insert(prop);
-    }
+  }
 }
-
diff --git a/Source/QtDialog/QCMakeCacheView.h b/Source/QtDialog/QCMakeCacheView.h
index 5631b86..6ad56fb 100644
--- a/Source/QtDialog/QCMakeCacheView.h
+++ b/Source/QtDialog/QCMakeCacheView.h
@@ -38,7 +38,7 @@ public:
   // get whether to show advanced entries
   bool showAdvanced() const;
 
-  QSize sizeHint() const { return QSize(200,200); }
+  QSize sizeHint() const { return QSize(200, 200); }
 
 public slots:
   // set whether to show advanced entries
@@ -65,14 +65,20 @@ public:
 
   // roles used to retrieve extra data such has help strings, types of
   // properties, and the advanced flag
-  enum { HelpRole = Qt::ToolTipRole,
-         TypeRole = Qt::UserRole,
-         AdvancedRole,
-         StringsRole,
-         GroupRole
-       };
-
-  enum ViewType { FlatView, GroupView };
+  enum
+  {
+    HelpRole = Qt::ToolTipRole,
+    TypeRole = Qt::UserRole,
+    AdvancedRole,
+    StringsRole,
+    GroupRole
+  };
+
+  enum ViewType
+  {
+    FlatView,
+    GroupView
+  };
 
 public slots:
   // set a list of properties.  This list will be sorted and grouped according
@@ -92,9 +98,9 @@ public slots:
 
   // insert a new property at a row specifying all the information about the
   // property
-  bool insertProperty(QCMakeProperty::PropertyType t,
-                      const QString& name, const QString& description,
-                      const QVariant& value, bool advanced);
+  bool insertProperty(QCMakeProperty::PropertyType t, const QString& name,
+                      const QString& description, const QVariant& value,
+                      bool advanced);
 
   // set the view type
   void setViewType(ViewType t);
@@ -111,12 +117,11 @@ public:
   int newPropertyCount() const;
 
   // return flags (overloaded to modify flag based on EditEnabled flag)
-  Qt::ItemFlags flags (const QModelIndex& index) const;
+  Qt::ItemFlags flags(const QModelIndex& index) const;
   QModelIndex buddy(const QModelIndex& idx) const;
 
   // get the data in the model for this property
-  void getPropertyData(const QModelIndex& idx1,
-                       QCMakeProperty& prop) const;
+  void getPropertyData(const QModelIndex& idx1, QCMakeProperty& prop) const;
 
 protected:
   bool EditEnabled;
@@ -125,17 +130,16 @@ protected:
   ViewType View;
 
   // set the data in the model for this property
-  void setPropertyData(const QModelIndex& idx1,
-                       const QCMakeProperty& p, bool isNew);
+  void setPropertyData(const QModelIndex& idx1, const QCMakeProperty& p,
+                       bool isNew);
 
   // breaks up he property list into groups
   // where each group has the same prefix up to the first underscore
   static void breakProperties(const QSet<QCMakeProperty>& props,
-                       QMap<QString, QCMakePropertyList>& result);
+                              QMap<QString, QCMakePropertyList>& result);
 
   // gets the prefix of a string up to the first _
   static QString prefix(const QString& s);
-
 };
 
 /// Qt delegate class for interaction (or other customization)
@@ -147,18 +151,22 @@ public:
   QCMakeCacheModelDelegate(QObject* p);
   /// create our own editors for cache properties
   QWidget* createEditor(QWidget* parent, const QStyleOptionViewItem& option,
-      const QModelIndex& index ) const;
-  bool editorEvent (QEvent* event, QAbstractItemModel* model,
-       const QStyleOptionViewItem& option, const QModelIndex& index);
+                        const QModelIndex& index) const;
+  bool editorEvent(QEvent* event, QAbstractItemModel* model,
+                   const QStyleOptionViewItem& option,
+                   const QModelIndex& index);
   bool eventFilter(QObject* object, QEvent* event);
-  void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex & index ) const;
-  QSize sizeHint(const QStyleOptionViewItem& option, const QModelIndex& index) const;
+  void setModelData(QWidget* editor, QAbstractItemModel* model,
+                    const QModelIndex& index) const;
+  QSize sizeHint(const QStyleOptionViewItem& option,
+                 const QModelIndex& index) const;
 
   QSet<QCMakeProperty> changes() const;
   void clearChanges();
 
 protected slots:
   void setFileDialogFlag(bool);
+
 protected:
   bool FileDialogFlag;
   // record a change to an item in the model.
@@ -170,4 +178,3 @@ protected:
 };
 
 #endif
-
diff --git a/Source/QtDialog/QCMakeWidgets.cxx b/Source/QtDialog/QCMakeWidgets.cxx
index 7803ef3..4b3eb34 100644
--- a/Source/QtDialog/QCMakeWidgets.cxx
+++ b/Source/QtDialog/QCMakeWidgets.cxx
@@ -19,23 +19,24 @@
 #include <QToolButton>
 
 QCMakeFileEditor::QCMakeFileEditor(QWidget* p, const QString& var)
-  : QLineEdit(p), Variable(var)
+  : QLineEdit(p)
+  , Variable(var)
 {
   this->ToolButton = new QToolButton(this);
   this->ToolButton->setText("...");
   this->ToolButton->setCursor(QCursor(Qt::ArrowCursor));
-  QObject::connect(this->ToolButton, SIGNAL(clicked(bool)),
-                   this, SLOT(chooseFile()));
+  QObject::connect(this->ToolButton, SIGNAL(clicked(bool)), this,
+                   SLOT(chooseFile()));
 }
 
 QCMakeFilePathEditor::QCMakeFilePathEditor(QWidget* p, const QString& var)
- : QCMakeFileEditor(p, var)
+  : QCMakeFileEditor(p, var)
 {
   this->setCompleter(new QCMakeFileCompleter(this, false));
 }
 
 QCMakePathEditor::QCMakePathEditor(QWidget* p, const QString& var)
- : QCMakeFileEditor(p, var)
+  : QCMakeFileEditor(p, var)
 {
   this->setCompleter(new QCMakeFileCompleter(this, true));
 }
@@ -57,24 +58,21 @@ void QCMakeFilePathEditor::chooseFile()
   QString path;
   QFileInfo info(this->text());
   QString title;
-  if(this->Variable.isEmpty())
-    {
+  if (this->Variable.isEmpty()) {
     title = tr("Select File");
-    }
-  else
-    {
+  } else {
     title = tr("Select File for %1");
     title = title.arg(this->Variable);
-    }
+  }
   this->fileDialogExists(true);
-  path = QFileDialog::getOpenFileName(this, title, info.absolutePath(),
-    QString(), NULL, QFileDialog::DontResolveSymlinks);
+  path =
+    QFileDialog::getOpenFileName(this, title, info.absolutePath(), QString(),
+                                 NULL, QFileDialog::DontResolveSymlinks);
   this->fileDialogExists(false);
 
-  if(!path.isEmpty())
-    {
+  if (!path.isEmpty()) {
     this->setText(QDir::fromNativeSeparators(path));
-    }
+  }
 }
 
 void QCMakePathEditor::chooseFile()
@@ -82,43 +80,38 @@ void QCMakePathEditor::chooseFile()
   // choose a file and set it
   QString path;
   QString title;
-  if(this->Variable.isEmpty())
-    {
+  if (this->Variable.isEmpty()) {
     title = tr("Select Path");
-    }
-  else
-    {
+  } else {
     title = tr("Select Path for %1");
     title = title.arg(this->Variable);
-    }
+  }
   this->fileDialogExists(true);
   path = QFileDialog::getExistingDirectory(this, title, this->text(),
-    QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+                                           QFileDialog::ShowDirsOnly |
+                                             QFileDialog::DontResolveSymlinks);
   this->fileDialogExists(false);
-  if(!path.isEmpty())
-    {
+  if (!path.isEmpty()) {
     this->setText(QDir::fromNativeSeparators(path));
-    }
+  }
 }
 
 // use same QDirModel for all completers
 static QDirModel* fileDirModel()
 {
   static QDirModel* m = NULL;
-  if(!m)
-    {
+  if (!m) {
     m = new QDirModel();
-    }
+  }
   return m;
 }
 static QDirModel* pathDirModel()
 {
   static QDirModel* m = NULL;
-  if(!m)
-    {
+  if (!m) {
     m = new QDirModel();
     m->setFilter(QDir::AllDirs | QDir::Drives | QDir::NoDotAndDotDot);
-    }
+  }
   return m;
 }
 
@@ -133,4 +126,3 @@ QString QCMakeFileCompleter::pathFromIndex(const QModelIndex& idx) const
 {
   return QDir::fromNativeSeparators(QCompleter::pathFromIndex(idx));
 }
-
diff --git a/Source/QtDialog/QCMakeWidgets.h b/Source/QtDialog/QCMakeWidgets.h
index 759b635..f1e87ce 100644
--- a/Source/QtDialog/QCMakeWidgets.h
+++ b/Source/QtDialog/QCMakeWidgets.h
@@ -31,6 +31,7 @@ protected slots:
   virtual void chooseFile() = 0;
 signals:
   void fileDialogExists(bool);
+
 protected:
   void resizeEvent(QResizeEvent* e);
   QToolButton* ToolButton;
@@ -69,20 +70,20 @@ class QCMakeComboBox : public QComboBox
 {
   Q_OBJECT
   Q_PROPERTY(QString value READ currentText WRITE setValue USER true);
+
 public:
-  QCMakeComboBox(QWidget* p, QStringList strings) : QComboBox(p)
+  QCMakeComboBox(QWidget* p, QStringList strings)
+    : QComboBox(p)
   {
     this->addItems(strings);
   }
   void setValue(const QString& v)
   {
     int i = this->findText(v);
-    if(i != -1)
-    {
+    if (i != -1) {
       this->setCurrentIndex(i);
     }
   }
 };
 
 #endif
-
diff --git a/Source/QtDialog/RegexExplorer.cxx b/Source/QtDialog/RegexExplorer.cxx
index dfcf048..d23a08c 100644
--- a/Source/QtDialog/RegexExplorer.cxx
+++ b/Source/QtDialog/RegexExplorer.cxx
@@ -12,16 +12,16 @@
 
 #include "RegexExplorer.h"
 
-RegexExplorer::RegexExplorer(QWidget* p) : QDialog(p), m_matched(false)
+RegexExplorer::RegexExplorer(QWidget* p)
+  : QDialog(p)
+  , m_matched(false)
 {
   this->setupUi(this);
 
-  for(int i = 1; i < cmsys::RegularExpression::NSUBEXP; ++i)
-    {
-    matchNumber->addItem(
-      QString("Match %1").arg(QString::number(i)),
-      QVariant(i));
-    }
+  for (int i = 1; i < cmsys::RegularExpression::NSUBEXP; ++i) {
+    matchNumber->addItem(QString("Match %1").arg(QString::number(i)),
+                         QVariant(i));
+  }
   matchNumber->setCurrentIndex(0);
 }
 
@@ -44,10 +44,9 @@ void RegexExplorer::on_regularExpression_textChanged(const QString& text)
 
   bool validExpression =
     stripEscapes(m_regex) && m_regexParser.compile(m_regex);
-  if(!validExpression)
-    {
+  if (!validExpression) {
     m_regexParser.set_invalid();
-    }
+  }
 
   setStatusColor(labelRegexValid, validExpression);
 
@@ -56,8 +55,7 @@ void RegexExplorer::on_regularExpression_textChanged(const QString& text)
 
 void RegexExplorer::on_inputText_textChanged()
 {
-  if(m_regexParser.is_valid())
-    {
+  if (m_regexParser.is_valid()) {
     QString plainText = inputText->toPlainText();
 #ifdef QT_NO_STL
     m_text = plainText.toAscii().constData();
@@ -65,19 +63,16 @@ void RegexExplorer::on_inputText_textChanged()
     m_text = plainText.toStdString();
 #endif
     m_matched = m_regexParser.find(m_text);
-    }
-  else
-    {
+  } else {
     m_matched = false;
-    }
+  }
 
   setStatusColor(labelRegexMatch, m_matched);
 
-  if(!m_matched)
-    {
+  if (!m_matched) {
     clearMatch();
     return;
-    }
+  }
 
 #ifdef QT_NO_STL
   QString matchText = m_regexParser.match(0).c_str();
@@ -91,18 +86,16 @@ void RegexExplorer::on_inputText_textChanged()
 
 void RegexExplorer::on_matchNumber_currentIndexChanged(int index)
 {
-  if(!m_matched)
-    {
+  if (!m_matched) {
     return;
-    }
+  }
 
   QVariant itemData = matchNumber->itemData(index);
   int idx = itemData.toInt();
 
-  if(idx < 1 || idx >= cmsys::RegularExpression::NSUBEXP)
-    {
+  if (idx < 1 || idx >= cmsys::RegularExpression::NSUBEXP) {
     return;
-    }
+  }
 
 #ifdef QT_NO_STL
   QString match = m_regexParser.match(idx).c_str();
@@ -125,42 +118,29 @@ bool RegexExplorer::stripEscapes(std::string& source)
   std::string result;
   result.reserve(source.size());
 
-  for(char inc = *in; inc != '\0'; inc = *++in)
-    {
-    if(inc == '\\')
-      {
+  for (char inc = *in; inc != '\0'; inc = *++in) {
+    if (inc == '\\') {
       char nextc = in[1];
-      if(nextc == 't')
-        {
+      if (nextc == 't') {
         result.append(1, '\t');
         in++;
-        }
-      else if(nextc == 'n')
-        {
+      } else if (nextc == 'n') {
         result.append(1, '\n');
         in++;
-        }
-      else if(nextc == 't')
-        {
+      } else if (nextc == 't') {
         result.append(1, '\t');
         in++;
-        }
-      else if(isalnum(nextc) || nextc == '\0')
-        {
+      } else if (isalnum(nextc) || nextc == '\0') {
         return false;
-        }
-      else
-        {
+      } else {
         result.append(1, nextc);
         in++;
-        }
-      }
-    else
-      {
-        result.append(1, inc);
       }
+    } else {
+      result.append(1, inc);
     }
+  }
 
-    source = result;
-    return true;
+  source = result;
+  return true;
 }
diff --git a/Source/QtDialog/WarningMessagesDialog.cxx b/Source/QtDialog/WarningMessagesDialog.cxx
index 4bd541f..3be6798 100644
--- a/Source/QtDialog/WarningMessagesDialog.cxx
+++ b/Source/QtDialog/WarningMessagesDialog.cxx
@@ -13,7 +13,8 @@
 #include "WarningMessagesDialog.h"
 
 WarningMessagesDialog::WarningMessagesDialog(QWidget* prnt, QCMake* instance)
-  : QDialog(prnt), cmakeInstance(instance)
+  : QDialog(prnt)
+  , cmakeInstance(instance)
 {
   this->setupUi(this);
   this->setInitialValues();
@@ -35,8 +36,8 @@ void WarningMessagesDialog::setInitialValues()
 
 void WarningMessagesDialog::setupSignals()
 {
-  QObject::connect(this->buttonBox, SIGNAL(accepted()),
-                   this, SLOT(doAccept()));
+  QObject::connect(this->buttonBox, SIGNAL(accepted()), this,
+                   SLOT(doAccept()));
 
   QObject::connect(this->suppressDeveloperWarnings, SIGNAL(stateChanged(int)),
                    this, SLOT(doSuppressDeveloperWarningsChanged(int)));
@@ -65,35 +66,31 @@ void WarningMessagesDialog::doAccept()
 void WarningMessagesDialog::doSuppressDeveloperWarningsChanged(int state)
 {
   // no warnings implies no errors either
-  if (state)
-    {
+  if (state) {
     this->developerWarningsAsErrors->setChecked(false);
-    }
+  }
 }
 
 void WarningMessagesDialog::doSuppressDeprecatedWarningsChanged(int state)
 {
   // no warnings implies no errors either
-  if (state)
-    {
+  if (state) {
     this->deprecatedWarningsAsErrors->setChecked(false);
-    }
+  }
 }
 
 void WarningMessagesDialog::doDeveloperWarningsAsErrorsChanged(int state)
 {
   // warnings as errors implies warnings are not suppressed
-  if (state)
-    {
+  if (state) {
     this->suppressDeveloperWarnings->setChecked(false);
-    }
+  }
 }
 
 void WarningMessagesDialog::doDeprecatedWarningsAsErrorsChanged(int state)
 {
   // warnings as errors implies warnings are not suppressed
-  if (state)
-    {
+  if (state) {
     this->suppressDeprecatedWarnings->setChecked(false);
-    }
+  }
 }
diff --git a/Source/cmAddCompileOptionsCommand.cxx b/Source/cmAddCompileOptionsCommand.cxx
index a6c3c00..2223cf4 100644
--- a/Source/cmAddCompileOptionsCommand.cxx
+++ b/Source/cmAddCompileOptionsCommand.cxx
@@ -11,18 +11,16 @@
 ============================================================================*/
 #include "cmAddCompileOptionsCommand.h"
 
-bool cmAddCompileOptionsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddCompileOptionsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
 
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
     this->Makefile->AddCompileOption(i->c_str());
-    }
+  }
   return true;
 }
diff --git a/Source/cmAddCompileOptionsCommand.h b/Source/cmAddCompileOptionsCommand.h
index f147ec0..5c073c8 100644
--- a/Source/cmAddCompileOptionsCommand.h
+++ b/Source/cmAddCompileOptionsCommand.h
@@ -20,22 +20,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddCompileOptionsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddCompileOptionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "add_compile_options";}
+  virtual std::string GetName() const { return "add_compile_options"; }
 
   cmTypeMacro(cmAddCompileOptionsCommand, cmCommand);
 };
diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx
index 30f431c..d8fd1d8 100644
--- a/Source/cmAddCustomCommandCommand.cxx
+++ b/Source/cmAddCustomCommandCommand.cxx
@@ -16,18 +16,17 @@
 #include "cmSourceFile.h"
 
 // cmAddCustomCommandCommand
-bool cmAddCustomCommandCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddCustomCommandCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   /* Let's complain at the end of this function about the lack of a particular
      arg. For the moment, let's say that COMMAND, and either TARGET or SOURCE
      are required.
   */
-  if (args.size() < 4)
-    {
-      this->SetError("called with wrong number of arguments.");
-      return false;
-    }
+  if (args.size() < 4) {
+    this->SetError("called with wrong number of arguments.");
+    return false;
+  }
 
   std::string source, target, main_dependency, working;
   std::string comment_buffer;
@@ -47,7 +46,8 @@ bool cmAddCustomCommandCommand
 
   cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
 
-  enum tdoing {
+  enum tdoing
+  {
     doing_source,
     doing_command,
     doing_target,
@@ -65,99 +65,58 @@ bool cmAddCustomCommandCommand
 
   tdoing doing = doing_nothing;
 
-  for (unsigned int j = 0; j < args.size(); ++j)
-    {
+  for (unsigned int j = 0; j < args.size(); ++j) {
     std::string const& copy = args[j];
 
-    if(copy == "SOURCE")
-      {
+    if (copy == "SOURCE") {
       doing = doing_source;
-      }
-    else if(copy == "COMMAND")
-      {
+    } else if (copy == "COMMAND") {
       doing = doing_command;
 
       // Save the current command before starting the next command.
-      if(!currentLine.empty())
-        {
+      if (!currentLine.empty()) {
         commandLines.push_back(currentLine);
         currentLine.clear();
-        }
       }
-    else if(copy == "PRE_BUILD")
-      {
+    } else if (copy == "PRE_BUILD") {
       cctype = cmTarget::PRE_BUILD;
-      }
-    else if(copy == "PRE_LINK")
-      {
+    } else if (copy == "PRE_LINK") {
       cctype = cmTarget::PRE_LINK;
-      }
-    else if(copy == "POST_BUILD")
-      {
+    } else if (copy == "POST_BUILD") {
       cctype = cmTarget::POST_BUILD;
-      }
-    else if(copy == "VERBATIM")
-      {
+    } else if (copy == "VERBATIM") {
       verbatim = true;
-      }
-    else if(copy == "APPEND")
-      {
+    } else if (copy == "APPEND") {
       append = true;
-      }
-    else if(copy == "USES_TERMINAL")
-      {
+    } else if (copy == "USES_TERMINAL") {
       uses_terminal = true;
-      }
-    else if(copy == "TARGET")
-      {
+    } else if (copy == "TARGET") {
       doing = doing_target;
-      }
-    else if(copy == "ARGS")
-      {
+    } else if (copy == "ARGS") {
       // Ignore this old keyword.
-      }
-    else if (copy == "DEPENDS")
-      {
+    } else if (copy == "DEPENDS") {
       doing = doing_depends;
-      }
-    else if (copy == "OUTPUTS")
-      {
+    } else if (copy == "OUTPUTS") {
       doing = doing_outputs;
-      }
-    else if (copy == "OUTPUT")
-      {
+    } else if (copy == "OUTPUT") {
       doing = doing_output;
-      }
-    else if (copy == "BYPRODUCTS")
-      {
+    } else if (copy == "BYPRODUCTS") {
       doing = doing_byproducts;
-      }
-    else if (copy == "WORKING_DIRECTORY")
-      {
+    } else if (copy == "WORKING_DIRECTORY") {
       doing = doing_working_directory;
-      }
-    else if (copy == "MAIN_DEPENDENCY")
-      {
+    } else if (copy == "MAIN_DEPENDENCY") {
       doing = doing_main_dependency;
-      }
-    else if (copy == "IMPLICIT_DEPENDS")
-      {
+    } else if (copy == "IMPLICIT_DEPENDS") {
       doing = doing_implicit_depends_lang;
-      }
-    else if (copy == "COMMENT")
-      {
+    } else if (copy == "COMMENT") {
       doing = doing_comment;
-      }
-    else
-      {
+    } else {
       std::string filename;
-      switch (doing)
-        {
+      switch (doing) {
         case doing_output:
         case doing_outputs:
         case doing_byproducts:
-          if (!cmSystemTools::FileIsFullPath(copy.c_str()))
-            {
+          if (!cmSystemTools::FileIsFullPath(copy.c_str())) {
             // This is an output to be generated, so it should be
             // under the build tree.  CMake 2.4 placed this under the
             // source tree.  However the only case that this change
@@ -170,139 +129,124 @@ bool cmAddCustomCommandCommand
             // complain.
             filename = this->Makefile->GetCurrentBinaryDirectory();
             filename += "/";
-            }
+          }
           filename += copy;
           cmSystemTools::ConvertToUnixSlashes(filename);
           break;
         case doing_source:
-          // We do not want to convert the argument to SOURCE because
-          // that option is only available for backward compatibility.
-          // Old-style use of this command may use the SOURCE==TARGET
-          // trick which we must preserve.  If we convert the source
-          // to a full path then it will no longer equal the target.
+        // We do not want to convert the argument to SOURCE because
+        // that option is only available for backward compatibility.
+        // Old-style use of this command may use the SOURCE==TARGET
+        // trick which we must preserve.  If we convert the source
+        // to a full path then it will no longer equal the target.
         default:
           break;
-        }
+      }
 
-      if (cmSystemTools::FileIsFullPath(filename.c_str()))
-        {
+      if (cmSystemTools::FileIsFullPath(filename.c_str())) {
         filename = cmSystemTools::CollapseFullPath(filename);
-        }
-       switch (doing)
-         {
-         case doing_working_directory:
-           working = copy;
-           break;
-         case doing_source:
-           source = copy;
-           break;
-         case doing_output:
-           output.push_back(filename);
-           break;
-         case doing_main_dependency:
-           main_dependency = copy;
-           break;
-         case doing_implicit_depends_lang:
-           implicit_depends_lang = copy;
-           doing = doing_implicit_depends_file;
-           break;
-         case doing_implicit_depends_file:
-           {
-           // An implicit dependency starting point is also an
-           // explicit dependency.
-           std::string dep = copy;
-           cmSystemTools::ConvertToUnixSlashes(dep);
-           depends.push_back(dep);
+      }
+      switch (doing) {
+        case doing_working_directory:
+          working = copy;
+          break;
+        case doing_source:
+          source = copy;
+          break;
+        case doing_output:
+          output.push_back(filename);
+          break;
+        case doing_main_dependency:
+          main_dependency = copy;
+          break;
+        case doing_implicit_depends_lang:
+          implicit_depends_lang = copy;
+          doing = doing_implicit_depends_file;
+          break;
+        case doing_implicit_depends_file: {
+          // An implicit dependency starting point is also an
+          // explicit dependency.
+          std::string dep = copy;
+          cmSystemTools::ConvertToUnixSlashes(dep);
+          depends.push_back(dep);
 
-           // Add the implicit dependency language and file.
-           cmCustomCommand::ImplicitDependsPair
-             entry(implicit_depends_lang, dep);
-           implicit_depends.push_back(entry);
+          // Add the implicit dependency language and file.
+          cmCustomCommand::ImplicitDependsPair entry(implicit_depends_lang,
+                                                     dep);
+          implicit_depends.push_back(entry);
 
-           // Switch back to looking for a language.
-           doing = doing_implicit_depends_lang;
-           }
-           break;
-         case doing_command:
-           currentLine.push_back(copy);
-           break;
-         case doing_target:
-           target = copy;
-           break;
-         case doing_depends:
-           {
-           std::string dep = copy;
-           cmSystemTools::ConvertToUnixSlashes(dep);
-           depends.push_back(dep);
-           }
-           break;
-         case doing_outputs:
-           outputs.push_back(filename);
-           break;
-         case doing_byproducts:
-           byproducts.push_back(filename);
-           break;
-         case doing_comment:
-           comment_buffer = copy;
-           comment = comment_buffer.c_str();
-           break;
-         default:
-           this->SetError("Wrong syntax. Unknown type of argument.");
-           return false;
-         }
+          // Switch back to looking for a language.
+          doing = doing_implicit_depends_lang;
+        } break;
+        case doing_command:
+          currentLine.push_back(copy);
+          break;
+        case doing_target:
+          target = copy;
+          break;
+        case doing_depends: {
+          std::string dep = copy;
+          cmSystemTools::ConvertToUnixSlashes(dep);
+          depends.push_back(dep);
+        } break;
+        case doing_outputs:
+          outputs.push_back(filename);
+          break;
+        case doing_byproducts:
+          byproducts.push_back(filename);
+          break;
+        case doing_comment:
+          comment_buffer = copy;
+          comment = comment_buffer.c_str();
+          break;
+        default:
+          this->SetError("Wrong syntax. Unknown type of argument.");
+          return false;
       }
     }
+  }
 
   // Store the last command line finished.
-  if(!currentLine.empty())
-    {
+  if (!currentLine.empty()) {
     commandLines.push_back(currentLine);
     currentLine.clear();
-    }
+  }
 
   // At this point we could complain about the lack of arguments.  For
   // the moment, let's say that COMMAND, TARGET are always required.
-  if(output.empty() && target.empty())
-    {
+  if (output.empty() && target.empty()) {
     this->SetError("Wrong syntax. A TARGET or OUTPUT must be specified.");
     return false;
-    }
+  }
 
-  if(source.empty() && !target.empty() && !output.empty())
-    {
+  if (source.empty() && !target.empty() && !output.empty()) {
     this->SetError(
       "Wrong syntax. A TARGET and OUTPUT can not both be specified.");
     return false;
-    }
-  if(append && output.empty())
-    {
+  }
+  if (append && output.empty()) {
     this->SetError("given APPEND option with no OUTPUT.");
     return false;
-    }
+  }
 
   // Make sure the output names and locations are safe.
-  if(!this->CheckOutputs(output) ||
-     !this->CheckOutputs(outputs) ||
-     !this->CheckOutputs(byproducts))
-    {
+  if (!this->CheckOutputs(output) || !this->CheckOutputs(outputs) ||
+      !this->CheckOutputs(byproducts)) {
     return false;
-    }
+  }
 
   // Check for an append request.
-  if(append)
-    {
+  if (append) {
     // Lookup an existing command.
-    if(cmSourceFile* sf =
-       this->Makefile->GetSourceFileWithOutput(output[0]))
-      {
-      if(cmCustomCommand* cc = sf->GetCustomCommand())
-        {
+    if (cmSourceFile* sf =
+          this->Makefile->GetSourceFileWithOutput(output[0])) {
+      if (cmCustomCommand* cc = sf->GetCustomCommand()) {
         cc->AppendCommands(commandLines);
         cc->AppendDepends(depends);
         cc->AppendImplicitDepends(implicit_depends);
         return true;
-        }
       }
+    }
 
     // No command for this output exists.
     std::ostringstream e;
@@ -310,136 +254,111 @@ bool cmAddCustomCommandCommand
       << "\" which is not already a custom command output.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Convert working directory to a full path.
-  if(!working.empty())
-    {
+  if (!working.empty()) {
     const char* build_dir = this->Makefile->GetCurrentBinaryDirectory();
     working = cmSystemTools::CollapseFullPath(working, build_dir);
-    }
+  }
 
   // Choose which mode of the command to use.
   bool escapeOldStyle = !verbatim;
-  if(source.empty() && output.empty())
-    {
+  if (source.empty() && output.empty()) {
     // Source is empty, use the target.
     std::vector<std::string> no_depends;
-    this->Makefile->AddCustomCommandToTarget(target, byproducts, no_depends,
-                                             commandLines, cctype,
-                                             comment, working.c_str(),
-                                             escapeOldStyle, uses_terminal);
-    }
-  else if(target.empty())
-    {
+    this->Makefile->AddCustomCommandToTarget(
+      target, byproducts, no_depends, commandLines, cctype, comment,
+      working.c_str(), escapeOldStyle, uses_terminal);
+  } else if (target.empty()) {
     // Target is empty, use the output.
-    this->Makefile->AddCustomCommandToOutput(output, byproducts,
-                                             depends, main_dependency,
-                                             commandLines, comment,
-                                             working.c_str(), false,
-                                             escapeOldStyle, uses_terminal);
+    this->Makefile->AddCustomCommandToOutput(
+      output, byproducts, depends, main_dependency, commandLines, comment,
+      working.c_str(), false, escapeOldStyle, uses_terminal);
 
     // Add implicit dependency scanning requests if any were given.
-    if(!implicit_depends.empty())
-      {
+    if (!implicit_depends.empty()) {
       bool okay = false;
-      if(cmSourceFile* sf =
-         this->Makefile->GetSourceFileWithOutput(output[0]))
-        {
-        if(cmCustomCommand* cc = sf->GetCustomCommand())
-          {
+      if (cmSourceFile* sf =
+            this->Makefile->GetSourceFileWithOutput(output[0])) {
+        if (cmCustomCommand* cc = sf->GetCustomCommand()) {
           okay = true;
           cc->SetImplicitDepends(implicit_depends);
-          }
         }
-      if(!okay)
-        {
+      }
+      if (!okay) {
         std::ostringstream e;
         e << "could not locate source file with a custom command producing \""
           << output[0] << "\" even though this command tried to create it!";
         this->SetError(e.str());
         return false;
-        }
       }
     }
-  else if (!byproducts.empty())
-    {
+  } else if (!byproducts.empty()) {
     this->SetError("BYPRODUCTS may not be specified with SOURCE signatures");
     return false;
-    }
-  else if (uses_terminal)
-    {
+  } else if (uses_terminal) {
     this->SetError("USES_TERMINAL may not be used with SOURCE signatures");
     return false;
-    }
-  else
-    {
+  } else {
     bool issueMessage = true;
     std::ostringstream e;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0050))
-    {
-    case cmPolicies::WARN:
-      e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0050) << "\n";
-      break;
-    case cmPolicies::OLD:
-      issueMessage = false;
-      break;
-    case cmPolicies::REQUIRED_ALWAYS:
-    case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::NEW:
-      messageType = cmake::FATAL_ERROR;
-      break;
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0050)) {
+      case cmPolicies::WARN:
+        e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0050) << "\n";
+        break;
+      case cmPolicies::OLD:
+        issueMessage = false;
+        break;
+      case cmPolicies::REQUIRED_ALWAYS:
+      case cmPolicies::REQUIRED_IF_USED:
+      case cmPolicies::NEW:
+        messageType = cmake::FATAL_ERROR;
+        break;
     }
 
-    if (issueMessage)
-      {
+    if (issueMessage) {
       e << "The SOURCE signatures of add_custom_command are no longer "
            "supported.";
       this->Makefile->IssueMessage(messageType, e.str());
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
+    }
 
     // Use the old-style mode for backward compatibility.
-    this->Makefile->AddCustomCommandOldStyle(target, outputs, depends,
-                                             source, commandLines,
-                                             comment);
-    }
+    this->Makefile->AddCustomCommandOldStyle(target, outputs, depends, source,
+                                             commandLines, comment);
+  }
 
   return true;
 }
 
-bool
-cmAddCustomCommandCommand
-::CheckOutputs(const std::vector<std::string>& outputs)
+bool cmAddCustomCommandCommand::CheckOutputs(
+  const std::vector<std::string>& outputs)
 {
-  for(std::vector<std::string>::const_iterator o = outputs.begin();
-      o != outputs.end(); ++o)
-    {
+  for (std::vector<std::string>::const_iterator o = outputs.begin();
+       o != outputs.end(); ++o) {
     // Make sure the file will not be generated into the source
     // directory during an out of source build.
-    if(!this->Makefile->CanIWriteThisFile(o->c_str()))
-      {
+    if (!this->Makefile->CanIWriteThisFile(o->c_str())) {
       std::string e = "attempted to have a file \"" + *o +
         "\" in a source directory as an output of custom command.";
       this->SetError(e);
       cmSystemTools::SetFatalErrorOccured();
       return false;
-      }
+    }
 
     // Make sure the output file name has no invalid characters.
     std::string::size_type pos = o->find_first_of("#<>");
-    if(pos != o->npos)
-      {
+    if (pos != o->npos) {
       std::ostringstream msg;
       msg << "called with OUTPUT containing a \"" << (*o)[pos]
           << "\".  This character is not allowed.";
       this->SetError(msg.str());
       return false;
-      }
     }
+  }
   return true;
 }
diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h
index 1d6ddb2..ccbd50c 100644
--- a/Source/cmAddCustomCommandCommand.h
+++ b/Source/cmAddCustomCommandCommand.h
@@ -26,27 +26,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddCustomCommandCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddCustomCommandCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "add_custom_command";}
+  virtual std::string GetName() const { return "add_custom_command"; }
 
   cmTypeMacro(cmAddCustomCommandCommand, cmCommand);
+
 protected:
   bool CheckOutputs(const std::vector<std::string>& outputs);
 };
 
-
 #endif
diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx
index 5bf752a..ac08cb2 100644
--- a/Source/cmAddCustomTargetCommand.cxx
+++ b/Source/cmAddCustomTargetCommand.cxx
@@ -15,28 +15,25 @@
 #include "cmGlobalGenerator.h"
 
 // cmAddCustomTargetCommand
-bool cmAddCustomTargetCommand
-::InitialPass(std::vector<std::string> const& args,
-              cmExecutionStatus&)
+bool cmAddCustomTargetCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string targetName = args[0];
 
   // Check the target name.
-  if(targetName.find_first_of("/\\") != targetName.npos)
-    {
+  if (targetName.find_first_of("/\\") != targetName.npos) {
     std::ostringstream e;
     e << "called with invalid target name \"" << targetName
       << "\".  Target names may not contain a slash.  "
       << "Use ADD_CUSTOM_COMMAND to generate files.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Accumulate one command line at a time.
   cmCustomCommandLine currentLine;
@@ -54,7 +51,8 @@ bool cmAddCustomTargetCommand
   std::vector<std::string> sources;
 
   // Keep track of parser state.
-  enum tdoing {
+  enum tdoing
+  {
     doing_command,
     doing_depends,
     doing_byproducts,
@@ -68,131 +66,100 @@ bool cmAddCustomTargetCommand
   // Look for the ALL option.
   bool excludeFromAll = true;
   unsigned int start = 1;
-  if(args.size() > 1)
-    {
-    if(args[1] == "ALL")
-      {
+  if (args.size() > 1) {
+    if (args[1] == "ALL") {
       excludeFromAll = false;
       start = 2;
-      }
     }
+  }
 
   // Parse the rest of the arguments.
-  for(unsigned int j = start; j < args.size(); ++j)
-    {
+  for (unsigned int j = start; j < args.size(); ++j) {
     std::string const& copy = args[j];
 
-    if(copy == "DEPENDS")
-      {
+    if (copy == "DEPENDS") {
       doing = doing_depends;
-      }
-    else if(copy == "BYPRODUCTS")
-      {
+    } else if (copy == "BYPRODUCTS") {
       doing = doing_byproducts;
-      }
-    else if(copy == "WORKING_DIRECTORY")
-      {
+    } else if (copy == "WORKING_DIRECTORY") {
       doing = doing_working_directory;
-      }
-    else if(copy == "VERBATIM")
-      {
+    } else if (copy == "VERBATIM") {
       doing = doing_nothing;
       verbatim = true;
-      }
-    else if(copy == "USES_TERMINAL")
-      {
+    } else if (copy == "USES_TERMINAL") {
       doing = doing_nothing;
       uses_terminal = true;
-      }
-    else if (copy == "COMMENT")
-      {
+    } else if (copy == "COMMENT") {
       doing = doing_comment;
-      }
-    else if(copy == "COMMAND")
-      {
+    } else if (copy == "COMMAND") {
       doing = doing_command;
 
       // Save the current command before starting the next command.
-      if(!currentLine.empty())
-        {
+      if (!currentLine.empty()) {
         commandLines.push_back(currentLine);
         currentLine.clear();
-        }
       }
-    else if(copy == "SOURCES")
-      {
+    } else if (copy == "SOURCES") {
       doing = doing_source;
-      }
-    else
-      {
-      switch (doing)
-        {
+    } else {
+      switch (doing) {
         case doing_working_directory:
           working_directory = copy;
           break;
         case doing_command:
           currentLine.push_back(copy);
           break;
-        case doing_byproducts:
-          {
+        case doing_byproducts: {
           std::string filename;
-          if (!cmSystemTools::FileIsFullPath(copy.c_str()))
-            {
+          if (!cmSystemTools::FileIsFullPath(copy.c_str())) {
             filename = this->Makefile->GetCurrentBinaryDirectory();
             filename += "/";
-            }
+          }
           filename += copy;
           cmSystemTools::ConvertToUnixSlashes(filename);
           byproducts.push_back(filename);
-          }
-          break;
-        case doing_depends:
-          {
+        } break;
+        case doing_depends: {
           std::string dep = copy;
           cmSystemTools::ConvertToUnixSlashes(dep);
           depends.push_back(dep);
-          }
+        } break;
+        case doing_comment:
+          comment_buffer = copy;
+          comment = comment_buffer.c_str();
           break;
-         case doing_comment:
-           comment_buffer = copy;
-           comment = comment_buffer.c_str();
-           break;
         case doing_source:
           sources.push_back(copy);
           break;
         default:
           this->SetError("Wrong syntax. Unknown type of argument.");
           return false;
-        }
       }
     }
+  }
 
   std::string::size_type pos = targetName.find_first_of("#<>");
-  if(pos != targetName.npos)
-    {
+  if (pos != targetName.npos) {
     std::ostringstream msg;
     msg << "called with target name containing a \"" << targetName[pos]
         << "\".  This character is not allowed.";
     this->SetError(msg.str());
     return false;
-    }
+  }
 
   // Some requirements on custom target names already exist
   // and have been checked at this point.
   // The following restrictions overlap but depend on policy CMP0037.
   bool nameOk = cmGeneratorExpression::IsValidTargetName(targetName) &&
     !cmGlobalGenerator::IsReservedTarget(targetName);
-  if (nameOk)
-    {
+  if (nameOk) {
     nameOk = targetName.find(":") == std::string::npos;
-    }
-  if (!nameOk)
-    {
+  }
+  if (!nameOk) {
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
     std::ostringstream e;
     bool issueMessage = false;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
         issueMessage = true;
@@ -203,9 +170,8 @@ bool cmAddCustomTargetCommand
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if (issueMessage)
-      {
+    }
+    if (issueMessage) {
       /* clang-format off */
       e << "The target name \"" << targetName <<
           "\" is reserved or not valid for certain "
@@ -214,59 +180,52 @@ bool cmAddCustomTargetCommand
       /* clang-format on */
       this->Makefile->IssueMessage(messageType, e.str());
 
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
   // Store the last command line finished.
-  if(!currentLine.empty())
-    {
+  if (!currentLine.empty()) {
     commandLines.push_back(currentLine);
     currentLine.clear();
-    }
+  }
 
   // Enforce name uniqueness.
   {
-  std::string msg;
-  if(!this->Makefile->EnforceUniqueName(targetName, msg, true))
-    {
-    this->SetError(msg);
-    return false;
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(targetName, msg, true)) {
+      this->SetError(msg);
+      return false;
     }
   }
 
   // Convert working directory to a full path.
-  if(!working_directory.empty())
-    {
+  if (!working_directory.empty()) {
     const char* build_dir = this->Makefile->GetCurrentBinaryDirectory();
     working_directory =
       cmSystemTools::CollapseFullPath(working_directory, build_dir);
-    }
+  }
 
-  if (commandLines.empty() && !byproducts.empty())
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+  if (commandLines.empty() && !byproducts.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
       "BYPRODUCTS may not be specified without any COMMAND");
     return true;
-    }
-  if (commandLines.empty() && uses_terminal)
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+  }
+  if (commandLines.empty() && uses_terminal) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
       "USES_TERMINAL may not be specified without any COMMAND");
     return true;
-    }
+  }
 
   // Add the utility target to the makefile.
   bool escapeOldStyle = !verbatim;
-  cmTarget* target =
-    this->Makefile->AddUtilityCommand(targetName, excludeFromAll,
-                                      working_directory.c_str(),
-                                      byproducts, depends,
-                                      commandLines, escapeOldStyle, comment,
-                                      uses_terminal);
+  cmTarget* target = this->Makefile->AddUtilityCommand(
+    targetName, excludeFromAll, working_directory.c_str(), byproducts, depends,
+    commandLines, escapeOldStyle, comment, uses_terminal);
 
   // Add additional user-specified source files to the target.
   target->AddSources(sources);
diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h
index d2b00ad..9c376c0 100644
--- a/Source/cmAddCustomTargetCommand.h
+++ b/Source/cmAddCustomTargetCommand.h
@@ -27,23 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddCustomTargetCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddCustomTargetCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const
-    {return "add_custom_target";}
+  virtual std::string GetName() const { return "add_custom_target"; }
 
   cmTypeMacro(cmAddCustomTargetCommand, cmCommand);
 };
diff --git a/Source/cmAddDefinitionsCommand.cxx b/Source/cmAddDefinitionsCommand.cxx
index b813e3e..2d0d026 100644
--- a/Source/cmAddDefinitionsCommand.cxx
+++ b/Source/cmAddDefinitionsCommand.cxx
@@ -12,20 +12,17 @@
 #include "cmAddDefinitionsCommand.h"
 
 // cmAddDefinitionsCommand
-bool cmAddDefinitionsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddDefinitionsCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
   // it is OK to have no arguments
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
 
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
     this->Makefile->AddDefineFlag(i->c_str());
-    }
+  }
   return true;
 }
-
diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h
index 9800fd2..959ed64 100644
--- a/Source/cmAddDefinitionsCommand.h
+++ b/Source/cmAddDefinitionsCommand.h
@@ -26,26 +26,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddDefinitionsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddDefinitionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "add_definitions";}
+  virtual std::string GetName() const { return "add_definitions"; }
 
   cmTypeMacro(cmAddDefinitionsCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmAddDependenciesCommand.cxx b/Source/cmAddDependenciesCommand.cxx
index 3b28359..5cf9d3b 100644
--- a/Source/cmAddDependenciesCommand.cxx
+++ b/Source/cmAddDependenciesCommand.cxx
@@ -14,34 +14,28 @@
 #include "cmGlobalGenerator.h"
 
 // cmDependenciesCommand
-bool cmAddDependenciesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddDependenciesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string target_name = args[0];
-  if(this->Makefile->IsAlias(target_name))
-    {
+  if (this->Makefile->IsAlias(target_name)) {
     std::ostringstream e;
     e << "Cannot add target-level dependencies to alias target \""
       << target_name << "\".\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
-  if(cmTarget* target = this->Makefile->FindTargetToUse(target_name))
-    {
+  }
+  if (cmTarget* target = this->Makefile->FindTargetToUse(target_name)) {
     std::vector<std::string>::const_iterator s = args.begin();
     ++s; // skip over target_name
-    for (; s != args.end(); ++s)
-      {
+    for (; s != args.end(); ++s) {
       target->AddUtility(*s, this->Makefile);
-      }
     }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "Cannot add target-level dependencies to non-existent target \""
       << target_name << "\".\n"
@@ -50,8 +44,7 @@ bool cmAddDependenciesCommand
       << "If you want to add file-level dependencies see the DEPENDS option "
       << "of the add_custom_target and add_custom_command commands.";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
+  }
 
   return true;
 }
-
diff --git a/Source/cmAddDependenciesCommand.h b/Source/cmAddDependenciesCommand.h
index db3712a..202d072 100644
--- a/Source/cmAddDependenciesCommand.h
+++ b/Source/cmAddDependenciesCommand.h
@@ -25,25 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddDependenciesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddDependenciesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_dependencies";}
+  virtual std::string GetName() const { return "add_dependencies"; }
 
   cmTypeMacro(cmAddDependenciesCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmAddExecutableCommand.cxx b/Source/cmAddExecutableCommand.cxx
index dccf9d9..fec5eb8 100644
--- a/Source/cmAddExecutableCommand.cxx
+++ b/Source/cmAddExecutableCommand.cxx
@@ -12,14 +12,13 @@
 #include "cmAddExecutableCommand.h"
 
 // cmExecutableCommand
-bool cmAddExecutableCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddExecutableCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::vector<std::string>::const_iterator s = args.begin();
 
   std::string exename = *s;
@@ -31,58 +30,41 @@ bool cmAddExecutableCommand
   bool importTarget = false;
   bool importGlobal = false;
   bool isAlias = false;
-  while ( s != args.end() )
-    {
-    if (*s == "WIN32")
-      {
+  while (s != args.end()) {
+    if (*s == "WIN32") {
       ++s;
       use_win32 = true;
-      }
-    else if ( *s == "MACOSX_BUNDLE" )
-      {
+    } else if (*s == "MACOSX_BUNDLE") {
       ++s;
       use_macbundle = true;
-      }
-    else if(*s == "EXCLUDE_FROM_ALL")
-      {
+    } else if (*s == "EXCLUDE_FROM_ALL") {
       ++s;
       excludeFromAll = true;
-      }
-    else if(*s == "IMPORTED")
-     {
-     ++s;
-     importTarget = true;
-     }
-    else if(importTarget && *s == "GLOBAL")
-      {
+    } else if (*s == "IMPORTED") {
+      ++s;
+      importTarget = true;
+    } else if (importTarget && *s == "GLOBAL") {
       ++s;
       importGlobal = true;
-      }
-    else if(*s == "ALIAS")
-      {
+    } else if (*s == "ALIAS") {
       ++s;
       isAlias = true;
-      }
-    else
-      {
+    } else {
       break;
-      }
     }
+  }
 
   bool nameOk = cmGeneratorExpression::IsValidTargetName(exename) &&
     !cmGlobalGenerator::IsReservedTarget(exename);
 
-  if (nameOk && !importTarget && !isAlias)
-    {
+  if (nameOk && !importTarget && !isAlias) {
     nameOk = exename.find(":") == std::string::npos;
-    }
-  if (!nameOk)
-    {
+  }
+  if (!nameOk) {
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
     std::ostringstream e;
     bool issueMessage = false;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
         issueMessage = true;
@@ -93,9 +75,8 @@ bool cmAddExecutableCommand
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if (issueMessage)
-      {
+    }
+    if (issueMessage) {
       /* clang-format off */
       e << "The target name \"" << exename <<
           "\" is reserved or not valid for certain "
@@ -104,147 +85,124 @@ bool cmAddExecutableCommand
       /* clang-format on */
       this->Makefile->IssueMessage(messageType, e.str());
 
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
   // Special modifiers are not allowed with IMPORTED signature.
-  if(importTarget
-      && (use_win32 || use_macbundle || excludeFromAll))
-    {
-    if(use_win32)
-      {
+  if (importTarget && (use_win32 || use_macbundle || excludeFromAll)) {
+    if (use_win32) {
       this->SetError("may not be given WIN32 for an IMPORTED target.");
-      }
-    else if(use_macbundle)
-      {
-      this->SetError(
-        "may not be given MACOSX_BUNDLE for an IMPORTED target.");
-      }
-    else // if(excludeFromAll)
-      {
+    } else if (use_macbundle) {
+      this->SetError("may not be given MACOSX_BUNDLE for an IMPORTED target.");
+    } else // if(excludeFromAll)
+    {
       this->SetError(
         "may not be given EXCLUDE_FROM_ALL for an IMPORTED target.");
-      }
-    return false;
     }
-  if (isAlias)
-    {
-    if(!cmGeneratorExpression::IsValidTargetName(exename))
-      {
+    return false;
+  }
+  if (isAlias) {
+    if (!cmGeneratorExpression::IsValidTargetName(exename)) {
       this->SetError("Invalid name for ALIAS: " + exename);
       return false;
-      }
-    if(excludeFromAll)
-      {
+    }
+    if (excludeFromAll) {
       this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
       return false;
-      }
-    if(importTarget || importGlobal)
-      {
+    }
+    if (importTarget || importGlobal) {
       this->SetError("IMPORTED with ALIAS is not allowed.");
       return false;
-      }
-    if(args.size() != 3)
-      {
+    }
+    if (args.size() != 3) {
       std::ostringstream e;
       e << "ALIAS requires exactly one target argument.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    const char *aliasedName = s->c_str();
-    if(this->Makefile->IsAlias(aliasedName))
-      {
+    const char* aliasedName = s->c_str();
+    if (this->Makefile->IsAlias(aliasedName)) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" is itself an ALIAS.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is itself an ALIAS.";
       this->SetError(e.str());
       return false;
-      }
-    cmTarget *aliasedTarget =
-                    this->Makefile->FindTargetToUse(aliasedName, true);
-    if(!aliasedTarget)
-      {
+    }
+    cmTarget* aliasedTarget =
+      this->Makefile->FindTargetToUse(aliasedName, true);
+    if (!aliasedTarget) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" does not already "
-        "exist.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" does not already "
+                          "exist.";
       this->SetError(e.str());
       return false;
-      }
+    }
     cmState::TargetType type = aliasedTarget->GetType();
-    if(type != cmState::EXECUTABLE)
-      {
+    if (type != cmState::EXECUTABLE) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" is not an "
-        "executable.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is not an "
+                          "executable.";
       this->SetError(e.str());
       return false;
-      }
-    if(aliasedTarget->IsImported())
-      {
+    }
+    if (aliasedTarget->IsImported()) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << exename
-        << "\" because target \"" << aliasedName << "\" is IMPORTED.";
+      e << "cannot create ALIAS target \"" << exename << "\" because target \""
+        << aliasedName << "\" is IMPORTED.";
       this->SetError(e.str());
       return false;
-      }
+    }
     this->Makefile->AddAlias(exename, aliasedName);
     return true;
-    }
+  }
 
   // Handle imported target creation.
-  if(importTarget)
-    {
+  if (importTarget) {
     // Make sure the target does not already exist.
-    if(this->Makefile->FindTargetToUse(exename))
-      {
+    if (this->Makefile->FindTargetToUse(exename)) {
       std::ostringstream e;
       e << "cannot create imported target \"" << exename
         << "\" because another target with the same name already exists.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
     // Create the imported target.
     this->Makefile->AddImportedTarget(exename, cmState::EXECUTABLE,
                                       importGlobal);
     return true;
-    }
+  }
 
   // Enforce name uniqueness.
   {
-  std::string msg;
-  if(!this->Makefile->EnforceUniqueName(exename, msg))
-    {
-    this->SetError(msg);
-    return false;
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(exename, msg)) {
+      this->SetError(msg);
+      return false;
     }
   }
 
-  if (s == args.end())
-    {
-    this->SetError
-      ("called with incorrect number of arguments, no sources provided");
+  if (s == args.end()) {
+    this->SetError(
+      "called with incorrect number of arguments, no sources provided");
     return false;
-    }
+  }
 
   std::vector<std::string> srclists(s, args.end());
-  cmTarget* tgt = this->Makefile->AddExecutable(exename.c_str(), srclists,
-                                                excludeFromAll);
-  if ( use_win32 )
-    {
+  cmTarget* tgt =
+    this->Makefile->AddExecutable(exename.c_str(), srclists, excludeFromAll);
+  if (use_win32) {
     tgt->SetProperty("WIN32_EXECUTABLE", "ON");
-    }
-  if ( use_macbundle)
-    {
+  }
+  if (use_macbundle) {
     tgt->SetProperty("MACOSX_BUNDLE", "ON");
-    }
+  }
 
   return true;
 }
diff --git a/Source/cmAddExecutableCommand.h b/Source/cmAddExecutableCommand.h
index e134077..1e3181f 100644
--- a/Source/cmAddExecutableCommand.h
+++ b/Source/cmAddExecutableCommand.h
@@ -26,25 +26,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddExecutableCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddExecutableCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_executable";}
+  virtual std::string GetName() const { return "add_executable"; }
 
   cmTypeMacro(cmAddExecutableCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmAddLibraryCommand.cxx b/Source/cmAddLibraryCommand.cxx
index e40ecf4..4516ed2 100644
--- a/Source/cmAddLibraryCommand.cxx
+++ b/Source/cmAddLibraryCommand.cxx
@@ -15,21 +15,20 @@
 #include "cmake.h"
 
 // cmLibraryCommand
-bool cmAddLibraryCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   // Library type defaults to value of BUILD_SHARED_LIBS, if it exists,
   // otherwise it defaults to static library.
   cmState::TargetType type = cmState::SHARED_LIBRARY;
-  if (cmSystemTools::IsOff(this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
-    {
+  if (cmSystemTools::IsOff(
+        this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
     type = cmState::STATIC_LIBRARY;
-    }
+  }
   bool excludeFromAll = false;
   bool importTarget = false;
   bool importGlobal = false;
@@ -45,186 +44,145 @@ bool cmAddLibraryCommand
   // source list name. There may be two keyword arguments, check for them
   bool haveSpecifiedType = false;
   bool isAlias = false;
-  while ( s != args.end() )
-    {
+  while (s != args.end()) {
     std::string libType = *s;
-    if(libType == "STATIC")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    if (libType == "STATIC") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting STATIC type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::STATIC_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "SHARED")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "SHARED") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting SHARED type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::SHARED_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "MODULE")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "MODULE") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting MODULE type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::MODULE_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "OBJECT")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "OBJECT") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting OBJECT type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::OBJECT_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "UNKNOWN")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "UNKNOWN") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting UNKNOWN type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::UNKNOWN_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(libType == "ALIAS")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (libType == "ALIAS") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting ALIAS type.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       isAlias = true;
-      }
-    else if(libType == "INTERFACE")
-      {
-      if (haveSpecifiedType)
-        {
+    } else if (libType == "INTERFACE") {
+      if (haveSpecifiedType) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting/multiple types.";
         this->SetError(e.str());
         return false;
-        }
-      if (isAlias)
-        {
+      }
+      if (isAlias) {
         std::ostringstream e;
         e << "INTERFACE library specified with conflicting ALIAS type.";
         this->SetError(e.str());
         return false;
-        }
-      if (excludeFromAll)
-        {
+      }
+      if (excludeFromAll) {
         std::ostringstream e;
         e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       type = cmState::INTERFACE_LIBRARY;
       haveSpecifiedType = true;
-      }
-    else if(*s == "EXCLUDE_FROM_ALL")
-      {
-      if (type == cmState::INTERFACE_LIBRARY)
-        {
+    } else if (*s == "EXCLUDE_FROM_ALL") {
+      if (type == cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
         this->SetError(e.str());
         return false;
-        }
+      }
       ++s;
       excludeFromAll = true;
-      }
-    else if(*s == "IMPORTED")
-      {
+    } else if (*s == "IMPORTED") {
       ++s;
       importTarget = true;
-      }
-    else if(importTarget && *s == "GLOBAL")
-      {
+    } else if (importTarget && *s == "GLOBAL") {
       ++s;
       importGlobal = true;
-      }
-    else if(type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL")
-      {
+    } else if (type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL") {
       std::ostringstream e;
       e << "GLOBAL option may only be used with IMPORTED libraries.";
       this->SetError(e.str());
       return false;
-      }
-    else
-      {
+    } else {
       break;
-      }
     }
+  }
 
-  if (type == cmState::INTERFACE_LIBRARY)
-    {
-    if (s != args.end())
-      {
+  if (type == cmState::INTERFACE_LIBRARY) {
+    if (s != args.end()) {
       std::ostringstream e;
       e << "INTERFACE library requires no source arguments.";
       this->SetError(e.str());
       return false;
-      }
-    if (importGlobal && !importTarget)
-      {
+    }
+    if (importGlobal && !importTarget) {
       std::ostringstream e;
       e << "INTERFACE library specified as GLOBAL, but not as IMPORTED.";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   bool nameOk = cmGeneratorExpression::IsValidTargetName(libName) &&
     !cmGlobalGenerator::IsReservedTarget(libName);
 
-  if (nameOk && !importTarget && !isAlias)
-    {
+  if (nameOk && !importTarget && !isAlias) {
     nameOk = libName.find(":") == std::string::npos;
-    }
-  if (!nameOk)
-    {
+  }
+  if (!nameOk) {
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
     std::ostringstream e;
     bool issueMessage = false;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) {
       case cmPolicies::WARN:
-        if(type != cmState::INTERFACE_LIBRARY)
-          {
+        if (type != cmState::INTERFACE_LIBRARY) {
           e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
           issueMessage = true;
-          }
+        }
       case cmPolicies::OLD:
         break;
       case cmPolicies::NEW:
@@ -232,208 +190,177 @@ bool cmAddLibraryCommand
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if (issueMessage)
-      {
-      e << "The target name \"" << libName <<
-          "\" is reserved or not valid for certain "
-          "CMake features, such as generator expressions, and may result "
-          "in undefined behavior.";
+    }
+    if (issueMessage) {
+      e << "The target name \"" << libName
+        << "\" is reserved or not valid for certain "
+           "CMake features, such as generator expressions, and may result "
+           "in undefined behavior.";
       this->Makefile->IssueMessage(messageType, e.str());
 
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
-  if (isAlias)
-    {
-    if(!cmGeneratorExpression::IsValidTargetName(libName))
-      {
+  if (isAlias) {
+    if (!cmGeneratorExpression::IsValidTargetName(libName)) {
       this->SetError("Invalid name for ALIAS: " + libName);
       return false;
-      }
-    if(excludeFromAll)
-      {
+    }
+    if (excludeFromAll) {
       this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
       return false;
-      }
-    if(importTarget || importGlobal)
-      {
+    }
+    if (importTarget || importGlobal) {
       this->SetError("IMPORTED with ALIAS is not allowed.");
       return false;
-      }
-    if(args.size() != 3)
-      {
+    }
+    if (args.size() != 3) {
       std::ostringstream e;
       e << "ALIAS requires exactly one target argument.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    const char *aliasedName = s->c_str();
-    if(this->Makefile->IsAlias(aliasedName))
-      {
+    const char* aliasedName = s->c_str();
+    if (this->Makefile->IsAlias(aliasedName)) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << libName
-        << "\" because target \"" << aliasedName << "\" is itself an ALIAS.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is itself an ALIAS.";
       this->SetError(e.str());
       return false;
-      }
-    cmTarget *aliasedTarget =
-                    this->Makefile->FindTargetToUse(aliasedName, true);
-    if(!aliasedTarget)
-      {
+    }
+    cmTarget* aliasedTarget =
+      this->Makefile->FindTargetToUse(aliasedName, true);
+    if (!aliasedTarget) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << libName
-        << "\" because target \"" << aliasedName << "\" does not already "
-        "exist.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" does not already "
+                          "exist.";
       this->SetError(e.str());
       return false;
-      }
+    }
     cmState::TargetType aliasedType = aliasedTarget->GetType();
-    if(aliasedType != cmState::SHARED_LIBRARY
-        && aliasedType != cmState::STATIC_LIBRARY
-        && aliasedType != cmState::MODULE_LIBRARY
-        && aliasedType != cmState::OBJECT_LIBRARY
-        && aliasedType != cmState::INTERFACE_LIBRARY)
-      {
+    if (aliasedType != cmState::SHARED_LIBRARY &&
+        aliasedType != cmState::STATIC_LIBRARY &&
+        aliasedType != cmState::MODULE_LIBRARY &&
+        aliasedType != cmState::OBJECT_LIBRARY &&
+        aliasedType != cmState::INTERFACE_LIBRARY) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << libName
-        << "\" because target \"" << aliasedName << "\" is not a library.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is not a library.";
       this->SetError(e.str());
       return false;
-      }
-    if(aliasedTarget->IsImported())
-      {
+    }
+    if (aliasedTarget->IsImported()) {
       std::ostringstream e;
-      e << "cannot create ALIAS target \"" << libName
-        << "\" because target \"" << aliasedName << "\" is IMPORTED.";
+      e << "cannot create ALIAS target \"" << libName << "\" because target \""
+        << aliasedName << "\" is IMPORTED.";
       this->SetError(e.str());
       return false;
-      }
+    }
     this->Makefile->AddAlias(libName, aliasedName);
     return true;
-    }
+  }
 
-  if(importTarget && excludeFromAll)
-    {
+  if (importTarget && excludeFromAll) {
     this->SetError("excludeFromAll with IMPORTED target makes no sense.");
     return false;
-    }
+  }
 
   /* ideally we should check whether for the linker language of the target
     CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to
     STATIC. But at this point we know only the name of the target, but not
     yet its linker language. */
-  if ((type == cmState::SHARED_LIBRARY ||
-       type == cmState::MODULE_LIBRARY) &&
-       (this->Makefile->GetState()->GetGlobalPropertyAsBool(
-                                      "TARGET_SUPPORTS_SHARED_LIBS") == false))
-    {
+  if ((type == cmState::SHARED_LIBRARY || type == cmState::MODULE_LIBRARY) &&
+      (this->Makefile->GetState()->GetGlobalPropertyAsBool(
+         "TARGET_SUPPORTS_SHARED_LIBS") == false)) {
     std::ostringstream w;
-    w <<
-      "ADD_LIBRARY called with " <<
-      (type==cmState::SHARED_LIBRARY ? "SHARED" : "MODULE") <<
-      " option but the target platform does not support dynamic linking. "
-      "Building a STATIC library instead. This may lead to problems.";
+    w << "ADD_LIBRARY called with "
+      << (type == cmState::SHARED_LIBRARY ? "SHARED" : "MODULE")
+      << " option but the target platform does not support dynamic linking. "
+         "Building a STATIC library instead. This may lead to problems.";
     this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
     type = cmState::STATIC_LIBRARY;
-    }
+  }
 
   // Handle imported target creation.
-  if(importTarget)
-    {
+  if (importTarget) {
     // The IMPORTED signature requires a type to be specified explicitly.
-    if (!haveSpecifiedType)
-      {
+    if (!haveSpecifiedType) {
       this->SetError("called with IMPORTED argument but no library type.");
       return false;
-      }
-    if(type == cmState::OBJECT_LIBRARY)
-      {
+    }
+    if (type == cmState::OBJECT_LIBRARY) {
       this->Makefile->IssueMessage(
         cmake::FATAL_ERROR,
-        "The OBJECT library type may not be used for IMPORTED libraries."
-        );
+        "The OBJECT library type may not be used for IMPORTED libraries.");
       return true;
-      }
-    if(type == cmState::INTERFACE_LIBRARY)
-      {
-      if (!cmGeneratorExpression::IsValidTargetName(libName))
-        {
+    }
+    if (type == cmState::INTERFACE_LIBRARY) {
+      if (!cmGeneratorExpression::IsValidTargetName(libName)) {
         std::ostringstream e;
         e << "Invalid name for IMPORTED INTERFACE library target: " << libName;
         this->SetError(e.str());
         return false;
-        }
       }
+    }
 
     // Make sure the target does not already exist.
-    if(this->Makefile->FindTargetToUse(libName))
-      {
+    if (this->Makefile->FindTargetToUse(libName)) {
       std::ostringstream e;
       e << "cannot create imported target \"" << libName
         << "\" because another target with the same name already exists.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
     // Create the imported target.
     this->Makefile->AddImportedTarget(libName, type, importGlobal);
     return true;
-    }
+  }
 
   // A non-imported target may not have UNKNOWN type.
-  if(type == cmState::UNKNOWN_LIBRARY)
-    {
+  if (type == cmState::UNKNOWN_LIBRARY) {
     this->Makefile->IssueMessage(
       cmake::FATAL_ERROR,
-      "The UNKNOWN library type may be used only for IMPORTED libraries."
-      );
+      "The UNKNOWN library type may be used only for IMPORTED libraries.");
     return true;
-    }
+  }
 
   // Enforce name uniqueness.
   {
-  std::string msg;
-  if(!this->Makefile->EnforceUniqueName(libName, msg))
-    {
-    this->SetError(msg);
-    return false;
+    std::string msg;
+    if (!this->Makefile->EnforceUniqueName(libName, msg)) {
+      this->SetError(msg);
+      return false;
     }
   }
 
   std::vector<std::string> srclists;
 
-  if(type == cmState::INTERFACE_LIBRARY)
-    {
-    if (!cmGeneratorExpression::IsValidTargetName(libName)
-        || libName.find("::") != std::string::npos)
-      {
+  if (type == cmState::INTERFACE_LIBRARY) {
+    if (!cmGeneratorExpression::IsValidTargetName(libName) ||
+        libName.find("::") != std::string::npos) {
       std::ostringstream e;
       e << "Invalid name for INTERFACE library target: " << libName;
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    this->Makefile->AddLibrary(libName,
-                               type,
-                               srclists,
-                               excludeFromAll);
+    this->Makefile->AddLibrary(libName, type, srclists, excludeFromAll);
     return true;
-    }
+  }
 
-  if (s == args.end())
-    {
+  if (s == args.end()) {
     std::string msg = "You have called ADD_LIBRARY for library ";
     msg += args[0];
     msg += " without any source files. This typically indicates a problem ";
     msg += "with your CMakeLists.txt file";
-    cmSystemTools::Message(msg.c_str() ,"Warning");
-    }
+    cmSystemTools::Message(msg.c_str(), "Warning");
+  }
 
   srclists.insert(srclists.end(), s, args.end());
 
@@ -441,5 +368,3 @@ bool cmAddLibraryCommand
 
   return true;
 }
-
-
diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h
index 350708b..0f0f768 100644
--- a/Source/cmAddLibraryCommand.h
+++ b/Source/cmAddLibraryCommand.h
@@ -26,25 +26,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddLibraryCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddLibraryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_library";}
+  virtual std::string GetName() const { return "add_library"; }
 
   cmTypeMacro(cmAddLibraryCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmAddSubDirectoryCommand.cxx b/Source/cmAddSubDirectoryCommand.cxx
index 69c6a14..63a9051 100644
--- a/Source/cmAddSubDirectoryCommand.cxx
+++ b/Source/cmAddSubDirectoryCommand.cxx
@@ -12,14 +12,13 @@
 #include "cmAddSubDirectoryCommand.h"
 
 // cmAddSubDirectoryCommand
-bool cmAddSubDirectoryCommand::InitialPass
-(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddSubDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // store the binpath
   std::string srcArg = args[0];
@@ -30,57 +29,45 @@ bool cmAddSubDirectoryCommand::InitialPass
   // process the rest of the arguments looking for optional args
   std::vector<std::string>::const_iterator i = args.begin();
   ++i;
-  for(;i != args.end(); ++i)
-    {
-    if(*i == "EXCLUDE_FROM_ALL")
-      {
+  for (; i != args.end(); ++i) {
+    if (*i == "EXCLUDE_FROM_ALL") {
       excludeFromAll = true;
       continue;
-      }
-    else if (binArg.empty())
-      {
+    } else if (binArg.empty()) {
       binArg = *i;
-      }
-    else
-      {
+    } else {
       this->SetError("called with incorrect number of arguments");
       return false;
-      }
     }
+  }
 
   // Compute the full path to the specified source directory.
   // Interpret a relative path with respect to the current source directory.
   std::string srcPath;
-  if(cmSystemTools::FileIsFullPath(srcArg.c_str()))
-    {
+  if (cmSystemTools::FileIsFullPath(srcArg.c_str())) {
     srcPath = srcArg;
-    }
-  else
-    {
+  } else {
     srcPath = this->Makefile->GetCurrentSourceDirectory();
     srcPath += "/";
     srcPath += srcArg;
-    }
-  if(!cmSystemTools::FileIsDirectory(srcPath))
-    {
+  }
+  if (!cmSystemTools::FileIsDirectory(srcPath)) {
     std::string error = "given source \"";
     error += srcArg;
     error += "\" which is not an existing directory.";
     this->SetError(error);
     return false;
-    }
+  }
   srcPath = cmSystemTools::CollapseFullPath(srcPath);
 
   // Compute the full path to the binary directory.
   std::string binPath;
-  if(binArg.empty())
-    {
+  if (binArg.empty()) {
     // No binary directory was specified.  If the source directory is
     // not a subdirectory of the current directory then it is an
     // error.
-    if(!cmSystemTools::IsSubDirectory(srcPath,
-          this->Makefile->GetCurrentSourceDirectory()))
-      {
+    if (!cmSystemTools::IsSubDirectory(
+          srcPath, this->Makefile->GetCurrentSourceDirectory())) {
       std::ostringstream e;
       e << "not given a binary directory but the given source directory "
         << "\"" << srcPath << "\" is not a subdirectory of \""
@@ -89,7 +76,7 @@ bool cmAddSubDirectoryCommand::InitialPass
         << "must be explicitly specified.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
     // Remove the CurrentDirectory from the srcPath and replace it
     // with the CurrentOutputDirectory.
@@ -97,32 +84,28 @@ bool cmAddSubDirectoryCommand::InitialPass
     const char* bin = this->Makefile->GetCurrentBinaryDirectory();
     size_t srcLen = strlen(src);
     size_t binLen = strlen(bin);
-    if(srcLen > 0 && src[srcLen-1] == '/')
-      { --srcLen; }
-    if(binLen > 0 && bin[binLen-1] == '/')
-      { --binLen; }
-    binPath = std::string(bin, binLen) + srcPath.substr(srcLen);
+    if (srcLen > 0 && src[srcLen - 1] == '/') {
+      --srcLen;
     }
-  else
-    {
+    if (binLen > 0 && bin[binLen - 1] == '/') {
+      --binLen;
+    }
+    binPath = std::string(bin, binLen) + srcPath.substr(srcLen);
+  } else {
     // Use the binary directory specified.
     // Interpret a relative path with respect to the current binary directory.
-    if(cmSystemTools::FileIsFullPath(binArg.c_str()))
-      {
+    if (cmSystemTools::FileIsFullPath(binArg.c_str())) {
       binPath = binArg;
-      }
-    else
-      {
+    } else {
       binPath = this->Makefile->GetCurrentBinaryDirectory();
       binPath += "/";
       binPath += binArg;
-      }
     }
+  }
   binPath = cmSystemTools::CollapseFullPath(binPath);
 
   // Add the subdirectory using the computed full paths.
-  this->Makefile->AddSubDirectory(srcPath, binPath,
-                                  excludeFromAll, true);
+  this->Makefile->AddSubDirectory(srcPath, binPath, excludeFromAll, true);
 
   return true;
 }
diff --git a/Source/cmAddSubDirectoryCommand.h b/Source/cmAddSubDirectoryCommand.h
index abf3efc..786c8b0 100644
--- a/Source/cmAddSubDirectoryCommand.h
+++ b/Source/cmAddSubDirectoryCommand.h
@@ -27,26 +27,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddSubDirectoryCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddSubDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_subdirectory";}
+  virtual std::string GetName() const { return "add_subdirectory"; }
 
   cmTypeMacro(cmAddSubDirectoryCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmAddTestCommand.cxx b/Source/cmAddTestCommand.cxx
index e813415..204dd97 100644
--- a/Source/cmAddTestCommand.cxx
+++ b/Source/cmAddTestCommand.cxx
@@ -15,24 +15,21 @@
 
 #include "cmTest.h"
 
-
 // cmExecutableCommand
-bool cmAddTestCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAddTestCommand::InitialPass(std::vector<std::string> const& args,
+                                   cmExecutionStatus&)
 {
-  if(!args.empty() && args[0] == "NAME")
-    {
+  if (!args.empty() && args[0] == "NAME") {
     return this->HandleNameMode(args);
-    }
+  }
 
   // First argument is the name of the test Second argument is the name of
   // the executable to run (a target or external program) Remaining arguments
   // are the arguments to pass to the executable
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Collect the command with arguments.
   std::vector<std::string> command;
@@ -41,25 +38,21 @@ bool cmAddTestCommand
   // Create the test but add a generator only the first time it is
   // seen.  This preserves behavior from before test generators.
   cmTest* test = this->Makefile->GetTest(args[0]);
-  if(test)
-    {
+  if (test) {
     // If the test was already added by a new-style signature do not
     // allow it to be duplicated.
-    if(!test->GetOldStyle())
-      {
+    if (!test->GetOldStyle()) {
       std::ostringstream e;
       e << " given test name \"" << args[0]
         << "\" which already exists in this directory.";
       this->SetError(e.str());
       return false;
-      }
     }
-  else
-    {
+  } else {
     test = this->Makefile->CreateTest(args[0]);
     test->SetOldStyle(true);
     this->Makefile->AddTestGenerator(new cmTestGenerator(test));
-    }
+  }
   test->SetCommand(command);
 
   return true;
@@ -73,7 +66,8 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
   std::vector<std::string> command;
 
   // Read the arguments.
-  enum Doing {
+  enum Doing
+  {
     DoingName,
     DoingCommand,
     DoingConfigs,
@@ -81,94 +75,71 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
     DoingNone
   };
   Doing doing = DoingName;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "COMMAND")
-      {
-      if(!command.empty())
-        {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "COMMAND") {
+      if (!command.empty()) {
         this->SetError(" may be given at most one COMMAND.");
         return false;
-        }
-      doing = DoingCommand;
       }
-    else if(args[i] == "CONFIGURATIONS")
-      {
-      if(!configurations.empty())
-        {
+      doing = DoingCommand;
+    } else if (args[i] == "CONFIGURATIONS") {
+      if (!configurations.empty()) {
         this->SetError(" may be given at most one set of CONFIGURATIONS.");
         return false;
-        }
-      doing = DoingConfigs;
       }
-    else if(args[i] == "WORKING_DIRECTORY")
-      {
-      if(!working_directory.empty())
-        {
+      doing = DoingConfigs;
+    } else if (args[i] == "WORKING_DIRECTORY") {
+      if (!working_directory.empty()) {
         this->SetError(" may be given at most one WORKING_DIRECTORY.");
         return false;
-        }
-      doing = DoingWorkingDirectory;
       }
-    else if(doing == DoingName)
-      {
+      doing = DoingWorkingDirectory;
+    } else if (doing == DoingName) {
       name = args[i];
       doing = DoingNone;
-      }
-    else if(doing == DoingCommand)
-      {
+    } else if (doing == DoingCommand) {
       command.push_back(args[i]);
-      }
-    else if(doing == DoingConfigs)
-      {
+    } else if (doing == DoingConfigs) {
       configurations.push_back(args[i]);
-      }
-    else if(doing == DoingWorkingDirectory)
-      {
+    } else if (doing == DoingWorkingDirectory) {
       working_directory = args[i];
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << " given unknown argument:\n  " << args[i] << "\n";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Require a test name.
-  if(name.empty())
-    {
+  if (name.empty()) {
     this->SetError(" must be given non-empty NAME.");
     return false;
-    }
+  }
 
   // Require a command.
-  if(command.empty())
-    {
+  if (command.empty()) {
     this->SetError(" must be given non-empty COMMAND.");
     return false;
-    }
+  }
 
   // Require a unique test name within the directory.
-  if(this->Makefile->GetTest(name))
-    {
+  if (this->Makefile->GetTest(name)) {
     std::ostringstream e;
     e << " given test NAME \"" << name
       << "\" which already exists in this directory.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Add the test.
   cmTest* test = this->Makefile->CreateTest(name);
   test->SetOldStyle(false);
   test->SetCommand(command);
-  if(!working_directory.empty())
-    {
+  if (!working_directory.empty()) {
     test->SetProperty("WORKING_DIRECTORY", working_directory.c_str());
-    }
+  }
   this->Makefile->AddTestGenerator(new cmTestGenerator(test, configurations));
 
   return true;
diff --git a/Source/cmAddTestCommand.h b/Source/cmAddTestCommand.h
index 624288f..295fb78 100644
--- a/Source/cmAddTestCommand.h
+++ b/Source/cmAddTestCommand.h
@@ -25,27 +25,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAddTestCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAddTestCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "add_test";}
+  virtual std::string GetName() const { return "add_test"; }
 
   cmTypeMacro(cmAddTestCommand, cmCommand);
+
 private:
   bool HandleNameMode(std::vector<std::string> const& args);
 };
 
-
 #endif
diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h
index bb65ea5..76acaca 100644
--- a/Source/cmAlgorithms.h
+++ b/Source/cmAlgorithms.h
@@ -14,65 +14,74 @@
 
 #include "cmStandardIncludes.h"
 
-inline bool cmHasLiteralPrefixImpl(const std::string &str1,
-                                 const char *str2,
-                                 size_t N)
+inline bool cmHasLiteralPrefixImpl(const std::string& str1, const char* str2,
+                                   size_t N)
 {
   return strncmp(str1.c_str(), str2, N) == 0;
 }
 
-inline bool cmHasLiteralPrefixImpl(const char* str1,
-                                 const char *str2,
-                                 size_t N)
+inline bool cmHasLiteralPrefixImpl(const char* str1, const char* str2,
+                                   size_t N)
 {
   return strncmp(str1, str2, N) == 0;
 }
 
-inline bool cmHasLiteralSuffixImpl(const std::string &str1,
-                                   const char *str2,
+inline bool cmHasLiteralSuffixImpl(const std::string& str1, const char* str2,
                                    size_t N)
 {
   size_t len = str1.size();
   return len >= N && strcmp(str1.c_str() + len - N, str2) == 0;
 }
 
-inline bool cmHasLiteralSuffixImpl(const char* str1,
-                                   const char* str2,
+inline bool cmHasLiteralSuffixImpl(const char* str1, const char* str2,
                                    size_t N)
 {
   size_t len = strlen(str1);
   return len >= N && strcmp(str1 + len - N, str2) == 0;
 }
 
-template<typename T, size_t N>
-const T* cmArrayBegin(const T (&a)[N]) { return a; }
-template<typename T, size_t N>
-const T* cmArrayEnd(const T (&a)[N]) { return a + N; }
-template<typename T, size_t N>
-size_t cmArraySize(const T (&)[N]) { return N; }
+template <typename T, size_t N>
+const T* cmArrayBegin(const T (&a)[N])
+{
+  return a;
+}
+template <typename T, size_t N>
+const T* cmArrayEnd(const T (&a)[N])
+{
+  return a + N;
+}
+template <typename T, size_t N>
+size_t cmArraySize(const T (&)[N])
+{
+  return N;
+}
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 bool cmHasLiteralPrefix(const T& str1, const char (&str2)[N])
 {
   return cmHasLiteralPrefixImpl(str1, str2, N - 1);
 }
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 bool cmHasLiteralSuffix(const T& str1, const char (&str2)[N])
 {
   return cmHasLiteralSuffixImpl(str1, str2, N - 1);
 }
 
-struct cmStrCmp {
-  cmStrCmp(const char *test) : m_test(test) {}
-  cmStrCmp(const std::string &test) : m_test(test) {}
-
-  bool operator()(const std::string& input) const
+struct cmStrCmp
+{
+  cmStrCmp(const char* test)
+    : m_test(test)
   {
-    return m_test == input;
   }
+  cmStrCmp(const std::string& test)
+    : m_test(test)
+  {
+  }
+
+  bool operator()(const std::string& input) const { return m_test == input; }
 
-  bool operator()(const char * input) const
+  bool operator()(const char* input) const
   {
     return strcmp(input, m_test.c_str()) == 0;
   }
@@ -81,11 +90,11 @@ private:
   const std::string m_test;
 };
 
-template<typename FwdIt>
+template <typename FwdIt>
 FwdIt cmRotate(FwdIt first, FwdIt middle, FwdIt last)
 {
   const typename std::iterator_traits<FwdIt>::difference_type dist =
-      std::distance(middle, last);
+    std::distance(middle, last);
   std::rotate(first, middle, last);
   std::advance(first, dist);
   return first;
@@ -93,36 +102,41 @@ FwdIt cmRotate(FwdIt first, FwdIt middle, FwdIt last)
 
 namespace ContainerAlgorithms {
 
-template<typename T>
+template <typename T>
 struct cmIsPair
 {
-  enum { value = false };
+  enum
+  {
+    value = false
+  };
 };
 
-template<typename K, typename V>
+template <typename K, typename V>
 struct cmIsPair<std::pair<K, V> >
 {
-  enum { value = true };
+  enum
+  {
+    value = true
+  };
 };
 
-template<typename Range,
-    bool valueTypeIsPair = cmIsPair<typename Range::value_type>::value>
+template <typename Range,
+          bool valueTypeIsPair = cmIsPair<typename Range::value_type>::value>
 struct DefaultDeleter
 {
-  void operator()(typename Range::value_type value) const {
-    delete value;
-  }
+  void operator()(typename Range::value_type value) const { delete value; }
 };
 
-template<typename Range>
+template <typename Range>
 struct DefaultDeleter<Range, /* valueTypeIsPair = */ true>
 {
-  void operator()(typename Range::value_type value) const {
+  void operator()(typename Range::value_type value) const
+  {
     delete value.second;
   }
 };
 
-template<typename FwdIt>
+template <typename FwdIt>
 FwdIt RemoveN(FwdIt i1, FwdIt i2, size_t n)
 {
   FwdIt m = i1;
@@ -130,7 +144,7 @@ FwdIt RemoveN(FwdIt i1, FwdIt i2, size_t n)
   return cmRotate(i1, m, i2);
 }
 
-template<typename Range>
+template <typename Range>
 struct BinarySearcher
 {
   typedef typename Range::value_type argument_type;
@@ -143,13 +157,13 @@ struct BinarySearcher
   {
     return std::binary_search(m_range.begin(), m_range.end(), item);
   }
+
 private:
   Range const& m_range;
 };
-
 }
 
-template<typename const_iterator_>
+template <typename const_iterator_>
 struct cmRange
 {
   typedef const_iterator_ const_iterator;
@@ -157,7 +171,10 @@ struct cmRange
   typedef typename std::iterator_traits<const_iterator>::difference_type
     difference_type;
   cmRange(const_iterator begin_, const_iterator end_)
-    : Begin(begin_), End(end_) {}
+    : Begin(begin_)
+    , End(end_)
+  {
+  }
   const_iterator begin() const { return Begin; }
   const_iterator end() const { return End; }
   bool empty() const { return std::distance(Begin, End) == 0; }
@@ -173,6 +190,7 @@ struct cmRange
     std::advance(End, -amount);
     return *this;
   }
+
 private:
   const_iterator Begin;
   const_iterator End;
@@ -181,73 +199,68 @@ private:
 typedef cmRange<std::vector<std::string>::const_iterator> cmStringRange;
 
 class cmListFileBacktrace;
-typedef
-cmRange<std::vector<cmListFileBacktrace>::const_iterator> cmBacktraceRange;
+typedef cmRange<std::vector<cmListFileBacktrace>::const_iterator>
+  cmBacktraceRange;
 
-template<typename Iter1, typename Iter2>
+template <typename Iter1, typename Iter2>
 cmRange<Iter1> cmMakeRange(Iter1 begin, Iter2 end)
 {
   return cmRange<Iter1>(begin, end);
 }
 
-template<typename Range>
-cmRange<typename Range::const_iterator>
-cmMakeRange(Range const& range)
+template <typename Range>
+cmRange<typename Range::const_iterator> cmMakeRange(Range const& range)
 {
-  return cmRange<typename Range::const_iterator>(
-      range.begin(), range.end());
+  return cmRange<typename Range::const_iterator>(range.begin(), range.end());
 }
 
-template<typename Range>
+template <typename Range>
 void cmDeleteAll(Range const& r)
 {
   std::for_each(r.begin(), r.end(),
                 ContainerAlgorithms::DefaultDeleter<Range>());
 }
 
-template<typename Range>
+template <typename Range>
 std::string cmJoin(Range const& r, const char* delimiter)
 {
-  if (r.empty())
-    {
+  if (r.empty()) {
     return std::string();
-    }
+  }
   std::ostringstream os;
   typedef typename Range::value_type ValueType;
   typedef typename Range::const_iterator InputIt;
   const InputIt first = r.begin();
   InputIt last = r.end();
   --last;
-  std::copy(first, last,
-      std::ostream_iterator<ValueType>(os, delimiter));
+  std::copy(first, last, std::ostream_iterator<ValueType>(os, delimiter));
 
   os << *last;
 
   return os.str();
 }
 
-template<typename Range>
+template <typename Range>
 std::string cmJoin(Range const& r, std::string delimiter)
 {
   return cmJoin(r, delimiter.c_str());
 }
 
-template<typename Range>
+template <typename Range>
 typename Range::const_iterator cmRemoveN(Range& r, size_t n)
 {
   return ContainerAlgorithms::RemoveN(r.begin(), r.end(), n);
 }
 
-template<typename Range, typename InputRange>
+template <typename Range, typename InputRange>
 typename Range::const_iterator cmRemoveIndices(Range& r, InputRange const& rem)
 {
   typename InputRange::const_iterator remIt = rem.begin();
   typename InputRange::const_iterator remEnd = rem.end();
   const typename Range::iterator rangeEnd = r.end();
-  if (remIt == remEnd)
-    {
+  if (remIt == remEnd) {
     return rangeEnd;
-    }
+  }
 
   typename Range::iterator writer = r.begin();
   std::advance(writer, *remIt);
@@ -255,17 +268,16 @@ typename Range::const_iterator cmRemoveIndices(Range& r, InputRange const& rem)
   typename InputRange::value_type prevRem = *remIt;
   ++remIt;
   size_t count = 1;
-  for ( ; writer != rangeEnd && remIt != remEnd; ++count, ++remIt)
-    {
+  for (; writer != rangeEnd && remIt != remEnd; ++count, ++remIt) {
     std::advance(pivot, *remIt - prevRem);
     prevRem = *remIt;
     writer = ContainerAlgorithms::RemoveN(writer, pivot, count);
-    }
+  }
   return ContainerAlgorithms::RemoveN(writer, rangeEnd, count);
 }
 
-template<typename Range, typename MatchRange>
-typename Range::const_iterator cmRemoveMatching(Range &r, MatchRange const& m)
+template <typename Range, typename MatchRange>
+typename Range::const_iterator cmRemoveMatching(Range& r, MatchRange const& m)
 {
   return std::remove_if(r.begin(), r.end(),
                         ContainerAlgorithms::BinarySearcher<MatchRange>(m));
@@ -273,7 +285,7 @@ typename Range::const_iterator cmRemoveMatching(Range &r, MatchRange const& m)
 
 namespace ContainerAlgorithms {
 
-template<typename Range, typename T = typename Range::value_type>
+template <typename Range, typename T = typename Range::value_type>
 struct RemoveDuplicatesAPI
 {
   typedef typename Range::const_iterator const_iterator;
@@ -281,11 +293,14 @@ struct RemoveDuplicatesAPI
 
   static bool lessThan(value_type a, value_type b) { return *a < *b; }
   static value_type uniqueValue(const_iterator a) { return a; }
-  template<typename It>
-  static bool valueCompare(It it, const_iterator it2) { return **it != *it2; }
+  template <typename It>
+  static bool valueCompare(It it, const_iterator it2)
+  {
+    return **it != *it2;
+  }
 };
 
-template<typename Range, typename T>
+template <typename Range, typename T>
 struct RemoveDuplicatesAPI<Range, T*>
 {
   typedef typename Range::const_iterator const_iterator;
@@ -293,13 +308,15 @@ struct RemoveDuplicatesAPI<Range, T*>
 
   static bool lessThan(value_type a, value_type b) { return a < b; }
   static value_type uniqueValue(const_iterator a) { return *a; }
-  template<typename It>
-  static bool valueCompare(It it, const_iterator it2) { return *it != *it2; }
+  template <typename It>
+  static bool valueCompare(It it, const_iterator it2)
+  {
+    return *it != *it2;
+  }
 };
-
 }
 
-template<typename Range>
+template <typename Range>
 typename Range::const_iterator cmRemoveDuplicates(Range& r)
 {
   typedef typename ContainerAlgorithms::RemoveDuplicatesAPI<Range> API;
@@ -309,58 +326,51 @@ typename Range::const_iterator cmRemoveDuplicates(Range& r)
   std::vector<size_t> indices;
   size_t count = 0;
   const typename Range::const_iterator end = r.end();
-  for(typename Range::const_iterator it = r.begin();
-      it != end; ++it, ++count)
-    {
-    const typename std::vector<T>::iterator low =
-        std::lower_bound(unique.begin(), unique.end(),
-                         API::uniqueValue(it), API::lessThan);
-    if (low == unique.end() || API::valueCompare(low, it))
-      {
+  for (typename Range::const_iterator it = r.begin(); it != end;
+       ++it, ++count) {
+    const typename std::vector<T>::iterator low = std::lower_bound(
+      unique.begin(), unique.end(), API::uniqueValue(it), API::lessThan);
+    if (low == unique.end() || API::valueCompare(low, it)) {
       unique.insert(low, API::uniqueValue(it));
-      }
-    else
-      {
+    } else {
       indices.push_back(count);
-      }
     }
-  if (indices.empty())
-    {
+  }
+  if (indices.empty()) {
     return end;
-    }
+  }
   return cmRemoveIndices(r, indices);
 }
 
-template<typename Range>
+template <typename Range>
 std::string cmWrap(std::string prefix, Range const& r, std::string suffix,
                    std::string sep)
 {
-  if (r.empty())
-    {
+  if (r.empty()) {
     return std::string();
-    }
+  }
   return prefix + cmJoin(r, (suffix + sep + prefix).c_str()) + suffix;
 }
 
-template<typename Range>
+template <typename Range>
 std::string cmWrap(char prefix, Range const& r, char suffix, std::string sep)
 {
   return cmWrap(std::string(1, prefix), r, std::string(1, suffix), sep);
 }
 
-template<typename Range, typename T>
+template <typename Range, typename T>
 typename Range::const_iterator cmFindNot(Range const& r, T const& t)
 {
   return std::find_if(r.begin(), r.end(),
                       std::bind1st(std::not_equal_to<T>(), t));
 }
 
-template<typename Range>
-cmRange<typename Range::const_reverse_iterator>
-cmReverseRange(Range const& range)
+template <typename Range>
+cmRange<typename Range::const_reverse_iterator> cmReverseRange(
+  Range const& range)
 {
-  return cmRange<typename Range::const_reverse_iterator>(
-      range.rbegin(), range.rend());
+  return cmRange<typename Range::const_reverse_iterator>(range.rbegin(),
+                                                         range.rend());
 }
 
 template <class Iter>
diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx
index 399c513..a0150ec 100644
--- a/Source/cmArchiveWrite.cxx
+++ b/Source/cmArchiveWrite.cxx
@@ -19,17 +19,17 @@
 #include <cmsys/FStream.hxx>
 
 #ifndef __LA_SSIZE_T
-# define __LA_SSIZE_T la_ssize_t
+#define __LA_SSIZE_T la_ssize_t
 #endif
 
 static std::string cm_archive_error_string(struct archive* a)
 {
   const char* e = archive_error_string(a);
-  return e? e : "unknown error";
+  return e ? e : "unknown error";
 }
 
 static void cm_archive_entry_copy_pathname(struct archive_entry* e,
-  const std::string& dest)
+                                           const std::string& dest)
 {
 #if cmsys_STL_HAS_WSTRING
   archive_entry_copy_pathname_w(e, cmsys::Encoding::ToWide(dest).c_str());
@@ -39,7 +39,7 @@ static void cm_archive_entry_copy_pathname(struct archive_entry* e,
 }
 
 static void cm_archive_entry_copy_sourcepath(struct archive_entry* e,
-  const std::string& file)
+                                             const std::string& file)
 {
 #if cmsys_STL_HAS_WSTRING
   archive_entry_copy_sourcepath_w(e, cmsys::Encoding::ToWide(file).c_str());
@@ -51,8 +51,12 @@ static void cm_archive_entry_copy_sourcepath(struct archive_entry* e,
 class cmArchiveWrite::Entry
 {
   struct archive_entry* Object;
+
 public:
-  Entry(): Object(archive_entry_new()) {}
+  Entry()
+    : Object(archive_entry_new())
+  {
+  }
   ~Entry() { archive_entry_free(this->Object); }
   operator struct archive_entry*() { return this->Object; }
 };
@@ -60,115 +64,100 @@ public:
 struct cmArchiveWrite::Callback
 {
   // archive_write_callback
-  static __LA_SSIZE_T Write(struct archive*, void *cd,
-                            const void *b, size_t n)
-    {
+  static __LA_SSIZE_T Write(struct archive*, void* cd, const void* b, size_t n)
+  {
     cmArchiveWrite* self = static_cast<cmArchiveWrite*>(cd);
-    if(self->Stream.write(static_cast<const char*>(b),
-                          static_cast<std::streamsize>(n)))
-      {
+    if (self->Stream.write(static_cast<const char*>(b),
+                           static_cast<std::streamsize>(n))) {
       return static_cast<__LA_SSIZE_T>(n);
-      }
-    else
-      {
+    } else {
       return static_cast<__LA_SSIZE_T>(-1);
-      }
     }
+  }
 };
 
-cmArchiveWrite::cmArchiveWrite(
-  std::ostream& os, Compress c, std::string const& format):
-    Stream(os),
-    Archive(archive_write_new()),
-    Disk(archive_read_disk_new()),
-    Verbose(false),
-    Format(format)
+cmArchiveWrite::cmArchiveWrite(std::ostream& os, Compress c,
+                               std::string const& format)
+  : Stream(os)
+  , Archive(archive_write_new())
+  , Disk(archive_read_disk_new())
+  , Verbose(false)
+  , Format(format)
 {
-  switch (c)
-    {
+  switch (c) {
     case CompressNone:
-      if(archive_write_add_filter_none(this->Archive) != ARCHIVE_OK)
-        {
+      if (archive_write_add_filter_none(this->Archive) != ARCHIVE_OK) {
         this->Error = "archive_write_add_filter_none: ";
         this->Error += cm_archive_error_string(this->Archive);
         return;
-        }
+      }
       break;
     case CompressCompress:
-      if(archive_write_add_filter_compress(this->Archive) != ARCHIVE_OK)
-        {
+      if (archive_write_add_filter_compress(this->Archive) != ARCHIVE_OK) {
         this->Error = "archive_write_add_filter_compress: ";
         this->Error += cm_archive_error_string(this->Archive);
         return;
-        }
+      }
       break;
     case CompressGZip:
-      if(archive_write_add_filter_gzip(this->Archive) != ARCHIVE_OK)
-        {
+      if (archive_write_add_filter_gzip(this->Archive) != ARCHIVE_OK) {
         this->Error = "archive_write_add_filter_gzip: ";
         this->Error += cm_archive_error_string(this->Archive);
         return;
-        }
+      }
       break;
     case CompressBZip2:
-      if(archive_write_add_filter_bzip2(this->Archive) != ARCHIVE_OK)
-        {
+      if (archive_write_add_filter_bzip2(this->Archive) != ARCHIVE_OK) {
         this->Error = "archive_write_add_filter_bzip2: ";
         this->Error += cm_archive_error_string(this->Archive);
         return;
-        }
+      }
       break;
     case CompressLZMA:
-      if(archive_write_add_filter_lzma(this->Archive) != ARCHIVE_OK)
-        {
+      if (archive_write_add_filter_lzma(this->Archive) != ARCHIVE_OK) {
         this->Error = "archive_write_add_filter_lzma: ";
         this->Error += cm_archive_error_string(this->Archive);
         return;
-        }
+      }
       break;
     case CompressXZ:
-      if(archive_write_add_filter_xz(this->Archive) != ARCHIVE_OK)
-        {
+      if (archive_write_add_filter_xz(this->Archive) != ARCHIVE_OK) {
         this->Error = "archive_write_add_filter_xz: ";
         this->Error += cm_archive_error_string(this->Archive);
         return;
-        }
+      }
       break;
-    };
+  };
 #if !defined(_WIN32) || defined(__CYGWIN__)
-  if (archive_read_disk_set_standard_lookup(this->Disk) != ARCHIVE_OK)
-    {
+  if (archive_read_disk_set_standard_lookup(this->Disk) != ARCHIVE_OK) {
     this->Error = "archive_read_disk_set_standard_lookup: ";
     this->Error += cm_archive_error_string(this->Archive);
     return;
-    }
+  }
 #endif
 
-  if(archive_write_set_format_by_name(this->Archive, format.c_str())
-    != ARCHIVE_OK)
-    {
+  if (archive_write_set_format_by_name(this->Archive, format.c_str()) !=
+      ARCHIVE_OK) {
     this->Error = "archive_write_set_format_by_name: ";
     this->Error += cm_archive_error_string(this->Archive);
     return;
-    }
+  }
 
   // do not pad the last block!!
-  if (archive_write_set_bytes_in_last_block(this->Archive, 1))
-    {
+  if (archive_write_set_bytes_in_last_block(this->Archive, 1)) {
     this->Error = "archive_write_set_bytes_in_last_block: ";
     this->Error += cm_archive_error_string(this->Archive);
     return;
-    }
+  }
 
-  if(archive_write_open(
-       this->Archive, this, 0,
-       reinterpret_cast<archive_write_callback*>(&Callback::Write),
-       0) != ARCHIVE_OK)
-    {
+  if (archive_write_open(
+        this->Archive, this, 0,
+        reinterpret_cast<archive_write_callback*>(&Callback::Write),
+        0) != ARCHIVE_OK) {
     this->Error = "archive_write_open: ";
     this->Error += cm_archive_error_string(this->Archive);
     return;
-    }
+  }
 }
 
 cmArchiveWrite::~cmArchiveWrite()
@@ -177,205 +166,174 @@ cmArchiveWrite::~cmArchiveWrite()
   archive_write_free(this->Archive);
 }
 
-bool cmArchiveWrite::Add(std::string path,
-                         size_t skip,
-                         const char* prefix,
+bool cmArchiveWrite::Add(std::string path, size_t skip, const char* prefix,
                          bool recursive)
 {
-  if(this->Okay())
-    {
-    if(!path.empty() && path[path.size()-1] == '/')
-      {
-      path.erase(path.size()-1);
-      }
-    this->AddPath(path.c_str(), skip, prefix, recursive);
+  if (this->Okay()) {
+    if (!path.empty() && path[path.size() - 1] == '/') {
+      path.erase(path.size() - 1);
     }
+    this->AddPath(path.c_str(), skip, prefix, recursive);
+  }
   return this->Okay();
 }
 
-bool cmArchiveWrite::AddPath(const char* path,
-                             size_t skip, const char* prefix,
+bool cmArchiveWrite::AddPath(const char* path, size_t skip, const char* prefix,
                              bool recursive)
 {
-  if(!this->AddFile(path, skip, prefix))
-    {
+  if (!this->AddFile(path, skip, prefix)) {
     return false;
-    }
-  if((!cmSystemTools::FileIsDirectory(path) || !recursive) ||
-    cmSystemTools::FileIsSymlink(path))
-    {
+  }
+  if ((!cmSystemTools::FileIsDirectory(path) || !recursive) ||
+      cmSystemTools::FileIsSymlink(path)) {
     return true;
-    }
+  }
   cmsys::Directory d;
-  if(d.Load(path))
-    {
+  if (d.Load(path)) {
     std::string next = path;
     next += "/";
     std::string::size_type end = next.size();
     unsigned long n = d.GetNumberOfFiles();
-    for(unsigned long i = 0; i < n; ++i)
-      {
+    for (unsigned long i = 0; i < n; ++i) {
       const char* file = d.GetFile(i);
-      if(strcmp(file, ".") != 0 && strcmp(file, "..") != 0)
-        {
+      if (strcmp(file, ".") != 0 && strcmp(file, "..") != 0) {
         next.erase(end);
         next += file;
-        if(!this->AddPath(next.c_str(), skip, prefix))
-          {
+        if (!this->AddPath(next.c_str(), skip, prefix)) {
           return false;
-          }
         }
       }
     }
+  }
   return true;
 }
 
-bool cmArchiveWrite::AddFile(const char* file,
-                             size_t skip, const char* prefix)
+bool cmArchiveWrite::AddFile(const char* file, size_t skip, const char* prefix)
 {
   // Skip the file if we have no name for it.  This may happen on a
   // top-level directory, which does not need to be included anyway.
-  if(skip >= strlen(file))
-    {
+  if (skip >= strlen(file)) {
     return true;
-    }
+  }
   const char* out = file + skip;
 
   cmLocaleRAII localeRAII;
   static_cast<void>(localeRAII);
 
   // Meta-data.
-  std::string dest = prefix? prefix : "";
+  std::string dest = prefix ? prefix : "";
   dest += out;
-  if(this->Verbose)
-    {
+  if (this->Verbose) {
     std::cout << dest << "\n";
-    }
+  }
   Entry e;
   cm_archive_entry_copy_sourcepath(e, file);
   cm_archive_entry_copy_pathname(e, dest);
-  if(archive_read_disk_entry_from_file(this->Disk, e, -1, 0) != ARCHIVE_OK)
-    {
+  if (archive_read_disk_entry_from_file(this->Disk, e, -1, 0) != ARCHIVE_OK) {
     this->Error = "archive_read_disk_entry_from_file '";
     this->Error += file;
     this->Error += "': ";
     this->Error += cm_archive_error_string(this->Disk);
     return false;
-    }
-  if (!this->MTime.empty())
-    {
+  }
+  if (!this->MTime.empty()) {
     time_t now;
     time(&now);
     time_t t = cm_get_date(now, this->MTime.c_str());
-    if (t == -1)
-      {
+    if (t == -1) {
       this->Error = "unable to parse mtime '";
       this->Error += this->MTime;
       this->Error += "'";
       return false;
-      }
-    archive_entry_set_mtime(e, t, 0);
     }
+    archive_entry_set_mtime(e, t, 0);
+  }
 
   // manages the uid/guid of the entry (if any)
-  if (this->Uid.IsSet() && this->Gid.IsSet())
-    {
+  if (this->Uid.IsSet() && this->Gid.IsSet()) {
     archive_entry_set_uid(e, this->Uid.Get());
     archive_entry_set_gid(e, this->Gid.Get());
-    }
+  }
 
-  if (this->Uname.size() && this->Gname.size())
-    {
+  if (this->Uname.size() && this->Gname.size()) {
     archive_entry_set_uname(e, this->Uname.c_str());
     archive_entry_set_gname(e, this->Gname.c_str());
-    }
-
+  }
 
   // manages the permissions
-  if (this->Permissions.IsSet())
-    {
+  if (this->Permissions.IsSet()) {
     archive_entry_set_perm(e, this->Permissions.Get());
-    }
+  }
 
-  if (this->PermissionsMask.IsSet())
-    {
+  if (this->PermissionsMask.IsSet()) {
     mode_t perm = archive_entry_perm(e);
     archive_entry_set_perm(e, perm & this->PermissionsMask.Get());
-    }
+  }
 
   // Clear acl and xattr fields not useful for distribution.
   archive_entry_acl_clear(e);
   archive_entry_xattr_clear(e);
   archive_entry_set_fflags(e, 0, 0);
 
-  if (this->Format == "pax" || this->Format == "paxr")
-    {
+  if (this->Format == "pax" || this->Format == "paxr") {
     // Sparse files are a GNU tar extension.
     // Do not use them in standard tar files.
     archive_entry_sparse_clear(e);
-    }
+  }
 
-  if(archive_write_header(this->Archive, e) != ARCHIVE_OK)
-    {
+  if (archive_write_header(this->Archive, e) != ARCHIVE_OK) {
     this->Error = "archive_write_header: ";
     this->Error += cm_archive_error_string(this->Archive);
     return false;
-    }
+  }
 
   // do not copy content of symlink
-  if (!archive_entry_symlink(e))
-    {
+  if (!archive_entry_symlink(e)) {
     // Content.
-    if(size_t size = static_cast<size_t>(archive_entry_size(e)))
-      {
+    if (size_t size = static_cast<size_t>(archive_entry_size(e))) {
       return this->AddData(file, size);
-      }
     }
+  }
   return true;
 }
 
 bool cmArchiveWrite::AddData(const char* file, size_t size)
 {
   cmsys::ifstream fin(file, std::ios::in | std::ios::binary);
-  if(!fin)
-    {
+  if (!fin) {
     this->Error = "Error opening \"";
     this->Error += file;
     this->Error += "\": ";
     this->Error += cmSystemTools::GetLastSystemError();
     return false;
-    }
+  }
 
   char buffer[16384];
   size_t nleft = size;
-  while(nleft > 0)
-    {
+  while (nleft > 0) {
     typedef std::streamsize ssize_type;
-    size_t const nnext = nleft > sizeof(buffer)? sizeof(buffer) : nleft;
+    size_t const nnext = nleft > sizeof(buffer) ? sizeof(buffer) : nleft;
     ssize_type const nnext_s = static_cast<ssize_type>(nnext);
     fin.read(buffer, nnext_s);
     // Some stream libraries (older HPUX) return failure at end of
     // file on the last read even if some data were read.  Check
     // gcount instead of trusting the stream error status.
-    if(static_cast<size_t>(fin.gcount()) != nnext)
-      {
+    if (static_cast<size_t>(fin.gcount()) != nnext) {
       break;
-      }
-    if(archive_write_data(this->Archive, buffer, nnext) != nnext_s)
-      {
+    }
+    if (archive_write_data(this->Archive, buffer, nnext) != nnext_s) {
       this->Error = "archive_write_data: ";
       this->Error += cm_archive_error_string(this->Archive);
       return false;
-      }
-    nleft -= nnext;
     }
-  if(nleft > 0)
-    {
+    nleft -= nnext;
+  }
+  if (nleft > 0) {
     this->Error = "Error reading \"";
     this->Error += file;
     this->Error += "\": ";
     this->Error += cmSystemTools::GetLastSystemError();
     return false;
-    }
+  }
   return true;
 }
diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h
index 8dbbb83..72d8f3a 100644
--- a/Source/cmArchiveWrite.h
+++ b/Source/cmArchiveWrite.h
@@ -15,20 +15,24 @@
 #include "cmStandardIncludes.h"
 
 #if !defined(CMAKE_BUILD_WITH_CMAKE)
-# error "cmArchiveWrite not allowed during bootstrap build!"
+#error "cmArchiveWrite not allowed during bootstrap build!"
 #endif
 
-template<typename T>
+template <typename T>
 class cmArchiveWriteOptional
 {
 public:
-  cmArchiveWriteOptional() {this->Clear();}
-  explicit cmArchiveWriteOptional(T val) {this->Set(val);}
+  cmArchiveWriteOptional() { this->Clear(); }
+  explicit cmArchiveWriteOptional(T val) { this->Set(val); }
 
-  void Set(T val) {this->IsValueSet = true; this->Value=val;}
-  void Clear() {this->IsValueSet = false;}
-  bool IsSet() const {return this->IsValueSet;}
-  T Get() const {return Value;}
+  void Set(T val)
+  {
+    this->IsValueSet = true;
+    this->Value = val;
+  }
+  void Clear() { this->IsValueSet = false; }
+  bool IsSet() const { return this->IsValueSet; }
+  T Get() const { return Value; }
 private:
   T Value;
   bool IsValueSet;
@@ -40,7 +44,7 @@ private:
  */
 class cmArchiveWrite
 {
-  typedef void (cmArchiveWrite::* safe_bool)();
+  typedef void (cmArchiveWrite::*safe_bool)();
   void safe_bool_true() {}
 public:
   /** Compression type.  */
@@ -56,7 +60,7 @@ public:
 
   /** Construct with output stream to which to write archive.  */
   cmArchiveWrite(std::ostream& os, Compress c = CompressNone,
-    std::string const& format = "paxr");
+                 std::string const& format = "paxr");
 
   ~cmArchiveWrite();
 
@@ -68,14 +72,14 @@ public:
    * skip.  The remaining part of the input path is appended to the
    * "prefix" value to construct the final name in the archive.
    */
-  bool Add(std::string path,
-     size_t skip = 0,
-     const char* prefix = 0,
-     bool recursive = true);
+  bool Add(std::string path, size_t skip = 0, const char* prefix = 0,
+           bool recursive = true);
 
   /** Returns true if there has been no error.  */
   operator safe_bool() const
-    { return this->Okay()? &cmArchiveWrite::safe_bool_true : 0; }
+  {
+    return this->Okay() ? &cmArchiveWrite::safe_bool_true : 0;
+  }
 
   /** Returns true if there has been an error.  */
   bool operator!() const { return !this->Okay(); }
@@ -91,9 +95,9 @@ public:
 
   //! Sets the permissions of the added files/folders
   void SetPermissions(mode_t permissions_)
-    {
+  {
     this->Permissions.Set(permissions_);
-    }
+  }
 
   //! Clears permissions - default is used instead
   void ClearPermissions() { this->Permissions.Clear(); }
@@ -104,44 +108,41 @@ public:
   //! or folder. The mask will then be applied to unset
   //! some of them
   void SetPermissionsMask(mode_t permissionsMask_)
-    {
+  {
     this->PermissionsMask.Set(permissionsMask_);
-    }
+  }
 
   //! Clears permissions mask - default is used instead
-  void ClearPermissionsMask()
-    {
-    this->PermissionsMask.Clear();
-    }
+  void ClearPermissionsMask() { this->PermissionsMask.Clear(); }
 
   //! Sets UID and GID to be used in the tar file
   void SetUIDAndGID(int uid_, int gid_)
-    {
+  {
     this->Uid.Set(uid_);
     this->Gid.Set(gid_);
-    }
+  }
 
   //! Clears UID and GID to be used in the tar file - default is used instead
   void ClearUIDAndGID()
-    {
+  {
     this->Uid.Clear();
     this->Gid.Clear();
-    }
+  }
 
   //! Sets UNAME and GNAME to be used in the tar file
   void SetUNAMEAndGNAME(const std::string& uname_, const std::string& gname_)
-    {
+  {
     this->Uname = uname_;
     this->Gname = gname_;
-    }
+  }
 
   //! Clears UNAME and GNAME to be used in the tar file
   //! default is used instead
   void ClearUNAMEAndGNAME()
-    {
+  {
     this->Uname = "";
     this->Gname = "";
-    }
+  }
 
 private:
   bool Okay() const { return this->Error.empty(); }
diff --git a/Source/cmAuxSourceDirectoryCommand.cxx b/Source/cmAuxSourceDirectoryCommand.cxx
index 07cb295..78f67a4 100644
--- a/Source/cmAuxSourceDirectoryCommand.cxx
+++ b/Source/cmAuxSourceDirectoryCommand.cxx
@@ -16,74 +16,62 @@
 #include <cmsys/Directory.hxx>
 
 // cmAuxSourceDirectoryCommand
-bool cmAuxSourceDirectoryCommand::InitialPass
-(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmAuxSourceDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2 || args.size() > 2)
-    {
+  if (args.size() < 2 || args.size() > 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string sourceListValue;
   std::string templateDirectory = args[0];
   std::string tdir;
-  if(!cmSystemTools::FileIsFullPath(templateDirectory.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(templateDirectory.c_str())) {
     tdir = this->Makefile->GetCurrentSourceDirectory();
     tdir += "/";
     tdir += templateDirectory;
-    }
-  else
-    {
+  } else {
     tdir = templateDirectory;
-    }
+  }
 
   // was the list already populated
-  const char *def = this->Makefile->GetDefinition(args[1]);
-  if (def)
-    {
+  const char* def = this->Makefile->GetDefinition(args[1]);
+  if (def) {
     sourceListValue = def;
-    }
+  }
 
   // Load all the files in the directory
   cmsys::Directory dir;
-  if(dir.Load(tdir.c_str()))
-    {
+  if (dir.Load(tdir.c_str())) {
     size_t numfiles = dir.GetNumberOfFiles();
-    for(size_t i =0; i < numfiles; ++i)
-      {
+    for (size_t i = 0; i < numfiles; ++i) {
       std::string file = dir.GetFile(static_cast<unsigned long>(i));
       // Split the filename into base and extension
       std::string::size_type dotpos = file.rfind(".");
-      if( dotpos != std::string::npos )
-        {
-        std::string ext = file.substr(dotpos+1);
+      if (dotpos != std::string::npos) {
+        std::string ext = file.substr(dotpos + 1);
         std::string base = file.substr(0, dotpos);
         // Process only source files
         std::vector<std::string> srcExts =
-            this->Makefile->GetCMakeInstance()->GetSourceExtensions();
-        if(!base.empty() &&
-           std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end())
-          {
+          this->Makefile->GetCMakeInstance()->GetSourceExtensions();
+        if (!base.empty() &&
+            std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) {
           std::string fullname = templateDirectory;
           fullname += "/";
           fullname += file;
           // add the file as a class file so
           // depends can be done
-          cmSourceFile* sf =
-            this->Makefile->GetOrCreateSource(fullname);
-          sf->SetProperty("ABSTRACT","0");
-          if(!sourceListValue.empty())
-            {
+          cmSourceFile* sf = this->Makefile->GetOrCreateSource(fullname);
+          sf->SetProperty("ABSTRACT", "0");
+          if (!sourceListValue.empty()) {
             sourceListValue += ";";
-            }
-          sourceListValue += fullname;
           }
+          sourceListValue += fullname;
         }
       }
     }
+  }
   this->Makefile->AddDefinition(args[1], sourceListValue.c_str());
   return true;
 }
-
diff --git a/Source/cmAuxSourceDirectoryCommand.h b/Source/cmAuxSourceDirectoryCommand.h
index 6615273..b5943f5 100644
--- a/Source/cmAuxSourceDirectoryCommand.h
+++ b/Source/cmAuxSourceDirectoryCommand.h
@@ -29,26 +29,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmAuxSourceDirectoryCommand;
-    }
+  virtual cmCommand* Clone() { return new cmAuxSourceDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "aux_source_directory";}
+  virtual std::string GetName() const { return "aux_source_directory"; }
 
   cmTypeMacro(cmAuxSourceDirectoryCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmBreakCommand.cxx b/Source/cmBreakCommand.cxx
index fc0c3f5..fd57705 100644
--- a/Source/cmBreakCommand.cxx
+++ b/Source/cmBreakCommand.cxx
@@ -12,16 +12,14 @@
 #include "cmBreakCommand.h"
 
 // cmBreakCommand
-bool cmBreakCommand::InitialPass(std::vector<std::string> const &args,
-                                  cmExecutionStatus &status)
+bool cmBreakCommand::InitialPass(std::vector<std::string> const& args,
+                                 cmExecutionStatus& status)
 {
-  if(!this->Makefile->IsLoopBlock())
-    {
+  if (!this->Makefile->IsLoopBlock()) {
     bool issueMessage = true;
     std::ostringstream e;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0055))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0055)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0055) << "\n";
         break;
@@ -33,29 +31,25 @@ bool cmBreakCommand::InitialPass(std::vector<std::string> const &args,
       case cmPolicies::NEW:
         messageType = cmake::FATAL_ERROR;
         break;
-      }
+    }
 
-    if(issueMessage)
-      {
+    if (issueMessage) {
       e << "A BREAK command was found outside of a proper "
            "FOREACH or WHILE loop scope.";
       this->Makefile->IssueMessage(messageType, e.str());
-       if(messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
   status.SetBreakInvoked(true);
 
-  if(!args.empty())
-    {
+  if (!args.empty()) {
     bool issueMessage = true;
     std::ostringstream e;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0055))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0055)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0055) << "\n";
         break;
@@ -67,19 +61,16 @@ bool cmBreakCommand::InitialPass(std::vector<std::string> const &args,
       case cmPolicies::NEW:
         messageType = cmake::FATAL_ERROR;
         break;
-      }
+    }
 
-    if(issueMessage)
-      {
+    if (issueMessage) {
       e << "The BREAK command does not accept any arguments.";
       this->Makefile->IssueMessage(messageType, e.str());
-       if(messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
   return true;
 }
-
diff --git a/Source/cmBreakCommand.h b/Source/cmBreakCommand.h
index 1fcae50..270d3e6 100644
--- a/Source/cmBreakCommand.h
+++ b/Source/cmBreakCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmBreakCommand;
-    }
+  virtual cmCommand* Clone() { return new cmBreakCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "break";}
+  virtual std::string GetName() const { return "break"; }
 
   cmTypeMacro(cmBreakCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx
index b9183ed..586e8a8 100644
--- a/Source/cmBuildCommand.cxx
+++ b/Source/cmBuildCommand.cxx
@@ -13,27 +13,24 @@
 
 #include "cmGlobalGenerator.h"
 
-bool cmBuildCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmBuildCommand::InitialPass(std::vector<std::string> const& args,
+                                 cmExecutionStatus&)
 {
   // Support the legacy signature of the command:
   //
-  if(2 == args.size())
-    {
+  if (2 == args.size()) {
     return this->TwoArgsSignature(args);
-    }
+  }
 
   return this->MainSignature(args);
 }
 
-bool cmBuildCommand
-::MainSignature(std::vector<std::string> const& args)
+bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("requires at least one argument naming a CMake variable");
     return false;
-    }
+  }
 
   // The cmake variable in which to store the result.
   const char* variable = args[0].c_str();
@@ -42,107 +39,91 @@ bool cmBuildCommand
   const char* configuration = 0;
   const char* project_name = 0;
   std::string target;
-  enum Doing { DoingNone, DoingConfiguration, DoingProjectName, DoingTarget };
+  enum Doing
+  {
+    DoingNone,
+    DoingConfiguration,
+    DoingProjectName,
+    DoingTarget
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "CONFIGURATION")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "CONFIGURATION") {
       doing = DoingConfiguration;
-      }
-    else if(args[i] == "PROJECT_NAME")
-      {
+    } else if (args[i] == "PROJECT_NAME") {
       doing = DoingProjectName;
-      }
-    else if(args[i] == "TARGET")
-      {
+    } else if (args[i] == "TARGET") {
       doing = DoingTarget;
-      }
-    else if(doing == DoingConfiguration)
-      {
+    } else if (doing == DoingConfiguration) {
       doing = DoingNone;
       configuration = args[i].c_str();
-      }
-    else if(doing == DoingProjectName)
-      {
+    } else if (doing == DoingProjectName) {
       doing = DoingNone;
       project_name = args[i].c_str();
-      }
-    else if(doing == DoingTarget)
-      {
+    } else if (doing == DoingTarget) {
       doing = DoingNone;
       target = args[i];
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "unknown argument \"" << args[i] << "\"";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // If null/empty CONFIGURATION argument, cmake --build uses 'Debug'
   // in the currently implemented multi-configuration global generators...
   // so we put this code here to end up with the same default configuration
   // as the original 2-arg build_command signature:
   //
-  if(!configuration || !*configuration)
-    {
+  if (!configuration || !*configuration) {
     configuration = getenv("CMAKE_CONFIG_TYPE");
-    }
-  if(!configuration || !*configuration)
-    {
+  }
+  if (!configuration || !*configuration) {
     configuration = "Release";
-    }
+  }
 
-  if(project_name && *project_name)
-    {
-    this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
+  if (project_name && *project_name) {
+    this->Makefile->IssueMessage(
+      cmake::AUTHOR_WARNING,
       "Ignoring PROJECT_NAME option because it has no effect.");
-    }
+  }
 
-  std::string makecommand = this->Makefile->GetGlobalGenerator()
-    ->GenerateCMakeBuildCommand(target, configuration, "",
-                                this->Makefile->IgnoreErrorsCMP0061());
+  std::string makecommand =
+    this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand(
+      target, configuration, "", this->Makefile->IgnoreErrorsCMP0061());
 
   this->Makefile->AddDefinition(variable, makecommand.c_str());
 
   return true;
 }
 
-bool cmBuildCommand
-::TwoArgsSignature(std::vector<std::string> const& args)
+bool cmBuildCommand::TwoArgsSignature(std::vector<std::string> const& args)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with less than two arguments");
     return false;
-    }
+  }
 
   const char* define = args[0].c_str();
-  const char* cacheValue
-    = this->Makefile->GetDefinition(define);
+  const char* cacheValue = this->Makefile->GetDefinition(define);
 
   std::string configType = "Release";
   const char* cfg = getenv("CMAKE_CONFIG_TYPE");
-  if ( cfg && *cfg )
-    {
+  if (cfg && *cfg) {
     configType = cfg;
-    }
+  }
 
-  std::string makecommand = this->Makefile->GetGlobalGenerator()
-    ->GenerateCMakeBuildCommand("", configType, "",
-                                this->Makefile->IgnoreErrorsCMP0061());
+  std::string makecommand =
+    this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand(
+      "", configType, "", this->Makefile->IgnoreErrorsCMP0061());
 
-  if(cacheValue)
-    {
+  if (cacheValue) {
     return true;
-    }
-  this->Makefile->AddCacheDefinition(define,
-                                 makecommand.c_str(),
-                                 "Command used to build entire project "
-                                 "from the command line.",
-                                 cmState::STRING);
+  }
+  this->Makefile->AddCacheDefinition(define, makecommand.c_str(),
+                                     "Command used to build entire project "
+                                     "from the command line.",
+                                     cmState::STRING);
   return true;
 }
diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h
index 979abc0..6cbf3ca 100644
--- a/Source/cmBuildCommand.h
+++ b/Source/cmBuildCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmBuildCommand;
-    }
+  virtual cmCommand* Clone() { return new cmBuildCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The primary command signature with optional, KEYWORD-based args.
@@ -50,9 +47,10 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "build_command";}
+  virtual std::string GetName() const { return "build_command"; }
 
   cmTypeMacro(cmBuildCommand, cmCommand);
+
 private:
   bool IgnoreErrors() const;
 };
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
index 2733d76..7ed96ab 100644
--- a/Source/cmBuildNameCommand.cxx
+++ b/Source/cmBuildNameCommand.cxx
@@ -14,67 +14,54 @@
 #include <cmsys/RegularExpression.hxx>
 
 // cmBuildNameCommand
-bool cmBuildNameCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmBuildNameCommand::InitialPass(std::vector<std::string> const& args,
+                                     cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0036,
-      "The build_name command should not be called; see CMP0036."))
-    { return true; }
-  if(args.size() < 1 )
-    {
+  if (this->Disallowed(
+        cmPolicies::CMP0036,
+        "The build_name command should not be called; see CMP0036.")) {
+    return true;
+  }
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   const char* cacheValue = this->Makefile->GetDefinition(args[0]);
-  if(cacheValue)
-    {
+  if (cacheValue) {
     // do we need to correct the value?
     cmsys::RegularExpression reg("[()/]");
-    if (reg.find(cacheValue))
-      {
+    if (reg.find(cacheValue)) {
       std::string cv = cacheValue;
-      cmSystemTools::ReplaceString(cv,"/", "_");
-      cmSystemTools::ReplaceString(cv,"(", "_");
-      cmSystemTools::ReplaceString(cv,")", "_");
-      this->Makefile->AddCacheDefinition(args[0],
-                                     cv.c_str(),
-                                     "Name of build.",
-                                     cmState::STRING);
-      }
-    return true;
+      cmSystemTools::ReplaceString(cv, "/", "_");
+      cmSystemTools::ReplaceString(cv, "(", "_");
+      cmSystemTools::ReplaceString(cv, ")", "_");
+      this->Makefile->AddCacheDefinition(args[0], cv.c_str(), "Name of build.",
+                                         cmState::STRING);
     }
-
+    return true;
+  }
 
   std::string buildname = "WinNT";
-  if(this->Makefile->GetDefinition("UNIX"))
-    {
+  if (this->Makefile->GetDefinition("UNIX")) {
     buildname = "";
     cmSystemTools::RunSingleCommand("uname -a", &buildname, &buildname);
-    if(!buildname.empty())
-      {
+    if (!buildname.empty()) {
       std::string RegExp = "([^ ]*) [^ ]* ([^ ]*) ";
-      cmsys::RegularExpression reg( RegExp.c_str() );
-      if(reg.find(buildname.c_str()))
-        {
+      cmsys::RegularExpression reg(RegExp.c_str());
+      if (reg.find(buildname.c_str())) {
         buildname = reg.match(1) + "-" + reg.match(2);
-        }
       }
     }
+  }
   std::string compiler = "${CMAKE_CXX_COMPILER}";
-  this->Makefile->ExpandVariablesInString ( compiler );
+  this->Makefile->ExpandVariablesInString(compiler);
   buildname += "-";
   buildname += cmSystemTools::GetFilenameName(compiler);
-  cmSystemTools::ReplaceString(buildname,
-                               "/", "_");
-  cmSystemTools::ReplaceString(buildname,
-                               "(", "_");
-  cmSystemTools::ReplaceString(buildname,
-                               ")", "_");
+  cmSystemTools::ReplaceString(buildname, "/", "_");
+  cmSystemTools::ReplaceString(buildname, "(", "_");
+  cmSystemTools::ReplaceString(buildname, ")", "_");
 
-  this->Makefile->AddCacheDefinition(args[0],
-                                 buildname.c_str(),
-                                 "Name of build.",
-                                 cmState::STRING);
+  this->Makefile->AddCacheDefinition(args[0], buildname.c_str(),
+                                     "Name of build.", cmState::STRING);
   return true;
 }
-
diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h
index 47455f8..43c24b0 100644
--- a/Source/cmBuildNameCommand.h
+++ b/Source/cmBuildNameCommand.h
@@ -20,11 +20,9 @@ public:
   cmTypeMacro(cmBuildNameCommand, cmCommand);
   virtual cmCommand* Clone() { return new cmBuildNameCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const {return "build_name";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "build_name"; }
   virtual bool IsScriptable() const { return true; }
 };
 
-
-
 #endif
diff --git a/Source/cmCLocaleEnvironmentScope.cxx b/Source/cmCLocaleEnvironmentScope.cxx
index 5792302..ee9acde 100644
--- a/Source/cmCLocaleEnvironmentScope.cxx
+++ b/Source/cmCLocaleEnvironmentScope.cxx
@@ -23,11 +23,10 @@ cmCLocaleEnvironmentScope::cmCLocaleEnvironmentScope()
 
   std::string lcAll = this->GetEnv("LC_ALL");
 
-  if(!lcAll.empty())
-    {
+  if (!lcAll.empty()) {
     this->SetEnv("LC_ALL", "");
     this->SetEnv("LC_CTYPE", lcAll);
-    }
+  }
 }
 
 std::string cmCLocaleEnvironmentScope::GetEnv(std::string const& key)
@@ -36,32 +35,28 @@ std::string cmCLocaleEnvironmentScope::GetEnv(std::string const& key)
   return value ? value : std::string();
 }
 
-void cmCLocaleEnvironmentScope::SetEnv(
-  std::string const& key, std::string const& value)
+void cmCLocaleEnvironmentScope::SetEnv(std::string const& key,
+                                       std::string const& value)
 {
   std::string oldValue = this->GetEnv(key);
 
   this->EnvironmentBackup.insert(std::make_pair(key, oldValue));
 
-  if(value.empty())
-    {
+  if (value.empty()) {
     cmSystemTools::UnsetEnv(key.c_str());
-    }
-  else
-    {
+  } else {
     std::stringstream tmp;
     tmp << key << "=" << value;
     cmSystemTools::PutEnv(tmp.str());
-    }
+  }
 }
 
 cmCLocaleEnvironmentScope::~cmCLocaleEnvironmentScope()
 {
-  for(backup_map_t::const_iterator i = this->EnvironmentBackup.begin();
-    i != this->EnvironmentBackup.end(); ++i)
-    {
+  for (backup_map_t::const_iterator i = this->EnvironmentBackup.begin();
+       i != this->EnvironmentBackup.end(); ++i) {
     std::stringstream tmp;
     tmp << i->first << "=" << i->second;
     cmSystemTools::PutEnv(tmp.str());
-    }
+  }
 }
diff --git a/Source/cmCMakeHostSystemInformationCommand.cxx b/Source/cmCMakeHostSystemInformationCommand.cxx
index 6ff7c0d..fbec6fd 100644
--- a/Source/cmCMakeHostSystemInformationCommand.cxx
+++ b/Source/cmCMakeHostSystemInformationCommand.cxx
@@ -12,25 +12,23 @@
 #include "cmCMakeHostSystemInformationCommand.h"
 
 // cmCMakeHostSystemInformation
-bool cmCMakeHostSystemInformationCommand
-::InitialPass(std::vector<std::string> const &args, cmExecutionStatus &)
+bool cmCMakeHostSystemInformationCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   size_t current_index = 0;
 
-  if(args.size() < (current_index + 2) || args[current_index] != "RESULT")
-    {
+  if (args.size() < (current_index + 2) || args[current_index] != "RESULT") {
     this->SetError("missing RESULT specification.");
     return false;
-    }
+  }
 
   std::string variable = args[current_index + 1];
   current_index += 2;
 
-  if(args.size() < (current_index + 2) || args[current_index] != "QUERY")
-    {
+  if (args.size() < (current_index + 2) || args[current_index] != "QUERY") {
     this->SetError("missing QUERY specification");
     return false;
-    }
+  }
 
   cmsys::SystemInformation info;
   info.RunCPUCheck();
@@ -38,87 +36,68 @@ bool cmCMakeHostSystemInformationCommand
   info.RunMemoryCheck();
 
   std::string result_list;
-  for(size_t i = current_index + 1; i < args.size(); ++i)
-    {
+  for (size_t i = current_index + 1; i < args.size(); ++i) {
     std::string key = args[i];
-    if(i != current_index + 1)
-      {
+    if (i != current_index + 1) {
       result_list += ";";
-      }
+    }
     std::string value;
-    if(!this->GetValue(info, key, value)) return false;
+    if (!this->GetValue(info, key, value))
+      return false;
 
     result_list += value;
-    }
+  }
 
   this->Makefile->AddDefinition(variable, result_list.c_str());
 
   return true;
 }
 
-bool cmCMakeHostSystemInformationCommand
-::GetValue(cmsys::SystemInformation &info,
-           std::string const& key, std::string &value)
+bool cmCMakeHostSystemInformationCommand::GetValue(
+  cmsys::SystemInformation& info, std::string const& key, std::string& value)
 {
-  if(key == "NUMBER_OF_LOGICAL_CORES")
-    {
+  if (key == "NUMBER_OF_LOGICAL_CORES") {
     value = this->ValueToString(info.GetNumberOfLogicalCPU());
-    }
-  else if(key == "NUMBER_OF_PHYSICAL_CORES")
-    {
+  } else if (key == "NUMBER_OF_PHYSICAL_CORES") {
     value = this->ValueToString(info.GetNumberOfPhysicalCPU());
-    }
-  else if(key == "HOSTNAME")
-    {
+  } else if (key == "HOSTNAME") {
     value = this->ValueToString(info.GetHostname());
-    }
-  else if(key == "FQDN")
-    {
+  } else if (key == "FQDN") {
     value = this->ValueToString(info.GetFullyQualifiedDomainName());
-    }
-  else if(key == "TOTAL_VIRTUAL_MEMORY")
-    {
+  } else if (key == "TOTAL_VIRTUAL_MEMORY") {
     value = this->ValueToString(info.GetTotalVirtualMemory());
-    }
-  else if(key == "AVAILABLE_VIRTUAL_MEMORY")
-    {
+  } else if (key == "AVAILABLE_VIRTUAL_MEMORY") {
     value = this->ValueToString(info.GetAvailableVirtualMemory());
-    }
-  else if(key == "TOTAL_PHYSICAL_MEMORY")
-    {
+  } else if (key == "TOTAL_PHYSICAL_MEMORY") {
     value = this->ValueToString(info.GetTotalPhysicalMemory());
-    }
-  else if(key == "AVAILABLE_PHYSICAL_MEMORY")
-    {
+  } else if (key == "AVAILABLE_PHYSICAL_MEMORY") {
     value = this->ValueToString(info.GetAvailablePhysicalMemory());
-    }
-  else
-    {
+  } else {
     std::string e = "does not recognize <key> " + key;
     this->SetError(e);
     return false;
-    }
+  }
 
   return true;
 }
 
-std::string cmCMakeHostSystemInformationCommand
-::ValueToString(size_t value) const
+std::string cmCMakeHostSystemInformationCommand::ValueToString(
+  size_t value) const
 {
   std::stringstream tmp;
   tmp << value;
   return tmp.str();
 }
 
-std::string cmCMakeHostSystemInformationCommand
-::ValueToString(const char *value) const
+std::string cmCMakeHostSystemInformationCommand::ValueToString(
+  const char* value) const
 {
   std::string safe_string = value ? value : "";
   return safe_string;
 }
 
-std::string cmCMakeHostSystemInformationCommand
-::ValueToString(std::string const& value) const
+std::string cmCMakeHostSystemInformationCommand::ValueToString(
+  std::string const& value) const
 {
   return value;
 }
diff --git a/Source/cmCMakeHostSystemInformationCommand.h b/Source/cmCMakeHostSystemInformationCommand.h
index 463b180..6981ea9 100644
--- a/Source/cmCMakeHostSystemInformationCommand.h
+++ b/Source/cmCMakeHostSystemInformationCommand.h
@@ -29,38 +29,38 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
+  {
     return new cmCMakeHostSystemInformationCommand;
-    }
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-               cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
-   /**
-   * This determines if the command is invoked when in script mode.
-   */
+  /**
+  * This determines if the command is invoked when in script mode.
+  */
   virtual bool IsScriptable() const { return true; }
 
-   /**
-   * The name of the command as specified in CMakeList.txt.
-   */
+  /**
+  * The name of the command as specified in CMakeList.txt.
+  */
   virtual std::string GetName() const
-    {
+  {
     return "cmake_host_system_information";
-    }
+  }
 
   cmTypeMacro(cmCMakeHostSystemInformationCommand, cmCommand);
 
 private:
-  bool GetValue(cmsys::SystemInformation &info,
-    std::string const& key, std::string &value);
+  bool GetValue(cmsys::SystemInformation& info, std::string const& key,
+                std::string& value);
 
   std::string ValueToString(size_t value) const;
-  std::string ValueToString(const char *value) const;
+  std::string ValueToString(const char* value) const;
   std::string ValueToString(std::string const& value) const;
 };
 
diff --git a/Source/cmCMakeMinimumRequired.cxx b/Source/cmCMakeMinimumRequired.cxx
index eac5965..1376845 100644
--- a/Source/cmCMakeMinimumRequired.cxx
+++ b/Source/cmCMakeMinimumRequired.cxx
@@ -14,54 +14,42 @@
 #include "cmVersion.h"
 
 // cmCMakeMinimumRequired
-bool cmCMakeMinimumRequired
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
   // Process arguments.
   std::string version_string;
   bool doing_version = false;
-  for(unsigned int i=0; i < args.size(); ++i)
-    {
-    if(args[i] == "VERSION")
-      {
+  for (unsigned int i = 0; i < args.size(); ++i) {
+    if (args[i] == "VERSION") {
       doing_version = true;
-      }
-    else if(args[i] == "FATAL_ERROR")
-      {
-      if(doing_version)
-        {
+    } else if (args[i] == "FATAL_ERROR") {
+      if (doing_version) {
         this->SetError("called with no value for VERSION.");
         return false;
-        }
-      doing_version = false;
       }
-    else if(doing_version)
-      {
+      doing_version = false;
+    } else if (doing_version) {
       doing_version = false;
       version_string = args[i];
-      }
-    else
-      {
+    } else {
       this->UnknownArguments.push_back(args[i]);
-      }
     }
-  if(doing_version)
-    {
+  }
+  if (doing_version) {
     this->SetError("called with no value for VERSION.");
     return false;
-    }
+  }
 
   // Make sure there was a version to check.
-  if(version_string.empty())
-    {
+  if (version_string.empty()) {
     return this->EnforceUnknownArguments();
-    }
+  }
 
   // Save the required version string.
   this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
                                 version_string.c_str());
 
-
   // Get the current version number.
   unsigned int current_major = cmVersion::GetMajorVersion();
   unsigned int current_minor = cmVersion::GetMinorVersion();
@@ -74,28 +62,21 @@ bool cmCMakeMinimumRequired
   unsigned int required_minor = 0;
   unsigned int required_patch = 0;
   unsigned int required_tweak = 0;
-  if(sscanf(version_string.c_str(), "%u.%u.%u.%u",
-            &required_major, &required_minor,
-            &required_patch, &required_tweak) < 2)
-    {
+  if (sscanf(version_string.c_str(), "%u.%u.%u.%u", &required_major,
+             &required_minor, &required_patch, &required_tweak) < 2) {
     std::ostringstream e;
     e << "could not parse VERSION \"" << version_string << "\".";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Compare the version numbers.
-  if((current_major < required_major) ||
-     (current_major == required_major &&
-      current_minor < required_minor) ||
-     (current_major == required_major &&
-      current_minor == required_minor &&
-      current_patch < required_patch) ||
-     (current_major == required_major &&
-      current_minor == required_minor &&
-      current_patch == required_patch &&
-      current_tweak < required_tweak))
-    {
+  if ((current_major < required_major) ||
+      (current_major == required_major && current_minor < required_minor) ||
+      (current_major == required_major && current_minor == required_minor &&
+       current_patch < required_patch) ||
+      (current_major == required_major && current_minor == required_minor &&
+       current_patch == required_patch && current_tweak < required_tweak)) {
     // The current version is too low.
     std::ostringstream e;
     e << "CMake " << version_string
@@ -104,23 +85,19 @@ bool cmCMakeMinimumRequired
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return true;
-    }
+  }
 
   // The version is not from the future, so enforce unknown arguments.
-  if(!this->EnforceUnknownArguments())
-    {
+  if (!this->EnforceUnknownArguments()) {
     return false;
-    }
+  }
 
-  if (required_major < 2 || (required_major == 2 && required_minor < 4))
-  {
+  if (required_major < 2 || (required_major == 2 && required_minor < 4)) {
     this->Makefile->IssueMessage(
       cmake::AUTHOR_WARNING,
       "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.");
     this->Makefile->SetPolicyVersion("2.4");
-  }
-  else
-  {
+  } else {
     this->Makefile->SetPolicyVersion(version_string.c_str());
   }
 
@@ -129,13 +106,12 @@ bool cmCMakeMinimumRequired
 
 bool cmCMakeMinimumRequired::EnforceUnknownArguments()
 {
-  if(!this->UnknownArguments.empty())
-    {
+  if (!this->UnknownArguments.empty()) {
     std::ostringstream e;
-    e << "called with unknown argument \""
-      << this->UnknownArguments[0] << "\".";
+    e << "called with unknown argument \"" << this->UnknownArguments[0]
+      << "\".";
     this->SetError(e.str());
     return false;
-    }
+  }
   return true;
 }
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
index 31b7271..fc73e87 100644
--- a/Source/cmCMakeMinimumRequired.h
+++ b/Source/cmCMakeMinimumRequired.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmCMakeMinimumRequired;
-    }
+  virtual cmCommand* Clone() { return new cmCMakeMinimumRequired; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,7 +42,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "cmake_minimum_required";}
+  virtual std::string GetName() const { return "cmake_minimum_required"; }
 
   cmTypeMacro(cmCMakeMinimumRequired, cmCommand);
 
@@ -54,6 +51,4 @@ private:
   bool EnforceUnknownArguments();
 };
 
-
-
 #endif
diff --git a/Source/cmCMakePolicyCommand.cxx b/Source/cmCMakePolicyCommand.cxx
index 9132aec..07e0885 100644
--- a/Source/cmCMakePolicyCommand.cxx
+++ b/Source/cmCMakePolicyCommand.cxx
@@ -14,47 +14,35 @@
 #include "cmVersion.h"
 
 // cmCMakePolicyCommand
-bool cmCMakePolicyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCMakePolicyCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("requires at least one argument.");
     return false;
-    }
+  }
 
-  if(args[0] == "SET")
-    {
+  if (args[0] == "SET") {
     return this->HandleSetMode(args);
-    }
-  else if(args[0] == "GET")
-    {
+  } else if (args[0] == "GET") {
     return this->HandleGetMode(args);
-    }
-  else if(args[0] == "PUSH")
-    {
-    if(args.size() > 1)
-      {
+  } else if (args[0] == "PUSH") {
+    if (args.size() > 1) {
       this->SetError("PUSH may not be given additional arguments.");
       return false;
-      }
+    }
     this->Makefile->PushPolicy();
     return true;
-    }
-  else if(args[0] == "POP")
-    {
-    if(args.size() > 1)
-      {
+  } else if (args[0] == "POP") {
+    if (args.size() > 1) {
       this->SetError("POP may not be given additional arguments.");
       return false;
-      }
+    }
     this->Makefile->PopPolicy();
     return true;
-    }
-  else if(args[0] == "VERSION")
-    {
+  } else if (args[0] == "VERSION") {
     return this->HandleVersionMode(args);
-    }
+  }
 
   std::ostringstream e;
   e << "given unknown first argument \"" << args[0] << "\"";
@@ -64,60 +52,50 @@ bool cmCMakePolicyCommand
 
 bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("SET must be given exactly 2 additional arguments.");
     return false;
-    }
+  }
 
   cmPolicies::PolicyStatus status;
-  if(args[2] == "OLD")
-    {
+  if (args[2] == "OLD") {
     status = cmPolicies::OLD;
-    }
-  else if(args[2] == "NEW")
-    {
+  } else if (args[2] == "NEW") {
     status = cmPolicies::NEW;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "SET given unrecognized policy status \"" << args[2] << "\"";
     this->SetError(e.str());
     return false;
-    }
+  }
 
-  if(!this->Makefile->SetPolicy(args[1].c_str(), status))
-    {
+  if (!this->Makefile->SetPolicy(args[1].c_str(), status)) {
     this->SetError("SET failed to set policy.");
     return false;
-    }
-  if(args[1] == "CMP0001" &&
-     (status == cmPolicies::WARN || status == cmPolicies::OLD))
-    {
-    if(!(this->Makefile->GetState()
-         ->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
-      {
+  }
+  if (args[1] == "CMP0001" &&
+      (status == cmPolicies::WARN || status == cmPolicies::OLD)) {
+    if (!(this->Makefile->GetState()->GetInitializedCacheValue(
+          "CMAKE_BACKWARDS_COMPATIBILITY"))) {
       // Set it to 2.4 because that is the last version where the
       // variable had meaning.
-      this->Makefile->AddCacheDefinition
-        ("CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
-         "For backwards compatibility, what version of CMake "
-         "commands and "
-         "syntax should this version of CMake try to support.",
-         cmState::STRING);
-      }
-    }
+      this->Makefile->AddCacheDefinition(
+        "CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
+        "For backwards compatibility, what version of CMake "
+        "commands and "
+        "syntax should this version of CMake try to support.",
+        cmState::STRING);
+    }
+  }
   return true;
 }
 
 bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("GET must be given exactly 2 additional arguments.");
     return false;
-    }
+  }
 
   // Get arguments.
   std::string const& id = args[1];
@@ -125,19 +103,17 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
 
   // Lookup the policy number.
   cmPolicies::PolicyID pid;
-  if(!cmPolicies::GetPolicyID(id.c_str(), pid))
-    {
+  if (!cmPolicies::GetPolicyID(id.c_str(), pid)) {
     std::ostringstream e;
     e << "GET given policy \"" << id << "\" which is not known to this "
       << "version of CMake.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Lookup the policy setting.
   cmPolicies::PolicyStatus status = this->Makefile->GetPolicyStatus(pid);
-  switch (status)
-    {
+  switch (status) {
     case cmPolicies::OLD:
       // Report that the policy is set to OLD.
       this->Makefile->AddDefinition(var, "OLD");
@@ -154,32 +130,28 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
     case cmPolicies::REQUIRED_ALWAYS:
       // The policy is required to be set before anything needs it.
       {
-      std::ostringstream e;
-      e << cmPolicies::GetRequiredPolicyError(pid)
-        << "\n"
-        << "The call to cmake_policy(GET " << id << " ...) at which this "
-        << "error appears requests the policy, and this version of CMake "
-        << "requires that the policy be set to NEW before it is checked.";
-      this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
+        std::ostringstream e;
+        e << cmPolicies::GetRequiredPolicyError(pid) << "\n"
+          << "The call to cmake_policy(GET " << id << " ...) at which this "
+          << "error appears requests the policy, and this version of CMake "
+          << "requires that the policy be set to NEW before it is checked.";
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       }
-    }
+  }
 
   return true;
 }
 
-bool
-cmCMakePolicyCommand::HandleVersionMode(std::vector<std::string> const& args)
+bool cmCMakePolicyCommand::HandleVersionMode(
+  std::vector<std::string> const& args)
 {
-  if(args.size() <= 1)
-    {
+  if (args.size() <= 1) {
     this->SetError("VERSION not given an argument");
     return false;
-    }
-  else if(args.size() >= 3)
-    {
+  } else if (args.size() >= 3) {
     this->SetError("VERSION given too many arguments");
     return false;
-    }
+  }
   this->Makefile->SetPolicyVersion(args[1].c_str());
   return true;
 }
diff --git a/Source/cmCMakePolicyCommand.h b/Source/cmCMakePolicyCommand.h
index 8dc8fbe..dbb91d5 100644
--- a/Source/cmCMakePolicyCommand.h
+++ b/Source/cmCMakePolicyCommand.h
@@ -26,35 +26,31 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmCMakePolicyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmCMakePolicyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
- /**
-   * This determines if the command is invoked when in script mode.
-   */
+  /**
+    * This determines if the command is invoked when in script mode.
+    */
   virtual bool IsScriptable() const { return true; }
 
- /**
-   * The name of the command as specified in CMakeList.txt.
-   */
-  virtual std::string GetName() const {return "cmake_policy";}
+  /**
+    * The name of the command as specified in CMakeList.txt.
+    */
+  virtual std::string GetName() const { return "cmake_policy"; }
 
   cmTypeMacro(cmCMakePolicyCommand, cmCommand);
+
 private:
   bool HandleSetMode(std::vector<std::string> const& args);
   bool HandleGetMode(std::vector<std::string> const& args);
   bool HandleVersionMode(std::vector<std::string> const& args);
 };
 
-
-
 #endif
diff --git a/Source/cmCPackPropertiesGenerator.cxx b/Source/cmCPackPropertiesGenerator.cxx
index 3eef55a..af01c7d 100644
--- a/Source/cmCPackPropertiesGenerator.cxx
+++ b/Source/cmCPackPropertiesGenerator.cxx
@@ -4,44 +4,40 @@
 #include "cmOutputConverter.h"
 
 cmCPackPropertiesGenerator::cmCPackPropertiesGenerator(
-  cmLocalGenerator* lg,
-  cmInstalledFile const& installedFile,
-  std::vector<std::string> const& configurations):
-    cmScriptGenerator("CPACK_BUILD_CONFIG", configurations),
-    LG(lg),
-    InstalledFile(installedFile)
+  cmLocalGenerator* lg, cmInstalledFile const& installedFile,
+  std::vector<std::string> const& configurations)
+  : cmScriptGenerator("CPACK_BUILD_CONFIG", configurations)
+  , LG(lg)
+  , InstalledFile(installedFile)
 {
   this->ActionsPerConfig = true;
 }
 
-void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os,
-  const std::string& config, Indent const& indent)
+void cmCPackPropertiesGenerator::GenerateScriptForConfig(
+  std::ostream& os, const std::string& config, Indent const& indent)
 {
   std::string const& expandedFileName =
-      this->InstalledFile.GetNameExpression().Evaluate(this->LG,
-                                                       config);
+    this->InstalledFile.GetNameExpression().Evaluate(this->LG, config);
 
   cmInstalledFile::PropertyMapType const& properties =
     this->InstalledFile.GetProperties();
 
-  for(cmInstalledFile::PropertyMapType::const_iterator i = properties.begin();
-    i != properties.end(); ++i)
-    {
+  for (cmInstalledFile::PropertyMapType::const_iterator i = properties.begin();
+       i != properties.end(); ++i) {
     std::string const& name = i->first;
     cmInstalledFile::Property const& property = i->second;
 
-    os << indent << "set_property(INSTALL " <<
-      cmOutputConverter::EscapeForCMake(expandedFileName) << " PROPERTY " <<
-      cmOutputConverter::EscapeForCMake(name);
+    os << indent << "set_property(INSTALL "
+       << cmOutputConverter::EscapeForCMake(expandedFileName) << " PROPERTY "
+       << cmOutputConverter::EscapeForCMake(name);
 
-    for(cmInstalledFile::ExpressionVectorType::const_iterator
-      j = property.ValueExpressions.begin();
-      j != property.ValueExpressions.end(); ++j)
-      {
+    for (cmInstalledFile::ExpressionVectorType::const_iterator j =
+           property.ValueExpressions.begin();
+         j != property.ValueExpressions.end(); ++j) {
       std::string value = (*j)->Evaluate(this->LG, config);
       os << " " << cmOutputConverter::EscapeForCMake(value);
-      }
+    }
 
     os << ")\n";
-    }
+  }
 }
diff --git a/Source/cmCPackPropertiesGenerator.h b/Source/cmCPackPropertiesGenerator.h
index e54bcab..4372b87 100644
--- a/Source/cmCPackPropertiesGenerator.h
+++ b/Source/cmCPackPropertiesGenerator.h
@@ -21,17 +21,17 @@ class cmLocalGenerator;
  * \brief Support class for generating CPackProperties.cmake.
  *
  */
-class cmCPackPropertiesGenerator: public cmScriptGenerator
+class cmCPackPropertiesGenerator : public cmScriptGenerator
 {
 public:
-  cmCPackPropertiesGenerator(
-     cmLocalGenerator* lg,
-     cmInstalledFile const& installedFile,
-     std::vector<std::string> const& configurations);
+  cmCPackPropertiesGenerator(cmLocalGenerator* lg,
+                             cmInstalledFile const& installedFile,
+                             std::vector<std::string> const& configurations);
 
 protected:
   virtual void GenerateScriptForConfig(std::ostream& os,
-    const std::string& config, Indent const& indent);
+                                       const std::string& config,
+                                       Indent const& indent);
 
   cmLocalGenerator* LG;
   cmInstalledFile const& InstalledFile;
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index b203a22..a78300c 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -24,191 +24,175 @@
 #include <stdlib.h>
 
 #ifdef __QNX__
-# include <malloc.h> /* for malloc/free on QNX */
+#include <malloc.h> /* for malloc/free on QNX */
 #endif
 
-extern "C"
-{
+extern "C" {
 
-void CCONV *cmGetClientData(void *info)
+void CCONV* cmGetClientData(void* info)
 {
-  return ((cmLoadedCommandInfo *)info)->ClientData;
+  return ((cmLoadedCommandInfo*)info)->ClientData;
 }
 
-void CCONV cmSetClientData(void *info, void *cd)
+void CCONV cmSetClientData(void* info, void* cd)
 {
-  ((cmLoadedCommandInfo *)info)->ClientData = cd;
+  ((cmLoadedCommandInfo*)info)->ClientData = cd;
 }
 
-void CCONV cmSetError(void *info, const char *err)
+void CCONV cmSetError(void* info, const char* err)
 {
-  if (((cmLoadedCommandInfo *)info)->Error)
-    {
-    free(((cmLoadedCommandInfo *)info)->Error);
-    }
-  ((cmLoadedCommandInfo *)info)->Error = strdup(err);
+  if (((cmLoadedCommandInfo*)info)->Error) {
+    free(((cmLoadedCommandInfo*)info)->Error);
+  }
+  ((cmLoadedCommandInfo*)info)->Error = strdup(err);
 }
 
-unsigned int CCONV  cmGetCacheMajorVersion(void *arg)
+unsigned int CCONV cmGetCacheMajorVersion(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
-  cmState *state = mf->GetState();
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmState* state = mf->GetState();
   return state->GetCacheMajorVersion();
 }
-unsigned int CCONV cmGetCacheMinorVersion(void *arg)
+unsigned int CCONV cmGetCacheMinorVersion(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
-  cmState *state = mf->GetState();
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  cmState* state = mf->GetState();
   return state->GetCacheMinorVersion();
 }
 
-unsigned int CCONV cmGetMajorVersion(void *)
+unsigned int CCONV cmGetMajorVersion(void*)
 {
   return cmVersion::GetMajorVersion();
 }
 
-unsigned int CCONV cmGetMinorVersion(void *)
+unsigned int CCONV cmGetMinorVersion(void*)
 {
   return cmVersion::GetMinorVersion();
 }
 
-void CCONV cmAddDefinition(void *arg, const char* name, const char* value)
+void CCONV cmAddDefinition(void* arg, const char* name, const char* value)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
-  mf->AddDefinition(name,value);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->AddDefinition(name, value);
 }
 
 /* Add a definition to this makefile and the global cmake cache. */
-void CCONV cmAddCacheDefinition(void *arg, const char* name,
-  const char* value, const char* doc, int type)
+void CCONV cmAddCacheDefinition(void* arg, const char* name, const char* value,
+                                const char* doc, int type)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
 
-  switch (type)
-    {
+  switch (type) {
     case CM_CACHE_BOOL:
-      mf->AddCacheDefinition(name,value,doc,
-                             cmState::BOOL);
+      mf->AddCacheDefinition(name, value, doc, cmState::BOOL);
       break;
     case CM_CACHE_PATH:
-      mf->AddCacheDefinition(name,value,doc,
-                             cmState::PATH);
+      mf->AddCacheDefinition(name, value, doc, cmState::PATH);
       break;
     case CM_CACHE_FILEPATH:
-      mf->AddCacheDefinition(name,value,doc,
-                             cmState::FILEPATH);
+      mf->AddCacheDefinition(name, value, doc, cmState::FILEPATH);
       break;
     case CM_CACHE_STRING:
-      mf->AddCacheDefinition(name,value,doc,
-                             cmState::STRING);
+      mf->AddCacheDefinition(name, value, doc, cmState::STRING);
       break;
     case CM_CACHE_INTERNAL:
-      mf->AddCacheDefinition(name,value,doc,
-                             cmState::INTERNAL);
+      mf->AddCacheDefinition(name, value, doc, cmState::INTERNAL);
       break;
     case CM_CACHE_STATIC:
-      mf->AddCacheDefinition(name,value,doc,
-                             cmState::STATIC);
+      mf->AddCacheDefinition(name, value, doc, cmState::STATIC);
       break;
-    }
+  }
 }
 
-const char* CCONV cmGetProjectName(void *arg)
+const char* CCONV cmGetProjectName(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   static std::string name;
   name = mf->GetStateSnapshot().GetProjectName();
   return name.c_str();
 }
 
-const char* CCONV cmGetHomeDirectory(void *arg)
+const char* CCONV cmGetHomeDirectory(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetHomeDirectory();
 }
-const char* CCONV cmGetHomeOutputDirectory(void *arg)
+const char* CCONV cmGetHomeOutputDirectory(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetHomeOutputDirectory();
 }
-const char* CCONV cmGetStartDirectory(void *arg)
+const char* CCONV cmGetStartDirectory(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetCurrentSourceDirectory();
 }
-const char* CCONV cmGetStartOutputDirectory(void *arg)
+const char* CCONV cmGetStartOutputDirectory(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetCurrentBinaryDirectory();
 }
-const char* CCONV cmGetCurrentDirectory(void *arg)
+const char* CCONV cmGetCurrentDirectory(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetCurrentSourceDirectory();
 }
-const char* CCONV cmGetCurrentOutputDirectory(void *arg)
+const char* CCONV cmGetCurrentOutputDirectory(void* arg)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetCurrentBinaryDirectory();
 }
-const char* CCONV cmGetDefinition(void *arg,const char*def)
+const char* CCONV cmGetDefinition(void* arg, const char* def)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return mf->GetDefinition(def);
 }
 
-int CCONV cmIsOn(void *arg, const char* name)
+int CCONV cmIsOn(void* arg, const char* name)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return static_cast<int>(mf->IsOn(name));
 }
 
 /** Check if a command exists. */
-int CCONV cmCommandExists(void *arg, const char* name)
+int CCONV cmCommandExists(void* arg, const char* name)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   return static_cast<int>(mf->GetState()->GetCommand(name) ? 1 : 0);
 }
 
-void CCONV cmAddDefineFlag(void *arg, const char* definition)
+void CCONV cmAddDefineFlag(void* arg, const char* definition)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   mf->AddDefineFlag(definition);
 }
 
-void CCONV cmAddLinkDirectoryForTarget(void *arg, const char *tgt,
-  const char* d)
+void CCONV cmAddLinkDirectoryForTarget(void* arg, const char* tgt,
+                                       const char* d)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
-  mf->AddLinkDirectoryForTarget(tgt,d);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->AddLinkDirectoryForTarget(tgt, d);
 }
 
-
-void CCONV cmAddExecutable(void *arg, const char *exename,
-                     int numSrcs, const char **srcs, int win32)
+void CCONV cmAddExecutable(void* arg, const char* exename, int numSrcs,
+                           const char** srcs, int win32)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   std::vector<std::string> srcs2;
   int i;
-  for (i = 0; i < numSrcs; ++i)
-    {
+  for (i = 0; i < numSrcs; ++i) {
     srcs2.push_back(srcs[i]);
-    }
- cmTarget* tg =  mf->AddExecutable(exename, srcs2);
- if ( win32 )
-   {
-   tg->SetProperty("WIN32_EXECUTABLE", "ON");
-   }
-}
-
-void CCONV cmAddUtilityCommand(void *arg, const char* utilityName,
-                         const char* command,
-                         const char* arguments,
-                         int all,
-                         int numDepends,
-                         const char **depends,
-                         int,
-                         const char **)
+  }
+  cmTarget* tg = mf->AddExecutable(exename, srcs2);
+  if (win32) {
+    tg->SetProperty("WIN32_EXECUTABLE", "ON");
+  }
+}
+
+void CCONV cmAddUtilityCommand(void* arg, const char* utilityName,
+                               const char* command, const char* arguments,
+                               int all, int numDepends, const char** depends,
+                               int, const char**)
 {
   // Get the makefile instance.  Perform an extra variable expansion
   // now because the API caller expects it.
@@ -218,33 +202,30 @@ void CCONV cmAddUtilityCommand(void *arg, const char* utilityName,
   cmCustomCommandLine commandLine;
   std::string expand = command;
   commandLine.push_back(mf->ExpandVariablesInString(expand));
-  if(arguments && arguments[0])
-    {
+  if (arguments && arguments[0]) {
     // TODO: Parse arguments!
     expand = arguments;
     commandLine.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
 
   // Accumulate the list of dependencies.
   std::vector<std::string> depends2;
-  for(int i = 0; i < numDepends; ++i)
-    {
+  for (int i = 0; i < numDepends; ++i) {
     expand = depends[i];
     depends2.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
 
   // Pass the call to the makefile instance.
-  mf->AddUtilityCommand(utilityName, (all ? false : true),
-                        0, depends2, commandLines);
+  mf->AddUtilityCommand(utilityName, (all ? false : true), 0, depends2,
+                        commandLines);
 }
-void CCONV cmAddCustomCommand(void *arg, const char* source,
-                        const char* command,
-                        int numArgs, const char **args,
-                        int numDepends, const char **depends,
-                        int numOutputs, const char **outputs,
-                        const char *target)
+void CCONV cmAddCustomCommand(void* arg, const char* source,
+                              const char* command, int numArgs,
+                              const char** args, int numDepends,
+                              const char** depends, int numOutputs,
+                              const char** outputs, const char* target)
 {
   // Get the makefile instance.  Perform an extra variable expansion
   // now because the API caller expects it.
@@ -254,29 +235,26 @@ void CCONV cmAddCustomCommand(void *arg, const char* source,
   cmCustomCommandLine commandLine;
   std::string expand = command;
   commandLine.push_back(mf->ExpandVariablesInString(expand));
-  for(int i=0; i < numArgs; ++i)
-    {
+  for (int i = 0; i < numArgs; ++i) {
     expand = args[i];
     commandLine.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
 
   // Accumulate the list of dependencies.
   std::vector<std::string> depends2;
-  for(int i = 0; i < numDepends; ++i)
-    {
+  for (int i = 0; i < numDepends; ++i) {
     expand = depends[i];
     depends2.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
 
   // Accumulate the list of outputs.
   std::vector<std::string> outputs2;
-  for(int i = 0; i < numOutputs; ++i)
-    {
+  for (int i = 0; i < numOutputs; ++i) {
     expand = outputs[i];
     outputs2.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
 
   // Pass the call to the makefile instance.
   const char* no_comment = 0;
@@ -284,11 +262,11 @@ void CCONV cmAddCustomCommand(void *arg, const char* source,
                                commandLines, no_comment);
 }
 
-void CCONV cmAddCustomCommandToOutput(void *arg, const char* output,
-                                const char* command,
-                                int numArgs, const char **args,
-                                const char* main_dependency,
-                                int numDepends, const char **depends)
+void CCONV cmAddCustomCommandToOutput(void* arg, const char* output,
+                                      const char* command, int numArgs,
+                                      const char** args,
+                                      const char* main_dependency,
+                                      int numDepends, const char** depends)
 {
   // Get the makefile instance.  Perform an extra variable expansion
   // now because the API caller expects it.
@@ -298,33 +276,30 @@ void CCONV cmAddCustomCommandToOutput(void *arg, const char* output,
   cmCustomCommandLine commandLine;
   std::string expand = command;
   commandLine.push_back(mf->ExpandVariablesInString(expand));
-  for(int i=0; i < numArgs; ++i)
-    {
+  for (int i = 0; i < numArgs; ++i) {
     expand = args[i];
     commandLine.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
 
   // Accumulate the list of dependencies.
   std::vector<std::string> depends2;
-  for(int i = 0; i < numDepends; ++i)
-    {
+  for (int i = 0; i < numDepends; ++i) {
     expand = depends[i];
     depends2.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
 
   // Pass the call to the makefile instance.
   const char* no_comment = 0;
   const char* no_working_dir = 0;
-  mf->AddCustomCommandToOutput(output, depends2, main_dependency,
-                               commandLines, no_comment, no_working_dir);
+  mf->AddCustomCommandToOutput(output, depends2, main_dependency, commandLines,
+                               no_comment, no_working_dir);
 }
 
-void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
-                                const char* command,
-                                int numArgs, const char **args,
-                                int commandType)
+void CCONV cmAddCustomCommandToTarget(void* arg, const char* target,
+                                      const char* command, int numArgs,
+                                      const char** args, int commandType)
 {
   // Get the makefile instance.
   cmMakefile* mf = static_cast<cmMakefile*>(arg);
@@ -334,18 +309,16 @@ void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
   cmCustomCommandLine commandLine;
   std::string expand = command;
   commandLine.push_back(mf->ExpandVariablesInString(expand));
-  for(int i=0; i < numArgs; ++i)
-    {
+  for (int i = 0; i < numArgs; ++i) {
     expand = args[i];
     commandLine.push_back(mf->ExpandVariablesInString(expand));
-    }
+  }
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
 
   // Select the command type.
   cmTarget::CustomCommandType cctype = cmTarget::POST_BUILD;
-  switch (commandType)
-    {
+  switch (commandType) {
     case CM_PRE_BUILD:
       cctype = cmTarget::PRE_BUILD;
       break;
@@ -355,7 +328,7 @@ void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
     case CM_POST_BUILD:
       cctype = cmTarget::POST_BUILD;
       break;
-    }
+  }
 
   // Pass the call to the makefile instance.
   std::vector<std::string> no_byproducts;
@@ -366,128 +339,112 @@ void CCONV cmAddCustomCommandToTarget(void *arg, const char* target,
                                cctype, no_comment, no_working_dir);
 }
 
-void CCONV cmAddLinkLibraryForTarget(void *arg, const char *tgt,
-  const char*value, int libtype)
+void CCONV cmAddLinkLibraryForTarget(void* arg, const char* tgt,
+                                     const char* value, int libtype)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
 
-  switch (libtype)
-    {
+  switch (libtype) {
     case CM_LIBRARY_GENERAL:
-      mf->AddLinkLibraryForTarget(tgt,value, GENERAL_LibraryType);
+      mf->AddLinkLibraryForTarget(tgt, value, GENERAL_LibraryType);
       break;
     case CM_LIBRARY_DEBUG:
-      mf->AddLinkLibraryForTarget(tgt,value, DEBUG_LibraryType);
+      mf->AddLinkLibraryForTarget(tgt, value, DEBUG_LibraryType);
       break;
     case CM_LIBRARY_OPTIMIZED:
-      mf->AddLinkLibraryForTarget(tgt,value, OPTIMIZED_LibraryType);
+      mf->AddLinkLibraryForTarget(tgt, value, OPTIMIZED_LibraryType);
       break;
-    }
+  }
 }
 
-void CCONV cmAddLibrary(void *arg, const char *libname, int shared,
-                  int numSrcs, const char **srcs)
+void CCONV cmAddLibrary(void* arg, const char* libname, int shared,
+                        int numSrcs, const char** srcs)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   std::vector<std::string> srcs2;
   int i;
-  for (i = 0; i < numSrcs; ++i)
-    {
+  for (i = 0; i < numSrcs; ++i) {
     srcs2.push_back(srcs[i]);
-    }
+  }
   mf->AddLibrary(libname,
-                 (shared? cmState::SHARED_LIBRARY : cmState::STATIC_LIBRARY),
-                  srcs2);
+                 (shared ? cmState::SHARED_LIBRARY : cmState::STATIC_LIBRARY),
+                 srcs2);
 }
 
-char CCONV *cmExpandVariablesInString(void *arg, const char *source,
-                                int escapeQuotes, int atOnly)
+char CCONV* cmExpandVariablesInString(void* arg, const char* source,
+                                      int escapeQuotes, int atOnly)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   std::string barf = source;
-  std::string result =
-    mf->ExpandVariablesInString(barf,
-                                (escapeQuotes ? true : false),
-                                (atOnly ? true : false));
-  char *res = static_cast<char *>(malloc(result.size() + 1));
-  if (result.size())
-    {
-    strcpy(res,result.c_str());
-    }
+  std::string result = mf->ExpandVariablesInString(
+    barf, (escapeQuotes ? true : false), (atOnly ? true : false));
+  char* res = static_cast<char*>(malloc(result.size() + 1));
+  if (result.size()) {
+    strcpy(res, result.c_str());
+  }
   res[result.size()] = '\0';
   return res;
 }
 
-
-int CCONV cmExecuteCommand(void *arg, const char *name,
-                     int numArgs, const char **args)
+int CCONV cmExecuteCommand(void* arg, const char* name, int numArgs,
+                           const char** args)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   cmListFileFunction lff;
   lff.Name = name;
-  for(int i = 0; i < numArgs; ++i)
-    {
+  for (int i = 0; i < numArgs; ++i) {
     // Assume all arguments are quoted.
     lff.Arguments.push_back(
       cmListFileArgument(args[i], cmListFileArgument::Quoted, 0));
-    }
+  }
   cmExecutionStatus status;
-  return mf->ExecuteCommand(lff,status);
+  return mf->ExecuteCommand(lff, status);
 }
 
-void CCONV cmExpandSourceListArguments(void *arg,
-                                 int numArgs,
-                                 const char **args,
-                                 int *resArgc,
-                                 char ***resArgv,
-                                 unsigned int startArgumentIndex)
+void CCONV cmExpandSourceListArguments(void* arg, int numArgs,
+                                       const char** args, int* resArgc,
+                                       char*** resArgv,
+                                       unsigned int startArgumentIndex)
 {
   (void)arg;
   (void)startArgumentIndex;
   std::vector<std::string> result;
   int i;
-  for (i = 0; i < numArgs; ++i)
-    {
+  for (i = 0; i < numArgs; ++i) {
     result.push_back(args[i]);
-    }
+  }
   int resargc = static_cast<int>(result.size());
-  char **resargv = 0;
-  if (resargc)
-    {
-    resargv = (char **)malloc(resargc*sizeof(char *));
-    }
-  for (i = 0; i < resargc; ++i)
-    {
+  char** resargv = 0;
+  if (resargc) {
+    resargv = (char**)malloc(resargc * sizeof(char*));
+  }
+  for (i = 0; i < resargc; ++i) {
     resargv[i] = strdup(result[i].c_str());
-    }
+  }
   *resArgc = resargc;
   *resArgv = resargv;
 }
 
-void CCONV cmFreeArguments(int argc, char **argv)
+void CCONV cmFreeArguments(int argc, char** argv)
 {
   int i;
-  for (i = 0; i < argc; ++i)
-    {
+  for (i = 0; i < argc; ++i) {
     free(argv[i]);
-    }
-  if (argv)
-    {
+  }
+  if (argv) {
     free(argv);
-    }
+  }
 }
 
-int CCONV cmGetTotalArgumentSize(int argc, char **argv)
+int CCONV cmGetTotalArgumentSize(int argc, char** argv)
 {
   int i;
   int result = 0;
-  for (i = 0; i < argc; ++i)
-    {
-    if (argv[i])
-      {
+  for (i = 0; i < argc; ++i) {
+    if (argv[i]) {
       result = result + static_cast<int>(strlen(argv[i]));
-      }
     }
+  }
   return result;
 }
 
@@ -495,7 +452,10 @@ int CCONV cmGetTotalArgumentSize(int argc, char **argv)
 // API for source files.
 struct cmCPluginAPISourceFile
 {
-  cmCPluginAPISourceFile(): RealSourceFile(0) {}
+  cmCPluginAPISourceFile()
+    : RealSourceFile(0)
+  {
+  }
   cmSourceFile* RealSourceFile;
   std::string SourceName;
   std::string SourceExtension;
@@ -506,54 +466,50 @@ struct cmCPluginAPISourceFile
 
 // Keep a map from real cmSourceFile instances stored in a makefile to
 // the CPluginAPI proxy source file.
-class cmCPluginAPISourceFileMap:
-  public std::map<cmSourceFile*, cmCPluginAPISourceFile*>
+class cmCPluginAPISourceFileMap
+  : public std::map<cmSourceFile*, cmCPluginAPISourceFile*>
 {
 public:
   typedef std::map<cmSourceFile*, cmCPluginAPISourceFile*> derived;
   typedef derived::iterator iterator;
   typedef derived::value_type value_type;
   ~cmCPluginAPISourceFileMap()
-    {
-    for(iterator i=this->begin(); i != this->end(); ++i)
-      {
+  {
+    for (iterator i = this->begin(); i != this->end(); ++i) {
       delete i->second;
-      }
     }
+  }
 };
 cmCPluginAPISourceFileMap cmCPluginAPISourceFiles;
 
-void * CCONV cmCreateSourceFile(void)
+void* CCONV cmCreateSourceFile(void)
 {
   return (void*)new cmCPluginAPISourceFile;
 }
 
-void * CCONV cmCreateNewSourceFile(void *)
+void* CCONV cmCreateNewSourceFile(void*)
 {
-  cmCPluginAPISourceFile *sf = new cmCPluginAPISourceFile;
+  cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
   return (void*)sf;
 }
 
-void CCONV cmDestroySourceFile(void *arg)
+void CCONV cmDestroySourceFile(void* arg)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
   // Only delete if it was created by cmCreateSourceFile or
   // cmCreateNewSourceFile and is therefore not in the map.
-  if(!sf->RealSourceFile)
-    {
+  if (!sf->RealSourceFile) {
     delete sf;
-    }
+  }
 }
 
-void CCONV *cmGetSource(void *arg, const char *name)
+void CCONV* cmGetSource(void* arg, const char* name)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
-  if(cmSourceFile* rsf = mf->GetSource(name))
-    {
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  if (cmSourceFile* rsf = mf->GetSource(name)) {
     // Lookup the proxy source file object for this source.
     cmCPluginAPISourceFileMap::iterator i = cmCPluginAPISourceFiles.find(rsf);
-    if(i == cmCPluginAPISourceFiles.end())
-      {
+    if (i == cmCPluginAPISourceFiles.end()) {
       // Create a proxy source file object for this source.
       cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
       sf->RealSourceFile = rsf;
@@ -566,32 +522,28 @@ void CCONV *cmGetSource(void *arg, const char *name)
       // Store the proxy in the map so it can be re-used and deleted later.
       cmCPluginAPISourceFileMap::value_type entry(rsf, sf);
       i = cmCPluginAPISourceFiles.insert(entry).first;
-      }
-    return (void *)i->second;
     }
-  else
-    {
+    return (void*)i->second;
+  } else {
     return 0;
-    }
+  }
 }
 
-void * CCONV cmAddSource(void *arg, void *arg2)
+void* CCONV cmAddSource(void* arg, void* arg2)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   cmCPluginAPISourceFile* osf = static_cast<cmCPluginAPISourceFile*>(arg2);
-  if(osf->FullPath.empty())
-    {
+  if (osf->FullPath.empty()) {
     return 0;
-    }
+  }
 
   // Create the real cmSourceFile instance and copy over saved information.
   cmSourceFile* rsf = mf->GetOrCreateSource(osf->FullPath);
   rsf->GetProperties() = osf->Properties;
-  for(std::vector<std::string>::iterator i = osf->Depends.begin();
-      i != osf->Depends.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = osf->Depends.begin();
+       i != osf->Depends.end(); ++i) {
     rsf->AddDepend(i->c_str());
-    }
+  }
 
   // Create the proxy for the real source file.
   cmCPluginAPISourceFile* sf = new cmCPluginAPISourceFile;
@@ -602,103 +554,89 @@ void * CCONV cmAddSource(void *arg, void *arg2)
 
   // Store the proxy in the map so it can be re-used and deleted later.
   cmCPluginAPISourceFiles[rsf] = sf;
-  return (void *)sf;
+  return (void*)sf;
 }
 
-const char * CCONV cmSourceFileGetSourceName(void *arg)
+const char* CCONV cmSourceFileGetSourceName(void* arg)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
   return sf->SourceName.c_str();
 }
 
-const char * CCONV  cmSourceFileGetFullPath(void *arg)
+const char* CCONV cmSourceFileGetFullPath(void* arg)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
   return sf->FullPath.c_str();
 }
 
-const char * CCONV  cmSourceFileGetProperty(void *arg,const char *prop)
+const char* CCONV cmSourceFileGetProperty(void* arg, const char* prop)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
-  if(cmSourceFile* rsf = sf->RealSourceFile)
-    {
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
     return rsf->GetProperty(prop);
-    }
-  else
-    {
-    if(!strcmp(prop,"LOCATION"))
-      {
+  } else {
+    if (!strcmp(prop, "LOCATION")) {
       return sf->FullPath.c_str();
-      }
-    return sf->Properties.GetPropertyValue(prop);
     }
+    return sf->Properties.GetPropertyValue(prop);
+  }
 }
 
-int CCONV cmSourceFileGetPropertyAsBool(void *arg,const char *prop)
+int CCONV cmSourceFileGetPropertyAsBool(void* arg, const char* prop)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
-  if(cmSourceFile* rsf = sf->RealSourceFile)
-    {
-    return rsf->GetPropertyAsBool(prop) ? 1:0;
-    }
-  else
-    {
-    return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop))? 1:0;
-    }
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
+    return rsf->GetPropertyAsBool(prop) ? 1 : 0;
+  } else {
+    return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop)) ? 1 : 0;
+  }
 }
 
-void CCONV cmSourceFileSetProperty(void *arg,const char *prop,
-                                   const char *value)
+void CCONV cmSourceFileSetProperty(void* arg, const char* prop,
+                                   const char* value)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
-  if(cmSourceFile* rsf = sf->RealSourceFile)
-    {
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
     rsf->SetProperty(prop, value);
+  } else if (prop) {
+    if (!value) {
+      value = "NOTFOUND";
     }
-  else if(prop)
-    {
-    if(!value) { value = "NOTFOUND"; }
     sf->Properties.SetProperty(prop, value);
-    }
+  }
 }
 
-void CCONV cmSourceFileAddDepend(void *arg, const char *depend)
+void CCONV cmSourceFileAddDepend(void* arg, const char* depend)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
-  if(cmSourceFile* rsf = sf->RealSourceFile)
-    {
+  if (cmSourceFile* rsf = sf->RealSourceFile) {
     rsf->AddDepend(depend);
-    }
-  else
-    {
+  } else {
     sf->Depends.push_back(depend);
-    }
+  }
 }
 
-void CCONV cmSourceFileSetName(void *arg, const char* name, const char* dir,
+void CCONV cmSourceFileSetName(void* arg, const char* name, const char* dir,
                                int numSourceExtensions,
-                               const char **sourceExtensions,
+                               const char** sourceExtensions,
                                int numHeaderExtensions,
-                               const char **headerExtensions)
+                               const char** headerExtensions)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
-  if(sf->RealSourceFile)
-    {
+  if (sf->RealSourceFile) {
     // SetName is allowed only on temporary source files created by
     // the command for building and passing to AddSource.
     return;
-    }
+  }
   std::vector<std::string> sourceExts;
   std::vector<std::string> headerExts;
   int i;
-  for (i = 0; i < numSourceExtensions; ++i)
-    {
+  for (i = 0; i < numSourceExtensions; ++i) {
     sourceExts.push_back(sourceExtensions[i]);
-    }
-  for (i = 0; i < numHeaderExtensions; ++i)
-    {
+  }
+  for (i = 0; i < numHeaderExtensions; ++i) {
     headerExts.push_back(headerExtensions[i]);
-    }
+  }
 
   // Save the original name given.
   sf->SourceName = name;
@@ -710,167 +648,150 @@ void CCONV cmSourceFileSetName(void *arg, const char* name, const char* dir,
   // First try and see whether the listed file can be found
   // as is without extensions added on.
   std::string hname = pathname;
-  if(cmSystemTools::FileExists(hname.c_str()))
-    {
+  if (cmSystemTools::FileExists(hname.c_str())) {
     sf->SourceName = cmSystemTools::GetFilenamePath(name);
-    if ( sf->SourceName.size() > 0 )
-      {
+    if (sf->SourceName.size() > 0) {
       sf->SourceName += "/";
-      }
+    }
     sf->SourceName += cmSystemTools::GetFilenameWithoutLastExtension(name);
     std::string::size_type pos = hname.rfind('.');
-    if(pos != std::string::npos)
-      {
-      sf->SourceExtension = hname.substr(pos+1, hname.size()-pos);
-      if ( cmSystemTools::FileIsFullPath(name) )
-        {
+    if (pos != std::string::npos) {
+      sf->SourceExtension = hname.substr(pos + 1, hname.size() - pos);
+      if (cmSystemTools::FileIsFullPath(name)) {
         std::string::size_type pos2 = hname.rfind('/');
-        if(pos2 != std::string::npos)
-          {
-          sf->SourceName = hname.substr(pos2+1, pos - pos2-1);
-          }
+        if (pos2 != std::string::npos) {
+          sf->SourceName = hname.substr(pos2 + 1, pos - pos2 - 1);
         }
       }
+    }
 
     sf->FullPath = hname;
     return;
-    }
+  }
 
   // Next, try the various source extensions
-  for( std::vector<std::string>::const_iterator ext = sourceExts.begin();
-       ext != sourceExts.end(); ++ext )
-    {
+  for (std::vector<std::string>::const_iterator ext = sourceExts.begin();
+       ext != sourceExts.end(); ++ext) {
     hname = pathname;
     hname += ".";
     hname += *ext;
-    if(cmSystemTools::FileExists(hname.c_str()))
-      {
+    if (cmSystemTools::FileExists(hname.c_str())) {
       sf->SourceExtension = *ext;
       sf->FullPath = hname;
       return;
-      }
     }
+  }
 
   // Finally, try the various header extensions
-  for( std::vector<std::string>::const_iterator ext = headerExts.begin();
-       ext != headerExts.end(); ++ext )
-    {
+  for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+       ext != headerExts.end(); ++ext) {
     hname = pathname;
     hname += ".";
     hname += *ext;
-    if(cmSystemTools::FileExists(hname.c_str()))
-      {
+    if (cmSystemTools::FileExists(hname.c_str())) {
       sf->SourceExtension = *ext;
       sf->FullPath = hname;
       return;
-      }
     }
+  }
 
   std::ostringstream e;
   e << "Cannot find source file \"" << pathname << "\"";
   e << "\n\nTried extensions";
-  for( std::vector<std::string>::const_iterator ext = sourceExts.begin();
-       ext != sourceExts.end(); ++ext )
-    {
+  for (std::vector<std::string>::const_iterator ext = sourceExts.begin();
+       ext != sourceExts.end(); ++ext) {
     e << " ." << *ext;
-    }
-  for( std::vector<std::string>::const_iterator ext = headerExts.begin();
-       ext != headerExts.end(); ++ext )
-    {
+  }
+  for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+       ext != headerExts.end(); ++ext) {
     e << " ." << *ext;
-    }
+  }
   cmSystemTools::Error(e.str().c_str());
   return;
 }
 
-void CCONV cmSourceFileSetName2(void *arg, const char* name, const char* dir,
-                                const char *ext, int headerFileOnly)
+void CCONV cmSourceFileSetName2(void* arg, const char* name, const char* dir,
+                                const char* ext, int headerFileOnly)
 {
   cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
-  if(sf->RealSourceFile)
-    {
+  if (sf->RealSourceFile) {
     // SetName is allowed only on temporary source files created by
     // the command for building and passing to AddSource.
     return;
-    }
+  }
 
   // Implement the old SetName method code here.
-  if(headerFileOnly)
-    {
+  if (headerFileOnly) {
     sf->Properties.SetProperty("HEADER_FILE_ONLY", "1");
-    }
+  }
   sf->SourceName = name;
   std::string fname = sf->SourceName;
-  if(ext && strlen(ext))
-    {
+  if (ext && strlen(ext)) {
     fname += ".";
     fname += ext;
-    }
+  }
   sf->FullPath = cmSystemTools::CollapseFullPath(fname.c_str(), dir);
   cmSystemTools::ConvertToUnixSlashes(sf->FullPath);
   sf->SourceExtension = ext;
 }
 
-char * CCONV cmGetFilenameWithoutExtension(const char *name)
+char* CCONV cmGetFilenameWithoutExtension(const char* name)
 {
   std::string sres = cmSystemTools::GetFilenameWithoutExtension(name);
-  char *result = (char *)malloc(sres.size()+1);
-  strcpy(result,sres.c_str());
+  char* result = (char*)malloc(sres.size() + 1);
+  strcpy(result, sres.c_str());
   return result;
 }
 
-char * CCONV cmGetFilenamePath(const char *name)
+char* CCONV cmGetFilenamePath(const char* name)
 {
   std::string sres = cmSystemTools::GetFilenamePath(name);
-  char *result = (char *)malloc(sres.size()+1);
-  strcpy(result,sres.c_str());
+  char* result = (char*)malloc(sres.size() + 1);
+  strcpy(result, sres.c_str());
   return result;
 }
 
-char * CCONV cmCapitalized(const char *name)
+char* CCONV cmCapitalized(const char* name)
 {
   std::string sres = cmSystemTools::Capitalized(name);
-  char *result = (char *)malloc(sres.size()+1);
-  strcpy(result,sres.c_str());
+  char* result = (char*)malloc(sres.size() + 1);
+  strcpy(result, sres.c_str());
   return result;
 }
 
-void CCONV cmCopyFileIfDifferent(const char *name1, const char *name2)
+void CCONV cmCopyFileIfDifferent(const char* name1, const char* name2)
 {
-  cmSystemTools::CopyFileIfDifferent(name1,name2);
+  cmSystemTools::CopyFileIfDifferent(name1, name2);
 }
 
-void CCONV cmRemoveFile(const char *name)
+void CCONV cmRemoveFile(const char* name)
 {
   cmSystemTools::RemoveFile(name);
 }
 
-void CCONV cmDisplayStatus(void *arg, const char* message)
+void CCONV cmDisplayStatus(void* arg, const char* message)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
   mf->DisplayStatus(message, -1);
 }
 
-void CCONV cmFree(void *data)
+void CCONV cmFree(void* data)
 {
   free(data);
 }
 
-void CCONV DefineSourceFileProperty (void *arg, const char *name,
-  const char *briefDocs,
-  const char *longDocs,
-  int chained)
+void CCONV DefineSourceFileProperty(void* arg, const char* name,
+                                    const char* briefDocs,
+                                    const char* longDocs, int chained)
 {
-  cmMakefile *mf = static_cast<cmMakefile *>(arg);
-  mf->GetState()->DefineProperty(name,cmProperty::SOURCE_FILE,
-                                         briefDocs, longDocs,
-                                         chained != 0);
+  cmMakefile* mf = static_cast<cmMakefile*>(arg);
+  mf->GetState()->DefineProperty(name, cmProperty::SOURCE_FILE, briefDocs,
+                                 longDocs, chained != 0);
 }
 
 } // close the extern "C" scope
 
-cmCAPI cmStaticCAPI =
-{
+cmCAPI cmStaticCAPI = {
   cmGetClientData,
   cmGetTotalArgumentSize,
   cmFreeArguments,
@@ -929,4 +850,3 @@ cmCAPI cmStaticCAPI =
   cmCreateNewSourceFile,
   DefineSourceFileProperty,
 };
-
diff --git a/Source/cmCPluginAPI.h b/Source/cmCPluginAPI.h
index 5c832c3..4d9a9a7 100644
--- a/Source/cmCPluginAPI.h
+++ b/Source/cmCPluginAPI.h
@@ -23,7 +23,7 @@
 #define CMAKE_VERSION_MAJOR 2
 #define CMAKE_VERSION_MINOR 5
 
-#ifdef  __cplusplus
+#ifdef __cplusplus
 extern "C" {
 #endif
 
@@ -46,141 +46,131 @@ typedef struct
   /* set/Get the ClientData in the cmLoadedCommandInfo structure, this is how
      information is passed from the InitialPass to FInalPass for commands
      that need a FinalPass and need information from the InitialPass */
-  void *(CCONV *GetClientData) (void *info);
+  void*(CCONV* GetClientData)(void* info);
   /* return the summed size in characters of all the arguments */
-  int   (CCONV *GetTotalArgumentSize) (int argc, char **argv);
+  int(CCONV* GetTotalArgumentSize)(int argc, char** argv);
   /* free all the memory associated with an argc, argv pair */
-  void  (CCONV *FreeArguments) (int argc, char **argv);
+  void(CCONV* FreeArguments)(int argc, char** argv);
   /* set/Get the ClientData in the cmLoadedCommandInfo structure, this is how
      information is passed from the InitialPass to FInalPass for commands
      that need a FinalPass and need information from the InitialPass */
-  void  (CCONV *SetClientData) (void *info, void *cd);
+  void(CCONV* SetClientData)(void* info, void* cd);
   /* when an error occurs, call this function to set the error string */
-  void  (CCONV *SetError) (void *info, const char *err);
+  void(CCONV* SetError)(void* info, const char* err);
 
   /*=========================================================================
   The following functions all directly map to methods in the cmMakefile
   class. See cmMakefile.h for descriptions of what each method does. All of
   these methods take the void * makefile pointer as their first argument.
   =========================================================================*/
-  void  (CCONV *AddCacheDefinition) (void *mf, const char* name,
-                               const char* value,
-                               const char* doc, int cachetype);
-  void  (CCONV *AddCustomCommand) (void *mf, const char* source,
-                             const char* command,
-                             int numArgs, const char **args,
-                             int numDepends, const char **depends,
-                             int numOutputs, const char **outputs,
-                             const char *target);
-  void  (CCONV *AddDefineFlag) (void *mf, const char* definition);
-  void  (CCONV *AddDefinition) (void *mf, const char* name,
-                                const char* value);
-  void  (CCONV *AddExecutable) (void *mf, const char *exename,
-                         int numSrcs, const char **srcs, int win32);
-  void  (CCONV *AddLibrary) (void *mf, const char *libname,
-                       int shared, int numSrcs, const char **srcs);
-  void  (CCONV *AddLinkDirectoryForTarget) (void *mf, const char *tgt,
-                                      const char* d);
-  void  (CCONV *AddLinkLibraryForTarget) (void *mf, const char *tgt,
-                                    const char *libname, int libtype);
-  void  (CCONV *AddUtilityCommand) (void *mf, const char* utilityName,
-                              const char *command, const char *arguments,
-                              int all, int numDepends, const char **depends,
-                              int numOutputs, const char **outputs);
-  int   (CCONV *CommandExists) (void *mf, const char* name);
-  int  (CCONV *ExecuteCommand) (void *mf, const char *name,
-                          int numArgs, const char **args);
-  void  (CCONV *ExpandSourceListArguments) (void *mf,int argc,
-                                      const char **argv,
-                                      int *resArgc, char ***resArgv,
-                                      unsigned int startArgumentIndex);
-  char *(CCONV *ExpandVariablesInString) (void *mf, const char *source,
-                                    int escapeQuotes, int atOnly);
-  unsigned int (CCONV *GetCacheMajorVersion) (void *mf);
-  unsigned int (CCONV *GetCacheMinorVersion) (void *mf);
-  const char*  (CCONV *GetCurrentDirectory) (void *mf);
-  const char*  (CCONV *GetCurrentOutputDirectory) (void *mf);
-  const char*  (CCONV *GetDefinition) (void *mf, const char *def);
-  const char*  (CCONV *GetHomeDirectory) (void *mf);
-  const char*  (CCONV *GetHomeOutputDirectory) (void *mf);
-  unsigned int (CCONV *GetMajorVersion) (void *mf);
-  unsigned int (CCONV *GetMinorVersion) (void *mf);
-  const char*  (CCONV *GetProjectName) (void *mf);
-  const char*  (CCONV *GetStartDirectory) (void *mf);
-  const char*  (CCONV *GetStartOutputDirectory) (void *mf);
-  int          (CCONV *IsOn) (void *mf, const char* name);
-
+  void(CCONV* AddCacheDefinition)(void* mf, const char* name,
+                                  const char* value, const char* doc,
+                                  int cachetype);
+  void(CCONV* AddCustomCommand)(void* mf, const char* source,
+                                const char* command, int numArgs,
+                                const char** args, int numDepends,
+                                const char** depends, int numOutputs,
+                                const char** outputs, const char* target);
+  void(CCONV* AddDefineFlag)(void* mf, const char* definition);
+  void(CCONV* AddDefinition)(void* mf, const char* name, const char* value);
+  void(CCONV* AddExecutable)(void* mf, const char* exename, int numSrcs,
+                             const char** srcs, int win32);
+  void(CCONV* AddLibrary)(void* mf, const char* libname, int shared,
+                          int numSrcs, const char** srcs);
+  void(CCONV* AddLinkDirectoryForTarget)(void* mf, const char* tgt,
+                                         const char* d);
+  void(CCONV* AddLinkLibraryForTarget)(void* mf, const char* tgt,
+                                       const char* libname, int libtype);
+  void(CCONV* AddUtilityCommand)(void* mf, const char* utilityName,
+                                 const char* command, const char* arguments,
+                                 int all, int numDepends, const char** depends,
+                                 int numOutputs, const char** outputs);
+  int(CCONV* CommandExists)(void* mf, const char* name);
+  int(CCONV* ExecuteCommand)(void* mf, const char* name, int numArgs,
+                             const char** args);
+  void(CCONV* ExpandSourceListArguments)(void* mf, int argc, const char** argv,
+                                         int* resArgc, char*** resArgv,
+                                         unsigned int startArgumentIndex);
+  char*(CCONV* ExpandVariablesInString)(void* mf, const char* source,
+                                        int escapeQuotes, int atOnly);
+  unsigned int(CCONV* GetCacheMajorVersion)(void* mf);
+  unsigned int(CCONV* GetCacheMinorVersion)(void* mf);
+  const char*(CCONV* GetCurrentDirectory)(void* mf);
+  const char*(CCONV* GetCurrentOutputDirectory)(void* mf);
+  const char*(CCONV* GetDefinition)(void* mf, const char* def);
+  const char*(CCONV* GetHomeDirectory)(void* mf);
+  const char*(CCONV* GetHomeOutputDirectory)(void* mf);
+  unsigned int(CCONV* GetMajorVersion)(void* mf);
+  unsigned int(CCONV* GetMinorVersion)(void* mf);
+  const char*(CCONV* GetProjectName)(void* mf);
+  const char*(CCONV* GetStartDirectory)(void* mf);
+  const char*(CCONV* GetStartOutputDirectory)(void* mf);
+  int(CCONV* IsOn)(void* mf, const char* name);
 
   /*=========================================================================
   The following functions are designed to operate or manipulate
   cmSourceFiles. Please see cmSourceFile.h for additional information on many
   of these methods. Some of these methods are in cmMakefile.h.
   =========================================================================*/
-  void *(CCONV *AddSource) (void *mf, void *sf);
-  void *(CCONV *CreateSourceFile) ();
-  void  (CCONV *DestroySourceFile) (void *sf);
-  void *(CCONV *GetSource) (void *mf, const char* sourceName);
-  void  (CCONV *SourceFileAddDepend) (void *sf, const char *depend);
-  const char *(CCONV *SourceFileGetProperty) (void *sf, const char *prop);
-  int   (CCONV *SourceFileGetPropertyAsBool) (void *sf, const char *prop);
-  const char *(CCONV *SourceFileGetSourceName) (void *sf);
-  const char *(CCONV *SourceFileGetFullPath) (void *sf);
-  void  (CCONV *SourceFileSetName) (void *sf, const char* name,
-                             const char* dir,
-                             int numSourceExtensions,
-                             const char **sourceExtensions,
-                             int numHeaderExtensions,
-                             const char **headerExtensions);
-  void  (CCONV *SourceFileSetName2) (void *sf, const char* name,
-                               const char* dir,
-                               const char *ext, int headerFileOnly);
-  void  (CCONV *SourceFileSetProperty) (void *sf, const char *prop,
-                                  const char *value);
-
+  void*(CCONV* AddSource)(void* mf, void* sf);
+  void*(CCONV* CreateSourceFile)();
+  void(CCONV* DestroySourceFile)(void* sf);
+  void*(CCONV* GetSource)(void* mf, const char* sourceName);
+  void(CCONV* SourceFileAddDepend)(void* sf, const char* depend);
+  const char*(CCONV* SourceFileGetProperty)(void* sf, const char* prop);
+  int(CCONV* SourceFileGetPropertyAsBool)(void* sf, const char* prop);
+  const char*(CCONV* SourceFileGetSourceName)(void* sf);
+  const char*(CCONV* SourceFileGetFullPath)(void* sf);
+  void(CCONV* SourceFileSetName)(void* sf, const char* name, const char* dir,
+                                 int numSourceExtensions,
+                                 const char** sourceExtensions,
+                                 int numHeaderExtensions,
+                                 const char** headerExtensions);
+  void(CCONV* SourceFileSetName2)(void* sf, const char* name, const char* dir,
+                                  const char* ext, int headerFileOnly);
+  void(CCONV* SourceFileSetProperty)(void* sf, const char* prop,
+                                     const char* value);
 
   /*=========================================================================
   The following methods are from cmSystemTools.h see that file for specific
   documentation on each method.
   =========================================================================*/
-  char  *(CCONV *Capitalized)(const char *);
-  void   (CCONV *CopyFileIfDifferent)(const char *f1, const char *f2);
-  char  *(CCONV *GetFilenameWithoutExtension)(const char *);
-  char  *(CCONV *GetFilenamePath)(const char *);
-  void   (CCONV *RemoveFile)(const char *f1);
-  void   (CCONV *Free)(void *);
+  char*(CCONV* Capitalized)(const char*);
+  void(CCONV* CopyFileIfDifferent)(const char* f1, const char* f2);
+  char*(CCONV* GetFilenameWithoutExtension)(const char*);
+  char*(CCONV* GetFilenamePath)(const char*);
+  void(CCONV* RemoveFile)(const char* f1);
+  void(CCONV* Free)(void*);
 
   /*=========================================================================
     The following are new functions added after 1.6
   =========================================================================*/
-  void  (CCONV *AddCustomCommandToOutput) (void *mf, const char* output,
-                                     const char* command,
-                                     int numArgs, const char **args,
-                                     const char* main_dependency,
-                                     int numDepends, const char **depends);
-  void  (CCONV *AddCustomCommandToTarget) (void *mf, const char* target,
-                                     const char* command,
-                                     int numArgs, const char **args,
-                                     int commandType);
+  void(CCONV* AddCustomCommandToOutput)(void* mf, const char* output,
+                                        const char* command, int numArgs,
+                                        const char** args,
+                                        const char* main_dependency,
+                                        int numDepends, const char** depends);
+  void(CCONV* AddCustomCommandToTarget)(void* mf, const char* target,
+                                        const char* command, int numArgs,
+                                        const char** args, int commandType);
 
   /* display status information */
-  void  (CCONV *DisplaySatus) (void *info, const char *message);
+  void(CCONV* DisplaySatus)(void* info, const char* message);
 
   /* new functions added after 2.4 */
-  void *(CCONV *CreateNewSourceFile) (void *mf);
-  void (CCONV *DefineSourceFileProperty) (void *mf, const char *name,
-                                          const char *briefDocs,
-                                          const char *longDocs,
-                                          int chained);
+  void*(CCONV* CreateNewSourceFile)(void* mf);
+  void(CCONV* DefineSourceFileProperty)(void* mf, const char* name,
+                                        const char* briefDocs,
+                                        const char* longDocs, int chained);
 
   /* this is the end of the C function stub API structure */
 } cmCAPI;
 
-
 /*=========================================================================
 CM_PLUGIN_EXPORT should be used by plugins
 =========================================================================*/
 #ifdef _WIN32
-#define CM_PLUGIN_EXPORT  __declspec( dllexport )
+#define CM_PLUGIN_EXPORT __declspec(dllexport)
 #else
 #define CM_PLUGIN_EXPORT
 #endif
@@ -206,37 +196,38 @@ define the different types of compiles a library may be
 /*=========================================================================
 define the different types of custom commands for a target
 =========================================================================*/
-#define CM_PRE_BUILD  0
-#define CM_PRE_LINK   1
+#define CM_PRE_BUILD 0
+#define CM_PRE_LINK 1
 #define CM_POST_BUILD 2
 
 /*=========================================================================
 Finally we define the key data structures and function prototypes
 =========================================================================*/
-  typedef const char* (CCONV *CM_DOC_FUNCTION)();
-  typedef int (CCONV *CM_INITIAL_PASS_FUNCTION)(void *info, void *mf,
-                                          int argc, char *[]);
-  typedef void (CCONV *CM_FINAL_PASS_FUNCTION)(void *info, void *mf);
-  typedef void (CCONV *CM_DESTRUCTOR_FUNCTION)(void *info);
-
-  typedef struct {
-    unsigned long reserved1; /* Reserved for future use.  DO NOT USE.  */
-    unsigned long reserved2; /* Reserved for future use.  DO NOT USE.  */
-    cmCAPI *CAPI;
-    int m_Inherited; /* this ivar is no longer used in CMake 2.2 or later */
-    CM_INITIAL_PASS_FUNCTION InitialPass;
-    CM_FINAL_PASS_FUNCTION FinalPass;
-    CM_DESTRUCTOR_FUNCTION Destructor;
-    CM_DOC_FUNCTION GetTerseDocumentation;
-    CM_DOC_FUNCTION GetFullDocumentation;
-    const char *Name;
-    char *Error;
-    void *ClientData;
-  } cmLoadedCommandInfo;
-
-  typedef void (CCONV *CM_INIT_FUNCTION)(cmLoadedCommandInfo *);
-
-#ifdef  __cplusplus
+typedef const char*(CCONV* CM_DOC_FUNCTION)();
+typedef int(CCONV* CM_INITIAL_PASS_FUNCTION)(void* info, void* mf, int argc,
+                                             char* []);
+typedef void(CCONV* CM_FINAL_PASS_FUNCTION)(void* info, void* mf);
+typedef void(CCONV* CM_DESTRUCTOR_FUNCTION)(void* info);
+
+typedef struct
+{
+  unsigned long reserved1; /* Reserved for future use.  DO NOT USE.  */
+  unsigned long reserved2; /* Reserved for future use.  DO NOT USE.  */
+  cmCAPI* CAPI;
+  int m_Inherited; /* this ivar is no longer used in CMake 2.2 or later */
+  CM_INITIAL_PASS_FUNCTION InitialPass;
+  CM_FINAL_PASS_FUNCTION FinalPass;
+  CM_DESTRUCTOR_FUNCTION Destructor;
+  CM_DOC_FUNCTION GetTerseDocumentation;
+  CM_DOC_FUNCTION GetFullDocumentation;
+  const char* Name;
+  char* Error;
+  void* ClientData;
+} cmLoadedCommandInfo;
+
+typedef void(CCONV* CM_INIT_FUNCTION)(cmLoadedCommandInfo*);
+
+#ifdef __cplusplus
 }
 #endif
 
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index a189430..7e5d966 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -57,15 +57,17 @@
 #include <cmsys/Base64.h>
 
 #if defined(__BEOS__) || defined(__HAIKU__)
-#include <be/kernel/OS.h>   /* disable_debugger() API. */
+#include <be/kernel/OS.h> /* disable_debugger() API. */
 #endif
 
+#define DEBUGOUT                                                              \
+  std::cout << __LINE__ << " ";                                               \
+  std::cout
+#define DEBUGERR                                                              \
+  std::cerr << __LINE__ << " ";                                               \
+  std::cerr
 
-#define DEBUGOUT std::cout << __LINE__ << " "; std::cout
-#define DEBUGERR std::cerr << __LINE__ << " "; std::cerr
-
-struct tm* cmCTest::GetNightlyTime(std::string str,
-                                   bool tomorrowtag)
+struct tm* cmCTest::GetNightlyTime(std::string str, bool tomorrowtag)
 {
   struct tm* lctime;
   time_t tctime = time(0);
@@ -73,19 +75,17 @@ struct tm* cmCTest::GetNightlyTime(std::string str,
   char buf[1024];
   // add todays year day and month to the time in str because
   // curl_getdate no longer assumes the day is today
-  sprintf(buf, "%d%02d%02d %s",
-          lctime->tm_year+1900,
-          lctime->tm_mon +1,
-          lctime->tm_mday,
-          str.c_str());
-  cmCTestLog(this, OUTPUT, "Determine Nightly Start Time" << std::endl
-    << "   Specified time: " << str << std::endl);
-  //Convert the nightly start time to seconds. Since we are
-  //providing only a time and a timezone, the current date of
-  //the local machine is assumed. Consequently, nightlySeconds
-  //is the time at which the nightly dashboard was opened or
-  //will be opened on the date of the current client machine.
-  //As such, this time may be in the past or in the future.
+  sprintf(buf, "%d%02d%02d %s", lctime->tm_year + 1900, lctime->tm_mon + 1,
+          lctime->tm_mday, str.c_str());
+  cmCTestLog(this, OUTPUT, "Determine Nightly Start Time"
+               << std::endl
+               << "   Specified time: " << str << std::endl);
+  // Convert the nightly start time to seconds. Since we are
+  // providing only a time and a timezone, the current date of
+  // the local machine is assumed. Consequently, nightlySeconds
+  // is the time at which the nightly dashboard was opened or
+  // will be opened on the date of the current client machine.
+  // As such, this time may be in the past or in the future.
   time_t ntime = curl_getdate(buf, &tctime);
   cmCTestLog(this, DEBUG, "   Get curl time: " << ntime << std::endl);
   tctime = time(0);
@@ -93,8 +93,7 @@ struct tm* cmCTest::GetNightlyTime(std::string str,
 
   const int dayLength = 24 * 60 * 60;
   cmCTestLog(this, DEBUG, "Seconds: " << tctime << std::endl);
-  while ( ntime > tctime )
-    {
+  while (ntime > tctime) {
     // If nightlySeconds is in the past, this is the current
     // open dashboard, then return nightlySeconds.  If
     // nightlySeconds is in the future, this is the next
@@ -103,21 +102,19 @@ struct tm* cmCTest::GetNightlyTime(std::string str,
     ntime -= dayLength;
     cmCTestLog(this, DEBUG, "Pick yesterday" << std::endl);
     cmCTestLog(this, DEBUG, "   Future time, subtract day: " << ntime
-      << std::endl);
-    }
-  while ( tctime > (ntime + dayLength) )
-    {
+                                                             << std::endl);
+  }
+  while (tctime > (ntime + dayLength)) {
     ntime += dayLength;
     cmCTestLog(this, DEBUG, "   Past time, add day: " << ntime << std::endl);
-    }
+  }
   cmCTestLog(this, DEBUG, "nightlySeconds: " << ntime << std::endl);
-  cmCTestLog(this, DEBUG, "   Current time: " << tctime
-    << " Nightly time: " << ntime << std::endl);
-  if ( tomorrowtag )
-    {
+  cmCTestLog(this, DEBUG, "   Current time: " << tctime << " Nightly time: "
+                                              << ntime << std::endl);
+  if (tomorrowtag) {
     cmCTestLog(this, OUTPUT, "   Use future tag, Add a day" << std::endl);
     ntime += dayLength;
-    }
+  }
   lctime = gmtime(&ntime);
   return lctime;
 }
@@ -126,14 +123,12 @@ std::string cmCTest::CleanString(const std::string& str)
 {
   std::string::size_type spos = str.find_first_not_of(" \n\t\r\f\v");
   std::string::size_type epos = str.find_last_not_of(" \n\t\r\f\v");
-  if ( spos == str.npos )
-    {
+  if (spos == str.npos) {
     return std::string();
-    }
-  if ( epos != str.npos )
-    {
+  }
+  if (epos != str.npos) {
     epos = epos - spos + 1;
-    }
+  }
   return str.substr(spos, epos);
 }
 
@@ -141,16 +136,13 @@ std::string cmCTest::CurrentTime()
 {
   time_t currenttime = time(0);
   struct tm* t = localtime(&currenttime);
-  //return ::CleanString(ctime(&currenttime));
+  // return ::CleanString(ctime(&currenttime));
   char current_time[1024];
-  if ( this->ShortDateFormat )
-    {
+  if (this->ShortDateFormat) {
     strftime(current_time, 1000, "%b %d %H:%M %Z", t);
-    }
-  else
-    {
+  } else {
     strftime(current_time, 1000, "%a %b %d %H:%M:%S %Z %Y", t);
-    }
+  }
   cmCTestLog(this, DEBUG, "   Current_Time: " << current_time << std::endl);
   return cmCTest::CleanString(current_time);
 }
@@ -158,21 +150,19 @@ std::string cmCTest::CurrentTime()
 std::string cmCTest::GetCostDataFile()
 {
   std::string fname = this->GetCTestConfiguration("CostDataFile");
-  if(fname == "")
-    {
-    fname= this->GetBinaryDir() + "/Testing/Temporary/CTestCostData.txt";
-    }
+  if (fname == "") {
+    fname = this->GetBinaryDir() + "/Testing/Temporary/CTestCostData.txt";
+  }
   return fname;
 }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-static size_t
-HTTPResponseCallback(void *ptr, size_t size, size_t nmemb, void *data)
+static size_t HTTPResponseCallback(void* ptr, size_t size, size_t nmemb,
+                                   void* data)
 {
   int realsize = (int)(size * nmemb);
 
-  std::string *response
-    = static_cast<std::string*>(data);
+  std::string* response = static_cast<std::string*>(data);
   const char* chPtr = static_cast<char*>(ptr);
   *response += chPtr;
 
@@ -180,9 +170,8 @@ HTTPResponseCallback(void *ptr, size_t size, size_t nmemb, void *data)
 }
 
 int cmCTest::HTTPRequest(std::string url, HTTPMethod method,
-                                       std::string& response,
-                                       std::string fields,
-                                       std::string putFile, int timeout)
+                         std::string& response, std::string fields,
+                         std::string putFile, int timeout)
 {
   CURL* curl;
   FILE* file;
@@ -190,39 +179,36 @@ int cmCTest::HTTPRequest(std::string url, HTTPMethod method,
   curl = ::curl_easy_init();
   cmCurlSetCAInfo(curl);
 
-  //set request options based on method
-  switch(method)
-    {
+  // set request options based on method
+  switch (method) {
     case cmCTest::HTTP_POST:
       ::curl_easy_setopt(curl, CURLOPT_POST, 1);
       ::curl_easy_setopt(curl, CURLOPT_POSTFIELDS, fields.c_str());
       break;
     case cmCTest::HTTP_PUT:
-      if(!cmSystemTools::FileExists(putFile.c_str()))
-        {
+      if (!cmSystemTools::FileExists(putFile.c_str())) {
         response = "Error: File ";
         response += putFile + " does not exist.\n";
         return -1;
-        }
+      }
       ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
       file = cmsys::SystemTools::Fopen(putFile, "rb");
       ::curl_easy_setopt(curl, CURLOPT_INFILE, file);
-      //fall through to append GET fields
+    // fall through to append GET fields
     case cmCTest::HTTP_GET:
-      if(!fields.empty())
-        {
+      if (!fields.empty()) {
         url += "?" + fields;
-        }
+      }
       break;
-    }
+  }
 
   ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
   ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
   ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
 
-  //set response options
+  // set response options
   ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HTTPResponseCallback);
-  ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&response);
+  ::curl_easy_setopt(curl, CURLOPT_FILE, (void*)&response);
   ::curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
 
   CURLcode res = ::curl_easy_perform(curl);
@@ -238,96 +224,84 @@ std::string cmCTest::MakeURLSafe(const std::string& str)
 {
   std::ostringstream ost;
   char buffer[10];
-  for ( std::string::size_type pos = 0; pos < str.size(); pos ++ )
-    {
+  for (std::string::size_type pos = 0; pos < str.size(); pos++) {
     unsigned char ch = str[pos];
-    if ( ( ch > 126 || ch < 32 ||
-           ch == '&' ||
-           ch == '%' ||
-           ch == '+' ||
-           ch == '=' ||
-           ch == '@'
-          ) && ch != 9 )
-      {
+    if ((ch > 126 || ch < 32 || ch == '&' || ch == '%' || ch == '+' ||
+         ch == '=' || ch == '@') &&
+        ch != 9) {
       sprintf(buffer, "%02x;", (unsigned int)ch);
       ost << buffer;
-      }
-    else
-      {
+    } else {
       ost << ch;
-      }
     }
+  }
   return ost.str();
 }
 
 std::string cmCTest::DecodeURL(const std::string& in)
 {
   std::string out;
-  for(const char* c = in.c_str(); *c; ++c)
-    {
-    if(*c == '%' && isxdigit(*(c+1)) && isxdigit(*(c+2)))
-      {
-      char buf[3] = {*(c+1), *(c+2), 0};
+  for (const char* c = in.c_str(); *c; ++c) {
+    if (*c == '%' && isxdigit(*(c + 1)) && isxdigit(*(c + 2))) {
+      char buf[3] = { *(c + 1), *(c + 2), 0 };
       out.append(1, char(strtoul(buf, 0, 16)));
       c += 2;
-      }
-    else
-      {
+    } else {
       out.append(1, *c);
-      }
     }
+  }
   return out;
 }
 
 cmCTest::cmCTest()
 {
-  this->LabelSummary           = true;
-  this->ParallelLevel          = 1;
-  this->ParallelLevelSetInCli  = false;
-  this->TestLoad               = 0;
-  this->SubmitIndex            = 0;
-  this->Failover               = false;
-  this->BatchJobs              = false;
-  this->ForceNewCTestProcess   = false;
-  this->TomorrowTag            = false;
-  this->Verbose                = false;
-
-  this->Debug                  = false;
-  this->ShowLineNumbers        = false;
-  this->Quiet                  = false;
-  this->ExtraVerbose           = false;
-  this->ProduceXML             = false;
-  this->ShowOnly               = false;
+  this->LabelSummary = true;
+  this->ParallelLevel = 1;
+  this->ParallelLevelSetInCli = false;
+  this->TestLoad = 0;
+  this->SubmitIndex = 0;
+  this->Failover = false;
+  this->BatchJobs = false;
+  this->ForceNewCTestProcess = false;
+  this->TomorrowTag = false;
+  this->Verbose = false;
+
+  this->Debug = false;
+  this->ShowLineNumbers = false;
+  this->Quiet = false;
+  this->ExtraVerbose = false;
+  this->ProduceXML = false;
+  this->ShowOnly = false;
   this->RunConfigurationScript = false;
-  this->UseHTTP10              = false;
-  this->PrintLabels            = false;
-  this->CompressTestOutput     = true;
+  this->UseHTTP10 = false;
+  this->PrintLabels = false;
+  this->CompressTestOutput = true;
   this->CompressMemCheckOutput = true;
-  this->TestModel              = cmCTest::EXPERIMENTAL;
-  this->MaxTestNameWidth       = 30;
-  this->InteractiveDebugMode   = true;
-  this->TimeOut                = 0;
-  this->GlobalTimeout          = 0;
-  this->LastStopTimeout        = 24 * 60 * 60;
-  this->CompressXMLFiles       = false;
-  this->CTestConfigFile        = "";
-  this->ScheduleType           = "";
-  this->StopTime               = "";
-  this->NextDayStopTime        = false;
-  this->OutputLogFile          = 0;
-  this->OutputLogFileLastTag   = -1;
+  this->TestModel = cmCTest::EXPERIMENTAL;
+  this->MaxTestNameWidth = 30;
+  this->InteractiveDebugMode = true;
+  this->TimeOut = 0;
+  this->GlobalTimeout = 0;
+  this->LastStopTimeout = 24 * 60 * 60;
+  this->CompressXMLFiles = false;
+  this->CTestConfigFile = "";
+  this->ScheduleType = "";
+  this->StopTime = "";
+  this->NextDayStopTime = false;
+  this->OutputLogFile = 0;
+  this->OutputLogFileLastTag = -1;
   this->SuppressUpdatingCTestConfiguration = false;
-  this->DartVersion            = 1;
-  this->DropSiteCDash          = false;
+  this->DartVersion = 1;
+  this->DropSiteCDash = false;
   this->OutputTestOutputOnTestFailure = false;
   this->ComputedCompressTestOutput = false;
   this->ComputedCompressMemCheckOutput = false;
   this->RepeatTests = 1; // default to run each test once
   this->RepeatUntilFail = false;
-  if(const char* outOnFail = cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE"))
-    {
+  if (const char* outOnFail =
+        cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE")) {
     this->OutputTestOutputOnTestFailure = !cmSystemTools::IsOff(outOnFail);
-    }
+  }
   this->InitStreams();
 
   this->Parts[PartStart].SetName("Start");
@@ -343,30 +317,28 @@ cmCTest::cmCTest()
   this->Parts[PartUpload].SetName("Upload");
 
   // Fill the part name-to-id map.
-  for(Part p = PartStart; p != PartCount; p = Part(p+1))
-    {
+  for (Part p = PartStart; p != PartCount; p = Part(p + 1)) {
     this->PartMap[cmSystemTools::LowerCase(this->Parts[p].GetName())] = p;
-    }
+  }
 
-  this->ShortDateFormat        = true;
+  this->ShortDateFormat = true;
 
-  this->TestingHandlers["build"]     = new cmCTestBuildHandler;
+  this->TestingHandlers["build"] = new cmCTestBuildHandler;
   this->TestingHandlers["buildtest"] = new cmCTestBuildAndTestHandler;
-  this->TestingHandlers["coverage"]  = new cmCTestCoverageHandler;
-  this->TestingHandlers["script"]    = new cmCTestScriptHandler;
-  this->TestingHandlers["test"]      = new cmCTestTestHandler;
-  this->TestingHandlers["update"]    = new cmCTestUpdateHandler;
+  this->TestingHandlers["coverage"] = new cmCTestCoverageHandler;
+  this->TestingHandlers["script"] = new cmCTestScriptHandler;
+  this->TestingHandlers["test"] = new cmCTestTestHandler;
+  this->TestingHandlers["update"] = new cmCTestUpdateHandler;
   this->TestingHandlers["configure"] = new cmCTestConfigureHandler;
-  this->TestingHandlers["memcheck"]  = new cmCTestMemCheckHandler;
-  this->TestingHandlers["submit"]    = new cmCTestSubmitHandler;
-  this->TestingHandlers["upload"]    = new cmCTestUploadHandler;
+  this->TestingHandlers["memcheck"] = new cmCTestMemCheckHandler;
+  this->TestingHandlers["submit"] = new cmCTestSubmitHandler;
+  this->TestingHandlers["upload"] = new cmCTestUploadHandler;
 
   cmCTest::t_TestingHandlers::iterator it;
-  for ( it = this->TestingHandlers.begin();
-    it != this->TestingHandlers.end(); ++ it )
-    {
+  for (it = this->TestingHandlers.begin(); it != this->TestingHandlers.end();
+       ++it) {
     it->second->SetCTestInstance(this);
-    }
+  }
 
   // Make sure we can capture the build tool output.
   cmSystemTools::EnableVSConsoleOutput();
@@ -390,38 +362,37 @@ void cmCTest::SetTestLoad(unsigned long load)
 
 bool cmCTest::ShouldCompressTestOutput()
 {
-  if(!this->ComputedCompressTestOutput)
-    {
+  if (!this->ComputedCompressTestOutput) {
     std::string cdashVersion = this->GetCDashVersion();
-    //version >= 1.6?
-    bool cdashSupportsGzip = cmSystemTools::VersionCompare(
-      cmSystemTools::OP_GREATER, cdashVersion.c_str(), "1.6") ||
+    // version >= 1.6?
+    bool cdashSupportsGzip =
+      cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
+                                    cdashVersion.c_str(), "1.6") ||
       cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
-      cdashVersion.c_str(), "1.6");
+                                    cdashVersion.c_str(), "1.6");
     this->CompressTestOutput &= cdashSupportsGzip;
     this->ComputedCompressTestOutput = true;
-    }
+  }
   return this->CompressTestOutput;
 }
 
 bool cmCTest::ShouldCompressMemCheckOutput()
 {
-  if(!this->ComputedCompressMemCheckOutput)
-    {
+  if (!this->ComputedCompressMemCheckOutput) {
     std::string cdashVersion = this->GetCDashVersion();
 
     bool compressionSupported = cmSystemTools::VersionCompare(
       cmSystemTools::OP_GREATER, cdashVersion.c_str(), "1.9.0");
     this->CompressMemCheckOutput &= compressionSupported;
     this->ComputedCompressMemCheckOutput = true;
-    }
+  }
   return this->CompressMemCheckOutput;
 }
 
 std::string cmCTest::GetCDashVersion()
 {
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  //First query the server.  If that fails, fall back to the local setting
+  // First query the server.  If that fails, fall back to the local setting
   std::string response;
   std::string url = "http://";
   url += this->GetCTestConfiguration("DropSite");
@@ -430,8 +401,7 @@ std::string cmCTest::GetCDashVersion()
   cdashUri = cdashUri.substr(0, cdashUri.find("/submit.php"));
 
   int res = 1;
-  if ( ! cdashUri.empty() )
-  {
+  if (!cdashUri.empty()) {
     url += cdashUri + "/api/getversion.php";
     res = cmCTest::HTTPRequest(url, cmCTest::HTTP_GET, response, "", "", 3);
   }
@@ -447,10 +417,9 @@ cmCTest::Part cmCTest::GetPartFromName(const char* name)
   // Look up by lower-case to make names case-insensitive.
   std::string lower_name = cmSystemTools::LowerCase(name);
   PartMapType::const_iterator i = this->PartMap.find(lower_name);
-  if(i != this->PartMap.end())
-    {
+  if (i != this->PartMap.end()) {
     return i->second;
-    }
+  }
 
   // The string does not name a valid part.
   return PartCount;
@@ -459,20 +428,16 @@ cmCTest::Part cmCTest::GetPartFromName(const char* name)
 int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
 {
   bool quiet = false;
-  if (command && command->ShouldBeQuiet())
-    {
+  if (command && command->ShouldBeQuiet()) {
     quiet = true;
-    }
+  }
 
   cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
-  if(!this->InteractiveDebugMode)
-    {
+  if (!this->InteractiveDebugMode) {
     this->BlockTestErrorDiagnostics();
-    }
-  else
-    {
+  } else {
     cmSystemTools::PutEnv("CTEST_INTERACTIVE_DEBUG_MODE=1");
-    }
+  }
 
   this->BinaryDir = binary_dir;
   cmSystemTools::ConvertToUnixSlashes(this->BinaryDir);
@@ -480,25 +445,29 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
   this->UpdateCTestConfiguration();
 
   cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
-  if ( this->ProduceXML )
-    {
+  if (this->ProduceXML) {
     cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl, quiet);
-    cmCTestOptionalLog(this, OUTPUT,
-      "   Site: " << this->GetCTestConfiguration("Site") << std::endl <<
-      "   Build name: " << cmCTest::SafeBuildIdField(
-      this->GetCTestConfiguration("BuildName")) << std::endl, quiet);
+    cmCTestOptionalLog(
+      this, OUTPUT, "   Site: "
+        << this->GetCTestConfiguration("Site") << std::endl
+        << "   Build name: "
+        << cmCTest::SafeBuildIdField(this->GetCTestConfiguration("BuildName"))
+        << std::endl,
+      quiet);
     cmCTestOptionalLog(this, DEBUG, "Produce XML is on" << std::endl, quiet);
-    if ( this->TestModel == cmCTest::NIGHTLY &&
-         this->GetCTestConfiguration("NightlyStartTime").empty() )
-      {
-      cmCTestOptionalLog(this, WARNING,
+    if (this->TestModel == cmCTest::NIGHTLY &&
+        this->GetCTestConfiguration("NightlyStartTime").empty()) {
+      cmCTestOptionalLog(
+        this, WARNING,
         "WARNING: No nightly start time found please set in CTestConfig.cmake"
-        " or DartConfig.cmake" << std::endl, quiet);
-      cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl,
+        " or DartConfig.cmake"
+          << std::endl,
         quiet);
+      cmCTestOptionalLog(this, DEBUG, "Here: " << __LINE__ << std::endl,
+                         quiet);
       return 0;
-      }
     }
+  }
 
   cmake cm;
   cm.SetHomeDirectory("");
@@ -506,154 +475,133 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
   cm.GetCurrentSnapshot().SetDefaultDefinitions();
   cmGlobalGenerator gg(&cm);
   cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
-  if ( !this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(),
-                                              mf.get()) )
-    {
-    cmCTestOptionalLog(this, DEBUG,
-      "Cannot find custom configuration file tree" << std::endl, quiet);
+  if (!this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(),
+                                             mf.get())) {
+    cmCTestOptionalLog(
+      this, DEBUG, "Cannot find custom configuration file tree" << std::endl,
+      quiet);
     return 0;
-    }
+  }
 
-  if ( this->ProduceXML )
-    {
+  if (this->ProduceXML) {
     // Verify "Testing" directory exists:
     //
     std::string testingDir = this->BinaryDir + "/Testing";
-    if ( cmSystemTools::FileExists(testingDir.c_str()) )
-      {
-      if ( !cmSystemTools::FileIsDirectory(testingDir) )
-        {
-        cmCTestLog(this, ERROR_MESSAGE, "File " << testingDir
-          << " is in the place of the testing directory" << std::endl);
+    if (cmSystemTools::FileExists(testingDir.c_str())) {
+      if (!cmSystemTools::FileIsDirectory(testingDir)) {
+        cmCTestLog(this, ERROR_MESSAGE, "File "
+                     << testingDir
+                     << " is in the place of the testing directory"
+                     << std::endl);
         return 0;
-        }
       }
-    else
-      {
-      if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) )
-        {
+    } else {
+      if (!cmSystemTools::MakeDirectory(testingDir.c_str())) {
         cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory "
-          << testingDir << std::endl);
+                     << testingDir << std::endl);
         return 0;
-        }
       }
+    }
 
     // Create new "TAG" file or read existing one:
     //
     bool createNewTag = true;
-    if (command)
-      {
+    if (command) {
       createNewTag = command->ShouldCreateNewTag();
-      }
+    }
 
     std::string tagfile = testingDir + "/TAG";
     cmsys::ifstream tfin(tagfile.c_str());
     std::string tag;
 
-    if (createNewTag)
-      {
+    if (createNewTag) {
       time_t tctime = time(0);
-      if ( this->TomorrowTag )
-        {
-        tctime += ( 24 * 60 * 60 );
-        }
-      struct tm *lctime = gmtime(&tctime);
-      if ( tfin && cmSystemTools::GetLineFromStream(tfin, tag) )
-        {
+      if (this->TomorrowTag) {
+        tctime += (24 * 60 * 60);
+      }
+      struct tm* lctime = gmtime(&tctime);
+      if (tfin && cmSystemTools::GetLineFromStream(tfin, tag)) {
         int year = 0;
         int mon = 0;
         int day = 0;
         int hour = 0;
         int min = 0;
-        sscanf(tag.c_str(), "%04d%02d%02d-%02d%02d",
-               &year, &mon, &day, &hour, &min);
-        if ( year != lctime->tm_year + 1900 ||
-             mon != lctime->tm_mon+1 ||
-             day != lctime->tm_mday )
-          {
+        sscanf(tag.c_str(), "%04d%02d%02d-%02d%02d", &year, &mon, &day, &hour,
+               &min);
+        if (year != lctime->tm_year + 1900 || mon != lctime->tm_mon + 1 ||
+            day != lctime->tm_mday) {
           tag = "";
-          }
+        }
         std::string tagmode;
-        if ( cmSystemTools::GetLineFromStream(tfin, tagmode) )
-          {
-          if (tagmode.size() > 4 && !this->Parts[PartStart])
-            {
+        if (cmSystemTools::GetLineFromStream(tfin, tagmode)) {
+          if (tagmode.size() > 4 && !this->Parts[PartStart]) {
             this->TestModel = cmCTest::GetTestModelFromString(tagmode.c_str());
-            }
           }
-        tfin.close();
         }
-      if (tag.empty() || (0 != command) || this->Parts[PartStart])
-        {
-        cmCTestOptionalLog(this, DEBUG, "TestModel: " <<
-          this->GetTestModelString() << std::endl, quiet);
-        cmCTestOptionalLog(this, DEBUG, "TestModel: " <<
-          this->TestModel << std::endl, quiet);
-        if ( this->TestModel == cmCTest::NIGHTLY )
-          {
+        tfin.close();
+      }
+      if (tag.empty() || (0 != command) || this->Parts[PartStart]) {
+        cmCTestOptionalLog(
+          this, DEBUG,
+          "TestModel: " << this->GetTestModelString() << std::endl, quiet);
+        cmCTestOptionalLog(
+          this, DEBUG, "TestModel: " << this->TestModel << std::endl, quiet);
+        if (this->TestModel == cmCTest::NIGHTLY) {
           lctime = this->GetNightlyTime(
             this->GetCTestConfiguration("NightlyStartTime"),
             this->TomorrowTag);
-          }
+        }
         char datestring[100];
-        sprintf(datestring, "%04d%02d%02d-%02d%02d",
-                lctime->tm_year + 1900,
-                lctime->tm_mon+1,
-                lctime->tm_mday,
-                lctime->tm_hour,
+        sprintf(datestring, "%04d%02d%02d-%02d%02d", lctime->tm_year + 1900,
+                lctime->tm_mon + 1, lctime->tm_mday, lctime->tm_hour,
                 lctime->tm_min);
         tag = datestring;
         cmsys::ofstream ofs(tagfile.c_str());
-        if ( ofs )
-          {
+        if (ofs) {
           ofs << tag << std::endl;
           ofs << this->GetTestModelString() << std::endl;
-          }
+        }
         ofs.close();
-        if ( 0 == command )
-          {
-          cmCTestOptionalLog(this, OUTPUT, "Create new tag: " << tag << " - "
-            << this->GetTestModelString() << std::endl, quiet);
-          }
+        if (0 == command) {
+          cmCTestOptionalLog(this, OUTPUT, "Create new tag: "
+                               << tag << " - " << this->GetTestModelString()
+                               << std::endl,
+                             quiet);
         }
       }
-    else
-      {
-      if ( tfin )
-        {
+    } else {
+      if (tfin) {
         cmSystemTools::GetLineFromStream(tfin, tag);
         tfin.close();
-        }
+      }
 
-      if ( tag.empty() )
-        {
-        cmCTestLog(this, ERROR_MESSAGE,
-          "Cannot read existing TAG file in " << testingDir
-          << std::endl);
+      if (tag.empty()) {
+        cmCTestLog(this, ERROR_MESSAGE, "Cannot read existing TAG file in "
+                     << testingDir << std::endl);
         return 0;
-        }
-
-      cmCTestOptionalLog(this, OUTPUT, "  Use existing tag: " << tag << " - "
-        << this->GetTestModelString() << std::endl, quiet);
       }
 
-    this->CurrentTag = tag;
+      cmCTestOptionalLog(this, OUTPUT, "  Use existing tag: "
+                           << tag << " - " << this->GetTestModelString()
+                           << std::endl,
+                         quiet);
     }
 
+    this->CurrentTag = tag;
+  }
+
   return 1;
 }
 
 bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
 {
-  std::string src_dir
-    = this->GetCTestConfiguration("SourceDirectory");
+  std::string src_dir = this->GetCTestConfiguration("SourceDirectory");
   std::string bld_dir = this->GetCTestConfiguration("BuildDirectory");
   this->DartVersion = 1;
   this->DropSiteCDash = false;
-  for(Part p = PartStart; p != PartCount; p = Part(p+1))
-    {
+  for (Part p = PartStart; p != PartCount; p = Part(p + 1)) {
     this->Parts[p].SubmitFiles.clear();
-    }
+  }
 
   cmMakefile* mf = command->GetMakefile();
   std::string fname;
@@ -666,168 +614,143 @@ bool cmCTest::InitializeFromCommand(cmCTestStartCommand* command)
   bld_dir_fname += "/CTestConfig.cmake";
   cmSystemTools::ConvertToUnixSlashes(bld_dir_fname);
 
-  if ( cmSystemTools::FileExists(bld_dir_fname.c_str()) )
-    {
+  if (cmSystemTools::FileExists(bld_dir_fname.c_str())) {
     fname = bld_dir_fname;
-    }
-  else if ( cmSystemTools::FileExists(src_dir_fname.c_str()) )
-    {
+  } else if (cmSystemTools::FileExists(src_dir_fname.c_str())) {
     fname = src_dir_fname;
-    }
+  }
 
-  if ( !fname.empty() )
-    {
+  if (!fname.empty()) {
     cmCTestOptionalLog(this, OUTPUT, "   Reading ctest configuration file: "
-      << fname << std::endl, command->ShouldBeQuiet());
+                         << fname << std::endl,
+                       command->ShouldBeQuiet());
     bool readit = mf->ReadDependentFile(fname.c_str());
-    if(!readit)
-      {
+    if (!readit) {
       std::string m = "Could not find include file: ";
       m += fname;
       command->SetError(m);
       return false;
-      }
     }
-  else
-    {
-    cmCTestOptionalLog(this, WARNING,
-      "Cannot locate CTest configuration: in BuildDirectory: "
-      << bld_dir_fname << std::endl, command->ShouldBeQuiet());
+  } else {
     cmCTestOptionalLog(this, WARNING,
-      "Cannot locate CTest configuration: in SourceDirectory: "
-      << src_dir_fname << std::endl, command->ShouldBeQuiet());
-    }
+                       "Cannot locate CTest configuration: in BuildDirectory: "
+                         << bld_dir_fname << std::endl,
+                       command->ShouldBeQuiet());
+    cmCTestOptionalLog(
+      this, WARNING, "Cannot locate CTest configuration: in SourceDirectory: "
+        << src_dir_fname << std::endl,
+      command->ShouldBeQuiet());
+  }
 
   this->SetCTestConfigurationFromCMakeVariable(mf, "NightlyStartTime",
-    "CTEST_NIGHTLY_START_TIME", command->ShouldBeQuiet());
+                                               "CTEST_NIGHTLY_START_TIME",
+                                               command->ShouldBeQuiet());
   this->SetCTestConfigurationFromCMakeVariable(mf, "Site", "CTEST_SITE",
-    command->ShouldBeQuiet());
-  this->SetCTestConfigurationFromCMakeVariable(mf, "BuildName",
-    "CTEST_BUILD_NAME", command->ShouldBeQuiet());
+                                               command->ShouldBeQuiet());
+  this->SetCTestConfigurationFromCMakeVariable(
+    mf, "BuildName", "CTEST_BUILD_NAME", command->ShouldBeQuiet());
   const char* dartVersion = mf->GetDefinition("CTEST_DART_SERVER_VERSION");
-  if ( dartVersion )
-    {
+  if (dartVersion) {
     this->DartVersion = atoi(dartVersion);
-    if ( this->DartVersion < 0 )
-      {
+    if (this->DartVersion < 0) {
       cmCTestLog(this, ERROR_MESSAGE, "Invalid Dart server version: "
-        << dartVersion << ". Please specify the version number."
-        << std::endl);
+                   << dartVersion << ". Please specify the version number."
+                   << std::endl);
       return false;
-      }
     }
+  }
   this->DropSiteCDash = mf->IsOn("CTEST_DROP_SITE_CDASH");
 
-  if ( !this->Initialize(bld_dir.c_str(), command) )
-    {
+  if (!this->Initialize(bld_dir.c_str(), command)) {
     return false;
-    }
-  cmCTestOptionalLog(this, OUTPUT, "   Use " << this->GetTestModelString()
-    << " tag: " << this->GetCurrentTag() << std::endl,
-    command->ShouldBeQuiet());
+  }
+  cmCTestOptionalLog(this, OUTPUT, "   Use "
+                       << this->GetTestModelString()
+                       << " tag: " << this->GetCurrentTag() << std::endl,
+                     command->ShouldBeQuiet());
   return true;
 }
 
-
 bool cmCTest::UpdateCTestConfiguration()
 {
-  if ( this->SuppressUpdatingCTestConfiguration )
-    {
+  if (this->SuppressUpdatingCTestConfiguration) {
     return true;
-    }
+  }
   std::string fileName = this->CTestConfigFile;
-  if ( fileName.empty() )
-    {
+  if (fileName.empty()) {
     fileName = this->BinaryDir + "/CTestConfiguration.ini";
-    if ( !cmSystemTools::FileExists(fileName.c_str()) )
-      {
+    if (!cmSystemTools::FileExists(fileName.c_str())) {
       fileName = this->BinaryDir + "/DartConfiguration.tcl";
-      }
     }
-  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "UpdateCTestConfiguration  from :"
-             << fileName << "\n");
-  if ( !cmSystemTools::FileExists(fileName.c_str()) )
-    {
+  }
+  cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+             "UpdateCTestConfiguration  from :" << fileName << "\n");
+  if (!cmSystemTools::FileExists(fileName.c_str())) {
     // No need to exit if we are not producing XML
-    if ( this->ProduceXML )
-      {
+    if (this->ProduceXML) {
       cmCTestLog(this, ERROR_MESSAGE, "Cannot find file: " << fileName
-        << std::endl);
+                                                           << std::endl);
       return false;
-      }
     }
-  else
-    {
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Parse Config file:"
-               << fileName << "\n");
+  } else {
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Parse Config file:" << fileName
+                                                                  << "\n");
     // parse the dart test file
     cmsys::ifstream fin(fileName.c_str());
 
-    if(!fin)
-      {
+    if (!fin) {
       return false;
-      }
+    }
 
     char buffer[1024];
-    while ( fin )
-      {
+    while (fin) {
       buffer[0] = 0;
       fin.getline(buffer, 1023);
       buffer[1023] = 0;
       std::string line = cmCTest::CleanString(buffer);
-      if(line.empty())
-        {
+      if (line.empty()) {
         continue;
-        }
-      while ( fin && (line[line.size()-1] == '\\') )
-        {
-        line = line.substr(0, line.size()-1);
+      }
+      while (fin && (line[line.size() - 1] == '\\')) {
+        line = line.substr(0, line.size() - 1);
         buffer[0] = 0;
         fin.getline(buffer, 1023);
         buffer[1023] = 0;
         line += cmCTest::CleanString(buffer);
-        }
-      if ( line[0] == '#' )
-        {
+      }
+      if (line[0] == '#') {
         continue;
-        }
+      }
       std::string::size_type cpos = line.find_first_of(":");
-      if ( cpos == line.npos )
-        {
+      if (cpos == line.npos) {
         continue;
-        }
+      }
       std::string key = line.substr(0, cpos);
-      std::string value
-        = cmCTest::CleanString(line.substr(cpos+1, line.npos));
+      std::string value =
+        cmCTest::CleanString(line.substr(cpos + 1, line.npos));
       this->CTestConfiguration[key] = value;
-      }
-    fin.close();
     }
-  if ( !this->GetCTestConfiguration("BuildDirectory").empty() )
-    {
+    fin.close();
+  }
+  if (!this->GetCTestConfiguration("BuildDirectory").empty()) {
     this->BinaryDir = this->GetCTestConfiguration("BuildDirectory");
     cmSystemTools::ChangeDirectory(this->BinaryDir);
-    }
+  }
   this->TimeOut = atoi(this->GetCTestConfiguration("TimeOut").c_str());
   std::string const& testLoad = this->GetCTestConfiguration("TestLoad");
-  if (!testLoad.empty())
-    {
+  if (!testLoad.empty()) {
     unsigned long load;
-    if (cmSystemTools::StringToULong(testLoad.c_str(), &load))
-      {
+    if (cmSystemTools::StringToULong(testLoad.c_str(), &load)) {
       this->SetTestLoad(load);
-      }
-    else
-      {
-      cmCTestLog(this, WARNING, "Invalid value for 'Test Load' : "
-          << testLoad << std::endl);
-      }
+    } else {
+      cmCTestLog(this, WARNING,
+                 "Invalid value for 'Test Load' : " << testLoad << std::endl);
     }
-  if ( this->ProduceXML )
-    {
+  }
+  if (this->ProduceXML) {
     this->CompressXMLFiles = cmSystemTools::IsOn(
       this->GetCTestConfiguration("CompressSubmission").c_str());
-    }
+  }
   return true;
 }
 
@@ -850,107 +773,85 @@ void cmCTest::SetTestModel(int mode)
 
 bool cmCTest::SetTest(const char* ttype, bool report)
 {
-  if ( cmSystemTools::LowerCase(ttype) == "all" )
-    {
-    for(Part p = PartStart; p != PartCount; p = Part(p+1))
-      {
+  if (cmSystemTools::LowerCase(ttype) == "all") {
+    for (Part p = PartStart; p != PartCount; p = Part(p + 1)) {
       this->Parts[p].Enable();
-      }
-    return true;
     }
+    return true;
+  }
   Part p = this->GetPartFromName(ttype);
-  if(p != PartCount)
-    {
+  if (p != PartCount) {
     this->Parts[p].Enable();
     return true;
+  } else {
+    if (report) {
+      cmCTestLog(this, ERROR_MESSAGE, "Don't know about test \""
+                   << ttype << "\" yet..." << std::endl);
     }
-  else
-    {
-    if ( report )
-      {
-      cmCTestLog(this, ERROR_MESSAGE, "Don't know about test \"" << ttype
-        << "\" yet..." << std::endl);
-      }
     return false;
-    }
+  }
 }
 
 void cmCTest::Finalize()
 {
 }
 
-bool cmCTest::OpenOutputFile(const std::string& path,
-                     const std::string& name, cmGeneratedFileStream& stream,
-                     bool compress)
+bool cmCTest::OpenOutputFile(const std::string& path, const std::string& name,
+                             cmGeneratedFileStream& stream, bool compress)
 {
   std::string testingDir = this->BinaryDir + "/Testing";
-  if (!path.empty())
-    {
+  if (!path.empty()) {
     testingDir += "/" + path;
-    }
-  if ( cmSystemTools::FileExists(testingDir.c_str()) )
-    {
-    if ( !cmSystemTools::FileIsDirectory(testingDir) )
-      {
-      cmCTestLog(this, ERROR_MESSAGE, "File " << testingDir
-                << " is in the place of the testing directory"
-                << std::endl);
+  }
+  if (cmSystemTools::FileExists(testingDir.c_str())) {
+    if (!cmSystemTools::FileIsDirectory(testingDir)) {
+      cmCTestLog(this, ERROR_MESSAGE, "File "
+                   << testingDir << " is in the place of the testing directory"
+                   << std::endl);
       return false;
-      }
     }
-  else
-    {
-    if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) )
-      {
+  } else {
+    if (!cmSystemTools::MakeDirectory(testingDir.c_str())) {
       cmCTestLog(this, ERROR_MESSAGE, "Cannot create directory " << testingDir
-                << std::endl);
+                                                                 << std::endl);
       return false;
-      }
     }
+  }
   std::string filename = testingDir + "/" + name;
   stream.Open(filename.c_str());
-  if( !stream )
-    {
+  if (!stream) {
     cmCTestLog(this, ERROR_MESSAGE, "Problem opening file: " << filename
-      << std::endl);
+                                                             << std::endl);
     return false;
-    }
-  if ( compress )
-    {
-    if ( this->CompressXMLFiles )
-      {
+  }
+  if (compress) {
+    if (this->CompressXMLFiles) {
       stream.SetCompression(true);
-      }
     }
+  }
   return true;
 }
 
 bool cmCTest::AddIfExists(Part part, const char* file)
 {
-  if ( this->CTestFileExists(file) )
-    {
+  if (this->CTestFileExists(file)) {
     this->AddSubmitFile(part, file);
-    }
-  else
-    {
+  } else {
     std::string name = file;
     name += ".gz";
-    if ( this->CTestFileExists(name) )
-      {
+    if (this->CTestFileExists(name)) {
       this->AddSubmitFile(part, file);
-      }
-    else
-      {
+    } else {
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmCTest::CTestFileExists(const std::string& filename)
 {
-  std::string testingDir = this->BinaryDir + "/Testing/" +
-    this->CurrentTag + "/" + filename;
+  std::string testingDir =
+    this->BinaryDir + "/Testing/" + this->CurrentTag + "/" + filename;
   return cmSystemTools::FileExists(testingDir.c_str());
 }
 
@@ -958,10 +859,9 @@ cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
 {
   cmCTest::t_TestingHandlers::iterator it =
     this->TestingHandlers.find(handler);
-  if ( it == this->TestingHandlers.end() )
-    {
+  if (it == this->TestingHandlers.end()) {
     return 0;
-    }
+  }
   it->second->Initialize();
   return it->second;
 }
@@ -970,20 +870,18 @@ cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
 {
   cmCTest::t_TestingHandlers::iterator it =
     this->TestingHandlers.find(handler);
-  if ( it == this->TestingHandlers.end() )
-    {
+  if (it == this->TestingHandlers.end()) {
     return 0;
-    }
+  }
   return it->second;
 }
 
 int cmCTest::ExecuteHandler(const char* shandler)
 {
   cmCTestGenericHandler* handler = this->GetHandler(shandler);
-  if ( !handler )
-    {
+  if (!handler) {
     return -1;
-    }
+  }
   handler->Initialize();
   return handler->ProcessHandler();
 }
@@ -994,150 +892,119 @@ int cmCTest::ProcessTests()
   bool notest = true;
   int update_count = 0;
 
-  for(Part p = PartStart; notest && p != PartCount; p = Part(p+1))
-    {
+  for (Part p = PartStart; notest && p != PartCount; p = Part(p + 1)) {
     notest = !this->Parts[p];
-    }
-  if (this->Parts[PartUpdate] &&
-      (this->GetRemainingTimeAllowed() - 120 > 0))
-    {
+  }
+  if (this->Parts[PartUpdate] && (this->GetRemainingTimeAllowed() - 120 > 0)) {
     cmCTestGenericHandler* uphandler = this->GetHandler("update");
-    uphandler->SetPersistentOption("SourceDirectory",
+    uphandler->SetPersistentOption(
+      "SourceDirectory",
       this->GetCTestConfiguration("SourceDirectory").c_str());
     update_count = uphandler->ProcessHandler();
-    if ( update_count < 0 )
-      {
+    if (update_count < 0) {
       res |= cmCTest::UPDATE_ERRORS;
-      }
     }
-  if ( this->TestModel == cmCTest::CONTINUOUS && !update_count )
-    {
+  }
+  if (this->TestModel == cmCTest::CONTINUOUS && !update_count) {
     return 0;
-    }
+  }
   if (this->Parts[PartConfigure] &&
-      (this->GetRemainingTimeAllowed() - 120 > 0))
-    {
-    if (this->GetHandler("configure")->ProcessHandler() < 0)
-      {
+      (this->GetRemainingTimeAllowed() - 120 > 0)) {
+    if (this->GetHandler("configure")->ProcessHandler() < 0) {
       res |= cmCTest::CONFIGURE_ERRORS;
-      }
     }
-  if (this->Parts[PartBuild] &&
-      (this->GetRemainingTimeAllowed() - 120 > 0))
-    {
+  }
+  if (this->Parts[PartBuild] && (this->GetRemainingTimeAllowed() - 120 > 0)) {
     this->UpdateCTestConfiguration();
-    if (this->GetHandler("build")->ProcessHandler() < 0)
-      {
+    if (this->GetHandler("build")->ProcessHandler() < 0) {
       res |= cmCTest::BUILD_ERRORS;
-      }
     }
+  }
   if ((this->Parts[PartTest] || notest) &&
-      (this->GetRemainingTimeAllowed() - 120 > 0))
-    {
+      (this->GetRemainingTimeAllowed() - 120 > 0)) {
     this->UpdateCTestConfiguration();
-    if (this->GetHandler("test")->ProcessHandler() < 0)
-      {
+    if (this->GetHandler("test")->ProcessHandler() < 0) {
       res |= cmCTest::TEST_ERRORS;
-      }
     }
+  }
   if (this->Parts[PartCoverage] &&
-      (this->GetRemainingTimeAllowed() - 120 > 0))
-    {
+      (this->GetRemainingTimeAllowed() - 120 > 0)) {
     this->UpdateCTestConfiguration();
-    if (this->GetHandler("coverage")->ProcessHandler() < 0)
-      {
+    if (this->GetHandler("coverage")->ProcessHandler() < 0) {
       res |= cmCTest::COVERAGE_ERRORS;
-      }
     }
+  }
   if (this->Parts[PartMemCheck] &&
-      (this->GetRemainingTimeAllowed() - 120 > 0))
-    {
+      (this->GetRemainingTimeAllowed() - 120 > 0)) {
     this->UpdateCTestConfiguration();
-    if (this->GetHandler("memcheck")->ProcessHandler() < 0)
-      {
+    if (this->GetHandler("memcheck")->ProcessHandler() < 0) {
       res |= cmCTest::MEMORY_ERRORS;
-      }
     }
-  if ( !notest )
-    {
+  }
+  if (!notest) {
     std::string notes_dir = this->BinaryDir + "/Testing/Notes";
-    if ( cmSystemTools::FileIsDirectory(notes_dir) )
-      {
+    if (cmSystemTools::FileIsDirectory(notes_dir)) {
       cmsys::Directory d;
       d.Load(notes_dir);
       unsigned long kk;
-      for ( kk = 0; kk < d.GetNumberOfFiles(); kk ++ )
-        {
+      for (kk = 0; kk < d.GetNumberOfFiles(); kk++) {
         const char* file = d.GetFile(kk);
         std::string fullname = notes_dir + "/" + file;
-        if ( cmSystemTools::FileExists(fullname.c_str()) &&
-          !cmSystemTools::FileIsDirectory(fullname) )
-          {
-          if (!this->NotesFiles.empty())
-            {
+        if (cmSystemTools::FileExists(fullname.c_str()) &&
+            !cmSystemTools::FileIsDirectory(fullname)) {
+          if (!this->NotesFiles.empty()) {
             this->NotesFiles += ";";
-            }
+          }
           this->NotesFiles += fullname;
           this->Parts[PartNotes].Enable();
-          }
         }
       }
     }
-  if (this->Parts[PartNotes])
-    {
+  }
+  if (this->Parts[PartNotes]) {
     this->UpdateCTestConfiguration();
-    if (!this->NotesFiles.empty())
-      {
+    if (!this->NotesFiles.empty()) {
       this->GenerateNotesFile(this->NotesFiles.c_str());
-      }
     }
-  if (this->Parts[PartSubmit])
-    {
+  }
+  if (this->Parts[PartSubmit]) {
     this->UpdateCTestConfiguration();
-    if (this->GetHandler("submit")->ProcessHandler() < 0)
-      {
+    if (this->GetHandler("submit")->ProcessHandler() < 0) {
       res |= cmCTest::SUBMIT_ERRORS;
-      }
-    }
-  if ( res != 0 )
-    {
-    cmCTestLog(this, ERROR_MESSAGE, "Errors while running CTest"
-                 << std::endl);
     }
+  }
+  if (res != 0) {
+    cmCTestLog(this, ERROR_MESSAGE, "Errors while running CTest" << std::endl);
+  }
   return res;
 }
 
 std::string cmCTest::GetTestModelString()
 {
-  if ( !this->SpecificTrack.empty() )
-    {
+  if (!this->SpecificTrack.empty()) {
     return this->SpecificTrack;
-    }
-  switch ( this->TestModel )
-    {
-  case cmCTest::NIGHTLY:
-    return "Nightly";
-  case cmCTest::CONTINUOUS:
-    return "Continuous";
-    }
+  }
+  switch (this->TestModel) {
+    case cmCTest::NIGHTLY:
+      return "Nightly";
+    case cmCTest::CONTINUOUS:
+      return "Continuous";
+  }
   return "Experimental";
 }
 
 int cmCTest::GetTestModelFromString(const char* str)
 {
-  if ( !str )
-    {
+  if (!str) {
     return cmCTest::EXPERIMENTAL;
-    }
+  }
   std::string rstr = cmSystemTools::LowerCase(str);
-  if ( cmHasLiteralPrefix(rstr.c_str(), "cont") )
-    {
+  if (cmHasLiteralPrefix(rstr.c_str(), "cont")) {
     return cmCTest::CONTINUOUS;
-    }
-  if ( cmHasLiteralPrefix(rstr.c_str(), "nigh") )
-    {
+  }
+  if (cmHasLiteralPrefix(rstr.c_str(), "nigh")) {
     return cmCTest::NIGHTLY;
-    }
+  }
   return cmCTest::EXPERIMENTAL;
 }
 
@@ -1147,31 +1014,29 @@ int cmCTest::GetTestModelFromString(const char* str)
 //######################################################################
 
 int cmCTest::RunMakeCommand(const char* command, std::string& output,
-  int* retVal, const char* dir, int timeout, std::ostream& ofs)
+                            int* retVal, const char* dir, int timeout,
+                            std::ostream& ofs)
 {
   // First generate the command and arguments
   std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     return false;
-    }
+  }
 
   std::vector<const char*> argv;
-  for(std::vector<std::string>::const_iterator a = args.begin();
-    a != args.end(); ++a)
-    {
+  for (std::vector<std::string>::const_iterator a = args.begin();
+       a != args.end(); ++a) {
     argv.push_back(a->c_str());
-    }
+  }
   argv.push_back(0);
 
   output = "";
   cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Run command:");
   std::vector<const char*>::iterator ait;
-  for ( ait = argv.begin(); ait != argv.end() && *ait; ++ ait )
-    {
+  for (ait = argv.begin(); ait != argv.end() && *ait; ++ait) {
     cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, " \"" << *ait << "\"");
-    }
+  }
   cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, std::endl);
 
   // Now create process object
@@ -1189,69 +1054,55 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
 
   char* data;
   int length;
-  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT,
-    "   Each . represents " << tick_len << " bytes of output" << std::endl
-    << "    " << std::flush);
-  while(cmsysProcess_WaitForData(cp, &data, &length, 0))
-    {
-    for(int cc =0; cc < length; ++cc)
-      {
-      if(data[cc] == 0)
-        {
+  cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, "   Each . represents "
+               << tick_len << " bytes of output" << std::endl
+               << "    " << std::flush);
+  while (cmsysProcess_WaitForData(cp, &data, &length, 0)) {
+    for (int cc = 0; cc < length; ++cc) {
+      if (data[cc] == 0) {
         data[cc] = '\n';
-        }
       }
+    }
     output.append(data, length);
-    while ( output.size() > (tick * tick_len) )
-      {
-      tick ++;
+    while (output.size() > (tick * tick_len)) {
+      tick++;
       cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, "." << std::flush);
-      if ( tick % tick_line_len == 0 && tick > 0 )
-        {
+      if (tick % tick_line_len == 0 && tick > 0) {
         cmCTestLog(this, HANDLER_PROGRESS_OUTPUT,
-                   "  Size: "
-                   << int((double(output.size()) / 1024.0) + 1)
-                   << "K" << std::endl
-                   << "    " << std::flush);
-        }
+                   "  Size: " << int((double(output.size()) / 1024.0) + 1)
+                              << "K" << std::endl
+                              << "    " << std::flush);
       }
+    }
     cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
-    if ( ofs )
-      {
+    if (ofs) {
       ofs << cmCTestLogWrite(data, length);
-      }
     }
+  }
   cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, " Size of output: "
-    << int(double(output.size()) / 1024.0) << "K" << std::endl);
+               << int(double(output.size()) / 1024.0) << "K" << std::endl);
 
   cmsysProcess_WaitForExit(cp, 0);
 
   int result = cmsysProcess_GetState(cp);
 
-  if(result == cmsysProcess_State_Exited)
-    {
+  if (result == cmsysProcess_State_Exited) {
     *retVal = cmsysProcess_GetExitValue(cp);
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Command exited with the value: "
-      << *retVal << std::endl);
-    }
-  else if(result == cmsysProcess_State_Exception)
-    {
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
+               "Command exited with the value: " << *retVal << std::endl);
+  } else if (result == cmsysProcess_State_Exception) {
     *retVal = cmsysProcess_GetExitException(cp);
     cmCTestLog(this, WARNING, "There was an exception: " << *retVal
-      << std::endl);
-    }
-  else if(result == cmsysProcess_State_Expired)
-    {
+                                                         << std::endl);
+  } else if (result == cmsysProcess_State_Expired) {
     cmCTestLog(this, WARNING, "There was a timeout" << std::endl);
-    }
-  else if(result == cmsysProcess_State_Error)
-    {
+  } else if (result == cmsysProcess_State_Error) {
     output += "\n*** ERROR executing: ";
     output += cmsysProcess_GetErrorString(cp);
     output += "\n***The build process failed.";
     cmCTestLog(this, ERROR_MESSAGE, "There was an error: "
-      << cmsysProcess_GetErrorString(cp) << std::endl);
-    }
+                 << cmsysProcess_GetErrorString(cp) << std::endl);
+  }
 
   cmsysProcess_Delete(cp);
 
@@ -1263,36 +1114,29 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output,
 //######################################################################
 //######################################################################
 
-int cmCTest::RunTest(std::vector<const char*> argv,
-                     std::string* output, int *retVal,
-                     std::ostream* log, double testTimeOut,
+int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
+                     int* retVal, std::ostream* log, double testTimeOut,
                      std::vector<std::string>* environment)
 {
   bool modifyEnv = (environment && !environment->empty());
 
   // determine how much time we have
   double timeout = this->GetRemainingTimeAllowed() - 120;
-  if (this->TimeOut > 0 && this->TimeOut < timeout)
-    {
+  if (this->TimeOut > 0 && this->TimeOut < timeout) {
     timeout = this->TimeOut;
-    }
-  if (testTimeOut > 0
-      && testTimeOut < this->GetRemainingTimeAllowed())
-    {
+  }
+  if (testTimeOut > 0 && testTimeOut < this->GetRemainingTimeAllowed()) {
     timeout = testTimeOut;
-    }
+  }
 
   // always have at least 1 second if we got to here
-  if (timeout <= 0)
-    {
+  if (timeout <= 0) {
     timeout = 1;
-    }
+  }
   cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
              "Test timeout computed to be: " << timeout << "\n");
-  if(cmSystemTools::SameFile(
-       argv[0], cmSystemTools::GetCTestCommand()) &&
-     !this->ForceNewCTestProcess)
-    {
+  if (cmSystemTools::SameFile(argv[0], cmSystemTools::GetCTestCommand()) &&
+      !this->ForceNewCTestProcess) {
     cmCTest inst;
     inst.ConfigType = this->ConfigType;
     inst.TimeOut = timeout;
@@ -1302,139 +1146,116 @@ int cmCTest::RunTest(std::vector<const char*> argv,
     inst.SetStreams(&oss, &oss);
 
     std::vector<std::string> args;
-    for(unsigned int i =0; i < argv.size(); ++i)
-      {
-      if(argv[i])
-        {
+    for (unsigned int i = 0; i < argv.size(); ++i) {
+      if (argv[i]) {
         // make sure we pass the timeout in for any build and test
         // invocations. Since --build-generator is required this is a
         // good place to check for it, and to add the arguments in
-        if (strcmp(argv[i],"--build-generator") == 0 && timeout > 0)
-          {
+        if (strcmp(argv[i], "--build-generator") == 0 && timeout > 0) {
           args.push_back("--test-timeout");
           std::ostringstream msg;
           msg << timeout;
           args.push_back(msg.str());
-          }
-        args.push_back(argv[i]);
         }
+        args.push_back(argv[i]);
       }
-    if ( log )
-      {
+    }
+    if (log) {
       *log << "* Run internal CTest" << std::endl;
-      }
+    }
     std::string oldpath = cmSystemTools::GetCurrentWorkingDirectory();
 
     cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
-    if (modifyEnv)
-      {
+    if (modifyEnv) {
       saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment);
       cmSystemTools::AppendEnv(*environment);
-      }
+    }
 
     *retVal = inst.Run(args, output);
-    if(output)
-      {
+    if (output) {
       *output += oss.str();
-      }
-    if ( log && output)
-      {
+    }
+    if (log && output) {
       *log << *output;
-      }
+    }
     cmSystemTools::ChangeDirectory(oldpath);
-    if(output)
-      {
+    if (output) {
       cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
                  "Internal cmCTest object used to run test." << std::endl
-                 <<  *output << std::endl);
-      }
+                                                             << *output
+                                                             << std::endl);
+    }
 
     return cmsysProcess_State_Exited;
-    }
+  }
   std::vector<char> tempOutput;
-  if ( output )
-    {
+  if (output) {
     *output = "";
-    }
+  }
 
   cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
-  if (modifyEnv)
-    {
+  if (modifyEnv) {
     saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment);
     cmSystemTools::AppendEnv(*environment);
-    }
+  }
 
   cmsysProcess* cp = cmsysProcess_New();
   cmsysProcess_SetCommand(cp, &*argv.begin());
   cmCTestLog(this, DEBUG, "Command is: " << argv[0] << std::endl);
-  if(cmSystemTools::GetRunCommandHideConsole())
-    {
+  if (cmSystemTools::GetRunCommandHideConsole()) {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
-    }
+  }
 
   cmsysProcess_SetTimeout(cp, timeout);
   cmsysProcess_Execute(cp);
 
   char* data;
   int length;
-  while(cmsysProcess_WaitForData(cp, &data, &length, 0))
-    {
-    if ( output )
-      {
-      tempOutput.insert(tempOutput.end(), data, data+length);
-      }
+  while (cmsysProcess_WaitForData(cp, &data, &length, 0)) {
+    if (output) {
+      tempOutput.insert(tempOutput.end(), data, data + length);
+    }
     cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
-    if ( log )
-      {
+    if (log) {
       log->write(data, length);
-      }
     }
+  }
 
   cmsysProcess_WaitForExit(cp, 0);
-  if(output && tempOutput.begin() != tempOutput.end())
-    {
+  if (output && tempOutput.begin() != tempOutput.end()) {
     output->append(&*tempOutput.begin(), tempOutput.size());
-    }
+  }
   cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "-- Process completed"
-    << std::endl);
+               << std::endl);
 
   int result = cmsysProcess_GetState(cp);
 
-  if(result == cmsysProcess_State_Exited)
-    {
+  if (result == cmsysProcess_State_Exited) {
     *retVal = cmsysProcess_GetExitValue(cp);
-    if(*retVal != 0 && this->OutputTestOutputOnTestFailure)
-      {
-        OutputTestErrors(tempOutput);
-      }
+    if (*retVal != 0 && this->OutputTestOutputOnTestFailure) {
+      OutputTestErrors(tempOutput);
+    }
+  } else if (result == cmsysProcess_State_Exception) {
+    if (this->OutputTestOutputOnTestFailure) {
+      OutputTestErrors(tempOutput);
     }
-  else if(result == cmsysProcess_State_Exception)
-    {
-    if(this->OutputTestOutputOnTestFailure)
-      {
-        OutputTestErrors(tempOutput);
-      }
     *retVal = cmsysProcess_GetExitException(cp);
     std::string outerr = "\n*** Exception executing: ";
     outerr += cmsysProcess_GetExceptionString(cp);
-    if(output)
-      {
+    if (output) {
       *output += outerr;
-      }
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl
-      << std::flush);
     }
-  else if(result == cmsysProcess_State_Error)
-    {
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl
+                                                            << std::flush);
+  } else if (result == cmsysProcess_State_Error) {
     std::string outerr = "\n*** ERROR executing: ";
     outerr += cmsysProcess_GetErrorString(cp);
-    if(output)
-      {
+    if (output) {
       *output += outerr;
-      }
-    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl
-      << std::flush);
     }
+    cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl
+                                                            << std::flush);
+  }
   cmsysProcess_Delete(cp);
 
   return result;
@@ -1444,45 +1265,40 @@ std::string cmCTest::SafeBuildIdField(const std::string& value)
 {
   std::string safevalue(value);
 
-  if (safevalue != "")
-    {
+  if (safevalue != "") {
     // Disallow non-filename and non-space whitespace characters.
     // If they occur, replace them with ""
     //
-    const char *disallowed = "\\:*?\"<>|\n\r\t\f\v";
+    const char* disallowed = "\\:*?\"<>|\n\r\t\f\v";
 
-    if (safevalue.find_first_of(disallowed) != value.npos)
-      {
+    if (safevalue.find_first_of(disallowed) != value.npos) {
       std::string::size_type i = 0;
       std::string::size_type n = strlen(disallowed);
       char replace[2];
       replace[1] = 0;
 
-      for (i= 0; i<n; ++i)
-        {
+      for (i = 0; i < n; ++i) {
         replace[0] = disallowed[i];
         cmSystemTools::ReplaceString(safevalue, replace, "");
-        }
       }
     }
+  }
 
-  if (safevalue == "")
-    {
+  if (safevalue == "") {
     safevalue = "(empty)";
-    }
+  }
 
   return safevalue;
 }
 
 void cmCTest::StartXML(cmXMLWriter& xml, bool append)
 {
-  if(this->CurrentTag.empty())
-    {
-    cmCTestLog(this, ERROR_MESSAGE,
-               "Current Tag empty, this may mean"
-               " NightlStartTime was not set correctly." << std::endl);
+  if (this->CurrentTag.empty()) {
+    cmCTestLog(this, ERROR_MESSAGE, "Current Tag empty, this may mean"
+                                    " NightlStartTime was not set correctly."
+                 << std::endl);
     cmSystemTools::SetFatalErrorOccured();
-    }
+  }
 
   // find out about the system
   cmsys::SystemInformation info;
@@ -1490,12 +1306,12 @@ void cmCTest::StartXML(cmXMLWriter& xml, bool append)
   info.RunOSCheck();
   info.RunMemoryCheck();
 
-  std::string buildname = cmCTest::SafeBuildIdField(
-    this->GetCTestConfiguration("BuildName"));
-  std::string stamp = cmCTest::SafeBuildIdField(
-    this->CurrentTag + "-" + this->GetTestModelString());
-  std::string site = cmCTest::SafeBuildIdField(
-    this->GetCTestConfiguration("Site"));
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->GetCTestConfiguration("BuildName"));
+  std::string stamp = cmCTest::SafeBuildIdField(this->CurrentTag + "-" +
+                                                this->GetTestModelString());
+  std::string site =
+    cmCTest::SafeBuildIdField(this->GetCTestConfiguration("Site"));
 
   xml.StartDocument();
   xml.StartElement("Site");
@@ -1504,14 +1320,13 @@ void cmCTest::StartXML(cmXMLWriter& xml, bool append)
   xml.Attribute("BuildStamp", stamp);
   xml.Attribute("Name", site);
   xml.Attribute("Generator",
-                     std::string("ctest-") + cmVersion::GetCMakeVersion());
-  if(append)
-    {
+                std::string("ctest-") + cmVersion::GetCMakeVersion());
+  if (append) {
     xml.Attribute("Append", "true");
-    }
+  }
   xml.Attribute("CompilerName", this->GetCTestConfiguration("Compiler"));
   xml.Attribute("CompilerVersion",
-    this->GetCTestConfiguration("CompilerVersion"));
+                this->GetCTestConfiguration("CompilerVersion"));
   xml.Attribute("OSName", info.GetOSName());
   xml.Attribute("Hostname", info.GetHostname());
   xml.Attribute("OSRelease", info.GetOSRelease());
@@ -1528,14 +1343,13 @@ void cmCTest::StartXML(cmXMLWriter& xml, bool append)
   xml.Attribute("TotalVirtualMemory", info.GetTotalVirtualMemory());
   xml.Attribute("TotalPhysicalMemory", info.GetTotalPhysicalMemory());
   xml.Attribute("LogicalProcessorsPerPhysical",
-                     info.GetLogicalProcessorsPerPhysical());
+                info.GetLogicalProcessorsPerPhysical());
   xml.Attribute("ProcessorClockFrequency", info.GetProcessorClockFrequency());
 
   std::string changeId = this->GetCTestConfiguration("ChangeId");
-  if(!changeId.empty())
-    {
+  if (!changeId.empty()) {
     xml.Attribute("ChangeId", changeId);
-    }
+  }
 
   this->AddSiteProperties(xml);
 }
@@ -1544,47 +1358,40 @@ void cmCTest::AddSiteProperties(cmXMLWriter& xml)
 {
   cmCTestScriptHandler* ch =
     static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
-  cmake* cm =  ch->GetCMake();
+  cmake* cm = ch->GetCMake();
   // if no CMake then this is the old style script and props like
   // this will not work anyway.
-  if(!cm)
-    {
+  if (!cm) {
     return;
-    }
+  }
   // This code should go when cdash is changed to use labels only
-  const char* subproject = cm->GetState()
-                             ->GetGlobalProperty("SubProject");
-  if(subproject)
-    {
+  const char* subproject = cm->GetState()->GetGlobalProperty("SubProject");
+  if (subproject) {
     xml.StartElement("Subproject");
     xml.Attribute("name", subproject);
     const char* labels =
-      ch->GetCMake()->GetState()
-                    ->GetGlobalProperty("SubProjectLabels");
-    if(labels)
-      {
+      ch->GetCMake()->GetState()->GetGlobalProperty("SubProjectLabels");
+    if (labels) {
       xml.StartElement("Labels");
       std::string l = labels;
       std::vector<std::string> args;
       cmSystemTools::ExpandListArgument(l, args);
-      for(std::vector<std::string>::iterator i = args.begin();
-          i != args.end(); ++i)
-        {
+      for (std::vector<std::string>::iterator i = args.begin();
+           i != args.end(); ++i) {
         xml.Element("Label", *i);
-        }
-      xml.EndElement();
       }
-    xml.EndElement();
+      xml.EndElement();
     }
+    xml.EndElement();
+  }
 
   // This code should stay when cdash only does label based sub-projects
   const char* label = cm->GetState()->GetGlobalProperty("Label");
-  if(label)
-    {
+  if (label) {
     xml.StartElement("Labels");
     xml.Element("Label", label);
     xml.EndElement();
-    }
+  }
 }
 
 void cmCTest::EndXML(cmXMLWriter& xml)
@@ -1594,25 +1401,27 @@ void cmCTest::EndXML(cmXMLWriter& xml)
 }
 
 int cmCTest::GenerateCTestNotesOutput(cmXMLWriter& xml,
-  const cmCTest::VectorOfStrings& files)
+                                      const cmCTest::VectorOfStrings& files)
 {
-  std::string buildname = cmCTest::SafeBuildIdField(
-    this->GetCTestConfiguration("BuildName"));
+  std::string buildname =
+    cmCTest::SafeBuildIdField(this->GetCTestConfiguration("BuildName"));
   cmCTest::VectorOfStrings::const_iterator it;
   xml.StartDocument();
-  xml.ProcessingInstruction("xml-stylesheet", "type=\"text/xsl\" "
-    "href=\"Dart/Source/Server/XSL/Build.xsl "
-    "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
+  xml.ProcessingInstruction("xml-stylesheet",
+                            "type=\"text/xsl\" "
+                            "href=\"Dart/Source/Server/XSL/Build.xsl "
+                            "<file:///Dart/Source/Server/XSL/Build.xsl> \"");
   xml.StartElement("Site");
   xml.Attribute("BuildName", buildname);
-  xml.Attribute("BuildStamp", this->CurrentTag+"-"+this->GetTestModelString());
+  xml.Attribute("BuildStamp",
+                this->CurrentTag + "-" + this->GetTestModelString());
   xml.Attribute("Name", this->GetCTestConfiguration("Site"));
-  xml.Attribute("Generator",std::string("ctest")+cmVersion::GetCMakeVersion());
+  xml.Attribute("Generator",
+                std::string("ctest") + cmVersion::GetCMakeVersion());
   this->AddSiteProperties(xml);
   xml.StartElement("Notes");
 
-  for ( it = files.begin(); it != files.end(); it ++ )
-    {
+  for (it = files.begin(); it != files.end(); it++) {
     cmCTestLog(this, OUTPUT, "\tAdd file: " << *it << std::endl);
     std::string note_time = this->CurrentTime();
     xml.StartElement("Note");
@@ -1621,39 +1430,34 @@ int cmCTest::GenerateCTestNotesOutput(cmXMLWriter& xml,
     xml.Element("DateTime", note_time);
     xml.StartElement("Text");
     cmsys::ifstream ifs(it->c_str());
-    if ( ifs )
-      {
+    if (ifs) {
       std::string line;
-      while ( cmSystemTools::GetLineFromStream(ifs, line) )
-        {
+      while (cmSystemTools::GetLineFromStream(ifs, line)) {
         xml.Content(line);
         xml.Content("\n");
-        }
-      ifs.close();
       }
-    else
-      {
+      ifs.close();
+    } else {
       xml.Content("Problem reading file: " + *it + "\n");
-      cmCTestLog(this, ERROR_MESSAGE, "Problem reading file: " << *it
-        << " while creating notes" << std::endl);
-      }
+      cmCTestLog(this, ERROR_MESSAGE, "Problem reading file: "
+                   << *it << " while creating notes" << std::endl);
+    }
     xml.EndElement(); // Text
     xml.EndElement(); // Note
-    }
+  }
   xml.EndElement(); // Notes
   xml.EndElement(); // Site
   xml.EndDocument();
   return 1;
 }
 
-int cmCTest::GenerateNotesFile(const VectorOfStrings &files)
+int cmCTest::GenerateNotesFile(const VectorOfStrings& files)
 {
   cmGeneratedFileStream ofs;
-  if ( !this->OpenOutputFile(this->CurrentTag, "Notes.xml", ofs) )
-    {
+  if (!this->OpenOutputFile(this->CurrentTag, "Notes.xml", ofs)) {
     cmCTestLog(this, ERROR_MESSAGE, "Cannot open notes file" << std::endl);
     return 1;
-    }
+  }
   cmXMLWriter xml(ofs);
   this->GenerateCTestNotesOutput(xml, files);
   return 0;
@@ -1661,20 +1465,18 @@ int cmCTest::GenerateNotesFile(const VectorOfStrings &files)
 
 int cmCTest::GenerateNotesFile(const char* cfiles)
 {
-  if ( !cfiles )
-    {
+  if (!cfiles) {
     return 1;
-    }
+  }
 
   VectorOfStrings files;
 
   cmCTestLog(this, OUTPUT, "Create notes file" << std::endl);
 
   files = cmSystemTools::SplitString(cfiles, ';');
-  if (files.empty())
-    {
+  if (files.empty()) {
     return 1;
-    }
+  }
 
   return this->GenerateNotesFile(files);
 }
@@ -1685,13 +1487,13 @@ std::string cmCTest::Base64GzipEncodeFile(std::string file)
   std::vector<std::string> files;
   files.push_back(file);
 
-  if(!cmSystemTools::CreateTar(tarFile.c_str(), files,
-                               cmSystemTools::TarCompressGZip, false))
-    {
+  if (!cmSystemTools::CreateTar(tarFile.c_str(), files,
+                                cmSystemTools::TarCompressGZip, false)) {
     cmCTestLog(this, ERROR_MESSAGE, "Error creating tar while "
-      "encoding file: " << file << std::endl);
+                                    "encoding file: "
+                 << file << std::endl);
     return "";
-    }
+  }
   std::string base64 = this->Base64EncodeFile(tarFile);
   cmSystemTools::RemoveFile(tarFile);
   return base64;
@@ -1702,77 +1504,64 @@ std::string cmCTest::Base64EncodeFile(std::string file)
   size_t const len = cmSystemTools::FileLength(file);
   cmsys::ifstream ifs(file.c_str(), std::ios::in
 #ifdef _WIN32
-    | std::ios::binary
+                        | std::ios::binary
 #endif
-    );
-  unsigned char *file_buffer = new unsigned char [ len + 1 ];
+                      );
+  unsigned char* file_buffer = new unsigned char[len + 1];
   ifs.read(reinterpret_cast<char*>(file_buffer), len);
   ifs.close();
 
-  unsigned char *encoded_buffer
-    = new unsigned char [ (len * 3) / 2 + 5 ];
+  unsigned char* encoded_buffer = new unsigned char[(len * 3) / 2 + 5];
 
-  size_t const rlen
-    = cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
+  size_t const rlen = cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
 
   std::string base64 = "";
-  for(size_t i = 0; i < rlen; i++)
-    {
+  for (size_t i = 0; i < rlen; i++) {
     base64 += encoded_buffer[i];
-    }
-  delete [] file_buffer;
-  delete [] encoded_buffer;
+  }
+  delete[] file_buffer;
+  delete[] encoded_buffer;
 
   return base64;
 }
 
-
-bool cmCTest::SubmitExtraFiles(const VectorOfStrings &files)
+bool cmCTest::SubmitExtraFiles(const VectorOfStrings& files)
 {
   VectorOfStrings::const_iterator it;
-  for ( it = files.begin();
-    it != files.end();
-    ++ it )
-    {
-    if ( !cmSystemTools::FileExists(it->c_str()) )
-      {
+  for (it = files.begin(); it != files.end(); ++it) {
+    if (!cmSystemTools::FileExists(it->c_str())) {
       cmCTestLog(this, ERROR_MESSAGE, "Cannot find extra file: "
-        << *it << " to submit."
-        << std::endl;);
+                   << *it << " to submit." << std::endl;);
       return false;
-      }
-    this->AddSubmitFile(PartExtraFiles, it->c_str());
     }
+    this->AddSubmitFile(PartExtraFiles, it->c_str());
+  }
   return true;
 }
 
 bool cmCTest::SubmitExtraFiles(const char* cfiles)
 {
-  if ( !cfiles )
-    {
+  if (!cfiles) {
     return 1;
-    }
+  }
 
   VectorOfStrings files;
 
   cmCTestLog(this, OUTPUT, "Submit extra files" << std::endl);
 
   files = cmSystemTools::SplitString(cfiles, ';');
-  if (files.empty())
-    {
+  if (files.empty()) {
     return 1;
-    }
+  }
 
   return this->SubmitExtraFiles(files);
 }
 
-
 // for a -D argument convert the next argument into
 // the proper list of dashboard steps via SetTest
-bool cmCTest::AddTestsForDashboardType(std::string &targ)
+bool cmCTest::AddTestsForDashboardType(std::string& targ)
 {
-  if ( targ == "Experimental" )
-    {
+  if (targ == "Experimental") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Start");
     this->SetTest("Configure");
@@ -1780,50 +1569,31 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
     this->SetTest("Test");
     this->SetTest("Coverage");
     this->SetTest("Submit");
-    }
-  else if ( targ == "ExperimentalStart" )
-    {
+  } else if (targ == "ExperimentalStart") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Start");
-    }
-  else if ( targ == "ExperimentalUpdate" )
-    {
+  } else if (targ == "ExperimentalUpdate") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Update");
-    }
-  else if ( targ == "ExperimentalConfigure" )
-    {
+  } else if (targ == "ExperimentalConfigure") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Configure");
-    }
-  else if ( targ == "ExperimentalBuild" )
-    {
+  } else if (targ == "ExperimentalBuild") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Build");
-    }
-  else if ( targ == "ExperimentalTest" )
-    {
+  } else if (targ == "ExperimentalTest") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Test");
-    }
-  else if ( targ == "ExperimentalMemCheck"
-            || targ == "ExperimentalPurify" )
-    {
+  } else if (targ == "ExperimentalMemCheck" || targ == "ExperimentalPurify") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("MemCheck");
-    }
-  else if ( targ == "ExperimentalCoverage" )
-    {
+  } else if (targ == "ExperimentalCoverage") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Coverage");
-    }
-  else if ( targ == "ExperimentalSubmit" )
-    {
+  } else if (targ == "ExperimentalSubmit") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Submit");
-    }
-  else if ( targ == "Continuous" )
-    {
+  } else if (targ == "Continuous") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Start");
     this->SetTest("Update");
@@ -1832,50 +1602,31 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
     this->SetTest("Test");
     this->SetTest("Coverage");
     this->SetTest("Submit");
-    }
-  else if ( targ == "ContinuousStart" )
-    {
+  } else if (targ == "ContinuousStart") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Start");
-    }
-  else if ( targ == "ContinuousUpdate" )
-    {
+  } else if (targ == "ContinuousUpdate") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Update");
-    }
-  else if ( targ == "ContinuousConfigure" )
-    {
+  } else if (targ == "ContinuousConfigure") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Configure");
-    }
-  else if ( targ == "ContinuousBuild" )
-    {
+  } else if (targ == "ContinuousBuild") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Build");
-    }
-  else if ( targ == "ContinuousTest" )
-    {
+  } else if (targ == "ContinuousTest") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Test");
-    }
-  else if ( targ == "ContinuousMemCheck"
-        || targ == "ContinuousPurify" )
-    {
+  } else if (targ == "ContinuousMemCheck" || targ == "ContinuousPurify") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("MemCheck");
-    }
-  else if ( targ == "ContinuousCoverage" )
-    {
+  } else if (targ == "ContinuousCoverage") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Coverage");
-    }
-  else if ( targ == "ContinuousSubmit" )
-    {
+  } else if (targ == "ContinuousSubmit") {
     this->SetTestModel(cmCTest::CONTINUOUS);
     this->SetTest("Submit");
-    }
-  else if ( targ == "Nightly" )
-    {
+  } else if (targ == "Nightly") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Start");
     this->SetTest("Update");
@@ -1884,50 +1635,31 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
     this->SetTest("Test");
     this->SetTest("Coverage");
     this->SetTest("Submit");
-    }
-  else if ( targ == "NightlyStart" )
-    {
+  } else if (targ == "NightlyStart") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Start");
-    }
-  else if ( targ == "NightlyUpdate" )
-    {
+  } else if (targ == "NightlyUpdate") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Update");
-    }
-  else if ( targ == "NightlyConfigure" )
-    {
+  } else if (targ == "NightlyConfigure") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Configure");
-    }
-  else if ( targ == "NightlyBuild" )
-    {
+  } else if (targ == "NightlyBuild") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Build");
-    }
-  else if ( targ == "NightlyTest" )
-    {
+  } else if (targ == "NightlyTest") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Test");
-    }
-  else if ( targ == "NightlyMemCheck"
-            || targ == "NightlyPurify" )
-    {
+  } else if (targ == "NightlyMemCheck" || targ == "NightlyPurify") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("MemCheck");
-    }
-  else if ( targ == "NightlyCoverage" )
-    {
+  } else if (targ == "NightlyCoverage") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Coverage");
-    }
-  else if ( targ == "NightlySubmit" )
-    {
+  } else if (targ == "NightlySubmit") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Submit");
-    }
-  else if ( targ == "MemoryCheck" )
-    {
+  } else if (targ == "MemoryCheck") {
     this->SetTestModel(cmCTest::EXPERIMENTAL);
     this->SetTest("Start");
     this->SetTest("Configure");
@@ -1935,9 +1667,7 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
     this->SetTest("MemCheck");
     this->SetTest("Coverage");
     this->SetTest("Submit");
-    }
-  else if ( targ == "NightlyMemoryCheck" )
-    {
+  } else if (targ == "NightlyMemoryCheck") {
     this->SetTestModel(cmCTest::NIGHTLY);
     this->SetTest("Start");
     this->SetTest("Update");
@@ -1946,391 +1676,326 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
     this->SetTest("MemCheck");
     this->SetTest("Coverage");
     this->SetTest("Submit");
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
   return true;
 }
 
-
-void cmCTest::ErrorMessageUnknownDashDValue(std::string &val)
+void cmCTest::ErrorMessageUnknownDashDValue(std::string& val)
 {
   cmCTestLog(this, ERROR_MESSAGE,
-    "CTest -D called with incorrect option: " << val << std::endl);
+             "CTest -D called with incorrect option: " << val << std::endl);
 
-  cmCTestLog(this, ERROR_MESSAGE,
-    "Available options are:" << std::endl
-    << "  ctest -D Continuous" << std::endl
-    << "  ctest -D Continuous(Start|Update|Configure|Build)" << std::endl
-    << "  ctest -D Continuous(Test|Coverage|MemCheck|Submit)" << std::endl
-    << "  ctest -D Experimental" << std::endl
-    << "  ctest -D Experimental(Start|Update|Configure|Build)" << std::endl
-    << "  ctest -D Experimental(Test|Coverage|MemCheck|Submit)" << std::endl
-    << "  ctest -D Nightly" << std::endl
-    << "  ctest -D Nightly(Start|Update|Configure|Build)" << std::endl
-    << "  ctest -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl
-    << "  ctest -D NightlyMemoryCheck" << std::endl);
+  cmCTestLog(
+    this, ERROR_MESSAGE, "Available options are:"
+      << std::endl
+      << "  ctest -D Continuous" << std::endl
+      << "  ctest -D Continuous(Start|Update|Configure|Build)" << std::endl
+      << "  ctest -D Continuous(Test|Coverage|MemCheck|Submit)" << std::endl
+      << "  ctest -D Experimental" << std::endl
+      << "  ctest -D Experimental(Start|Update|Configure|Build)" << std::endl
+      << "  ctest -D Experimental(Test|Coverage|MemCheck|Submit)" << std::endl
+      << "  ctest -D Nightly" << std::endl
+      << "  ctest -D Nightly(Start|Update|Configure|Build)" << std::endl
+      << "  ctest -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl
+      << "  ctest -D NightlyMemoryCheck" << std::endl);
 }
 
-
 bool cmCTest::CheckArgument(const std::string& arg, const char* varg1,
-  const char* varg2)
+                            const char* varg2)
 {
   return (varg1 && arg == varg1) || (varg2 && arg == varg2);
 }
 
-
 // Processes one command line argument (and its arguments if any)
 // for many simple options and then returns
-bool cmCTest::HandleCommandLineArguments(size_t &i,
-                                         std::vector<std::string> &args,
+bool cmCTest::HandleCommandLineArguments(size_t& i,
+                                         std::vector<std::string>& args,
                                          std::string& errormsg)
 {
   std::string arg = args[i];
-  if(this->CheckArgument(arg, "-F"))
-    {
+  if (this->CheckArgument(arg, "-F")) {
     this->Failover = true;
-    }
-  if(this->CheckArgument(arg, "-j", "--parallel") && i < args.size() - 1)
-    {
+  }
+  if (this->CheckArgument(arg, "-j", "--parallel") && i < args.size() - 1) {
     i++;
     int plevel = atoi(args[i].c_str());
     this->SetParallelLevel(plevel);
     this->ParallelLevelSetInCli = true;
-    }
-  else if(arg.find("-j") == 0)
-    {
+  } else if (arg.find("-j") == 0) {
     int plevel = atoi(arg.substr(2).c_str());
     this->SetParallelLevel(plevel);
     this->ParallelLevelSetInCli = true;
-    }
-  if(this->CheckArgument(arg, "--repeat-until-fail"))
-    {
-    if( i >= args.size() - 1)
-      {
+  }
+  if (this->CheckArgument(arg, "--repeat-until-fail")) {
+    if (i >= args.size() - 1) {
       errormsg = "'--repeat-until-fail' requires an argument";
       return false;
-      }
+    }
     i++;
     long repeat = 1;
-    if(!cmSystemTools::StringToLong(args[i].c_str(), &repeat))
-      {
-      errormsg = "'--repeat-until-fail' given non-integer value '"
-        + args[i] + "'";
+    if (!cmSystemTools::StringToLong(args[i].c_str(), &repeat)) {
+      errormsg =
+        "'--repeat-until-fail' given non-integer value '" + args[i] + "'";
       return false;
-      }
+    }
     this->RepeatTests = static_cast<int>(repeat);
-    if(repeat > 1)
-      {
+    if (repeat > 1) {
       this->RepeatUntilFail = true;
-      }
     }
+  }
 
-  if(this->CheckArgument(arg, "--test-load") && i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "--test-load") && i < args.size() - 1) {
     i++;
     unsigned long load;
-    if (cmSystemTools::StringToULong(args[i].c_str(), &load))
-      {
+    if (cmSystemTools::StringToULong(args[i].c_str(), &load)) {
       this->SetTestLoad(load);
-      }
-    else
-      {
+    } else {
       cmCTestLog(this, WARNING,
                  "Invalid value for 'Test Load' : " << args[i] << std::endl);
-      }
     }
+  }
 
-  if(this->CheckArgument(arg, "--no-compress-output"))
-    {
+  if (this->CheckArgument(arg, "--no-compress-output")) {
     this->CompressTestOutput = false;
     this->CompressMemCheckOutput = false;
-    }
+  }
 
-  if(this->CheckArgument(arg, "--print-labels"))
-    {
+  if (this->CheckArgument(arg, "--print-labels")) {
     this->PrintLabels = true;
-    }
+  }
 
-  if(this->CheckArgument(arg, "--http1.0"))
-    {
+  if (this->CheckArgument(arg, "--http1.0")) {
     this->UseHTTP10 = true;
-    }
+  }
 
-  if(this->CheckArgument(arg, "--timeout") && i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "--timeout") && i < args.size() - 1) {
     i++;
     double timeout = (double)atof(args[i].c_str());
     this->GlobalTimeout = timeout;
-    }
+  }
 
-  if(this->CheckArgument(arg, "--stop-time") && i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "--stop-time") && i < args.size() - 1) {
     i++;
     this->SetStopTime(args[i]);
-    }
+  }
 
-  if(this->CheckArgument(arg, "-C", "--build-config") &&
-     i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "-C", "--build-config") &&
+      i < args.size() - 1) {
     i++;
     this->SetConfigType(args[i].c_str());
-    }
+  }
 
-  if(this->CheckArgument(arg, "--debug"))
-    {
+  if (this->CheckArgument(arg, "--debug")) {
     this->Debug = true;
     this->ShowLineNumbers = true;
-    }
-  if(this->CheckArgument(arg, "--track") && i < args.size() - 1)
-    {
+  }
+  if (this->CheckArgument(arg, "--track") && i < args.size() - 1) {
     i++;
     this->SpecificTrack = args[i];
-    }
-  if(this->CheckArgument(arg, "--show-line-numbers"))
-    {
+  }
+  if (this->CheckArgument(arg, "--show-line-numbers")) {
     this->ShowLineNumbers = true;
-    }
-  if(this->CheckArgument(arg, "--no-label-summary"))
-    {
+  }
+  if (this->CheckArgument(arg, "--no-label-summary")) {
     this->LabelSummary = false;
-    }
-  if(this->CheckArgument(arg, "-Q", "--quiet"))
-    {
+  }
+  if (this->CheckArgument(arg, "-Q", "--quiet")) {
     this->Quiet = true;
-    }
-  if(this->CheckArgument(arg, "-V", "--verbose"))
-    {
+  }
+  if (this->CheckArgument(arg, "-V", "--verbose")) {
     this->Verbose = true;
-    }
-  if(this->CheckArgument(arg, "-B"))
-    {
+  }
+  if (this->CheckArgument(arg, "-B")) {
     this->BatchJobs = true;
-    }
-  if(this->CheckArgument(arg, "-VV", "--extra-verbose"))
-    {
+  }
+  if (this->CheckArgument(arg, "-VV", "--extra-verbose")) {
     this->ExtraVerbose = true;
     this->Verbose = true;
-    }
-  if(this->CheckArgument(arg, "--output-on-failure"))
-    {
+  }
+  if (this->CheckArgument(arg, "--output-on-failure")) {
     this->OutputTestOutputOnTestFailure = true;
-    }
+  }
   if (this->CheckArgument(arg, "--test-output-size-passed") &&
-      i < args.size() - 1)
-    {
+      i < args.size() - 1) {
     i++;
     long outputSize;
-    if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize))
-      {
-      if (cmCTestTestHandler *pCTestTestHandler =
-          static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"]))
-        {
+    if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize)) {
+      if (cmCTestTestHandler* pCTestTestHandler =
+            static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"])) {
         pCTestTestHandler->SetTestOutputSizePassed(int(outputSize));
-        }
       }
-    else
-      {
+    } else {
       cmCTestLog(this, WARNING,
-                 "Invalid value for '--test-output-size-passed': " <<
-                 args[i] << "\n");
-      }
+                 "Invalid value for '--test-output-size-passed': " << args[i]
+                                                                   << "\n");
     }
+  }
   if (this->CheckArgument(arg, "--test-output-size-failed") &&
-      i < args.size() - 1)
-    {
+      i < args.size() - 1) {
     i++;
     long outputSize;
-    if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize))
-      {
-      if (cmCTestTestHandler *pCTestTestHandler =
-          static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"]))
-        {
+    if (cmSystemTools::StringToLong(args[i].c_str(), &outputSize)) {
+      if (cmCTestTestHandler* pCTestTestHandler =
+            static_cast<cmCTestTestHandler*>(this->TestingHandlers["test"])) {
         pCTestTestHandler->SetTestOutputSizeFailed(int(outputSize));
-        }
       }
-    else
-      {
+    } else {
       cmCTestLog(this, WARNING,
-                 "Invalid value for '--test-output-size-failed': " <<
-                 args[i] << "\n");
-      }
+                 "Invalid value for '--test-output-size-failed': " << args[i]
+                                                                   << "\n");
     }
-  if(this->CheckArgument(arg, "-N", "--show-only"))
-    {
+  }
+  if (this->CheckArgument(arg, "-N", "--show-only")) {
     this->ShowOnly = true;
-    }
+  }
 
-  if(this->CheckArgument(arg, "-O", "--output-log") && i < args.size() - 1 )
-    {
+  if (this->CheckArgument(arg, "-O", "--output-log") && i < args.size() - 1) {
     i++;
     this->SetOutputLogFileName(args[i].c_str());
-    }
+  }
 
-  if(this->CheckArgument(arg, "--tomorrow-tag"))
-    {
+  if (this->CheckArgument(arg, "--tomorrow-tag")) {
     this->TomorrowTag = true;
-    }
-  if(this->CheckArgument(arg, "--force-new-ctest-process"))
-    {
+  }
+  if (this->CheckArgument(arg, "--force-new-ctest-process")) {
     this->ForceNewCTestProcess = true;
-    }
-  if(this->CheckArgument(arg, "-W", "--max-width") && i < args.size() - 1)
-    {
+  }
+  if (this->CheckArgument(arg, "-W", "--max-width") && i < args.size() - 1) {
     i++;
     this->MaxTestNameWidth = atoi(args[i].c_str());
-    }
-  if(this->CheckArgument(arg, "--interactive-debug-mode") &&
-     i < args.size() - 1 )
-    {
+  }
+  if (this->CheckArgument(arg, "--interactive-debug-mode") &&
+      i < args.size() - 1) {
     i++;
     this->InteractiveDebugMode = cmSystemTools::IsOn(args[i].c_str());
-    }
-  if(this->CheckArgument(arg, "--submit-index") && i < args.size() - 1 )
-    {
+  }
+  if (this->CheckArgument(arg, "--submit-index") && i < args.size() - 1) {
     i++;
     this->SubmitIndex = atoi(args[i].c_str());
-    if ( this->SubmitIndex < 0 )
-      {
+    if (this->SubmitIndex < 0) {
       this->SubmitIndex = 0;
-      }
     }
+  }
 
-  if(this->CheckArgument(arg, "--overwrite") && i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "--overwrite") && i < args.size() - 1) {
     i++;
     this->AddCTestConfigurationOverwrite(args[i]);
-    }
-  if(this->CheckArgument(arg, "-A", "--add-notes") && i < args.size() - 1)
-    {
+  }
+  if (this->CheckArgument(arg, "-A", "--add-notes") && i < args.size() - 1) {
     this->ProduceXML = true;
     this->SetTest("Notes");
     i++;
     this->SetNotesFiles(args[i].c_str());
-    }
+  }
 
   // options that control what tests are run
-  if(this->CheckArgument(arg, "-I", "--tests-information") &&
-     i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "-I", "--tests-information") &&
+      i < args.size() - 1) {
     i++;
     this->GetHandler("test")->SetPersistentOption("TestsToRunInformation",
                                                   args[i].c_str());
-    this->GetHandler("memcheck")->
-      SetPersistentOption("TestsToRunInformation",args[i].c_str());
-    }
-  if(this->CheckArgument(arg, "-U", "--union"))
-    {
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("TestsToRunInformation", args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-U", "--union")) {
     this->GetHandler("test")->SetPersistentOption("UseUnion", "true");
     this->GetHandler("memcheck")->SetPersistentOption("UseUnion", "true");
-    }
-  if(this->CheckArgument(arg, "-R", "--tests-regex") && i < args.size() - 1)
-    {
+  }
+  if (this->CheckArgument(arg, "-R", "--tests-regex") && i < args.size() - 1) {
     i++;
-    this->GetHandler("test")->
-      SetPersistentOption("IncludeRegularExpression", args[i].c_str());
-    this->GetHandler("memcheck")->
-      SetPersistentOption("IncludeRegularExpression", args[i].c_str());
-    }
-  if(this->CheckArgument(arg, "-L", "--label-regex") && i < args.size() - 1)
-    {
+    this->GetHandler("test")->SetPersistentOption("IncludeRegularExpression",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("IncludeRegularExpression", args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-L", "--label-regex") && i < args.size() - 1) {
     i++;
-    this->GetHandler("test")->
-      SetPersistentOption("LabelRegularExpression", args[i].c_str());
-    this->GetHandler("memcheck")->
-      SetPersistentOption("LabelRegularExpression", args[i].c_str());
-    }
-  if(this->CheckArgument(arg, "-LE", "--label-exclude") && i < args.size() - 1)
-    {
+    this->GetHandler("test")->SetPersistentOption("LabelRegularExpression",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("LabelRegularExpression", args[i].c_str());
+  }
+  if (this->CheckArgument(arg, "-LE", "--label-exclude") &&
+      i < args.size() - 1) {
     i++;
-    this->GetHandler("test")->
-      SetPersistentOption("ExcludeLabelRegularExpression", args[i].c_str());
-    this->GetHandler("memcheck")->
-      SetPersistentOption("ExcludeLabelRegularExpression", args[i].c_str());
-    }
+    this->GetHandler("test")->SetPersistentOption(
+      "ExcludeLabelRegularExpression", args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeLabelRegularExpression", args[i].c_str());
+  }
 
-  if(this->CheckArgument(arg, "-E", "--exclude-regex") &&
-     i < args.size() - 1)
-    {
+  if (this->CheckArgument(arg, "-E", "--exclude-regex") &&
+      i < args.size() - 1) {
     i++;
-    this->GetHandler("test")->
-      SetPersistentOption("ExcludeRegularExpression", args[i].c_str());
-    this->GetHandler("memcheck")->
-      SetPersistentOption("ExcludeRegularExpression", args[i].c_str());
-    }
+    this->GetHandler("test")->SetPersistentOption("ExcludeRegularExpression",
+                                                  args[i].c_str());
+    this->GetHandler("memcheck")
+      ->SetPersistentOption("ExcludeRegularExpression", args[i].c_str());
+  }
 
-  if(this->CheckArgument(arg, "--rerun-failed"))
-    {
+  if (this->CheckArgument(arg, "--rerun-failed")) {
     this->GetHandler("test")->SetPersistentOption("RerunFailed", "true");
     this->GetHandler("memcheck")->SetPersistentOption("RerunFailed", "true");
-    }
+  }
   return true;
 }
 
 // handle the -S -SR and -SP arguments
-void cmCTest::HandleScriptArguments(size_t &i,
-                                    std::vector<std::string> &args,
-                                    bool &SRArgumentSpecified)
+void cmCTest::HandleScriptArguments(size_t& i, std::vector<std::string>& args,
+                                    bool& SRArgumentSpecified)
 {
   std::string arg = args[i];
-  if(this->CheckArgument(arg, "-SP", "--script-new-process") &&
-     i < args.size() - 1 )
-    {
+  if (this->CheckArgument(arg, "-SP", "--script-new-process") &&
+      i < args.size() - 1) {
     this->RunConfigurationScript = true;
     i++;
-    cmCTestScriptHandler* ch
-      = static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+    cmCTestScriptHandler* ch =
+      static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
     // -SR is an internal argument, -SP should be ignored when it is passed
-    if (!SRArgumentSpecified)
-      {
-      ch->AddConfigurationScript(args[i].c_str(),false);
-      }
+    if (!SRArgumentSpecified) {
+      ch->AddConfigurationScript(args[i].c_str(), false);
     }
+  }
 
-  if(this->CheckArgument(arg, "-SR", "--script-run") &&
-     i < args.size() - 1 )
-    {
+  if (this->CheckArgument(arg, "-SR", "--script-run") && i < args.size() - 1) {
     SRArgumentSpecified = true;
     this->RunConfigurationScript = true;
     i++;
-    cmCTestScriptHandler* ch
-      = static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
-    ch->AddConfigurationScript(args[i].c_str(),true);
-    }
+    cmCTestScriptHandler* ch =
+      static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+    ch->AddConfigurationScript(args[i].c_str(), true);
+  }
 
-  if(this->CheckArgument(arg, "-S", "--script") && i < args.size() - 1 )
-    {
+  if (this->CheckArgument(arg, "-S", "--script") && i < args.size() - 1) {
     this->RunConfigurationScript = true;
     i++;
-    cmCTestScriptHandler* ch
-      = static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+    cmCTestScriptHandler* ch =
+      static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
     // -SR is an internal argument, -S should be ignored when it is passed
-    if (!SRArgumentSpecified)
-      {
-      ch->AddConfigurationScript(args[i].c_str(),true);
-      }
+    if (!SRArgumentSpecified) {
+      ch->AddConfigurationScript(args[i].c_str(), true);
     }
+  }
 }
 
-bool cmCTest::AddVariableDefinition(const std::string &arg)
+bool cmCTest::AddVariableDefinition(const std::string& arg)
 {
   std::string name;
   std::string value;
   cmState::CacheEntryType type = cmState::UNINITIALIZED;
 
-  if (cmake::ParseCacheEntry(arg, name, value, type))
-    {
+  if (cmake::ParseCacheEntry(arg, name, value, type)) {
     this->Definitions[name] = value;
     return true;
-    }
+  }
 
   return false;
 }
 
 // the main entry point of ctest, called from main
-int cmCTest::Run(std::vector<std::string> &args, std::string* output)
+int cmCTest::Run(std::vector<std::string>& args, std::string* output)
 {
   const char* ctestExec = "ctest";
   bool cmakeAndTest = false;
@@ -2339,161 +2004,136 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
 
   // copy the command line
   this->InitialCommandLineArguments.insert(
-      this->InitialCommandLineArguments.end(),
-      args.begin(), args.end());
+    this->InitialCommandLineArguments.end(), args.begin(), args.end());
 
   // process the command line arguments
-  for(size_t i=1; i < args.size(); ++i)
-    {
+  for (size_t i = 1; i < args.size(); ++i) {
     // handle the simple commandline arguments
     std::string errormsg;
-    if(!this->HandleCommandLineArguments(i,args, errormsg))
-      {
+    if (!this->HandleCommandLineArguments(i, args, errormsg)) {
       cmSystemTools::Error(errormsg.c_str());
       return 1;
-      }
+    }
 
     // handle the script arguments -S -SR -SP
-    this->HandleScriptArguments(i,args,SRArgumentSpecified);
+    this->HandleScriptArguments(i, args, SRArgumentSpecified);
 
     // handle a request for a dashboard
     std::string arg = args[i];
-    if(this->CheckArgument(arg, "-D", "--dashboard") && i < args.size() - 1 )
-      {
+    if (this->CheckArgument(arg, "-D", "--dashboard") && i < args.size() - 1) {
       this->ProduceXML = true;
       i++;
       std::string targ = args[i];
       // AddTestsForDashboard parses the dashboard type and converts it
       // into the separate stages
-      if (!this->AddTestsForDashboardType(targ))
-        {
-        if (!this->AddVariableDefinition(targ))
-          {
+      if (!this->AddTestsForDashboardType(targ)) {
+        if (!this->AddVariableDefinition(targ)) {
           this->ErrorMessageUnknownDashDValue(targ);
           executeTests = false;
-          }
         }
       }
+    }
 
     // If it's not exactly -D, but it starts with -D, then try to parse out
     // a variable definition from it, same as CMake does. Unsuccessful
     // attempts are simply ignored since previous ctest versions ignore
     // this too. (As well as many other unknown command line args.)
     //
-    if(arg != "-D" && cmSystemTools::StringStartsWith(arg.c_str(), "-D"))
-      {
+    if (arg != "-D" && cmSystemTools::StringStartsWith(arg.c_str(), "-D")) {
       std::string input = arg.substr(2);
       this->AddVariableDefinition(input);
-      }
+    }
 
-    if(this->CheckArgument(arg, "-T", "--test-action") &&
-      (i < args.size() -1) )
-      {
+    if (this->CheckArgument(arg, "-T", "--test-action") &&
+        (i < args.size() - 1)) {
       this->ProduceXML = true;
       i++;
-      if ( !this->SetTest(args[i].c_str(), false) )
-        {
+      if (!this->SetTest(args[i].c_str(), false)) {
         executeTests = false;
         cmCTestLog(this, ERROR_MESSAGE,
-          "CTest -T called with incorrect option: "
-          << args[i] << std::endl);
-        cmCTestLog(this, ERROR_MESSAGE, "Available options are:" << std::endl
-          << "  " << ctestExec << " -T all" << std::endl
-          << "  " << ctestExec << " -T start" << std::endl
-          << "  " << ctestExec << " -T update" << std::endl
-          << "  " << ctestExec << " -T configure" << std::endl
-          << "  " << ctestExec << " -T build" << std::endl
-          << "  " << ctestExec << " -T test" << std::endl
-          << "  " << ctestExec << " -T coverage" << std::endl
-          << "  " << ctestExec << " -T memcheck" << std::endl
-          << "  " << ctestExec << " -T notes" << std::endl
-          << "  " << ctestExec << " -T submit" << std::endl);
-        }
+                   "CTest -T called with incorrect option: " << args[i]
+                                                             << std::endl);
+        cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
+                     << std::endl
+                     << "  " << ctestExec << " -T all" << std::endl
+                     << "  " << ctestExec << " -T start" << std::endl
+                     << "  " << ctestExec << " -T update" << std::endl
+                     << "  " << ctestExec << " -T configure" << std::endl
+                     << "  " << ctestExec << " -T build" << std::endl
+                     << "  " << ctestExec << " -T test" << std::endl
+                     << "  " << ctestExec << " -T coverage" << std::endl
+                     << "  " << ctestExec << " -T memcheck" << std::endl
+                     << "  " << ctestExec << " -T notes" << std::endl
+                     << "  " << ctestExec << " -T submit" << std::endl);
       }
+    }
 
     // what type of test model
-    if(this->CheckArgument(arg, "-M", "--test-model") &&
-      (i < args.size() -1) )
-      {
+    if (this->CheckArgument(arg, "-M", "--test-model") &&
+        (i < args.size() - 1)) {
       i++;
       std::string const& str = args[i];
-      if ( cmSystemTools::LowerCase(str) == "nightly" )
-        {
+      if (cmSystemTools::LowerCase(str) == "nightly") {
         this->SetTestModel(cmCTest::NIGHTLY);
-        }
-      else if ( cmSystemTools::LowerCase(str) == "continuous" )
-        {
+      } else if (cmSystemTools::LowerCase(str) == "continuous") {
         this->SetTestModel(cmCTest::CONTINUOUS);
-        }
-      else if ( cmSystemTools::LowerCase(str) == "experimental" )
-        {
+      } else if (cmSystemTools::LowerCase(str) == "experimental") {
         this->SetTestModel(cmCTest::EXPERIMENTAL);
-        }
-      else
-        {
+      } else {
         executeTests = false;
         cmCTestLog(this, ERROR_MESSAGE,
-          "CTest -M called with incorrect option: " << str
-          << std::endl);
-        cmCTestLog(this, ERROR_MESSAGE, "Available options are:" << std::endl
-          << "  " << ctestExec << " -M Continuous" << std::endl
-          << "  " << ctestExec << " -M Experimental" << std::endl
-                   << "  " << ctestExec << " -M Nightly" << std::endl);
-        }
+                   "CTest -M called with incorrect option: " << str
+                                                             << std::endl);
+        cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
+                     << std::endl
+                     << "  " << ctestExec << " -M Continuous" << std::endl
+                     << "  " << ctestExec << " -M Experimental" << std::endl
+                     << "  " << ctestExec << " -M Nightly" << std::endl);
       }
+    }
 
-    if(this->CheckArgument(arg, "--extra-submit") && i < args.size() - 1)
-      {
+    if (this->CheckArgument(arg, "--extra-submit") && i < args.size() - 1) {
       this->ProduceXML = true;
       this->SetTest("Submit");
       i++;
-      if ( !this->SubmitExtraFiles(args[i].c_str()) )
-        {
+      if (!this->SubmitExtraFiles(args[i].c_str())) {
         return 0;
-        }
       }
+    }
 
     // --build-and-test options
-    if(this->CheckArgument(arg, "--build-and-test") && i < args.size() - 1)
-      {
+    if (this->CheckArgument(arg, "--build-and-test") && i < args.size() - 1) {
       cmakeAndTest = true;
-      }
+    }
 
-    if(this->CheckArgument(arg, "--schedule-random"))
-      {
+    if (this->CheckArgument(arg, "--schedule-random")) {
       this->ScheduleType = "Random";
-      }
+    }
 
     // pass the argument to all the handlers as well, but i may no longer be
     // set to what it was originally so I'm not sure this is working as
     // intended
     cmCTest::t_TestingHandlers::iterator it;
-    for ( it = this->TestingHandlers.begin();
-      it != this->TestingHandlers.end();
-      ++ it )
-      {
-      if ( !it->second->ProcessCommandLineArguments(arg, i, args) )
-        {
+    for (it = this->TestingHandlers.begin(); it != this->TestingHandlers.end();
+         ++it) {
+      if (!it->second->ProcessCommandLineArguments(arg, i, args)) {
         cmCTestLog(this, ERROR_MESSAGE,
-          "Problem parsing command line arguments within a handler");
+                   "Problem parsing command line arguments within a handler");
         return 0;
-        }
       }
-    } // the close of the for argument loop
+    }
+  } // the close of the for argument loop
 
-  if (!this->ParallelLevelSetInCli)
-    {
-    if (const char *parallel = cmSystemTools::GetEnv("CTEST_PARALLEL_LEVEL"))
-      {
+  if (!this->ParallelLevelSetInCli) {
+    if (const char* parallel = cmSystemTools::GetEnv("CTEST_PARALLEL_LEVEL")) {
       int plevel = atoi(parallel);
       this->SetParallelLevel(plevel);
-      }
     }
+  }
 
   // now what sould cmake do? if --build-and-test was specified then
   // we run the build and test handler and return
-  if(cmakeAndTest)
-    {
+  if (cmakeAndTest) {
     this->Verbose = true;
     cmCTestBuildAndTestHandler* handler =
       static_cast<cmCTestBuildAndTestHandler*>(this->GetHandler("buildtest"));
@@ -2502,85 +2142,69 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
 #ifdef CMAKE_BUILD_WITH_CMAKE
     cmDynamicLoader::FlushCache();
 #endif
-    if(retv != 0)
-      {
-      cmCTestLog(this, DEBUG, "build and test failing returning: " << retv
-                 << std::endl);
-      }
-    return retv;
+    if (retv != 0) {
+      cmCTestLog(this, DEBUG,
+                 "build and test failing returning: " << retv << std::endl);
     }
+    return retv;
+  }
 
-  if(executeTests)
-    {
+  if (executeTests) {
     int res;
     // call process directory
-    if (this->RunConfigurationScript)
-      {
-      if ( this->ExtraVerbose )
-        {
+    if (this->RunConfigurationScript) {
+      if (this->ExtraVerbose) {
         cmCTestLog(this, OUTPUT, "* Extra verbosity turned on" << std::endl);
-        }
+      }
       cmCTest::t_TestingHandlers::iterator it;
-      for ( it = this->TestingHandlers.begin();
-        it != this->TestingHandlers.end();
-        ++ it )
-        {
+      for (it = this->TestingHandlers.begin();
+           it != this->TestingHandlers.end(); ++it) {
         it->second->SetVerbose(this->ExtraVerbose);
         it->second->SetSubmitIndex(this->SubmitIndex);
-        }
+      }
       this->GetHandler("script")->SetVerbose(this->Verbose);
       res = this->GetHandler("script")->ProcessHandler();
-      if(res != 0)
-        {
-        cmCTestLog(this, DEBUG, "running script failing returning: " << res
-                   << std::endl);
-        }
-
+      if (res != 0) {
+        cmCTestLog(this, DEBUG,
+                   "running script failing returning: " << res << std::endl);
       }
-    else
-      {
+
+    } else {
       // What is this?  -V seems to be the same as -VV,
       // and Verbose is always on in this case
       this->ExtraVerbose = this->Verbose;
       this->Verbose = true;
       cmCTest::t_TestingHandlers::iterator it;
-      for ( it = this->TestingHandlers.begin();
-        it != this->TestingHandlers.end();
-        ++ it )
-        {
+      for (it = this->TestingHandlers.begin();
+           it != this->TestingHandlers.end(); ++it) {
         it->second->SetVerbose(this->Verbose);
         it->second->SetSubmitIndex(this->SubmitIndex);
-        }
+      }
       std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
-      if(!this->Initialize(cwd.c_str(), 0))
-        {
+      if (!this->Initialize(cwd.c_str(), 0)) {
         res = 12;
         cmCTestLog(this, ERROR_MESSAGE, "Problem initializing the dashboard."
-          << std::endl);
-        }
-      else
-        {
+                     << std::endl);
+      } else {
         res = this->ProcessTests();
-        }
-      this->Finalize();
       }
-    if(res != 0)
-      {
-      cmCTestLog(this, DEBUG, "Running a test(s) failed returning : " << res
-                 << std::endl);
-      }
-    return res;
+      this->Finalize();
+    }
+    if (res != 0) {
+      cmCTestLog(this, DEBUG,
+                 "Running a test(s) failed returning : " << res << std::endl);
     }
+    return res;
+  }
 
   return 1;
 }
 
 void cmCTest::SetNotesFiles(const char* notes)
 {
-  if ( !notes )
-    {
+  if (!notes) {
     return;
-    }
+  }
   this->NotesFiles = notes;
 }
 
@@ -2596,122 +2220,105 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf)
   VectorOfStrings dirs;
   VectorOfStrings ndirs;
   cmCTestLog(this, DEBUG, "* Read custom CTest configuration directory: "
-    << dir << std::endl);
+               << dir << std::endl);
 
   std::string fname = dir;
   fname += "/CTestCustom.cmake";
-  cmCTestLog(this, DEBUG, "* Check for file: "
-    << fname << std::endl);
-  if ( cmSystemTools::FileExists(fname.c_str()) )
-    {
+  cmCTestLog(this, DEBUG, "* Check for file: " << fname << std::endl);
+  if (cmSystemTools::FileExists(fname.c_str())) {
     cmCTestLog(this, DEBUG, "* Read custom CTest configuration file: "
-      << fname << std::endl);
+                 << fname << std::endl);
     bool erroroc = cmSystemTools::GetErrorOccuredFlag();
     cmSystemTools::ResetErrorOccuredFlag();
 
-    if ( !mf->ReadListFile(fname.c_str()) ||
-      cmSystemTools::GetErrorOccuredFlag() )
-      {
-      cmCTestLog(this, ERROR_MESSAGE,
-        "Problem reading custom configuration: "
-        << fname << std::endl);
-      }
+    if (!mf->ReadListFile(fname.c_str()) ||
+        cmSystemTools::GetErrorOccuredFlag()) {
+      cmCTestLog(this, ERROR_MESSAGE, "Problem reading custom configuration: "
+                   << fname << std::endl);
+    }
     found = true;
-    if ( erroroc )
-      {
+    if (erroroc) {
       cmSystemTools::SetErrorOccured();
-      }
     }
+  }
 
   std::string rexpr = dir;
   rexpr += "/CTestCustom.ctest";
-  cmCTestLog(this, DEBUG, "* Check for file: "
-    << rexpr << std::endl);
-  if ( !found && cmSystemTools::FileExists(rexpr.c_str()) )
-    {
+  cmCTestLog(this, DEBUG, "* Check for file: " << rexpr << std::endl);
+  if (!found && cmSystemTools::FileExists(rexpr.c_str())) {
     cmsys::Glob gl;
     gl.RecurseOn();
     gl.FindFiles(rexpr);
     std::vector<std::string>& files = gl.GetFiles();
     std::vector<std::string>::iterator fileIt;
-    for ( fileIt = files.begin(); fileIt != files.end();
-      ++ fileIt )
-      {
+    for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
       cmCTestLog(this, DEBUG, "* Read custom CTest configuration file: "
-        << *fileIt << std::endl);
-      if ( !mf->ReadListFile(fileIt->c_str()) ||
-        cmSystemTools::GetErrorOccuredFlag() )
-        {
+                   << *fileIt << std::endl);
+      if (!mf->ReadListFile(fileIt->c_str()) ||
+          cmSystemTools::GetErrorOccuredFlag()) {
         cmCTestLog(this, ERROR_MESSAGE,
-          "Problem reading custom configuration: "
-          << *fileIt << std::endl);
-        }
+                   "Problem reading custom configuration: " << *fileIt
+                                                            << std::endl);
       }
-    found = true;
     }
+    found = true;
+  }
 
-  if ( found )
-    {
+  if (found) {
     cmCTest::t_TestingHandlers::iterator it;
-    for ( it = this->TestingHandlers.begin();
-      it != this->TestingHandlers.end(); ++ it )
-      {
+    for (it = this->TestingHandlers.begin(); it != this->TestingHandlers.end();
+         ++it) {
       cmCTestLog(this, DEBUG,
-        "* Read custom CTest configuration vectors for handler: "
-        << it->first << " (" << it->second << ")" << std::endl);
+                 "* Read custom CTest configuration vectors for handler: "
+                   << it->first << " (" << it->second << ")" << std::endl);
       it->second->PopulateCustomVectors(mf);
-      }
     }
+  }
 
   return 1;
 }
 
 void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
-  std::vector<std::string>& vec)
+                                   std::vector<std::string>& vec)
 {
   const char* dval = mf->GetDefinition(def);
-  if ( !dval )
-    {
+  if (!dval) {
     return;
-    }
+  }
   cmCTestLog(this, DEBUG, "PopulateCustomVector: " << def << std::endl);
 
   vec.clear();
   cmSystemTools::ExpandListArgument(dval, vec);
 
   for (std::vector<std::string>::const_iterator it = vec.begin();
-       it != vec.end(); ++it )
-    {
+       it != vec.end(); ++it) {
     cmCTestLog(this, DEBUG, "  -- " << *it << std::endl);
-    }
+  }
 }
 
 void cmCTest::PopulateCustomInteger(cmMakefile* mf, const std::string& def,
-  int& val)
+                                    int& val)
 {
   const char* dval = mf->GetDefinition(def);
-  if ( !dval )
-    {
+  if (!dval) {
     return;
-    }
+  }
   val = atoi(dval);
 }
 
 std::string cmCTest::GetShortPathToFile(const char* cfname)
 {
-  const std::string& sourceDir
-    = cmSystemTools::CollapseFullPath(
-        this->GetCTestConfiguration("SourceDirectory"));
-  const std::string& buildDir
-    = cmSystemTools::CollapseFullPath(
-        this->GetCTestConfiguration("BuildDirectory"));
+  const std::string& sourceDir = cmSystemTools::CollapseFullPath(
+    this->GetCTestConfiguration("SourceDirectory"));
+  const std::string& buildDir = cmSystemTools::CollapseFullPath(
+    this->GetCTestConfiguration("BuildDirectory"));
   std::string fname = cmSystemTools::CollapseFullPath(cfname);
 
   // Find relative paths to both directories
-  std::string srcRelpath
-    = cmSystemTools::RelativePath(sourceDir.c_str(), fname.c_str());
-  std::string bldRelpath
-    = cmSystemTools::RelativePath(buildDir.c_str(), fname.c_str());
+  std::string srcRelpath =
+    cmSystemTools::RelativePath(sourceDir.c_str(), fname.c_str());
+  std::string bldRelpath =
+    cmSystemTools::RelativePath(buildDir.c_str(), fname.c_str());
 
   // If any contains "." it is not parent directory
   bool inSrc = srcRelpath.find("..") == srcRelpath.npos;
@@ -2720,43 +2327,31 @@ std::string cmCTest::GetShortPathToFile(const char* cfname)
 
   std::string* res = 0;
 
-  if ( inSrc && inBld )
-    {
+  if (inSrc && inBld) {
     // If both have relative path with no dots, pick the shorter one
-    if ( srcRelpath.size() < bldRelpath.size() )
-      {
+    if (srcRelpath.size() < bldRelpath.size()) {
       res = &srcRelpath;
-      }
-    else
-      {
+    } else {
       res = &bldRelpath;
-      }
     }
-  else if ( inSrc )
-    {
+  } else if (inSrc) {
     res = &srcRelpath;
-    }
-  else if ( inBld )
-    {
+  } else if (inBld) {
     res = &bldRelpath;
-    }
+  }
 
   std::string path;
 
-  if ( !res )
-    {
+  if (!res) {
     path = fname;
-    }
-  else
-    {
+  } else {
     cmSystemTools::ConvertToUnixSlashes(*res);
 
     path = "./" + *res;
-    if ( path[path.size()-1] == '/' )
-      {
-      path = path.substr(0, path.size()-1);
-      }
+    if (path[path.size() - 1] == '/') {
+      path = path.substr(0, path.size() - 1);
     }
+  }
 
   cmsys::SystemTools::ReplaceString(path, ":", "_");
   cmsys::SystemTools::ReplaceString(path, " ", "_");
@@ -2765,11 +2360,10 @@ std::string cmCTest::GetShortPathToFile(const char* cfname)
 
 std::string cmCTest::GetCTestConfiguration(const std::string& name)
 {
-  if ( this->CTestConfigurationOverwrites.find(name) !=
-    this->CTestConfigurationOverwrites.end() )
-    {
+  if (this->CTestConfigurationOverwrites.find(name) !=
+      this->CTestConfigurationOverwrites.end()) {
     return this->CTestConfigurationOverwrites[name];
-    }
+  }
   return this->CTestConfiguration[name];
 }
 
@@ -2789,53 +2383,44 @@ void cmCTest::DetermineNextDayStop()
   int local_hour = lctime->tm_hour;
 
   int tzone_offset = local_hour - gm_hour;
-  if(gm_time > current_time && gm_hour < local_hour)
-    {
+  if (gm_time > current_time && gm_hour < local_hour) {
     // this means gm_time is on the next day
     tzone_offset -= 24;
-    }
-  else if(gm_time < current_time && gm_hour > local_hour)
-    {
+  } else if (gm_time < current_time && gm_hour > local_hour) {
     // this means gm_time is on the previous day
     tzone_offset += 24;
-    }
+  }
 
   tzone_offset *= 100;
   char buf[1024];
-  sprintf(buf, "%d%02d%02d %s %+05i",
-          lctime->tm_year + 1900,
-          lctime->tm_mon + 1,
-          lctime->tm_mday,
-          this->StopTime.c_str(),
+  sprintf(buf, "%d%02d%02d %s %+05i", lctime->tm_year + 1900,
+          lctime->tm_mon + 1, lctime->tm_mday, this->StopTime.c_str(),
           tzone_offset);
 
   time_t stop_time = curl_getdate(buf, &current_time);
 
-  if(stop_time < current_time)
-    {
+  if (stop_time < current_time) {
     this->NextDayStopTime = true;
-    }
+  }
 }
 
-void cmCTest::SetCTestConfiguration(const char *name, const char* value,
+void cmCTest::SetCTestConfiguration(const char* name, const char* value,
                                     bool suppress)
 {
   cmCTestOptionalLog(this, HANDLER_VERBOSE_OUTPUT, "SetCTestConfiguration:"
-    << name << ":" << (value ? value : "(null)") << "\n", suppress);
+                       << name << ":" << (value ? value : "(null)") << "\n",
+                     suppress);
 
-  if ( !name )
-    {
+  if (!name) {
     return;
-    }
-  if ( !value )
-    {
+  }
+  if (!value) {
     this->CTestConfiguration.erase(name);
     return;
-    }
+  }
   this->CTestConfiguration[name] = value;
 }
 
-
 std::string cmCTest::GetCurrentTag()
 {
   return this->CurrentTag;
@@ -2873,20 +2458,18 @@ bool cmCTest::GetProduceXML()
 
 const char* cmCTest::GetSpecificTrack()
 {
-  if ( this->SpecificTrack.empty() )
-    {
+  if (this->SpecificTrack.empty()) {
     return 0;
-    }
+  }
   return this->SpecificTrack.c_str();
 }
 
 void cmCTest::SetSpecificTrack(const char* track)
 {
-  if ( !track )
-    {
+  if (!track) {
     this->SpecificTrack = "";
     return;
-    }
+  }
   this->SpecificTrack = track;
 }
 
@@ -2898,66 +2481,59 @@ void cmCTest::AddSubmitFile(Part part, const char* name)
 void cmCTest::AddCTestConfigurationOverwrite(const std::string& overStr)
 {
   size_t epos = overStr.find("=");
-  if ( epos == overStr.npos )
-    {
+  if (epos == overStr.npos) {
     cmCTestLog(this, ERROR_MESSAGE,
-      "CTest configuration overwrite specified in the wrong format."
-      << std::endl
-      << "Valid format is: --overwrite key=value" << std::endl
-      << "The specified was: --overwrite " << overStr << std::endl);
+               "CTest configuration overwrite specified in the wrong format."
+                 << std::endl
+                 << "Valid format is: --overwrite key=value" << std::endl
+                 << "The specified was: --overwrite " << overStr << std::endl);
     return;
-    }
+  }
   std::string key = overStr.substr(0, epos);
-  std::string value = overStr.substr(epos+1, overStr.npos);
+  std::string value = overStr.substr(epos + 1, overStr.npos);
   this->CTestConfigurationOverwrites[key] = value;
 }
 
 void cmCTest::SetConfigType(const char* ct)
 {
-  this->ConfigType = ct?ct:"";
+  this->ConfigType = ct ? ct : "";
   cmSystemTools::ReplaceString(this->ConfigType, ".\\", "");
-  std::string confTypeEnv
-    = "CMAKE_CONFIG_TYPE=" + this->ConfigType;
+  std::string confTypeEnv = "CMAKE_CONFIG_TYPE=" + this->ConfigType;
   cmSystemTools::PutEnv(confTypeEnv);
 }
 
-bool cmCTest::SetCTestConfigurationFromCMakeVariable(cmMakefile* mf,
-  const char* dconfig, const std::string& cmake_var, bool suppress)
+bool cmCTest::SetCTestConfigurationFromCMakeVariable(
+  cmMakefile* mf, const char* dconfig, const std::string& cmake_var,
+  bool suppress)
 {
   const char* ctvar;
   ctvar = mf->GetDefinition(cmake_var);
-  if ( !ctvar )
-    {
+  if (!ctvar) {
     return false;
-    }
+  }
   cmCTestOptionalLog(this, HANDLER_VERBOSE_OUTPUT,
-    "SetCTestConfigurationFromCMakeVariable:" << dconfig << ":" <<
-    cmake_var << std::endl, suppress);
+                     "SetCTestConfigurationFromCMakeVariable:"
+                       << dconfig << ":" << cmake_var << std::endl,
+                     suppress);
   this->SetCTestConfiguration(dconfig, ctvar, suppress);
   return true;
 }
 
-bool cmCTest::RunCommand(
-  const char* command,
-  std::string* stdOut,
-  std::string* stdErr,
-  int *retVal,
-  const char* dir,
-  double timeout)
+bool cmCTest::RunCommand(const char* command, std::string* stdOut,
+                         std::string* stdErr, int* retVal, const char* dir,
+                         double timeout)
 {
   std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     return false;
-    }
+  }
 
   std::vector<const char*> argv;
-  for(std::vector<std::string>::const_iterator a = args.begin();
-      a != args.end(); ++a)
-    {
+  for (std::vector<std::string>::const_iterator a = args.begin();
+       a != args.end(); ++a) {
     argv.push_back(a->c_str());
-    }
+  }
   argv.push_back(0);
 
   *stdOut = "";
@@ -2966,10 +2542,9 @@ bool cmCTest::RunCommand(
   cmsysProcess* cp = cmsysProcess_New();
   cmsysProcess_SetCommand(cp, &*argv.begin());
   cmsysProcess_SetWorkingDirectory(cp, dir);
-  if(cmSystemTools::GetRunCommandHideConsole())
-    {
+  if (cmSystemTools::GetRunCommandHideConsole()) {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
-    }
+  }
   cmsysProcess_SetTimeout(cp, timeout);
   cmsysProcess_Execute(cp);
 
@@ -2979,73 +2554,57 @@ bool cmCTest::RunCommand(
   int length;
   int res;
   bool done = false;
-  while(!done)
-    {
+  while (!done) {
     res = cmsysProcess_WaitForData(cp, &data, &length, 0);
-    switch ( res )
-      {
-    case cmsysProcess_Pipe_STDOUT:
-      tempOutput.insert(tempOutput.end(), data, data+length);
-      break;
-    case cmsysProcess_Pipe_STDERR:
-      tempError.insert(tempError.end(), data, data+length);
-      break;
-    default:
-      done = true;
-      }
-    if ( (res == cmsysProcess_Pipe_STDOUT ||
-        res == cmsysProcess_Pipe_STDERR) && this->ExtraVerbose )
-      {
+    switch (res) {
+      case cmsysProcess_Pipe_STDOUT:
+        tempOutput.insert(tempOutput.end(), data, data + length);
+        break;
+      case cmsysProcess_Pipe_STDERR:
+        tempError.insert(tempError.end(), data, data + length);
+        break;
+      default:
+        done = true;
+    }
+    if ((res == cmsysProcess_Pipe_STDOUT || res == cmsysProcess_Pipe_STDERR) &&
+        this->ExtraVerbose) {
       cmSystemTools::Stdout(data, length);
-      }
     }
+  }
 
   cmsysProcess_WaitForExit(cp, 0);
-  if (!tempOutput.empty())
-    {
+  if (!tempOutput.empty()) {
     stdOut->append(&*tempOutput.begin(), tempOutput.size());
-    }
-  if (!tempError.empty())
-    {
+  }
+  if (!tempError.empty()) {
     stdErr->append(&*tempError.begin(), tempError.size());
-    }
+  }
 
   bool result = true;
-  if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exited)
-    {
-    if ( retVal )
-      {
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
+    if (retVal) {
       *retVal = cmsysProcess_GetExitValue(cp);
-      }
-    else
-      {
-      if ( cmsysProcess_GetExitValue(cp) !=  0 )
-        {
+    } else {
+      if (cmsysProcess_GetExitValue(cp) != 0) {
         result = false;
-        }
       }
     }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exception)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exception) {
     const char* exception_str = cmsysProcess_GetExceptionString(cp);
     cmCTestLog(this, ERROR_MESSAGE, exception_str << std::endl);
     stdErr->append(exception_str, strlen(exception_str));
     result = false;
-    }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Error)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
     const char* error_str = cmsysProcess_GetErrorString(cp);
     cmCTestLog(this, ERROR_MESSAGE, error_str << std::endl);
     stdErr->append(error_str, strlen(error_str));
     result = false;
-    }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Expired)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Expired) {
     const char* error_str = "Process terminated due to timeout\n";
     cmCTestLog(this, ERROR_MESSAGE, error_str << std::endl);
     stdErr->append(error_str, strlen(error_str));
     result = false;
-    }
+  }
 
   cmsysProcess_Delete(cp);
   return result;
@@ -3053,41 +2612,35 @@ bool cmCTest::RunCommand(
 
 void cmCTest::SetOutputLogFileName(const char* name)
 {
-  if ( this->OutputLogFile)
-    {
+  if (this->OutputLogFile) {
     delete this->OutputLogFile;
-    this->OutputLogFile= 0;
-    }
-  if ( name )
-    {
+    this->OutputLogFile = 0;
+  }
+  if (name) {
     this->OutputLogFile = new cmGeneratedFileStream(name);
-    }
+  }
 }
 
-static const char* cmCTestStringLogType[] =
-{
-  "DEBUG",
-  "OUTPUT",
-  "HANDLER_OUTPUT",
-  "HANDLER_PROGRESS_OUTPUT",
-  "HANDLER_VERBOSE_OUTPUT",
-  "WARNING",
-  "ERROR_MESSAGE",
-  0
-};
+static const char* cmCTestStringLogType[] = { "DEBUG",
+                                              "OUTPUT",
+                                              "HANDLER_OUTPUT",
+                                              "HANDLER_PROGRESS_OUTPUT",
+                                              "HANDLER_VERBOSE_OUTPUT",
+                                              "WARNING",
+                                              "ERROR_MESSAGE",
+                                              0 };
 
 #ifdef cerr
-#  undef cerr
+#undef cerr
 #endif
 #ifdef cout
-#  undef cout
+#undef cout
 #endif
 
-#define cmCTestLogOutputFileLine(stream) \
-  if ( this->ShowLineNumbers ) \
-    { \
-    (stream) << std::endl << file << ":" << line << " "; \
-    }
+#define cmCTestLogOutputFileLine(stream)                                      \
+  if (this->ShowLineNumbers) {                                                \
+    (stream) << std::endl << file << ":" << line << " ";                      \
+  }
 
 void cmCTest::InitStreams()
 {
@@ -3099,118 +2652,106 @@ void cmCTest::InitStreams()
 void cmCTest::Log(int logType, const char* file, int line, const char* msg,
                   bool suppress)
 {
-  if ( !msg || !*msg )
-    {
+  if (!msg || !*msg) {
     return;
-    }
-  if ( suppress && logType != cmCTest::ERROR_MESSAGE )
-    {
+  }
+  if (suppress && logType != cmCTest::ERROR_MESSAGE) {
     return;
-    }
-  if ( logType == cmCTest::HANDLER_PROGRESS_OUTPUT &&
-      ( this->Debug || this->ExtraVerbose ) )
-    {
+  }
+  if (logType == cmCTest::HANDLER_PROGRESS_OUTPUT &&
+      (this->Debug || this->ExtraVerbose)) {
     return;
-    }
-  if ( this->OutputLogFile )
-    {
+  }
+  if (this->OutputLogFile) {
     bool display = true;
-    if ( logType == cmCTest::DEBUG && !this->Debug ) { display = false; }
-    if ( logType == cmCTest::HANDLER_VERBOSE_OUTPUT && !this->Debug &&
-      !this->ExtraVerbose ) { display = false; }
-    if ( display )
-      {
+    if (logType == cmCTest::DEBUG && !this->Debug) {
+      display = false;
+    }
+    if (logType == cmCTest::HANDLER_VERBOSE_OUTPUT && !this->Debug &&
+        !this->ExtraVerbose) {
+      display = false;
+    }
+    if (display) {
       cmCTestLogOutputFileLine(*this->OutputLogFile);
-      if ( logType != this->OutputLogFileLastTag )
-        {
+      if (logType != this->OutputLogFileLastTag) {
         *this->OutputLogFile << "[";
-        if ( logType >= OTHER || logType < 0 )
-          {
+        if (logType >= OTHER || logType < 0) {
           *this->OutputLogFile << "OTHER";
-          }
-        else
-          {
+        } else {
           *this->OutputLogFile << cmCTestStringLogType[logType];
-          }
-        *this->OutputLogFile << "] " << std::endl << std::flush;
         }
+        *this->OutputLogFile << "] " << std::endl << std::flush;
+      }
       *this->OutputLogFile << msg << std::flush;
-      if ( logType != this->OutputLogFileLastTag )
-        {
+      if (logType != this->OutputLogFileLastTag) {
         *this->OutputLogFile << std::endl << std::flush;
         this->OutputLogFileLastTag = logType;
-        }
       }
     }
-  if ( !this->Quiet )
-    {
+  }
+  if (!this->Quiet) {
     std::ostream& out = *this->StreamOut;
     std::ostream& err = *this->StreamErr;
-    switch ( logType )
-      {
-    case DEBUG:
-      if ( this->Debug )
-        {
-        cmCTestLogOutputFileLine(out);
-        out << msg;
-        out.flush();
+    switch (logType) {
+      case DEBUG:
+        if (this->Debug) {
+          cmCTestLogOutputFileLine(out);
+          out << msg;
+          out.flush();
         }
-      break;
-    case OUTPUT: case HANDLER_OUTPUT:
-      if ( this->Debug || this->Verbose )
-        {
-        cmCTestLogOutputFileLine(out);
-        out << msg;
-        out.flush();
+        break;
+      case OUTPUT:
+      case HANDLER_OUTPUT:
+        if (this->Debug || this->Verbose) {
+          cmCTestLogOutputFileLine(out);
+          out << msg;
+          out.flush();
         }
-      break;
-    case HANDLER_VERBOSE_OUTPUT:
-      if ( this->Debug || this->ExtraVerbose )
-        {
+        break;
+      case HANDLER_VERBOSE_OUTPUT:
+        if (this->Debug || this->ExtraVerbose) {
+          cmCTestLogOutputFileLine(out);
+          out << msg;
+          out.flush();
+        }
+        break;
+      case WARNING:
+        cmCTestLogOutputFileLine(err);
+        err << msg;
+        err.flush();
+        break;
+      case ERROR_MESSAGE:
+        cmCTestLogOutputFileLine(err);
+        err << msg;
+        err.flush();
+        cmSystemTools::SetErrorOccured();
+        break;
+      default:
         cmCTestLogOutputFileLine(out);
         out << msg;
         out.flush();
-        }
-      break;
-    case WARNING:
-      cmCTestLogOutputFileLine(err);
-      err << msg;
-      err.flush();
-      break;
-    case ERROR_MESSAGE:
-      cmCTestLogOutputFileLine(err);
-      err << msg;
-      err.flush();
-      cmSystemTools::SetErrorOccured();
-      break;
-    default:
-      cmCTestLogOutputFileLine(out);
-      out << msg;
-      out.flush();
-      }
     }
+  }
 }
 
 double cmCTest::GetRemainingTimeAllowed()
 {
-  if (!this->GetHandler("script"))
-    {
+  if (!this->GetHandler("script")) {
     return 1.0e7;
-    }
+  }
 
-  cmCTestScriptHandler* ch
-    = static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
+  cmCTestScriptHandler* ch =
+    static_cast<cmCTestScriptHandler*>(this->GetHandler("script"));
 
   return ch->GetRemainingTimeAllowed();
 }
 
-void cmCTest::OutputTestErrors(std::vector<char> const &process_output)
+void cmCTest::OutputTestErrors(std::vector<char> const& process_output)
 {
   std::string test_outputs("\n*** Test Failed:\n");
-  if(!process_output.empty())
-    {
+  if (!process_output.empty()) {
     test_outputs.append(&*process_output.begin(), process_output.size());
-    }
+  }
   cmCTestLog(this, HANDLER_OUTPUT, test_outputs << std::endl << std::flush);
 }
 
@@ -3219,22 +2760,21 @@ bool cmCTest::CompressString(std::string& str)
   int ret;
   z_stream strm;
 
-  unsigned char* in = reinterpret_cast<unsigned char*>(
-    const_cast<char*>(str.c_str()));
-  //zlib makes the guarantee that this is the maximum output size
-  int outSize = static_cast<int>(
-    static_cast<double>(str.size()) * 1.001 + 13.0);
+  unsigned char* in =
+    reinterpret_cast<unsigned char*>(const_cast<char*>(str.c_str()));
+  // zlib makes the guarantee that this is the maximum output size
+  int outSize =
+    static_cast<int>(static_cast<double>(str.size()) * 1.001 + 13.0);
   unsigned char* out = new unsigned char[outSize];
 
   strm.zalloc = Z_NULL;
   strm.zfree = Z_NULL;
   strm.opaque = Z_NULL;
-  ret = deflateInit(&strm, -1); //default compression level
-  if (ret != Z_OK)
-    {
+  ret = deflateInit(&strm, -1); // default compression level
+  if (ret != Z_OK) {
     delete[] out;
     return false;
-    }
+  }
 
   strm.avail_in = static_cast<uInt>(str.size());
   strm.next_in = in;
@@ -3242,28 +2782,26 @@ bool cmCTest::CompressString(std::string& str)
   strm.next_out = out;
   ret = deflate(&strm, Z_FINISH);
 
-  if(ret == Z_STREAM_ERROR || ret != Z_STREAM_END)
-    {
+  if (ret == Z_STREAM_ERROR || ret != Z_STREAM_END) {
     cmCTestLog(this, ERROR_MESSAGE, "Error during gzip compression."
-      << std::endl);
+                 << std::endl);
     delete[] out;
     return false;
-    }
+  }
 
   (void)deflateEnd(&strm);
 
   // Now base64 encode the resulting binary string
-  unsigned char* base64EncodedBuffer
-    = new unsigned char[(outSize * 3) / 2];
+  unsigned char* base64EncodedBuffer = new unsigned char[(outSize * 3) / 2];
 
-  size_t rlen
-    = cmsysBase64_Encode(out, strm.total_out, base64EncodedBuffer, 1);
+  size_t rlen =
+    cmsysBase64_Encode(out, strm.total_out, base64EncodedBuffer, 1);
 
   str = "";
   str.append(reinterpret_cast<char*>(base64EncodedBuffer), rlen);
 
-  delete [] base64EncodedBuffer;
-  delete [] out;
+  delete[] base64EncodedBuffer;
+  delete[] out;
 
   return true;
 }
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
index 07081fc..1c3490e 100644
--- a/Source/cmCTest.h
+++ b/Source/cmCTest.h
@@ -27,29 +27,29 @@ class cmCTestScriptHandler;
 class cmCTestStartCommand;
 class cmXMLWriter;
 
-#define cmCTestLog(ctSelf, logType, msg) \
-  do { \
-  std::ostringstream cmCTestLog_msg; \
-  cmCTestLog_msg << msg; \
-  (ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,\
-                cmCTestLog_msg.str().c_str());\
-  } while ( 0 )
-
-#define cmCTestOptionalLog(ctSelf, logType, msg, suppress) \
-  do { \
-  std::ostringstream cmCTestLog_msg; \
-  cmCTestLog_msg << msg; \
-  (ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,\
-                cmCTestLog_msg.str().c_str(), suppress);\
-  } while ( 0 )
+#define cmCTestLog(ctSelf, logType, msg)                                      \
+  do {                                                                        \
+    std::ostringstream cmCTestLog_msg;                                        \
+    cmCTestLog_msg << msg;                                                    \
+    (ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,                       \
+                  cmCTestLog_msg.str().c_str());                              \
+  } while (0)
+
+#define cmCTestOptionalLog(ctSelf, logType, msg, suppress)                    \
+  do {                                                                        \
+    std::ostringstream cmCTestLog_msg;                                        \
+    cmCTestLog_msg << msg;                                                    \
+    (ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,                       \
+                  cmCTestLog_msg.str().c_str(), suppress);                    \
+  } while (0)
 
 #ifdef cerr
-#  undef cerr
+#undef cerr
 #endif
 #define cerr no_cerr_use_cmCTestLog
 
 #ifdef cout
-#  undef cout
+#undef cout
 #endif
 #define cout no_cout_use_cmCTestLog
 
@@ -57,6 +57,7 @@ class cmCTest
 {
   friend class cmCTestRunTest;
   friend class cmCTestMultiProcessHandler;
+
 public:
   /** Enumerate parts of the testing and submission process.  */
   enum Part
@@ -78,7 +79,10 @@ public:
   /** Representation of one part.  */
   struct PartInfo
   {
-    PartInfo(): Enabled(false) {}
+    PartInfo()
+      : Enabled(false)
+    {
+    }
 
     void SetName(const std::string& name) { this->Name = name; }
     const std::string& GetName() const { return this->Name; }
@@ -87,12 +91,14 @@ public:
     operator bool() const { return this->Enabled; }
 
     std::vector<std::string> SubmitFiles;
+
   private:
     bool Enabled;
     std::string Name;
   };
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  enum HTTPMethod {
+  enum HTTPMethod
+  {
     HTTP_GET,
     HTTP_POST,
     HTTP_PUT
@@ -102,9 +108,8 @@ public:
    * Perform an HTTP request.
    */
   static int HTTPRequest(std::string url, HTTPMethod method,
-                          std::string& response,
-                          std::string fields = "",
-                          std::string putFile = "", int timeout = 0);
+                         std::string& response, std::string fields = "",
+                         std::string putFile = "", int timeout = 0);
 #endif
 
   /** Get a testing part id from its string name.  Returns PartCount
@@ -115,7 +120,7 @@ public:
   typedef std::set<std::string> SetOfStrings;
 
   ///! Process Command line arguments
-  int Run(std::vector<std::string> &, std::string* output = 0);
+  int Run(std::vector<std::string>&, std::string* output = 0);
 
   /**
    * Initialize and finalize testing
@@ -138,8 +143,7 @@ public:
   /*
    * A utility function that returns the nightly time
    */
-  struct tm* GetNightlyTime(std::string str,
-    bool tomorrowtag);
+  struct tm* GetNightlyTime(std::string str, bool tomorrowtag);
 
   /*
    * Is the tomorrow tag set?
@@ -186,8 +190,8 @@ public:
   static int GetTestModelFromString(const char* str);
   static std::string CleanString(const std::string& str);
   std::string GetCTestConfiguration(const std::string& name);
-  void SetCTestConfiguration(const char *name, const char* value,
-    bool suppress=false);
+  void SetCTestConfiguration(const char* name, const char* value,
+                             bool suppress = false);
   void EmptyCTestConfiguration();
 
   /**
@@ -200,9 +204,8 @@ public:
   void SetNotesFiles(const char* notes);
 
   void PopulateCustomVector(cmMakefile* mf, const std::string& definition,
-    std::vector<std::string>& vec);
-  void PopulateCustomInteger(cmMakefile* mf, const std::string& def,
-    int& val);
+                            std::vector<std::string>& vec);
+  void PopulateCustomInteger(cmMakefile* mf, const std::string& def, int& val);
 
   ///! Get the current time as string
   std::string CurrentTime();
@@ -220,10 +223,8 @@ public:
   double GetRemainingTimeAllowed();
 
   ///! Open file in the output directory and set the stream
-  bool OpenOutputFile(const std::string& path,
-                      const std::string& name,
-                      cmGeneratedFileStream& stream,
-                      bool compress = false);
+  bool OpenOutputFile(const std::string& path, const std::string& name,
+                      cmGeneratedFileStream& stream, bool compress = false);
 
   ///! Should we only show what we would do?
   bool GetShowOnly();
@@ -241,13 +242,13 @@ public:
   std::string GetStopTime() { return this->StopTime; }
   void SetStopTime(std::string time);
 
-  //Used for parallel ctest job scheduling
+  // Used for parallel ctest job scheduling
   std::string GetScheduleType() { return this->ScheduleType; }
   void SetScheduleType(std::string type) { this->ScheduleType = type; }
 
   ///! The max output width
   int GetMaxTestNameWidth() const;
-  void SetMaxTestNameWidth(int w) { this->MaxTestNameWidth = w;}
+  void SetMaxTestNameWidth(int w) { this->MaxTestNameWidth = w; }
 
   /**
    * Run a single executable command and put the stdout and stderr
@@ -269,9 +270,9 @@ public:
    * it into this function or it will not work.  The command must be correctly
    * escaped for this to with spaces.
    */
-  bool RunCommand(const char* command,
-    std::string* stdOut, std::string* stdErr,
-    int* retVal = 0, const char* dir = 0, double timeout = 0.0);
+  bool RunCommand(const char* command, std::string* stdOut,
+                  std::string* stdErr, int* retVal = 0, const char* dir = 0,
+                  double timeout = 0.0);
 
   //! Clean/make safe for xml the given value such that it may be used as
   // one of the key fields by CDash when computing the buildid.
@@ -285,9 +286,8 @@ public:
 
   //! Run command specialized for make and configure. Returns process status
   // and retVal is return value or exception.
-  int RunMakeCommand(const char* command, std::string& output,
-    int* retVal, const char* dir, int timeout,
-    std::ostream& ofs);
+  int RunMakeCommand(const char* command, std::string& output, int* retVal,
+                     const char* dir, int timeout, std::ostream& ofs);
 
   /*
    * return the current tag
@@ -298,24 +298,26 @@ public:
   std::string GetBinaryDir();
 
   //! Get the short path to the file. This means if the file is in binary or
-  //source directory, it will become /.../relative/path/to/file
+  // source directory, it will become /.../relative/path/to/file
   std::string GetShortPathToFile(const char* fname);
 
-  enum {
+  enum
+  {
     EXPERIMENTAL,
     NIGHTLY,
     CONTINUOUS
   };
 
   // provide some more detailed info on the return code for ctest
-  enum {
-    UPDATE_ERRORS    = 0x01,
+  enum
+  {
+    UPDATE_ERRORS = 0x01,
     CONFIGURE_ERRORS = 0x02,
-    BUILD_ERRORS     = 0x04,
-    TEST_ERRORS      = 0x08,
-    MEMORY_ERRORS    = 0x10,
-    COVERAGE_ERRORS  = 0x20,
-    SUBMIT_ERRORS    = 0x40
+    BUILD_ERRORS = 0x04,
+    TEST_ERRORS = 0x08,
+    MEMORY_ERRORS = 0x10,
+    COVERAGE_ERRORS = 0x20,
+    SUBMIT_ERRORS = 0x40
   };
 
   ///! Are we producing XML
@@ -326,9 +328,9 @@ public:
   // return value or exception. If environment is non-null, it is used to set
   // environment variables prior to running the test. After running the test,
   // environment variables are restored to their previous values.
-  int RunTest(std::vector<const char*> args, std::string* output, int *retVal,
-    std::ostream* logfile, double testTimeOut,
-    std::vector<std::string>* environment);
+  int RunTest(std::vector<const char*> args, std::string* output, int* retVal,
+              std::ostream* logfile, double testTimeOut,
+              std::vector<std::string>* environment);
 
   /**
    * Execute handler and return its result. If the handler fails, it returns
@@ -346,7 +348,9 @@ public:
    * Set the CTest variable from CMake variable
    */
   bool SetCTestConfigurationFromCMakeVariable(cmMakefile* mf,
-    const char* dconfig, const std::string& cmake_var, bool suppress=false);
+                                              const char* dconfig,
+                                              const std::string& cmake_var,
+                                              bool suppress = false);
 
   //! Make string safe to be send as an URL
   static std::string MakeURLSafe(const std::string&);
@@ -357,20 +361,20 @@ public:
   //! Should ctect configuration be updated. When using new style ctest
   // script, this should be true.
   void SetSuppressUpdatingCTestConfiguration(bool val)
-    {
+  {
     this->SuppressUpdatingCTestConfiguration = val;
-    }
+  }
 
   //! Add overwrite to ctest configuration.
   // The format is key=value
   void AddCTestConfigurationOverwrite(const std::string& encstr);
 
   //! Create XML file that contains all the notes specified
-  int GenerateNotesFile(const VectorOfStrings &files);
+  int GenerateNotesFile(const VectorOfStrings& files);
 
   //! Submit extra files to the server
   bool SubmitExtraFiles(const char* files);
-  bool SubmitExtraFiles(const VectorOfStrings &files);
+  bool SubmitExtraFiles(const VectorOfStrings& files);
 
   //! Set the output log file name
   void SetOutputLogFileName(const char* name);
@@ -379,7 +383,8 @@ public:
   void SetConfigType(const char* ct);
 
   //! Various log types
-  enum {
+  enum
+  {
     DEBUG = 0,
     OUTPUT,
     HANDLER_OUTPUT,
@@ -392,7 +397,7 @@ public:
 
   //! Add log to the output
   void Log(int logType, const char* file, int line, const char* msg,
-           bool suppress=false);
+           bool suppress = false);
 
   //! Get the version of dart server
   int GetDartVersion() { return this->DartVersion; }
@@ -401,14 +406,18 @@ public:
   //! Add file to be submitted
   void AddSubmitFile(Part part, const char* name);
   std::vector<std::string> const& GetSubmitFiles(Part part)
-    { return this->Parts[part].SubmitFiles; }
+  {
+    return this->Parts[part].SubmitFiles;
+  }
   void ClearSubmitFiles(Part part) { this->Parts[part].SubmitFiles.clear(); }
 
   //! Read the custom configuration files and apply them to the current ctest
   int ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf);
 
-  std::vector<std::string> &GetInitialCommandLineArguments()
-  { return this->InitialCommandLineArguments; }
+  std::vector<std::string>& GetInitialCommandLineArguments()
+  {
+    return this->InitialCommandLineArguments;
+  }
 
   //! Set the track to submit to
   void SetSpecificTrack(const char* track);
@@ -420,25 +429,28 @@ public:
   void SetBatchJobs(bool batch = true) { this->BatchJobs = batch; }
   bool GetBatchJobs() { return this->BatchJobs; }
 
-  bool GetVerbose() { return this->Verbose;}
-  bool GetExtraVerbose() { return this->ExtraVerbose;}
+  bool GetVerbose() { return this->Verbose; }
+  bool GetExtraVerbose() { return this->ExtraVerbose; }
 
   /** Direct process output to given streams.  */
   void SetStreams(std::ostream* out, std::ostream* err)
-    { this->StreamOut = out; this->StreamErr = err; }
+  {
+    this->StreamOut = out;
+    this->StreamErr = err;
+  }
   void AddSiteProperties(cmXMLWriter& xml);
-  bool GetLabelSummary() { return this->LabelSummary;}
+  bool GetLabelSummary() { return this->LabelSummary; }
 
   std::string GetCostDataFile();
 
-  const std::map<std::string, std::string> &GetDefinitions()
-    {
+  const std::map<std::string, std::string>& GetDefinitions()
+  {
     return this->Definitions;
-    }
+  }
   // return the number of times a test should be run
-  int GetTestRepeat() { return this->RepeatTests;}
+  int GetTestRepeat() { return this->RepeatTests; }
   // return true if test should run until fail
-  bool GetRepeatUntilFail() { return this->RepeatUntilFail;}
+  bool GetRepeatUntilFail() { return this->RepeatUntilFail; }
 private:
   int RepeatTests;
   bool RepeatUntilFail;
@@ -459,7 +471,7 @@ private:
 
   bool RunConfigurationScript;
 
-  //flag for lazy getter (optimization)
+  // flag for lazy getter (optimization)
   bool ComputedCompressTestOutput;
   bool ComputedCompressMemCheckOutput;
 
@@ -468,7 +480,7 @@ private:
   void DetermineNextDayStop();
 
   // these are helper classes
-  typedef std::map<std::string,cmCTestGenericHandler*> t_TestingHandlers;
+  typedef std::map<std::string, cmCTestGenericHandler*> t_TestingHandlers;
   t_TestingHandlers TestingHandlers;
 
   bool ShowOnly;
@@ -476,51 +488,50 @@ private:
   //! Map of configuration properties
   typedef std::map<std::string, std::string> CTestConfigurationMap;
 
-  std::string             CTestConfigFile;
+  std::string CTestConfigFile;
   // TODO: The ctest configuration should be a hierarchy of
   // configuration option sources: command-line, script, ini file.
   // Then the ini file can get re-loaded whenever it changes without
   // affecting any higher-precedence settings.
   CTestConfigurationMap CTestConfiguration;
   CTestConfigurationMap CTestConfigurationOverwrites;
-  PartInfo                Parts[PartCount];
+  PartInfo Parts[PartCount];
   typedef std::map<std::string, Part> PartMapType;
-  PartMapType             PartMap;
+  PartMapType PartMap;
 
-  std::string             CurrentTag;
-  bool                    TomorrowTag;
+  std::string CurrentTag;
+  bool TomorrowTag;
 
-  int                     TestModel;
-  std::string             SpecificTrack;
+  int TestModel;
+  std::string SpecificTrack;
 
-  double                  TimeOut;
+  double TimeOut;
 
-  double                  GlobalTimeout;
+  double GlobalTimeout;
 
-  int                     LastStopTimeout;
+  int LastStopTimeout;
 
-  int                     MaxTestNameWidth;
+  int MaxTestNameWidth;
 
-  int                     ParallelLevel;
-  bool                    ParallelLevelSetInCli;
+  int ParallelLevel;
+  bool ParallelLevelSetInCli;
 
-  unsigned long           TestLoad;
+  unsigned long TestLoad;
 
-  int                     CompatibilityMode;
+  int CompatibilityMode;
 
   // information for the --build-and-test options
-  std::string              BinaryDir;
-
-  std::string              NotesFiles;
+  std::string BinaryDir;
 
+  std::string NotesFiles;
 
-  bool                     InteractiveDebugMode;
+  bool InteractiveDebugMode;
 
-  bool                     ShortDateFormat;
+  bool ShortDateFormat;
 
-  bool                     CompressXMLFiles;
-  bool                     CompressTestOutput;
-  bool                     CompressMemCheckOutput;
+  bool CompressXMLFiles;
+  bool CompressTestOutput;
+  bool CompressMemCheckOutput;
 
   void InitStreams();
   std::ostream* StreamOut;
@@ -539,45 +550,42 @@ private:
   int Initialize(const char* binary_dir, cmCTestStartCommand* command);
 
   //! parse the option after -D and convert it into the appropriate steps
-  bool AddTestsForDashboardType(std::string &targ);
+  bool AddTestsForDashboardType(std::string& targ);
 
   //! read as "emit an error message for an unknown -D value"
-  void ErrorMessageUnknownDashDValue(std::string &val);
+  void ErrorMessageUnknownDashDValue(std::string& val);
 
   //! add a variable definition from a command line -D value
-  bool AddVariableDefinition(const std::string &arg);
+  bool AddVariableDefinition(const std::string& arg);
 
   //! parse and process most common command line arguments
-  bool HandleCommandLineArguments(size_t &i,
-                                  std::vector<std::string> &args,
+  bool HandleCommandLineArguments(size_t& i, std::vector<std::string>& args,
                                   std::string& errormsg);
 
   //! hande the -S -SP and -SR arguments
-  void HandleScriptArguments(size_t &i,
-                             std::vector<std::string> &args,
-                             bool &SRArgumentSpecified);
+  void HandleScriptArguments(size_t& i, std::vector<std::string>& args,
+                             bool& SRArgumentSpecified);
 
   //! Reread the configuration file
   bool UpdateCTestConfiguration();
 
   //! Create note from files.
-  int GenerateCTestNotesOutput(cmXMLWriter& xml,
-    const VectorOfStrings& files);
+  int GenerateCTestNotesOutput(cmXMLWriter& xml, const VectorOfStrings& files);
 
   //! Check if the argument is the one specified
   bool CheckArgument(const std::string& arg, const char* varg1,
-    const char* varg2 = 0);
+                     const char* varg2 = 0);
 
   //! Output errors from a test
-  void OutputTestErrors(std::vector<char> const &process_output);
+  void OutputTestErrors(std::vector<char> const& process_output);
 
-  bool                      SuppressUpdatingCTestConfiguration;
+  bool SuppressUpdatingCTestConfiguration;
 
   bool Debug;
   bool ShowLineNumbers;
   bool Quiet;
 
-  int  DartVersion;
+  int DartVersion;
   bool DropSiteCDash;
 
   std::vector<std::string> InitialCommandLineArguments;
@@ -596,18 +604,20 @@ class cmCTestLogWrite
 {
 public:
   cmCTestLogWrite(const char* data, size_t length)
-    : Data(data), Length(length) {}
+    : Data(data)
+    , Length(length)
+  {
+  }
 
   const char* Data;
   size_t Length;
 };
 
-inline std::ostream& operator<< (std::ostream& os, const cmCTestLogWrite& c)
+inline std::ostream& operator<<(std::ostream& os, const cmCTestLogWrite& c)
 {
-  if (!c.Length)
-    {
+  if (!c.Length) {
     return os;
-    }
+  }
   os.write(c.Data, c.Length);
   os.flush();
   return os;
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 30caa32..d143193 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -38,223 +38,183 @@ void cmCacheManager::CleanCMakeFiles(const std::string& path)
   std::for_each(files.begin(), files.end(), cmSystemTools::RemoveFile);
 }
 
-bool cmCacheManager::LoadCache(const std::string& path,
-                               bool internal,
+bool cmCacheManager::LoadCache(const std::string& path, bool internal,
                                std::set<std::string>& excludes,
                                std::set<std::string>& includes)
 {
   std::string cacheFile = path;
   cacheFile += "/CMakeCache.txt";
   // clear the old cache, if we are reading in internal values
-  if ( internal )
-    {
+  if (internal) {
     this->Cache.clear();
-    }
-  if(!cmSystemTools::FileExists(cacheFile.c_str()))
-    {
+  }
+  if (!cmSystemTools::FileExists(cacheFile.c_str())) {
     this->CleanCMakeFiles(path);
     return false;
-    }
+  }
 
   cmsys::ifstream fin(cacheFile.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     return false;
-    }
-  const char *realbuffer;
+  }
+  const char* realbuffer;
   std::string buffer;
   std::string entryKey;
   unsigned int lineno = 0;
-  while(fin)
-    {
+  while (fin) {
     // Format is key:type=value
     std::string helpString;
     CacheEntry e;
     cmSystemTools::GetLineFromStream(fin, buffer);
     lineno++;
     realbuffer = buffer.c_str();
-    while(*realbuffer != '0' &&
-          (*realbuffer == ' ' ||
-           *realbuffer == '\t' ||
-           *realbuffer == '\r' ||
-           *realbuffer == '\n'))
-      {
-      if (*realbuffer == '\n') lineno++;
+    while (*realbuffer != '0' &&
+           (*realbuffer == ' ' || *realbuffer == '\t' || *realbuffer == '\r' ||
+            *realbuffer == '\n')) {
+      if (*realbuffer == '\n')
+        lineno++;
       realbuffer++;
-      }
+    }
     // skip blank lines and comment lines
-    if(realbuffer[0] == '#' || realbuffer[0] == 0)
-      {
+    if (realbuffer[0] == '#' || realbuffer[0] == 0) {
       continue;
-      }
-    while(realbuffer[0] == '/' && realbuffer[1] == '/')
-      {
-      if ((realbuffer[2] == '\\') && (realbuffer[3]=='n'))
-        {
+    }
+    while (realbuffer[0] == '/' && realbuffer[1] == '/') {
+      if ((realbuffer[2] == '\\') && (realbuffer[3] == 'n')) {
         helpString += "\n";
         helpString += &realbuffer[4];
-        }
-      else
-        {
+      } else {
         helpString += &realbuffer[2];
-        }
+      }
       cmSystemTools::GetLineFromStream(fin, buffer);
       lineno++;
       realbuffer = buffer.c_str();
-      if(!fin)
-        {
+      if (!fin) {
         continue;
-        }
       }
+    }
     e.SetProperty("HELPSTRING", helpString.c_str());
-    if(cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type))
-      {
-      if ( excludes.find(entryKey) == excludes.end() )
-        {
+    if (cmState::ParseCacheEntry(realbuffer, entryKey, e.Value, e.Type)) {
+      if (excludes.find(entryKey) == excludes.end()) {
         // Load internal values if internal is set.
         // If the entry is not internal to the cache being loaded
         // or if it is in the list of internal entries to be
         // imported, load it.
-        if ( internal || (e.Type != cmState::INTERNAL) ||
-             (includes.find(entryKey) != includes.end()) )
-          {
+        if (internal || (e.Type != cmState::INTERNAL) ||
+            (includes.find(entryKey) != includes.end())) {
           // If we are loading the cache from another project,
           // make all loaded entries internal so that it is
           // not visible in the gui
-          if (!internal)
-            {
+          if (!internal) {
             e.Type = cmState::INTERNAL;
             helpString = "DO NOT EDIT, ";
             helpString += entryKey;
             helpString += " loaded from external file.  "
-              "To change this value edit this file: ";
+                          "To change this value edit this file: ";
             helpString += path;
-            helpString += "/CMakeCache.txt"   ;
+            helpString += "/CMakeCache.txt";
             e.SetProperty("HELPSTRING", helpString.c_str());
-            }
-          if(!this->ReadPropertyEntry(entryKey, e))
-            {
+          }
+          if (!this->ReadPropertyEntry(entryKey, e)) {
             e.Initialized = true;
             this->Cache[entryKey] = e;
-            }
           }
         }
       }
-    else
-      {
+    } else {
       std::ostringstream error;
       error << "Parse error in cache file " << cacheFile;
       error << " on line " << lineno << ". Offending entry: " << realbuffer;
       cmSystemTools::Error(error.str().c_str());
-      }
     }
+  }
   this->CacheMajorVersion = 0;
   this->CacheMinorVersion = 0;
-  if(const char* cmajor =
-                  this->GetInitializedCacheValue("CMAKE_CACHE_MAJOR_VERSION"))
-    {
-    unsigned int v=0;
-    if(sscanf(cmajor, "%u", &v) == 1)
-      {
+  if (const char* cmajor =
+        this->GetInitializedCacheValue("CMAKE_CACHE_MAJOR_VERSION")) {
+    unsigned int v = 0;
+    if (sscanf(cmajor, "%u", &v) == 1) {
       this->CacheMajorVersion = v;
-      }
-    if(const char* cminor =
-                  this->GetInitializedCacheValue("CMAKE_CACHE_MINOR_VERSION"))
-      {
-      if(sscanf(cminor, "%u", &v) == 1)
-        {
+    }
+    if (const char* cminor =
+          this->GetInitializedCacheValue("CMAKE_CACHE_MINOR_VERSION")) {
+      if (sscanf(cminor, "%u", &v) == 1) {
         this->CacheMinorVersion = v;
-        }
       }
     }
-  else
-    {
+  } else {
     // CMake version not found in the list file.
     // Set as version 0.0
     this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", "0",
                         "Minor version of cmake used to create the "
-                        "current loaded cache", cmState::INTERNAL);
+                        "current loaded cache",
+                        cmState::INTERNAL);
     this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
                         "Major version of cmake used to create the "
-                        "current loaded cache", cmState::INTERNAL);
-
-    }
+                        "current loaded cache",
+                        cmState::INTERNAL);
+  }
   // check to make sure the cache directory has not
   // been moved
   const char* oldDir = this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR");
-  if (internal && oldDir)
-    {
+  if (internal && oldDir) {
     std::string currentcwd = path;
     std::string oldcwd = oldDir;
     cmSystemTools::ConvertToUnixSlashes(currentcwd);
     currentcwd += "/CMakeCache.txt";
     oldcwd += "/CMakeCache.txt";
-    if(!cmSystemTools::SameFile(oldcwd, currentcwd))
-      {
+    if (!cmSystemTools::SameFile(oldcwd, currentcwd)) {
       std::string message =
-        std::string("The current CMakeCache.txt directory ") +
-        currentcwd + std::string(" is different than the directory ") +
+        std::string("The current CMakeCache.txt directory ") + currentcwd +
+        std::string(" is different than the directory ") +
         std::string(this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")) +
         std::string(" where CMakeCache.txt was created. This may result "
                     "in binaries being created in the wrong place. If you "
                     "are not sure, reedit the CMakeCache.txt");
       cmSystemTools::Error(message.c_str());
-      }
     }
+  }
   return true;
 }
 
-const char* cmCacheManager::PersistentProperties[] =
-{
-  "ADVANCED",
-  "MODIFIED",
-  "STRINGS",
-  0
-};
+const char* cmCacheManager::PersistentProperties[] = { "ADVANCED", "MODIFIED",
+                                                       "STRINGS", 0 };
 
 bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
                                        CacheEntry& e)
 {
   // All property entries are internal.
-  if(e.Type != cmState::INTERNAL)
-    {
+  if (e.Type != cmState::INTERNAL) {
     return false;
-    }
+  }
 
   const char* end = entryKey.c_str() + entryKey.size();
-  for(const char** p = this->PersistentProperties; *p; ++p)
-    {
+  for (const char** p = this->PersistentProperties; *p; ++p) {
     std::string::size_type plen = strlen(*p) + 1;
-    if(entryKey.size() > plen && *(end-plen) == '-' &&
-       strcmp(end-plen+1, *p) == 0)
-      {
+    if (entryKey.size() > plen && *(end - plen) == '-' &&
+        strcmp(end - plen + 1, *p) == 0) {
       std::string key = entryKey.substr(0, entryKey.size() - plen);
       cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
-      if(it.IsAtEnd())
-        {
+      if (it.IsAtEnd()) {
         // Create an entry and store the property.
         CacheEntry& ne = this->Cache[key];
         ne.Type = cmState::UNINITIALIZED;
         ne.SetProperty(*p, e.Value.c_str());
-        }
-      else
-        {
+      } else {
         // Store this property on its entry.
         it.SetProperty(*p, e.Value.c_str());
-        }
-      return true;
       }
+      return true;
     }
+  }
   return false;
 }
 
 void cmCacheManager::WritePropertyEntries(std::ostream& os,
                                           CacheIterator const& i)
 {
-  for(const char** p = this->PersistentProperties; *p; ++p)
-    {
-    if(const char* value = i.GetProperty(*p))
-      {
+  for (const char** p = this->PersistentProperties; *p; ++p) {
+    if (const char* value = i.GetProperty(*p)) {
       std::string helpstring = *p;
       helpstring += " property for variable: ";
       helpstring += i.GetName();
@@ -267,8 +227,8 @@ void cmCacheManager::WritePropertyEntries(std::ostream& os,
       os << ":INTERNAL=";
       this->OutputValue(os, value);
       os << "\n";
-      }
     }
+  }
 }
 
 bool cmCacheManager::SaveCache(const std::string& path)
@@ -277,43 +237,44 @@ bool cmCacheManager::SaveCache(const std::string& path)
   cacheFile += "/CMakeCache.txt";
   cmGeneratedFileStream fout(cacheFile.c_str());
   fout.SetCopyIfDifferent(true);
-  if(!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("Unable to open cache file for save. ",
                          cacheFile.c_str());
     cmSystemTools::ReportLastSystemError("");
     return false;
-    }
+  }
   // before writing the cache, update the version numbers
   // to the
   char temp[1024];
   sprintf(temp, "%d", cmVersion::GetMinorVersion());
   this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", temp,
                       "Minor version of cmake used to create the "
-                      "current loaded cache", cmState::INTERNAL);
+                      "current loaded cache",
+                      cmState::INTERNAL);
   sprintf(temp, "%d", cmVersion::GetMajorVersion());
   this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", temp,
                       "Major version of cmake used to create the "
-                      "current loaded cache", cmState::INTERNAL);
+                      "current loaded cache",
+                      cmState::INTERNAL);
   sprintf(temp, "%d", cmVersion::GetPatchVersion());
   this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION", temp,
                       "Patch version of cmake used to create the "
-                      "current loaded cache", cmState::INTERNAL);
+                      "current loaded cache",
+                      cmState::INTERNAL);
 
   // Let us store the current working directory so that if somebody
   // Copies it, he will not be surprised
   std::string currentcwd = path;
-  if ( currentcwd[0] >= 'A' && currentcwd[0] <= 'Z' &&
-       currentcwd[1] == ':' )
-    {
+  if (currentcwd[0] >= 'A' && currentcwd[0] <= 'Z' && currentcwd[1] == ':') {
     // Cast added to avoid compiler warning. Cast is ok because
     // value is guaranteed to fit in char by the above if...
     currentcwd[0] = static_cast<char>(currentcwd[0] - 'A' + 'a');
-    }
+  }
   cmSystemTools::ConvertToUnixSlashes(currentcwd);
   this->AddCacheEntry("CMAKE_CACHEFILE_DIR", currentcwd.c_str(),
                       "This is the directory where this CMakeCache.txt"
-                      " was created", cmState::INTERNAL);
+                      " was created",
+                      cmState::INTERNAL);
 
   /* clang-format off */
   fout << "# This is the CMakeCache file.\n"
@@ -342,36 +303,30 @@ bool cmCacheManager::SaveCache(const std::string& path)
   fout << "########################\n";
   fout << "\n";
 
-  for( std::map<std::string, CacheEntry>::const_iterator i =
-         this->Cache.begin(); i != this->Cache.end(); ++i)
-    {
+  for (std::map<std::string, CacheEntry>::const_iterator i =
+         this->Cache.begin();
+       i != this->Cache.end(); ++i) {
     const CacheEntry& ce = (*i).second;
     cmState::CacheEntryType t = ce.Type;
-    if(!ce.Initialized)
-      {
+    if (!ce.Initialized) {
       /*
         // This should be added in, but is not for now.
       cmSystemTools::Error("Cache entry \"", (*i).first.c_str(),
                            "\" is uninitialized");
       */
-      }
-    else if(t != cmState::INTERNAL)
-      {
+    } else if (t != cmState::INTERNAL) {
       // Format is key:type=value
-      if(const char* help = ce.GetProperty("HELPSTRING"))
-        {
+      if (const char* help = ce.GetProperty("HELPSTRING")) {
         cmCacheManager::OutputHelpString(fout, help);
-        }
-      else
-        {
+      } else {
         cmCacheManager::OutputHelpString(fout, "Missing description");
-        }
+      }
       this->OutputKey(fout, i->first);
       fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
       this->OutputValue(fout, ce.Value);
       fout << "\n\n";
-      }
     }
+  }
 
   fout << "\n";
   fout << "########################\n";
@@ -379,29 +334,25 @@ bool cmCacheManager::SaveCache(const std::string& path)
   fout << "########################\n";
   fout << "\n";
 
-  for( cmCacheManager::CacheIterator i = this->NewIterator();
-       !i.IsAtEnd(); i.Next())
-    {
-    if ( !i.Initialized() )
-      {
+  for (cmCacheManager::CacheIterator i = this->NewIterator(); !i.IsAtEnd();
+       i.Next()) {
+    if (!i.Initialized()) {
       continue;
-      }
+    }
 
     cmState::CacheEntryType t = i.GetType();
     this->WritePropertyEntries(fout, i);
-    if(t == cmState::INTERNAL)
-      {
+    if (t == cmState::INTERNAL) {
       // Format is key:type=value
-      if(const char* help = i.GetProperty("HELPSTRING"))
-        {
+      if (const char* help = i.GetProperty("HELPSTRING")) {
         this->OutputHelpString(fout, help);
-        }
+      }
       this->OutputKey(fout, i.GetName());
       fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
       this->OutputValue(fout, i.GetValue());
       fout << "\n";
-      }
     }
+  }
   fout << "\n";
   fout.Close();
   std::string checkCacheFile = path;
@@ -409,14 +360,13 @@ bool cmCacheManager::SaveCache(const std::string& path)
   cmSystemTools::MakeDirectory(checkCacheFile.c_str());
   checkCacheFile += "/cmake.check_cache";
   cmsys::ofstream checkCache(checkCacheFile.c_str());
-  if(!checkCache)
-    {
+  if (!checkCache) {
     cmSystemTools::Error("Unable to open check cache file for write. ",
                          checkCacheFile.c_str());
     return false;
-    }
+  }
   checkCache << "# This file is generated by cmake for dependency checking "
-    "of the CMakeCache.txt file\n";
+                "of the CMakeCache.txt file\n";
   return true;
 }
 
@@ -426,25 +376,23 @@ bool cmCacheManager::DeleteCache(const std::string& path)
   cmSystemTools::ConvertToUnixSlashes(cacheFile);
   std::string cmakeFiles = cacheFile;
   cacheFile += "/CMakeCache.txt";
-  if(cmSystemTools::FileExists(cacheFile.c_str()))
-    {
+  if (cmSystemTools::FileExists(cacheFile.c_str())) {
     cmSystemTools::RemoveFile(cacheFile);
     // now remove the files in the CMakeFiles directory
     // this cleans up language cache files
     cmakeFiles += cmake::GetCMakeFilesDirectory();
-    if(cmSystemTools::FileIsDirectory(cmakeFiles))
-      {
+    if (cmSystemTools::FileIsDirectory(cmakeFiles)) {
       cmSystemTools::RemoveADirectory(cmakeFiles);
-      }
     }
+  }
   return true;
 }
 
 void cmCacheManager::OutputKey(std::ostream& fout, std::string const& key)
 {
   // support : in key name by double quoting
-  const char* q = (key.find(':') != key.npos ||
-                   key.find("//") == 0)? "\"" : "";
+  const char* q =
+    (key.find(':') != key.npos || key.find("//") == 0) ? "\"" : "";
   fout << q << key << q;
 }
 
@@ -452,147 +400,120 @@ void cmCacheManager::OutputValue(std::ostream& fout, std::string const& value)
 {
   // if value has trailing space or tab, enclose it in single quotes
   if (!value.empty() &&
-      (value[value.size() - 1] == ' ' ||
-       value[value.size() - 1] == '\t'))
-    {
+      (value[value.size() - 1] == ' ' || value[value.size() - 1] == '\t')) {
     fout << '\'' << value << '\'';
-    }
-  else
-    {
+  } else {
     fout << value;
-    }
+  }
 }
 
 void cmCacheManager::OutputHelpString(std::ostream& fout,
                                       const std::string& helpString)
 {
   std::string::size_type end = helpString.size();
-  if(end == 0)
-    {
+  if (end == 0) {
     return;
-    }
+  }
   std::string oneLine;
   std::string::size_type pos = 0;
-  for (std::string::size_type i=0; i<=end; i++)
-    {
-    if ((i==end)
-        || (helpString[i]=='\n')
-        || ((i-pos >= 60) && (helpString[i]==' ')))
-      {
+  for (std::string::size_type i = 0; i <= end; i++) {
+    if ((i == end) || (helpString[i] == '\n') ||
+        ((i - pos >= 60) && (helpString[i] == ' '))) {
       fout << "//";
-      if (helpString[pos] == '\n')
-        {
+      if (helpString[pos] == '\n') {
         pos++;
         fout << "\\n";
-        }
+      }
       oneLine = helpString.substr(pos, i - pos);
       fout << oneLine << "\n";
       pos = i;
-      }
     }
+  }
 }
 
 void cmCacheManager::RemoveCacheEntry(const std::string& key)
 {
   CacheEntryMap::iterator i = this->Cache.find(key);
-  if(i != this->Cache.end())
-    {
+  if (i != this->Cache.end()) {
     this->Cache.erase(i);
-    }
+  }
 }
 
-
-cmCacheManager::CacheEntry *cmCacheManager::GetCacheEntry(
-    const std::string& key)
+cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry(
+  const std::string& key)
 {
   CacheEntryMap::iterator i = this->Cache.find(key);
-  if(i != this->Cache.end())
-    {
+  if (i != this->Cache.end()) {
     return &i->second;
-    }
+  }
   return 0;
 }
 
-cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
-  const char *key)
+cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(const char* key)
 {
   return CacheIterator(*this, key);
 }
 
-const char*
-cmCacheManager::GetInitializedCacheValue(const std::string& key) const
+const char* cmCacheManager::GetInitializedCacheValue(
+  const std::string& key) const
 {
   CacheEntryMap::const_iterator i = this->Cache.find(key);
-  if(i != this->Cache.end() &&
-    i->second.Initialized)
-    {
+  if (i != this->Cache.end() && i->second.Initialized) {
     return i->second.Value.c_str();
-    }
+  }
   return 0;
 }
 
-
 void cmCacheManager::PrintCache(std::ostream& out) const
 {
   out << "=================================================" << std::endl;
   out << "CMakeCache Contents:" << std::endl;
-  for(std::map<std::string, CacheEntry>::const_iterator i =
-        this->Cache.begin(); i != this->Cache.end(); ++i)
-    {
-    if((*i).second.Type != cmState::INTERNAL)
-      {
-      out << (*i).first << " = " << (*i).second.Value
-          << std::endl;
-      }
+  for (std::map<std::string, CacheEntry>::const_iterator i =
+         this->Cache.begin();
+       i != this->Cache.end(); ++i) {
+    if ((*i).second.Type != cmState::INTERNAL) {
+      out << (*i).first << " = " << (*i).second.Value << std::endl;
     }
+  }
   out << "\n\n";
-  out << "To change values in the CMakeCache, "
-    << std::endl << "edit CMakeCache.txt in your output directory.\n";
+  out << "To change values in the CMakeCache, " << std::endl
+      << "edit CMakeCache.txt in your output directory.\n";
   out << "=================================================" << std::endl;
 }
 
-
-void cmCacheManager::AddCacheEntry(const std::string& key,
-                                   const char* value,
+void cmCacheManager::AddCacheEntry(const std::string& key, const char* value,
                                    const char* helpString,
                                    cmState::CacheEntryType type)
 {
   CacheEntry& e = this->Cache[key];
-  if ( value )
-    {
+  if (value) {
     e.Value = value;
     e.Initialized = true;
-    }
-  else
-    {
+  } else {
     e.Value = "";
-    }
+  }
   e.Type = type;
   // make sure we only use unix style paths
-  if(type == cmState::FILEPATH || type == cmState::PATH)
-    {
-    if(e.Value.find(';') != e.Value.npos)
-      {
+  if (type == cmState::FILEPATH || type == cmState::PATH) {
+    if (e.Value.find(';') != e.Value.npos) {
       std::vector<std::string> paths;
       cmSystemTools::ExpandListArgument(e.Value, paths);
       const char* sep = "";
       e.Value = "";
-      for(std::vector<std::string>::iterator i = paths.begin();
-          i != paths.end(); ++i)
-        {
+      for (std::vector<std::string>::iterator i = paths.begin();
+           i != paths.end(); ++i) {
         cmSystemTools::ConvertToUnixSlashes(*i);
         e.Value += sep;
         e.Value += *i;
         sep = ";";
-        }
       }
-    else
-      {
+    } else {
       cmSystemTools::ConvertToUnixSlashes(e.Value);
-      }
     }
-  e.SetProperty("HELPSTRING", helpString? helpString :
-                "(This variable does not exist and should not be used)");
+  }
+  e.SetProperty("HELPSTRING", helpString
+                  ? helpString
+                  : "(This variable does not exist and should not be used)");
 }
 
 bool cmCacheManager::CacheIterator::IsAtEnd() const
@@ -613,28 +534,23 @@ bool cmCacheManager::CacheIterator::Find(const std::string& key)
 
 void cmCacheManager::CacheIterator::Next()
 {
-  if (!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     ++this->Position;
-    }
+  }
 }
 
 void cmCacheManager::CacheIterator::SetValue(const char* value)
 {
-  if (this->IsAtEnd())
-    {
+  if (this->IsAtEnd()) {
     return;
-    }
+  }
   CacheEntry* entry = &this->GetEntry();
-  if ( value )
-    {
+  if (value) {
     entry->Value = value;
     entry->Initialized = true;
-    }
-  else
-    {
+  } else {
     entry->Value = "";
-    }
+  }
 }
 
 bool cmCacheManager::CacheIterator::GetValueAsBool() const
@@ -642,98 +558,79 @@ bool cmCacheManager::CacheIterator::GetValueAsBool() const
   return cmSystemTools::IsOn(this->GetEntry().Value.c_str());
 }
 
-const char*
-cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
+const char* cmCacheManager::CacheEntry::GetProperty(
+  const std::string& prop) const
 {
-  if(prop == "TYPE")
-    {
+  if (prop == "TYPE") {
     return cmState::CacheEntryTypeToString(this->Type);
-    }
-  else if(prop == "VALUE")
-    {
+  } else if (prop == "VALUE") {
     return this->Value.c_str();
-    }
+  }
   return this->Properties.GetPropertyValue(prop);
 }
 
 void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
                                              const char* value)
 {
-  if(prop == "TYPE")
-    {
-    this->Type = cmState::StringToCacheEntryType(value? value : "STRING");
-    }
-  else if(prop == "VALUE")
-    {
-    this->Value = value? value : "";
-    }
-  else
-    {
+  if (prop == "TYPE") {
+    this->Type = cmState::StringToCacheEntryType(value ? value : "STRING");
+  } else if (prop == "VALUE") {
+    this->Value = value ? value : "";
+  } else {
     this->Properties.SetProperty(prop, value);
-    }
+  }
 }
 
 void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
                                                 const char* value,
                                                 bool asString)
 {
-  if(prop == "TYPE")
-    {
-    this->Type = cmState::StringToCacheEntryType(value? value : "STRING");
-    }
-  else if(prop == "VALUE")
-    {
-    if(value)
-      {
-      if(!this->Value.empty() && *value && !asString)
-        {
+  if (prop == "TYPE") {
+    this->Type = cmState::StringToCacheEntryType(value ? value : "STRING");
+  } else if (prop == "VALUE") {
+    if (value) {
+      if (!this->Value.empty() && *value && !asString) {
         this->Value += ";";
-        }
-      this->Value += value;
       }
+      this->Value += value;
     }
-  else
-    {
+  } else {
     this->Properties.AppendProperty(prop, value, asString);
-    }
+  }
 }
 
 const char* cmCacheManager::CacheIterator::GetProperty(
-    const std::string& prop) const
+  const std::string& prop) const
 {
-  if(!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     return this->GetEntry().GetProperty(prop);
-    }
+  }
   return 0;
 }
 
 void cmCacheManager::CacheIterator::SetProperty(const std::string& p,
                                                 const char* v)
 {
-  if(!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     this->GetEntry().SetProperty(p, v);
-    }
+  }
 }
 
 void cmCacheManager::CacheIterator::AppendProperty(const std::string& p,
                                                    const char* v,
                                                    bool asString)
 {
-  if(!this->IsAtEnd())
-    {
+  if (!this->IsAtEnd()) {
     this->GetEntry().AppendProperty(p, v, asString);
-    }
+  }
 }
 
 bool cmCacheManager::CacheIterator::GetPropertyAsBool(
-    const std::string& prop) const
+  const std::string& prop) const
 {
-  if(const char* value = this->GetProperty(prop))
-    {
+  if (const char* value = this->GetProperty(prop)) {
     return cmSystemTools::IsOn(value);
-    }
+  }
   return false;
 }
 
@@ -743,7 +640,7 @@ void cmCacheManager::CacheIterator::SetProperty(const std::string& p, bool v)
 }
 
 bool cmCacheManager::CacheIterator::PropertyExists(
-    const std::string& prop) const
+  const std::string& prop) const
 {
-  return this->GetProperty(prop)? true:false;
+  return this->GetProperty(prop) ? true : false;
 }
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 614ff69..e9b80cb 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -41,13 +41,14 @@ private:
     const char* GetProperty(const std::string&) const;
     void SetProperty(const std::string& property, const char* value);
     void AppendProperty(const std::string& property, const char* value,
-                        bool asString=false);
+                        bool asString = false);
     bool Initialized;
     CacheEntry()
-      : Value(""),
-        Type(cmState::UNINITIALIZED),
-        Initialized(false)
-      {}
+      : Value("")
+      , Type(cmState::UNINITIALIZED)
+      , Initialized(false)
+    {
+    }
   };
 
 public:
@@ -58,45 +59,42 @@ public:
     bool Find(const std::string&);
     bool IsAtEnd() const;
     void Next();
-    std::string GetName() const {
-      return this->Position->first; }
-    const char* GetProperty(const std::string&) const ;
-    bool GetPropertyAsBool(const std::string&) const ;
+    std::string GetName() const { return this->Position->first; }
+    const char* GetProperty(const std::string&) const;
+    bool GetPropertyAsBool(const std::string&) const;
     bool PropertyExists(const std::string&) const;
     void SetProperty(const std::string& property, const char* value);
     void AppendProperty(const std::string& property, const char* value,
-                        bool asString=false);
+                        bool asString = false);
     void SetProperty(const std::string& property, bool value);
     const char* GetValue() const { return this->GetEntry().Value.c_str(); }
     bool GetValueAsBool() const;
     void SetValue(const char*);
-    cmState::CacheEntryType GetType() const
-    { return this->GetEntry().Type; }
-    void SetType(cmState::CacheEntryType ty)
-    { this->GetEntry().Type = ty; }
+    cmState::CacheEntryType GetType() const { return this->GetEntry().Type; }
+    void SetType(cmState::CacheEntryType ty) { this->GetEntry().Type = ty; }
     bool Initialized() { return this->GetEntry().Initialized; }
-    cmCacheManager &Container;
+    cmCacheManager& Container;
     std::map<std::string, CacheEntry>::iterator Position;
-    CacheIterator(cmCacheManager &cm) : Container(cm) {
+    CacheIterator(cmCacheManager& cm)
+      : Container(cm)
+    {
       this->Begin();
     }
-    CacheIterator(cmCacheManager &cm, const char* key) : Container(cm)
-      {
-      if ( key )
-        {
+    CacheIterator(cmCacheManager& cm, const char* key)
+      : Container(cm)
+    {
+      if (key) {
         this->Find(key);
-        }
       }
+    }
+
   private:
     CacheEntry const& GetEntry() const { return this->Position->second; }
     CacheEntry& GetEntry() { return this->Position->second; }
   };
 
   ///! return an iterator to iterate through the cache map
-  cmCacheManager::CacheIterator NewIterator()
-    {
-      return CacheIterator(*this);
-    }
+  cmCacheManager::CacheIterator NewIterator() { return CacheIterator(*this); }
 
   ///! Load a cache for given makefile.  Loads from path/CMakeCache.txt.
   bool LoadCache(const std::string& path, bool internal,
@@ -104,7 +102,7 @@ public:
                  std::set<std::string>& includes);
 
   ///! Save cache for given makefile.  Saves to ouput path/CMakeCache.txt
-  bool SaveCache(const std::string& path) ;
+  bool SaveCache(const std::string& path);
 
   ///! Delete the cache given
   bool DeleteCache(const std::string& path);
@@ -113,14 +111,13 @@ public:
   void PrintCache(std::ostream&) const;
 
   ///! Get the iterator for an entry with a given key.
-  cmCacheManager::CacheIterator GetCacheIterator(const char *key=0);
+  cmCacheManager::CacheIterator GetCacheIterator(const char* key = 0);
 
   ///! Remove an entry from the cache
   void RemoveCacheEntry(const std::string& key);
 
   ///! Get the number of entries in the cache
-  int GetSize() {
-    return static_cast<int>(this->Cache.size()); }
+  int GetSize() { return static_cast<int>(this->Cache.size()); }
 
   ///! Get a value from the cache given a key
   const char* GetInitializedCacheValue(const std::string& key) const;
@@ -128,10 +125,9 @@ public:
   const char* GetCacheEntryValue(const std::string& key)
   {
     cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
-    if (it.IsAtEnd())
-      {
+    if (it.IsAtEnd()) {
       return 0;
-      }
+    }
     return it.GetValue();
   }
 
@@ -160,14 +156,12 @@ public:
   }
 
   void SetCacheEntryBoolProperty(std::string const& key,
-                                 std::string const& propName,
-                                 bool value)
+                                 std::string const& propName, bool value)
   {
     this->GetCacheIterator(key.c_str()).SetProperty(propName, value);
   }
 
-  void SetCacheEntryValue(std::string const& key,
-                          std::string const& value)
+  void SetCacheEntryValue(std::string const& key, std::string const& value)
   {
     this->GetCacheIterator(key.c_str()).SetValue(value.c_str());
   }
@@ -183,9 +177,8 @@ public:
                                 std::string const& value,
                                 bool asString = false)
   {
-    this->GetCacheIterator(key.c_str()).AppendProperty(propName,
-                                                       value.c_str(),
-                                                       asString);
+    this->GetCacheIterator(key.c_str())
+      .AppendProperty(propName, value.c_str(), asString);
   }
 
   std::vector<std::string> GetCacheEntryKeys()
@@ -193,36 +186,33 @@ public:
     std::vector<std::string> definitions;
     definitions.reserve(this->GetSize());
     cmCacheManager::CacheIterator cit = this->GetCacheIterator();
-    for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
-      {
+    for (cit.Begin(); !cit.IsAtEnd(); cit.Next()) {
       definitions.push_back(cit.GetName());
-      }
+    }
     return definitions;
   }
 
   /** Get the version of CMake that wrote the cache.  */
-  unsigned int GetCacheMajorVersion() const
-    { return this->CacheMajorVersion; }
-  unsigned int GetCacheMinorVersion() const
-    { return this->CacheMinorVersion; }
+  unsigned int GetCacheMajorVersion() const { return this->CacheMajorVersion; }
+  unsigned int GetCacheMinorVersion() const { return this->CacheMinorVersion; }
 
 protected:
   ///! Add an entry into the cache
   void AddCacheEntry(const std::string& key, const char* value,
-                     const char* helpString,
-                     cmState::CacheEntryType type);
+                     const char* helpString, cmState::CacheEntryType type);
 
   ///! Get a cache entry object for a key
-  CacheEntry *GetCacheEntry(const std::string& key);
+  CacheEntry* GetCacheEntry(const std::string& key);
   ///! Clean out the CMakeFiles directory if no CMakeCache.txt
   void CleanCMakeFiles(const std::string& path);
 
   // Cache version info
   unsigned int CacheMajorVersion;
   unsigned int CacheMinorVersion;
+
 private:
   cmake* CMakeInstance;
-  typedef  std::map<std::string, CacheEntry> CacheEntryMap;
+  typedef std::map<std::string, CacheEntry> CacheEntryMap;
   static void OutputHelpString(std::ostream& fout,
                                const std::string& helpString);
   static void OutputKey(std::ostream& fout, std::string const& key);
@@ -236,7 +226,7 @@ private:
   // Only cmake and cmState should be able to add cache values
   // the commands should never use the cmCacheManager directly
   friend class cmState; // allow access to add cache values
-  friend class cmake; // allow access to add cache values
+  friend class cmake;   // allow access to add cache values
 };
 
 #endif
diff --git a/Source/cmCallVisualStudioMacro.cxx b/Source/cmCallVisualStudioMacro.cxx
index 9cc5a69..e608d6b 100644
--- a/Source/cmCallVisualStudioMacro.cxx
+++ b/Source/cmCallVisualStudioMacro.cxx
@@ -13,86 +13,73 @@
 
 #include "cmSystemTools.h"
 
-
 #if defined(_MSC_VER)
 #define HAVE_COMDEF_H
 #endif
 
-
 // Just for this file:
 //
 static bool LogErrorsAsMessages;
 
-
 #if defined(HAVE_COMDEF_H)
 
-
 #include <comdef.h>
 
-
 // Copied from a correct comdef.h to avoid problems with deficient versions
 // of comdef.h that exist in the wild... Fixes issue #7533.
 //
 #ifdef _NATIVE_WCHAR_T_DEFINED
-# ifdef _DEBUG
-# pragma comment(lib, "comsuppwd.lib")
-# else
-# pragma comment(lib, "comsuppw.lib")
-# endif
+#ifdef _DEBUG
+#pragma comment(lib, "comsuppwd.lib")
 #else
-# ifdef _DEBUG
-# pragma comment(lib, "comsuppd.lib")
-# else
-# pragma comment(lib, "comsupp.lib")
-# endif
+#pragma comment(lib, "comsuppw.lib")
+#endif
+#else
+#ifdef _DEBUG
+#pragma comment(lib, "comsuppd.lib")
+#else
+#pragma comment(lib, "comsupp.lib")
+#endif
 #endif
-
 
 ///! Use ReportHRESULT to make a cmSystemTools::Message after calling
 ///! a COM method that may have failed.
-#define ReportHRESULT(hr, context) \
-  if (FAILED(hr)) \
-    { \
-    if (LogErrorsAsMessages) \
-      { \
-      std::ostringstream _hresult_oss; \
-      _hresult_oss.flags(std::ios::hex); \
-      _hresult_oss << context << " failed HRESULT, hr = 0x" \
-                   << hr << std::endl; \
-      _hresult_oss.flags(std::ios::dec); \
-      _hresult_oss << __FILE__ << "(" << __LINE__ << ")"; \
-      cmSystemTools::Message(_hresult_oss.str().c_str()); \
-      } \
-    }
-
+#define ReportHRESULT(hr, context)                                            \
+  if (FAILED(hr)) {                                                           \
+    if (LogErrorsAsMessages) {                                                \
+      std::ostringstream _hresult_oss;                                        \
+      _hresult_oss.flags(std::ios::hex);                                      \
+      _hresult_oss << context << " failed HRESULT, hr = 0x" << hr             \
+                   << std::endl;                                              \
+      _hresult_oss.flags(std::ios::dec);                                      \
+      _hresult_oss << __FILE__ << "(" << __LINE__ << ")";                     \
+      cmSystemTools::Message(_hresult_oss.str().c_str());                     \
+    }                                                                         \
+  }
 
 ///! Using the given instance of Visual Studio, call the named macro
-HRESULT InstanceCallMacro(
-  IDispatch* vsIDE,
-  const std::string& macro,
-  const std::string& args)
+HRESULT InstanceCallMacro(IDispatch* vsIDE, const std::string& macro,
+                          const std::string& args)
 {
   HRESULT hr = E_POINTER;
 
   _bstr_t macroName(macro.c_str());
   _bstr_t macroArgs(args.c_str());
 
-  if (0 != vsIDE)
-    {
-    DISPID dispid = (DISPID) -1;
-    OLECHAR *name = L"ExecuteCommand";
+  if (0 != vsIDE) {
+    DISPID dispid = (DISPID)-1;
+    OLECHAR* name = L"ExecuteCommand";
 
-    hr = vsIDE->GetIDsOfNames(IID_NULL, &name, 1,
-           LOCALE_USER_DEFAULT, &dispid);
+    hr =
+      vsIDE->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
     ReportHRESULT(hr, "GetIDsOfNames(ExecuteCommand)");
 
-    if (SUCCEEDED(hr))
-      {
+    if (SUCCEEDED(hr)) {
       VARIANTARG vargs[2];
       DISPPARAMS params;
       VARIANT result;
       EXCEPINFO excep;
-      UINT arg = (UINT) -1;
+      UINT arg = (UINT)-1;
 
       // No VariantInit or VariantClear calls are necessary for
       // these two vargs. They are both local _bstr_t variables
@@ -105,7 +92,7 @@ HRESULT InstanceCallMacro(
 
       params.rgvarg = &vargs[0];
       params.rgdispidNamedArgs = 0;
-      params.cArgs = sizeof(vargs)/sizeof(vargs[0]);
+      params.cArgs = sizeof(vargs) / sizeof(vargs[0]);
       params.cNamedArgs = 0;
 
       VariantInit(&result);
@@ -113,7 +100,7 @@ HRESULT InstanceCallMacro(
       memset(&excep, 0, sizeof(excep));
 
       hr = vsIDE->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT,
-        DISPATCH_METHOD, &params, &result, &excep, &arg);
+                         DISPATCH_METHOD, &params, &result, &excep, &arg);
 
       std::ostringstream oss;
       oss << std::endl;
@@ -121,65 +108,56 @@ HRESULT InstanceCallMacro(
       oss << "  Macro: " << macro.c_str() << std::endl;
       oss << "  Args: " << args.c_str() << std::endl;
 
-      if (DISP_E_EXCEPTION == hr)
-        {
+      if (DISP_E_EXCEPTION == hr) {
         oss << "DISP_E_EXCEPTION EXCEPINFO:" << excep.wCode << std::endl;
         oss << "  wCode: " << excep.wCode << std::endl;
         oss << "  wReserved: " << excep.wReserved << std::endl;
-        if (excep.bstrSource)
-          {
-          oss << "  bstrSource: " <<
-            (const char*)(_bstr_t)excep.bstrSource << std::endl;
-          }
-        if (excep.bstrDescription)
-          {
-          oss << "  bstrDescription: " <<
-            (const char*)(_bstr_t)excep.bstrDescription << std::endl;
-          }
-        if (excep.bstrHelpFile)
-          {
-          oss << "  bstrHelpFile: " <<
-            (const char*)(_bstr_t)excep.bstrHelpFile << std::endl;
-          }
+        if (excep.bstrSource) {
+          oss << "  bstrSource: " << (const char*)(_bstr_t)excep.bstrSource
+              << std::endl;
+        }
+        if (excep.bstrDescription) {
+          oss << "  bstrDescription: "
+              << (const char*)(_bstr_t)excep.bstrDescription << std::endl;
+        }
+        if (excep.bstrHelpFile) {
+          oss << "  bstrHelpFile: " << (const char*)(_bstr_t)excep.bstrHelpFile
+              << std::endl;
+        }
         oss << "  dwHelpContext: " << excep.dwHelpContext << std::endl;
         oss << "  pvReserved: " << excep.pvReserved << std::endl;
         oss << "  pfnDeferredFillIn: " << excep.pfnDeferredFillIn << std::endl;
         oss << "  scode: " << excep.scode << std::endl;
-        }
+      }
 
       std::string exstr(oss.str());
       ReportHRESULT(hr, exstr.c_str());
 
       VariantClear(&result);
-      }
     }
+  }
 
   return hr;
 }
 
-
 ///! Get the Solution object from the IDE object
-HRESULT GetSolutionObject(
-  IDispatch* vsIDE,
-  IDispatchPtr& vsSolution)
+HRESULT GetSolutionObject(IDispatch* vsIDE, IDispatchPtr& vsSolution)
 {
   HRESULT hr = E_POINTER;
 
-  if (0 != vsIDE)
-    {
-    DISPID dispid = (DISPID) -1;
-    OLECHAR *name = L"Solution";
+  if (0 != vsIDE) {
+    DISPID dispid = (DISPID)-1;
+    OLECHAR* name = L"Solution";
 
-    hr = vsIDE->GetIDsOfNames(IID_NULL, &name, 1,
-           LOCALE_USER_DEFAULT, &dispid);
+    hr =
+      vsIDE->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT, &dispid);
     ReportHRESULT(hr, "GetIDsOfNames(Solution)");
 
-    if (SUCCEEDED(hr))
-      {
+    if (SUCCEEDED(hr)) {
       DISPPARAMS params;
       VARIANT result;
       EXCEPINFO excep;
-      UINT arg = (UINT) -1;
+      UINT arg = (UINT)-1;
 
       params.rgvarg = 0;
       params.rgdispidNamedArgs = 0;
@@ -191,44 +169,38 @@ HRESULT GetSolutionObject(
       memset(&excep, 0, sizeof(excep));
 
       hr = vsIDE->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT,
-        DISPATCH_PROPERTYGET, &params, &result, &excep, &arg);
+                         DISPATCH_PROPERTYGET, &params, &result, &excep, &arg);
       ReportHRESULT(hr, "Invoke(Solution)");
 
-      if (SUCCEEDED(hr))
-        {
+      if (SUCCEEDED(hr)) {
         vsSolution = V_DISPATCH(&result);
-        }
+      }
 
       VariantClear(&result);
-      }
     }
+  }
 
   return hr;
 }
 
-
 ///! Get the FullName property from the Solution object
-HRESULT GetSolutionFullName(
-  IDispatch* vsSolution,
-  std::string& fullName)
+HRESULT GetSolutionFullName(IDispatch* vsSolution, std::string& fullName)
 {
   HRESULT hr = E_POINTER;
 
-  if (0 != vsSolution)
-    {
-    DISPID dispid = (DISPID) -1;
-    OLECHAR *name = L"FullName";
+  if (0 != vsSolution) {
+    DISPID dispid = (DISPID)-1;
+    OLECHAR* name = L"FullName";
 
-    hr = vsSolution->GetIDsOfNames(IID_NULL, &name, 1,
-           LOCALE_USER_DEFAULT, &dispid);
+    hr = vsSolution->GetIDsOfNames(IID_NULL, &name, 1, LOCALE_USER_DEFAULT,
+                                   &dispid);
     ReportHRESULT(hr, "GetIDsOfNames(FullName)");
 
-    if (SUCCEEDED(hr))
-      {
+    if (SUCCEEDED(hr)) {
       DISPPARAMS params;
       VARIANT result;
       EXCEPINFO excep;
-      UINT arg = (UINT) -1;
+      UINT arg = (UINT)-1;
 
       params.rgvarg = 0;
       params.rgdispidNamedArgs = 0;
@@ -240,41 +212,36 @@ HRESULT GetSolutionFullName(
       memset(&excep, 0, sizeof(excep));
 
       hr = vsSolution->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT,
-        DISPATCH_PROPERTYGET, &params, &result, &excep, &arg);
+                              DISPATCH_PROPERTYGET, &params, &result, &excep,
+                              &arg);
       ReportHRESULT(hr, "Invoke(FullName)");
 
-      if (SUCCEEDED(hr))
-        {
-        fullName = (std::string) (_bstr_t) V_BSTR(&result);
-        }
+      if (SUCCEEDED(hr)) {
+        fullName = (std::string)(_bstr_t)V_BSTR(&result);
+      }
 
       VariantClear(&result);
-      }
     }
+  }
 
   return hr;
 }
 
-
 ///! Get the FullName property from the Solution object, given the IDE object
-HRESULT GetIDESolutionFullName(
-  IDispatch* vsIDE,
-  std::string& fullName)
+HRESULT GetIDESolutionFullName(IDispatch* vsIDE, std::string& fullName)
 {
   IDispatchPtr vsSolution;
   HRESULT hr = GetSolutionObject(vsIDE, vsSolution);
   ReportHRESULT(hr, "GetSolutionObject");
 
-  if (SUCCEEDED(hr))
-    {
+  if (SUCCEEDED(hr)) {
     GetSolutionFullName(vsSolution, fullName);
     ReportHRESULT(hr, "GetSolutionFullName");
-    }
+  }
 
   return hr;
 }
 
-
 ///! Get all running objects from the Windows running object table.
 ///! Save them in a map by their display names.
 HRESULT GetRunningInstances(std::map<std::string, IUnknownPtr>& mrot)
@@ -289,22 +256,18 @@ HRESULT GetRunningInstances(std::map<std::string, IUnknownPtr>& mrot)
   HRESULT hr = GetRunningObjectTable(0, &runningObjectTable);
   ReportHRESULT(hr, "GetRunningObjectTable");
 
-  if(SUCCEEDED(hr))
-    {
+  if (SUCCEEDED(hr)) {
     hr = runningObjectTable->EnumRunning(&monikerEnumerator);
     ReportHRESULT(hr, "EnumRunning");
-    }
+  }
 
-  if(SUCCEEDED(hr))
-    {
+  if (SUCCEEDED(hr)) {
     hr = monikerEnumerator->Reset();
     ReportHRESULT(hr, "Reset");
-    }
+  }
 
-  if(SUCCEEDED(hr))
-    {
-    while (S_OK == monikerEnumerator->Next(1, &moniker, &numFetched))
-      {
+  if (SUCCEEDED(hr)) {
+    while (S_OK == monikerEnumerator->Next(1, &moniker, &numFetched)) {
       std::string runningObjectName;
       IUnknownPtr runningObjectVal;
       IBindCtxPtr ctx;
@@ -312,44 +275,37 @@ HRESULT GetRunningInstances(std::map<std::string, IUnknownPtr>& mrot)
       hr = CreateBindCtx(0, &ctx);
       ReportHRESULT(hr, "CreateBindCtx");
 
-      if(SUCCEEDED(hr))
-        {
+      if (SUCCEEDED(hr)) {
         LPOLESTR displayName = 0;
         hr = moniker->GetDisplayName(ctx, 0, &displayName);
         ReportHRESULT(hr, "GetDisplayName");
-        if (displayName)
-          {
-          runningObjectName = (std::string) (_bstr_t) displayName;
+        if (displayName) {
+          runningObjectName = (std::string)(_bstr_t)displayName;
           CoTaskMemFree(displayName);
-          }
+        }
 
         hr = runningObjectTable->GetObject(moniker, &runningObjectVal);
         ReportHRESULT(hr, "GetObject");
-        if(SUCCEEDED(hr))
-          {
+        if (SUCCEEDED(hr)) {
           mrot.insert(std::make_pair(runningObjectName, runningObjectVal));
-          }
         }
+      }
 
       numFetched = 0;
       moniker = 0;
-      }
     }
+  }
 
   return hr;
 }
 
-
 ///! Do the two file names refer to the same Visual Studio solution? Or are
 ///! we perhaps looking for any and all solutions?
-bool FilesSameSolution(
-  const std::string& slnFile,
-  const std::string& slnName)
+bool FilesSameSolution(const std::string& slnFile, const std::string& slnName)
 {
-  if (slnFile == "ALL" || slnName == "ALL")
-    {
+  if (slnFile == "ALL" || slnName == "ALL") {
     return true;
-    }
+  }
 
   // Otherwise, make lowercase local copies, convert to Unix slashes, and
   // see if the resulting strings are the same:
@@ -361,56 +317,47 @@ bool FilesSameSolution(
   return s1 == s2;
 }
 
-
 ///! Find instances of Visual Studio with the given solution file
 ///! open. Pass "ALL" for slnFile to gather all running instances
 ///! of Visual Studio.
-HRESULT FindVisualStudioInstances(
-  const std::string& slnFile,
-  std::vector<IDispatchPtr>& instances)
+HRESULT FindVisualStudioInstances(const std::string& slnFile,
+                                  std::vector<IDispatchPtr>& instances)
 {
   std::map<std::string, IUnknownPtr> mrot;
 
   HRESULT hr = GetRunningInstances(mrot);
   ReportHRESULT(hr, "GetRunningInstances");
 
-  if(SUCCEEDED(hr))
-    {
+  if (SUCCEEDED(hr)) {
     std::map<std::string, IUnknownPtr>::iterator it;
-    for(it = mrot.begin(); it != mrot.end(); ++it)
-      {
+    for (it = mrot.begin(); it != mrot.end(); ++it) {
       if (cmSystemTools::StringStartsWith(it->first.c_str(),
-        "!VisualStudio.DTE."))
-        {
+                                          "!VisualStudio.DTE.")) {
         IDispatchPtr disp(it->second);
-        if (disp != (IDispatch*) 0)
-          {
+        if (disp != (IDispatch*)0) {
           std::string slnName;
           hr = GetIDESolutionFullName(disp, slnName);
           ReportHRESULT(hr, "GetIDESolutionFullName");
 
-          if (FilesSameSolution(slnFile, slnName))
-            {
+          if (FilesSameSolution(slnFile, slnName)) {
             instances.push_back(disp);
 
-            //std::cout << "Found Visual Studio instance." << std::endl;
-            //std::cout << "  ROT entry name: " << it->first << std::endl;
-            //std::cout << "  ROT entry object: "
+            // std::cout << "Found Visual Studio instance." << std::endl;
+            // std::cout << "  ROT entry name: " << it->first << std::endl;
+            // std::cout << "  ROT entry object: "
             //          << (IUnknown*) it->second << std::endl;
-            //std::cout << "  slnFile: " << slnFile << std::endl;
-            //std::cout << "  slnName: " << slnName << std::endl;
-            }
+            // std::cout << "  slnFile: " << slnFile << std::endl;
+            // std::cout << "  slnName: " << slnName << std::endl;
           }
         }
       }
     }
+  }
 
   return hr;
 }
 
-
-#endif  //defined(HAVE_COMDEF_H)
-
+#endif // defined(HAVE_COMDEF_H)
 
 int cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
   const std::string& slnFile)
@@ -423,22 +370,20 @@ int cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
   HRESULT hr = CoInitialize(0);
   ReportHRESULT(hr, "CoInitialize");
 
-  if(SUCCEEDED(hr))
-    {
+  if (SUCCEEDED(hr)) {
     std::vector<IDispatchPtr> instances;
     hr = FindVisualStudioInstances(slnFile, instances);
     ReportHRESULT(hr, "FindVisualStudioInstances");
 
-    if(SUCCEEDED(hr))
-      {
+    if (SUCCEEDED(hr)) {
       count = static_cast<int>(instances.size());
-      }
+    }
 
     // Force release all COM pointers before CoUninitialize:
     instances.clear();
 
     CoUninitialize();
-    }
+  }
 #else
   (void)slnFile;
 #endif
@@ -446,14 +391,12 @@ int cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
   return count;
 }
 
-
 ///! Get all running objects from the Windows running object table.
 ///! Save them in a map by their display names.
-int cmCallVisualStudioMacro::CallMacro(
-  const std::string& slnFile,
-  const std::string& macro,
-  const std::string& args,
-  const bool logErrorsAsMessages)
+int cmCallVisualStudioMacro::CallMacro(const std::string& slnFile,
+                                       const std::string& macro,
+                                       const std::string& args,
+                                       const bool logErrorsAsMessages)
 {
   int err = 1; // no comdef.h
 
@@ -465,60 +408,53 @@ int cmCallVisualStudioMacro::CallMacro(
   HRESULT hr = CoInitialize(0);
   ReportHRESULT(hr, "CoInitialize");
 
-  if(SUCCEEDED(hr))
-    {
+  if (SUCCEEDED(hr)) {
     std::vector<IDispatchPtr> instances;
     hr = FindVisualStudioInstances(slnFile, instances);
     ReportHRESULT(hr, "FindVisualStudioInstances");
 
-    if(SUCCEEDED(hr))
-      {
+    if (SUCCEEDED(hr)) {
       err = 0; // no error
 
       std::vector<IDispatchPtr>::iterator it;
-      for(it = instances.begin(); it != instances.end(); ++it)
-        {
+      for (it = instances.begin(); it != instances.end(); ++it) {
         hr = InstanceCallMacro(*it, macro, args);
         ReportHRESULT(hr, "InstanceCallMacro");
 
-        if (FAILED(hr))
-          {
+        if (FAILED(hr)) {
           err = 3; // error attempting to call the macro
-          }
         }
+      }
 
-      if(instances.empty())
-        {
+      if (instances.empty()) {
         // no instances to call
 
-        //cmSystemTools::Message(
+        // cmSystemTools::Message(
         //  "cmCallVisualStudioMacro::CallMacro no instances found to call",
         //  "Warning");
-        }
       }
+    }
 
     // Force release all COM pointers before CoUninitialize:
     instances.clear();
 
     CoUninitialize();
-    }
+  }
 #else
   (void)slnFile;
   (void)macro;
   (void)args;
-  if (LogErrorsAsMessages)
-    {
+  if (LogErrorsAsMessages) {
     cmSystemTools::Message("cmCallVisualStudioMacro::CallMacro is not "
-      "supported on this platform");
-    }
+                           "supported on this platform");
+  }
 #endif
 
-  if (err && LogErrorsAsMessages)
-    {
+  if (err && LogErrorsAsMessages) {
     std::ostringstream oss;
     oss << "cmCallVisualStudioMacro::CallMacro failed, err = " << err;
     cmSystemTools::Message(oss.str().c_str());
-    }
+  }
 
   return 0;
 }
diff --git a/Source/cmCallVisualStudioMacro.h b/Source/cmCallVisualStudioMacro.h
index 09bddfa..e516fe2 100644
--- a/Source/cmCallVisualStudioMacro.h
+++ b/Source/cmCallVisualStudioMacro.h
@@ -26,8 +26,7 @@ public:
   ///! Call the named macro in instances of Visual Studio with the
   ///! given solution file open. Pass "ALL" for slnFile to call the
   ///! macro in each Visual Studio instance.
-  static int CallMacro(const std::string& slnFile,
-                       const std::string& macro,
+  static int CallMacro(const std::string& slnFile, const std::string& macro,
                        const std::string& args,
                        const bool logErrorsAsMessages);
 
@@ -38,7 +37,6 @@ public:
     const std::string& slnFile);
 
 protected:
-
 private:
 };
 
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index d5e394d..0157293 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -37,7 +37,10 @@ public:
    * Construct the command. By default it is enabled with no makefile.
    */
   cmCommand()
-    {this->Makefile = 0; this->Enabled = true;}
+  {
+    this->Makefile = 0;
+    this->Enabled = true;
+  }
 
   /**
    * Need virtual destructor to destroy real command type.
@@ -47,8 +50,7 @@ public:
   /**
    * Specify the makefile.
    */
-  void SetMakefile(cmMakefile*m)
-    {this->Makefile = m; }
+  void SetMakefile(cmMakefile* m) { this->Makefile = m; }
   cmMakefile* GetMakefile() { return this->Makefile; }
 
   /**
@@ -57,24 +59,23 @@ public:
    * arguments and then invokes the InitialPass.
    */
   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus &status)
-    {
+                                 cmExecutionStatus& status)
+  {
     std::vector<std::string> expandedArguments;
-    if(!this->Makefile->ExpandArguments(args, expandedArguments))
-      {
+    if (!this->Makefile->ExpandArguments(args, expandedArguments)) {
       // There was an error expanding arguments.  It was already
       // reported, so we can skip this command without error.
       return true;
-      }
-    return this->InitialPass(expandedArguments,status);
     }
+    return this->InitialPass(expandedArguments, status);
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &) = 0;
+                           cmExecutionStatus&) = 0;
 
   /**
    * This is called at the end after all the information
@@ -97,10 +98,7 @@ public:
   /**
    * This determines if the command is invoked when in script mode.
    */
-  virtual bool IsScriptable() const
-    {
-    return false;
-    }
+  virtual bool IsScriptable() const { return false; }
 
   /**
    * This is used to avoid including this command
@@ -108,10 +106,7 @@ public:
    * cmMacroHelperCommand and cmFunctionHelperCommand
    * which cannot provide appropriate documentation.
    */
-  virtual bool ShouldAppearInDocumentation() const
-    {
-    return true;
-    }
+  virtual bool ShouldAppearInDocumentation() const { return true; }
 
   /**
    * The name of the command as specified in CMakeList.txt.
@@ -121,58 +116,52 @@ public:
   /**
    * Enable the command.
    */
-  void EnabledOn()
-    {this->Enabled = true;}
+  void EnabledOn() { this->Enabled = true; }
 
   /**
    * Disable the command.
    */
-  void EnabledOff()
-    {this->Enabled = false;}
+  void EnabledOff() { this->Enabled = false; }
 
   /**
    * Query whether the command is enabled.
    */
-  bool GetEnabled() const
-    {return this->Enabled;}
+  bool GetEnabled() const { return this->Enabled; }
 
   /**
    * Disable or enable the command.
    */
-  void SetEnabled(bool enabled)
-    {this->Enabled = enabled;}
+  void SetEnabled(bool enabled) { this->Enabled = enabled; }
 
   /**
    * Return the last error string.
    */
   const char* GetError()
-    {
-      if(this->Error.empty())
-        {
-        this->Error = this->GetName();
-        this->Error += " unknown error.";
-        }
-      return this->Error.c_str();
+  {
+    if (this->Error.empty()) {
+      this->Error = this->GetName();
+      this->Error += " unknown error.";
     }
+    return this->Error.c_str();
+  }
 
   /**
    * Set the error message
    */
   void SetError(const std::string& e)
-    {
+  {
     this->Error = this->GetName();
     this->Error += " ";
     this->Error += e;
-    }
+  }
 
   /** Check if the command is disallowed by a policy.  */
   bool Disallowed(cmPolicies::PolicyID pol, const char* e)
-    {
-    switch(this->Makefile->GetPolicyStatus(pol))
-      {
+  {
+    switch (this->Makefile->GetPolicyStatus(pol)) {
       case cmPolicies::WARN:
         this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
-          cmPolicies::GetPolicyWarning(pol));
+                                     cmPolicies::GetPolicyWarning(pol));
       case cmPolicies::OLD:
         return false;
       case cmPolicies::REQUIRED_IF_USED:
@@ -180,9 +169,9 @@ public:
       case cmPolicies::NEW:
         this->Makefile->IssueMessage(cmake::FATAL_ERROR, e);
         break;
-      }
-    return true;
     }
+    return true;
+  }
 
 protected:
   cmMakefile* Makefile;
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index 0b2fd81..a4f3c7d 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -18,7 +18,7 @@
 
 #include "cmCommandArgumentLexer.h"
 
-int cmCommandArgument_yyparse( yyscan_t yyscanner );
+int cmCommandArgument_yyparse(yyscan_t yyscanner);
 //
 cmCommandArgumentParserHelper::cmCommandArgumentParserHelper()
 {
@@ -30,7 +30,7 @@ cmCommandArgumentParserHelper::cmCommandArgumentParserHelper()
   this->EmptyVariable[0] = 0;
   strcpy(this->DCURLYVariable, "${");
   strcpy(this->RCURLYVariable, "}");
-  strcpy(this->ATVariable,     "@");
+  strcpy(this->ATVariable, "@");
   strcpy(this->DOLLARVariable, "$");
   strcpy(this->LCURLYVariable, "{");
   strcpy(this->BSLASHVariable, "\\");
@@ -39,7 +39,6 @@ cmCommandArgumentParserHelper::cmCommandArgumentParserHelper()
   this->ReplaceAtSyntax = false;
 }
 
-
 cmCommandArgumentParserHelper::~cmCommandArgumentParserHelper()
 {
   this->CleanupParser();
@@ -53,11 +52,10 @@ void cmCommandArgumentParserHelper::SetLineFile(long line, const char* file)
 
 char* cmCommandArgumentParserHelper::AddString(const std::string& str)
 {
-  if ( str.empty() )
-    {
+  if (str.empty()) {
     return this->EmptyVariable;
-    }
-  char* stVal = new char[str.size()+1];
+  }
+  char* stVal = new char[str.size() + 1];
   strcpy(stVal, str.c_str());
   this->Variables.push_back(stVal);
   return stVal;
@@ -66,46 +64,34 @@ char* cmCommandArgumentParserHelper::AddString(const std::string& str)
 char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
                                                            const char* var)
 {
-  if ( !key )
-    {
+  if (!key) {
     return this->ExpandVariable(var);
-    }
-  if(!var)
-    {
+  }
+  if (!var) {
     return this->EmptyVariable;
-    }
-  if ( strcmp(key, "ENV") == 0 )
-    {
-    char *ptr = getenv(var);
-    if (ptr)
-      {
-      if (this->EscapeQuotes)
-        {
+  }
+  if (strcmp(key, "ENV") == 0) {
+    char* ptr = getenv(var);
+    if (ptr) {
+      if (this->EscapeQuotes) {
         return this->AddString(cmSystemTools::EscapeQuotes(ptr));
-        }
-      else
-        {
+      } else {
         return ptr;
-        }
       }
-    return this->EmptyVariable;
     }
-  if ( strcmp(key, "CACHE") == 0 )
-    {
-    if(const char* c = this->Makefile->GetState()
-                           ->GetInitializedCacheValue(var))
-      {
-      if(this->EscapeQuotes)
-        {
+    return this->EmptyVariable;
+  }
+  if (strcmp(key, "CACHE") == 0) {
+    if (const char* c =
+          this->Makefile->GetState()->GetInitializedCacheValue(var)) {
+      if (this->EscapeQuotes) {
         return this->AddString(cmSystemTools::EscapeQuotes(c));
-        }
-      else
-        {
+      } else {
         return this->AddString(c);
-        }
       }
-    return this->EmptyVariable;
     }
+    return this->EmptyVariable;
+  }
   std::ostringstream e;
   e << "Syntax $" << key << "{} is not supported.  "
     << "Only ${}, $ENV{}, and $CACHE{} are allowed.";
@@ -115,62 +101,53 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
 
 char* cmCommandArgumentParserHelper::ExpandVariable(const char* var)
 {
-  if(!var)
-    {
+  if (!var) {
     return 0;
-    }
-  if(this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0)
-    {
+  }
+  if (this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0) {
     std::ostringstream ostr;
     ostr << this->FileLine;
     return this->AddString(ostr.str());
-    }
+  }
   const char* value = this->Makefile->GetDefinition(var);
-  if(!value && !this->RemoveEmpty)
-    {
+  if (!value && !this->RemoveEmpty) {
     // check to see if we need to print a warning
     // if strict mode is on and the variable has
     // not been "cleared"/initialized with a set(foo ) call
-    if(this->WarnUninitialized && !this->Makefile->VariableInitialized(var))
-      {
+    if (this->WarnUninitialized && !this->Makefile->VariableInitialized(var)) {
       if (this->CheckSystemVars ||
           cmSystemTools::IsSubDirectory(this->FileName,
                                         this->Makefile->GetHomeDirectory()) ||
-          cmSystemTools::IsSubDirectory(this->FileName,
-                                     this->Makefile->GetHomeOutputDirectory()))
-        {
+          cmSystemTools::IsSubDirectory(
+            this->FileName, this->Makefile->GetHomeOutputDirectory())) {
         std::ostringstream msg;
         msg << "uninitialized variable \'" << var << "\'";
         this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, msg.str());
-        }
       }
-    return 0;
     }
-  if (this->EscapeQuotes && value)
-    {
+    return 0;
+  }
+  if (this->EscapeQuotes && value) {
     return this->AddString(cmSystemTools::EscapeQuotes(value));
-    }
+  }
   return this->AddString(value ? value : "");
 }
 
 char* cmCommandArgumentParserHelper::ExpandVariableForAt(const char* var)
 {
-  if(this->ReplaceAtSyntax)
-    {
+  if (this->ReplaceAtSyntax) {
     // try to expand the variable
     char* ret = this->ExpandVariable(var);
     // if the return was 0 and we want to replace empty strings
     // then return an empty string
-    if(!ret && this->RemoveEmpty)
-      {
+    if (!ret && this->RemoveEmpty) {
       return this->AddString("");
-      }
+    }
     // if the ret was not 0, then return it
-    if(ret)
-      {
+    if (ret) {
       return ret;
-      }
     }
+  }
   // at this point we want to put it back because of one of these cases:
   // - this->ReplaceAtSyntax is false
   // - this->ReplaceAtSyntax is true, but this->RemoveEmpty is false,
@@ -183,79 +160,72 @@ char* cmCommandArgumentParserHelper::ExpandVariableForAt(const char* var)
 
 char* cmCommandArgumentParserHelper::CombineUnions(char* in1, char* in2)
 {
-  if ( !in1 )
-    {
+  if (!in1) {
     return in2;
-    }
-  else if ( !in2 )
-    {
+  } else if (!in2) {
     return in1;
-    }
+  }
   size_t len = strlen(in1) + strlen(in2) + 1;
-  char* out = new char [ len ];
+  char* out = new char[len];
   strcpy(out, in1);
   strcat(out, in2);
   this->Variables.push_back(out);
   return out;
 }
 
-void cmCommandArgumentParserHelper::AllocateParserType
-(cmCommandArgumentParserHelper::ParserType* pt,const char* str, int len)
+void cmCommandArgumentParserHelper::AllocateParserType(
+  cmCommandArgumentParserHelper::ParserType* pt, const char* str, int len)
 {
   pt->str = 0;
-  if ( len == 0 )
-    {
+  if (len == 0) {
     len = static_cast<int>(strlen(str));
-    }
-  if ( len == 0 )
-    {
+  }
+  if (len == 0) {
     return;
-    }
-  pt->str = new char[ len + 1 ];
+  }
+  pt->str = new char[len + 1];
   strncpy(pt->str, str, len);
   pt->str[len] = 0;
   this->Variables.push_back(pt->str);
 }
 
-bool cmCommandArgumentParserHelper::HandleEscapeSymbol
-(cmCommandArgumentParserHelper::ParserType* pt, char symbol)
+bool cmCommandArgumentParserHelper::HandleEscapeSymbol(
+  cmCommandArgumentParserHelper::ParserType* pt, char symbol)
 {
-  switch ( symbol )
-    {
-  case '\\':
-  case '"':
-  case ' ':
-  case '#':
-  case '(':
-  case ')':
-  case '$':
-  case '@':
-  case '^':
-    this->AllocateParserType(pt, &symbol, 1);
-    break;
-  case ';':
-    this->AllocateParserType(pt, "\\;", 2);
-    break;
-  case 't':
-    this->AllocateParserType(pt, "\t", 1);
-    break;
-  case 'n':
-    this->AllocateParserType(pt, "\n", 1);
-    break;
-  case 'r':
-    this->AllocateParserType(pt, "\r", 1);
-    break;
-  case '0':
-    this->AllocateParserType(pt, "\0", 1);
-    break;
-  default:
-    {
-    std::ostringstream e;
-    e << "Invalid escape sequence \\" << symbol;
-    this->SetError(e.str());
-    }
-    return false;
+  switch (symbol) {
+    case '\\':
+    case '"':
+    case ' ':
+    case '#':
+    case '(':
+    case ')':
+    case '$':
+    case '@':
+    case '^':
+      this->AllocateParserType(pt, &symbol, 1);
+      break;
+    case ';':
+      this->AllocateParserType(pt, "\\;", 2);
+      break;
+    case 't':
+      this->AllocateParserType(pt, "\t", 1);
+      break;
+    case 'n':
+      this->AllocateParserType(pt, "\n", 1);
+      break;
+    case 'r':
+      this->AllocateParserType(pt, "\r", 1);
+      break;
+    case '0':
+      this->AllocateParserType(pt, "\0", 1);
+      break;
+    default: {
+      std::ostringstream e;
+      e << "Invalid escape sequence \\" << symbol;
+      this->SetError(e.str());
     }
+      return false;
+  }
   return true;
 }
 
@@ -263,10 +233,9 @@ void cmCommandArgument_SetupEscapes(yyscan_t yyscanner, bool noEscapes);
 
 int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
 {
-  if ( !str)
-    {
+  if (!str) {
     return 0;
-    }
+  }
   this->Verbose = verb;
   this->InputBuffer = str;
   this->InputBufferPos = 0;
@@ -280,53 +249,43 @@ int cmCommandArgumentParserHelper::ParseString(const char* str, int verb)
   cmCommandArgument_SetupEscapes(yyscanner, this->NoEscapeMode);
   int res = cmCommandArgument_yyparse(yyscanner);
   cmCommandArgument_yylex_destroy(yyscanner);
-  if ( res != 0 )
-    {
+  if (res != 0) {
     return 0;
-    }
+  }
 
   this->CleanupParser();
 
-  if ( Verbose )
-    {
-    std::cerr << "Expanding [" << str << "] produced: ["
-              << this->Result << "]" << std::endl;
-    }
+  if (Verbose) {
+    std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]"
+              << std::endl;
+  }
   return 1;
 }
 
 void cmCommandArgumentParserHelper::CleanupParser()
 {
   std::vector<char*>::iterator sit;
-  for ( sit = this->Variables.begin();
-    sit != this->Variables.end();
-    ++ sit )
-    {
-    delete [] *sit;
-    }
+  for (sit = this->Variables.begin(); sit != this->Variables.end(); ++sit) {
+    delete[] * sit;
+  }
   this->Variables.erase(this->Variables.begin(), this->Variables.end());
 }
 
 int cmCommandArgumentParserHelper::LexInput(char* buf, int maxlen)
 {
-  if ( maxlen < 1 )
-    {
+  if (maxlen < 1) {
     return 0;
+  }
+  if (this->InputBufferPos < this->InputBuffer.size()) {
+    buf[0] = this->InputBuffer[this->InputBufferPos++];
+    if (buf[0] == '\n') {
+      this->CurrentLine++;
     }
-  if ( this->InputBufferPos < this->InputBuffer.size() )
-    {
-    buf[0] = this->InputBuffer[ this->InputBufferPos++ ];
-    if ( buf[0] == '\n' )
-      {
-      this->CurrentLine ++;
-      }
-    return(1);
-    }
-  else
-    {
+    return (1);
+  } else {
     buf[0] = '\n';
-    return( 0 );
-    }
+    return (0);
+  }
 }
 
 void cmCommandArgumentParserHelper::Error(const char* str)
@@ -346,19 +305,17 @@ void cmCommandArgumentParserHelper::SetMakefile(const cmMakefile* mf)
 
 void cmCommandArgumentParserHelper::SetResult(const char* value)
 {
-  if ( !value )
-    {
+  if (!value) {
     this->Result = "";
     return;
-    }
+  }
   this->Result = value;
 }
 
 void cmCommandArgumentParserHelper::SetError(std::string const& msg)
 {
   // Keep only the first error.
-  if(this->ErrorString.empty())
-    {
+  if (this->ErrorString.empty()) {
     this->ErrorString = msg;
-    }
+  }
 }
diff --git a/Source/cmCommandArgumentParserHelper.h b/Source/cmCommandArgumentParserHelper.h
index 387afc6..97b706c 100644
--- a/Source/cmCommandArgumentParserHelper.h
+++ b/Source/cmCommandArgumentParserHelper.h
@@ -17,8 +17,8 @@
 #define YYSTYPE cmCommandArgumentParserHelper::ParserType
 #define YYSTYPE_IS_DECLARED
 #define YY_EXTRA_TYPE cmCommandArgumentParserHelper*
-#define YY_DECL int cmCommandArgument_yylex(YYSTYPE* yylvalp,\
-  yyscan_t yyscanner)
+#define YY_DECL                                                               \
+  int cmCommandArgument_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
 
 /** \class cmCommandArgumentParserHelper
  * \brief Helper class for parsing java source files
@@ -31,7 +31,8 @@ class cmMakefile;
 class cmCommandArgumentParserHelper
 {
 public:
-  typedef struct {
+  typedef struct
+  {
     char* str;
   } ParserType;
 
@@ -42,9 +43,9 @@ public:
 
   // For the lexer:
   void AllocateParserType(cmCommandArgumentParserHelper::ParserType* pt,
-    const char* str, int len = 0);
+                          const char* str, int len = 0);
   bool HandleEscapeSymbol(cmCommandArgumentParserHelper::ParserType* pt,
-    char symbol);
+                          char symbol);
 
   int LexInput(char* buf, int maxlen);
   void Error(const char* str);
@@ -106,5 +107,3 @@ private:
 };
 
 #endif
-
-
diff --git a/Source/cmCommandArgumentsHelper.cxx b/Source/cmCommandArgumentsHelper.cxx
index 1a2efc6..c336bc5 100644
--- a/Source/cmCommandArgumentsHelper.cxx
+++ b/Source/cmCommandArgumentsHelper.cxx
@@ -15,26 +15,24 @@
 cmCommandArgument::cmCommandArgument(cmCommandArgumentsHelper* args,
                                      const char* key,
                                      cmCommandArgumentGroup* group)
-:Key(key)
-,Group(group)
-,WasActive(false)
-,ArgumentsBeforeEmpty(true)
-,CurrentIndex(0)
+  : Key(key)
+  , Group(group)
+  , WasActive(false)
+  , ArgumentsBeforeEmpty(true)
+  , CurrentIndex(0)
 {
-  if (args!=0)
-    {
+  if (args != 0) {
     args->AddArgument(this);
-    }
+  }
 
-  if (this->Group!=0)
-    {
+  if (this->Group != 0) {
     this->Group->ContainedArguments.push_back(this);
-    }
+  }
 }
 
 void cmCommandArgument::Reset()
 {
-  this->WasActive =false;
+  this->WasActive = false;
   this->CurrentIndex = 0;
   this->DoReset();
 }
@@ -47,55 +45,47 @@ void cmCommandArgument::Follows(const cmCommandArgument* arg)
 
 void cmCommandArgument::FollowsGroup(const cmCommandArgumentGroup* group)
 {
-  if (group!=0)
-    {
+  if (group != 0) {
     this->ArgumentsBeforeEmpty = false;
     this->ArgumentsBefore.insert(group->ContainedArguments.begin(),
                                  group->ContainedArguments.end());
-    }
+  }
 }
 
 bool cmCommandArgument::MayFollow(const cmCommandArgument* current) const
 {
-  if (this->ArgumentsBeforeEmpty)
-    {
+  if (this->ArgumentsBeforeEmpty) {
     return true;
-    }
+  }
 
-  std::set<const cmCommandArgument*>::const_iterator argIt
-                                         = this->ArgumentsBefore.find(current);
-  if (argIt != this->ArgumentsBefore.end())
-    {
+  std::set<const cmCommandArgument*>::const_iterator argIt =
+    this->ArgumentsBefore.find(current);
+  if (argIt != this->ArgumentsBefore.end()) {
     return true;
-    }
+  }
 
   return false;
 }
 
 bool cmCommandArgument::KeyMatches(const std::string& key) const
 {
-  if ((this->Key==0) || (this->Key[0]=='\0'))
-    {
+  if ((this->Key == 0) || (this->Key[0] == '\0')) {
     return true;
-    }
-  return (key==this->Key);
+  }
+  return (key == this->Key);
 }
 
 void cmCommandArgument::ApplyOwnGroup()
 {
-  if (this->Group!=0)
-    {
-    for (std::vector<cmCommandArgument*>::const_iterator
-         it = this->Group->ContainedArguments.begin();
-         it != this->Group->ContainedArguments.end();
-         ++it)
-      {
-      if(*it != this)
-        {
+  if (this->Group != 0) {
+    for (std::vector<cmCommandArgument*>::const_iterator it =
+           this->Group->ContainedArguments.begin();
+         it != this->Group->ContainedArguments.end(); ++it) {
+      if (*it != this) {
         this->ArgumentsBefore.insert(*it);
-        }
       }
     }
+  }
 }
 
 void cmCommandArgument::Activate()
@@ -106,37 +96,31 @@ void cmCommandArgument::Activate()
 
 bool cmCommandArgument::Consume(const std::string& arg)
 {
-  bool res=this->DoConsume(arg, this->CurrentIndex);
+  bool res = this->DoConsume(arg, this->CurrentIndex);
   this->CurrentIndex++;
   return res;
 }
 
-
 cmCAStringVector::cmCAStringVector(cmCommandArgumentsHelper* args,
                                    const char* key,
                                    cmCommandArgumentGroup* group)
-:cmCommandArgument(args, key, group)
-,Ignore(0)
+  : cmCommandArgument(args, key, group)
+  , Ignore(0)
 {
-  if ((key==0) || (*key==0))
-    {
+  if ((key == 0) || (*key == 0)) {
     this->DataStart = 0;
-    }
-  else
-    {
+  } else {
     this->DataStart = 1;
-    }
+  }
 }
 
-bool cmCAStringVector::DoConsume(const std::string& arg,unsigned int index)
+bool cmCAStringVector::DoConsume(const std::string& arg, unsigned int index)
 {
-  if (index >= this->DataStart)
-    {
-    if ((this->Ignore==0) || (arg != this->Ignore))
-      {
+  if (index >= this->DataStart) {
+    if ((this->Ignore == 0) || (arg != this->Ignore)) {
       this->Vector.push_back(arg);
-      }
     }
+  }
 
   return false;
 }
@@ -146,27 +130,22 @@ void cmCAStringVector::DoReset()
   this->Vector.clear();
 }
 
-cmCAString::cmCAString(cmCommandArgumentsHelper* args,
-                       const char* key,
+cmCAString::cmCAString(cmCommandArgumentsHelper* args, const char* key,
                        cmCommandArgumentGroup* group)
-:cmCommandArgument(args, key, group)
+  : cmCommandArgument(args, key, group)
 {
-  if ((key==0) || (*key==0))
-    {
+  if ((key == 0) || (*key == 0)) {
     this->DataStart = 0;
-    }
-  else
-    {
+  } else {
     this->DataStart = 1;
-    }
+  }
 }
 
 bool cmCAString::DoConsume(const std::string& arg, unsigned int index)
 {
-  if (index == this->DataStart)
-    {
+  if (index == this->DataStart) {
     this->String = arg;
-    }
+  }
 
   return index >= this->DataStart;
 }
@@ -176,19 +155,18 @@ void cmCAString::DoReset()
   this->String = "";
 }
 
-cmCAEnabler::cmCAEnabler(cmCommandArgumentsHelper* args,
-                         const char* key,
+cmCAEnabler::cmCAEnabler(cmCommandArgumentsHelper* args, const char* key,
                          cmCommandArgumentGroup* group)
-:cmCommandArgument(args, key, group)
-,Enabled(false)
-{}
+  : cmCommandArgument(args, key, group)
+  , Enabled(false)
+{
+}
 
 bool cmCAEnabler::DoConsume(const std::string&, unsigned int index)
 {
-  if (index==0)
-    {
+  if (index == 0) {
     this->Enabled = true;
-    }
+  }
   return true;
 }
 
@@ -197,19 +175,18 @@ void cmCAEnabler::DoReset()
   this->Enabled = false;
 }
 
-cmCADisabler::cmCADisabler(cmCommandArgumentsHelper* args,
-                           const char* key,
+cmCADisabler::cmCADisabler(cmCommandArgumentsHelper* args, const char* key,
                            cmCommandArgumentGroup* group)
-:cmCommandArgument(args, key, group)
-,Enabled(true)
-{}
+  : cmCommandArgument(args, key, group)
+  , Enabled(true)
+{
+}
 
 bool cmCADisabler::DoConsume(const std::string&, unsigned int index)
 {
-  if (index==0)
-    {
+  if (index == 0) {
     this->Enabled = false;
-    }
+  }
   return true;
 }
 
@@ -220,83 +197,66 @@ void cmCADisabler::DoReset()
 
 void cmCommandArgumentGroup::Follows(const cmCommandArgument* arg)
 {
-  for(std::vector<cmCommandArgument*>::iterator
-      it = this->ContainedArguments.begin();
-      it != this->ContainedArguments.end();
-      ++it)
-    {
+  for (std::vector<cmCommandArgument*>::iterator it =
+         this->ContainedArguments.begin();
+       it != this->ContainedArguments.end(); ++it) {
     (*it)->Follows(arg);
-    }
+  }
 }
 
 void cmCommandArgumentGroup::FollowsGroup(const cmCommandArgumentGroup* group)
 {
-  for(std::vector<cmCommandArgument*>::iterator
-      it = this->ContainedArguments.begin();
-      it != this->ContainedArguments.end();
-      ++it)
-    {
+  for (std::vector<cmCommandArgument*>::iterator it =
+         this->ContainedArguments.begin();
+       it != this->ContainedArguments.end(); ++it) {
     (*it)->FollowsGroup(group);
-    }
+  }
 }
 
 void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args,
                                      std::vector<std::string>* unconsumedArgs)
 {
-  if(args==0)
-    {
+  if (args == 0) {
     return;
-    }
+  }
 
-  for(std::vector<cmCommandArgument*>::iterator
-      argIt = this->Arguments.begin();
-      argIt != this->Arguments.end();
-      ++argIt)
-    {
+  for (std::vector<cmCommandArgument*>::iterator argIt =
+         this->Arguments.begin();
+       argIt != this->Arguments.end(); ++argIt) {
     (*argIt)->ApplyOwnGroup();
     (*argIt)->Reset();
-    }
+  }
 
   cmCommandArgument* activeArgument = 0;
   const cmCommandArgument* previousArgument = 0;
-  for(std::vector<std::string>::const_iterator it = args->begin();
-      it != args->end();
-      ++it)
-    {
-    for(std::vector<cmCommandArgument*>::iterator
-        argIt = this->Arguments.begin();
-        argIt != this->Arguments.end();
-        ++argIt)
-      {
-      if ((*argIt)->KeyMatches(*it) && ((*argIt)->MayFollow(previousArgument)))
-        {
+  for (std::vector<std::string>::const_iterator it = args->begin();
+       it != args->end(); ++it) {
+    for (std::vector<cmCommandArgument*>::iterator argIt =
+           this->Arguments.begin();
+         argIt != this->Arguments.end(); ++argIt) {
+      if ((*argIt)->KeyMatches(*it) &&
+          ((*argIt)->MayFollow(previousArgument))) {
         activeArgument = *argIt;
         activeArgument->Activate();
         break;
-        }
       }
+    }
 
-    if (activeArgument)
-      {
+    if (activeArgument) {
       bool argDone = activeArgument->Consume(*it);
       previousArgument = activeArgument;
-      if (argDone)
-        {
+      if (argDone) {
         activeArgument = 0;
-        }
       }
-    else
-      {
-      if (unconsumedArgs!=0)
-        {
+    } else {
+      if (unconsumedArgs != 0) {
         unconsumedArgs->push_back(*it);
-        }
       }
     }
+  }
 }
 
 void cmCommandArgumentsHelper::AddArgument(cmCommandArgument* arg)
 {
   this->Arguments.push_back(arg);
 }
-
diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h
index f732f8f..c2a6f92 100644
--- a/Source/cmCommandArgumentsHelper.h
+++ b/Source/cmCommandArgumentsHelper.h
@@ -41,164 +41,161 @@ For an example see cmExportCommand.cxx.
 */
 class cmCommandArgument
 {
-  public:
-    cmCommandArgument(cmCommandArgumentsHelper* args,
-                      const char* key,
-                      cmCommandArgumentGroup* group=0);
-    virtual ~cmCommandArgument() {}
-
-    /// this argument may follow after arg. 0 means it comes first.
-    void Follows(const cmCommandArgument* arg);
-
-    /// this argument may follow after any of the arguments in the given group
-    void FollowsGroup(const cmCommandArgumentGroup* group);
-
-    /// Returns true if the argument was found in the argument list
-    bool WasFound() const                             {return this->WasActive;}
-
-    // The following methods are only called from
-    // cmCommandArgumentsHelper::Parse(), but making this a friend would
-    // give it access to everything
-
-    /// Make the current argument the currently active argument
-    void Activate();
-    /// Consume the current string
-    bool Consume(const std::string& arg);
-
-    /// Return true if this argument may follow after the given argument.
-    bool MayFollow(const cmCommandArgument* current) const;
-
-    /** Returns true if the given key matches the key for this argument.
-    If this argument has an empty key everything matches. */
-    bool KeyMatches(const std::string& key) const;
-
-    /// Make this argument follow all members of the own group
-    void ApplyOwnGroup();
-
-    /// Reset argument, so it's back to its initial state
-    void Reset();
-  private:
-    const char* Key;
-    std::set<const cmCommandArgument*> ArgumentsBefore;
-    cmCommandArgumentGroup* Group;
-    bool WasActive;
-    bool ArgumentsBeforeEmpty;
-    unsigned int CurrentIndex;
-
-    virtual bool DoConsume(const std::string& arg, unsigned int index) = 0;
-    virtual void DoReset() = 0;
+public:
+  cmCommandArgument(cmCommandArgumentsHelper* args, const char* key,
+                    cmCommandArgumentGroup* group = 0);
+  virtual ~cmCommandArgument() {}
+
+  /// this argument may follow after arg. 0 means it comes first.
+  void Follows(const cmCommandArgument* arg);
+
+  /// this argument may follow after any of the arguments in the given group
+  void FollowsGroup(const cmCommandArgumentGroup* group);
+
+  /// Returns true if the argument was found in the argument list
+  bool WasFound() const { return this->WasActive; }
+
+  // The following methods are only called from
+  // cmCommandArgumentsHelper::Parse(), but making this a friend would
+  // give it access to everything
+
+  /// Make the current argument the currently active argument
+  void Activate();
+  /// Consume the current string
+  bool Consume(const std::string& arg);
+
+  /// Return true if this argument may follow after the given argument.
+  bool MayFollow(const cmCommandArgument* current) const;
+
+  /** Returns true if the given key matches the key for this argument.
+  If this argument has an empty key everything matches. */
+  bool KeyMatches(const std::string& key) const;
+
+  /// Make this argument follow all members of the own group
+  void ApplyOwnGroup();
+
+  /// Reset argument, so it's back to its initial state
+  void Reset();
+
+private:
+  const char* Key;
+  std::set<const cmCommandArgument*> ArgumentsBefore;
+  cmCommandArgumentGroup* Group;
+  bool WasActive;
+  bool ArgumentsBeforeEmpty;
+  unsigned int CurrentIndex;
+
+  virtual bool DoConsume(const std::string& arg, unsigned int index) = 0;
+  virtual void DoReset() = 0;
 };
 
 /** cmCAStringVector is to be used for arguments which can consist of more
 than one string, e.g. the FILES argument in INSTALL(FILES f1 f2 f3 ...). */
 class cmCAStringVector : public cmCommandArgument
 {
-  public:
-    cmCAStringVector(cmCommandArgumentsHelper* args,
-                     const char* key,
-                     cmCommandArgumentGroup* group=0);
-
-    /// Return the vector of strings
-    const std::vector<std::string>& GetVector() const    {return this->Vector;}
-
-    /** Is there a keyword which should be skipped in
-    the arguments (e.g. ARGS for ADD_CUSTOM_COMMAND) ? */
-    void SetIgnore(const char* ignore)                   {this->Ignore=ignore;}
-  private:
-    std::vector<std::string> Vector;
-    unsigned int DataStart;
-    const char* Ignore;
-    cmCAStringVector();
-    virtual bool DoConsume(const std::string& arg, unsigned int index);
-    virtual void DoReset();
+public:
+  cmCAStringVector(cmCommandArgumentsHelper* args, const char* key,
+                   cmCommandArgumentGroup* group = 0);
+
+  /// Return the vector of strings
+  const std::vector<std::string>& GetVector() const { return this->Vector; }
+
+  /** Is there a keyword which should be skipped in
+  the arguments (e.g. ARGS for ADD_CUSTOM_COMMAND) ? */
+  void SetIgnore(const char* ignore) { this->Ignore = ignore; }
+private:
+  std::vector<std::string> Vector;
+  unsigned int DataStart;
+  const char* Ignore;
+  cmCAStringVector();
+  virtual bool DoConsume(const std::string& arg, unsigned int index);
+  virtual void DoReset();
 };
 
 /** cmCAString is to be used for arguments which consist of one value,
 e.g. the executable name in ADD_EXECUTABLE(). */
 class cmCAString : public cmCommandArgument
 {
-  public:
-    cmCAString(cmCommandArgumentsHelper* args,
-               const char* key,
-               cmCommandArgumentGroup* group=0);
-
-    /// Return the string
-    const std::string& GetString() const                 {return this->String;}
-    const char* GetCString() const               {return this->String.c_str();}
-  private:
-    std::string String;
-    unsigned int DataStart;
-    virtual bool DoConsume(const std::string& arg, unsigned int index);
-    virtual void DoReset();
-    cmCAString();
+public:
+  cmCAString(cmCommandArgumentsHelper* args, const char* key,
+             cmCommandArgumentGroup* group = 0);
+
+  /// Return the string
+  const std::string& GetString() const { return this->String; }
+  const char* GetCString() const { return this->String.c_str(); }
+private:
+  std::string String;
+  unsigned int DataStart;
+  virtual bool DoConsume(const std::string& arg, unsigned int index);
+  virtual void DoReset();
+  cmCAString();
 };
 
 /** cmCAEnabler is to be used for options which are off by default and can be
 enabled using a special argument, e.g. EXCLUDE_FROM_ALL in ADD_EXECUTABLE(). */
 class cmCAEnabler : public cmCommandArgument
 {
-  public:
-    cmCAEnabler(cmCommandArgumentsHelper* args,
-                const char* key,
-                cmCommandArgumentGroup* group=0);
-
-    /// Has it been enabled ?
-    bool IsEnabled() const                              {return this->Enabled;}
-  private:
-    bool Enabled;
-    virtual bool DoConsume(const std::string& arg, unsigned int index);
-    virtual void DoReset();
-    cmCAEnabler();
+public:
+  cmCAEnabler(cmCommandArgumentsHelper* args, const char* key,
+              cmCommandArgumentGroup* group = 0);
+
+  /// Has it been enabled ?
+  bool IsEnabled() const { return this->Enabled; }
+private:
+  bool Enabled;
+  virtual bool DoConsume(const std::string& arg, unsigned int index);
+  virtual void DoReset();
+  cmCAEnabler();
 };
 
 /** cmCADisable is to be used for options which are on by default and can be
 disabled using a special argument.*/
 class cmCADisabler : public cmCommandArgument
 {
-  public:
-    cmCADisabler(cmCommandArgumentsHelper* args,
-                 const char* key,
-                 cmCommandArgumentGroup* group=0);
-
-    /// Is it still enabled ?
-    bool IsEnabled() const                              {return this->Enabled;}
-  private:
-    bool Enabled;
-    virtual bool DoConsume(const std::string& arg, unsigned int index);
-    virtual void DoReset();
-    cmCADisabler();
+public:
+  cmCADisabler(cmCommandArgumentsHelper* args, const char* key,
+               cmCommandArgumentGroup* group = 0);
+
+  /// Is it still enabled ?
+  bool IsEnabled() const { return this->Enabled; }
+private:
+  bool Enabled;
+  virtual bool DoConsume(const std::string& arg, unsigned int index);
+  virtual void DoReset();
+  cmCADisabler();
 };
 
-
 /** Group of arguments, needed for ordering. E.g. WIN32, EXCLUDE_FROM_ALL and
 MACSOX_BUNDLE from ADD_EXECUTABLE() are a group.
 */
 class cmCommandArgumentGroup
 {
   friend class cmCommandArgument;
-  public:
-    cmCommandArgumentGroup() {}
 
-    /// All members of this group may follow the given argument
-    void Follows(const cmCommandArgument* arg);
+public:
+  cmCommandArgumentGroup() {}
 
-    /// All members of this group may follow all members of the given group
-    void FollowsGroup(const cmCommandArgumentGroup* group);
-  private:
-    std::vector<cmCommandArgument*> ContainedArguments;
+  /// All members of this group may follow the given argument
+  void Follows(const cmCommandArgument* arg);
+
+  /// All members of this group may follow all members of the given group
+  void FollowsGroup(const cmCommandArgumentGroup* group);
+
+private:
+  std::vector<cmCommandArgument*> ContainedArguments;
 };
 
 class cmCommandArgumentsHelper
 {
-  public:
-    /// Parse the argument list
-    void Parse(const std::vector<std::string>* args,
-               std::vector<std::string>* unconsumedArgs);
-    /// Add an argument.
-    void AddArgument(cmCommandArgument* arg);
-  private:
-    std::vector<cmCommandArgument*> Arguments;
+public:
+  /// Parse the argument list
+  void Parse(const std::vector<std::string>* args,
+             std::vector<std::string>* unconsumedArgs);
+  /// Add an argument.
+  void AddArgument(cmCommandArgument* arg);
+
+private:
+  std::vector<cmCommandArgument*> Arguments;
 };
 
-
 #endif
diff --git a/Source/cmCommands.h b/Source/cmCommands.h
index 0786a64..d0f1ab7 100644
--- a/Source/cmCommands.h
+++ b/Source/cmCommands.h
@@ -28,5 +28,4 @@ void GetBootstrapCommands1(std::vector<cmCommand*>& commands);
 void GetBootstrapCommands2(std::vector<cmCommand*>& commands);
 void GetPredefinedCommands(std::vector<cmCommand*>& commands);
 
-
 #endif
diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index d00a416..6b2d1e3 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -20,15 +20,13 @@
 #include "cmSystemTools.h"
 
 cmCommonTargetGenerator::cmCommonTargetGenerator(
-  cmOutputConverter::RelativeRoot wd,
-  cmGeneratorTarget* gt
-  )
+  cmOutputConverter::RelativeRoot wd, cmGeneratorTarget* gt)
   : WorkingDirectory(wd)
   , GeneratorTarget(gt)
   , Makefile(gt->Makefile)
   , LocalGenerator(static_cast<cmLocalCommonGenerator*>(gt->LocalGenerator))
   , GlobalGenerator(static_cast<cmGlobalCommonGenerator*>(
-                      gt->LocalGenerator->GetGlobalGenerator()))
+      gt->LocalGenerator->GetGlobalGenerator()))
   , ConfigName(LocalGenerator->GetConfigName())
   , ModuleDefinitionFile(GeneratorTarget->GetModuleDefinitionFile(ConfigName))
   , FortranModuleDirectoryComputed(false)
@@ -45,8 +43,7 @@ std::string const& cmCommonTargetGenerator::GetConfigName() const
 }
 
 std::string cmCommonTargetGenerator::Convert(
-  std::string const& source,
-  cmLocalGenerator::RelativeRoot relative,
+  std::string const& source, cmLocalGenerator::RelativeRoot relative,
   cmLocalGenerator::OutputFormat output)
 {
   return this->LocalGenerator->Convert(source, relative, output);
@@ -62,39 +59,35 @@ bool cmCommonTargetGenerator::GetFeatureAsBool(const std::string& feature)
   return this->GeneratorTarget->GetFeatureAsBool(feature, this->ConfigName);
 }
 
-void cmCommonTargetGenerator::AddFeatureFlags(
-  std::string& flags, const std::string& lang
-  )
+void cmCommonTargetGenerator::AddFeatureFlags(std::string& flags,
+                                              const std::string& lang)
 {
   // Add language-specific flags.
   this->LocalGenerator->AddLanguageFlags(flags, lang, this->ConfigName);
 
-  if(this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION"))
-    {
+  if (this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION")) {
     this->LocalGenerator->AppendFeatureOptions(flags, lang, "IPO");
-    }
+  }
 }
 
 void cmCommonTargetGenerator::AddModuleDefinitionFlag(std::string& flags)
 {
-  if(!this->ModuleDefinitionFile)
-    {
+  if (!this->ModuleDefinitionFile) {
     return;
-    }
+  }
 
   // TODO: Create a per-language flag variable.
   const char* defFileFlag =
     this->Makefile->GetDefinition("CMAKE_LINK_DEF_FILE_FLAG");
-  if(!defFileFlag)
-    {
+  if (!defFileFlag) {
     return;
-    }
+  }
 
   // Append the flag and value.  Use ConvertToLinkReference to help
   // vs6's "cl -link" pass it to the linker.
   std::string flag = defFileFlag;
   flag += (this->LocalGenerator->ConvertToLinkReference(
-             this->ModuleDefinitionFile->GetFullPath()));
+    this->ModuleDefinitionFile->GetFullPath()));
   this->LocalGenerator->AppendFlags(flags, flag);
 }
 
@@ -105,36 +98,31 @@ std::string cmCommonTargetGenerator::ComputeFortranModuleDirectory() const
     this->GeneratorTarget->GetProperty("Fortran_MODULE_DIRECTORY");
   const char* moddir_flag =
     this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG");
-  if(target_mod_dir && moddir_flag)
-    {
+  if (target_mod_dir && moddir_flag) {
     // Compute the full path to the module directory.
-    if(cmSystemTools::FileIsFullPath(target_mod_dir))
-      {
+    if (cmSystemTools::FileIsFullPath(target_mod_dir)) {
       // Already a full path.
       mod_dir = target_mod_dir;
-      }
-    else
-      {
+    } else {
       // Interpret relative to the current output directory.
       mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory();
       mod_dir += "/";
       mod_dir += target_mod_dir;
-      }
+    }
 
     // Make sure the module output directory exists.
     cmSystemTools::MakeDirectory(mod_dir);
-    }
+  }
   return mod_dir;
 }
 
 std::string cmCommonTargetGenerator::GetFortranModuleDirectory()
 {
   // Compute the module directory.
-  if(!this->FortranModuleDirectoryComputed)
-    {
+  if (!this->FortranModuleDirectoryComputed) {
     this->FortranModuleDirectoryComputed = true;
     this->FortranModuleDirectory = this->ComputeFortranModuleDirectory();
-    }
+  }
 
   // Return the computed directory.
   return this->FortranModuleDirectory;
@@ -143,154 +131,133 @@ std::string cmCommonTargetGenerator::GetFortranModuleDirectory()
 void cmCommonTargetGenerator::AddFortranFlags(std::string& flags)
 {
   // Enable module output if necessary.
-  if(const char* modout_flag =
-     this->Makefile->GetDefinition("CMAKE_Fortran_MODOUT_FLAG"))
-    {
+  if (const char* modout_flag =
+        this->Makefile->GetDefinition("CMAKE_Fortran_MODOUT_FLAG")) {
     this->LocalGenerator->AppendFlags(flags, modout_flag);
-    }
+  }
 
   // Add a module output directory flag if necessary.
   std::string mod_dir = this->GetFortranModuleDirectory();
-  if (!mod_dir.empty())
-    {
-    mod_dir = this->Convert(mod_dir,
-                            this->WorkingDirectory,
-                            cmLocalGenerator::SHELL);
-    }
-  else
-    {
+  if (!mod_dir.empty()) {
+    mod_dir =
+      this->Convert(mod_dir, this->WorkingDirectory, cmLocalGenerator::SHELL);
+  } else {
     mod_dir =
       this->Makefile->GetSafeDefinition("CMAKE_Fortran_MODDIR_DEFAULT");
-    }
-  if (!mod_dir.empty())
-    {
+  }
+  if (!mod_dir.empty()) {
     const char* moddir_flag =
       this->Makefile->GetRequiredDefinition("CMAKE_Fortran_MODDIR_FLAG");
     std::string modflag = moddir_flag;
     modflag += mod_dir;
     this->LocalGenerator->AppendFlags(flags, modflag);
-    }
+  }
 
   // If there is a separate module path flag then duplicate the
   // include path with it.  This compiler does not search the include
   // path for modules.
-  if(const char* modpath_flag =
-     this->Makefile->GetDefinition("CMAKE_Fortran_MODPATH_FLAG"))
-    {
+  if (const char* modpath_flag =
+        this->Makefile->GetDefinition("CMAKE_Fortran_MODPATH_FLAG")) {
     std::vector<std::string> includes;
     const std::string& config =
       this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
-    this->LocalGenerator->GetIncludeDirectories(includes,
-                                                this->GeneratorTarget,
-                                                "C", config);
-    for(std::vector<std::string>::const_iterator idi = includes.begin();
-        idi != includes.end(); ++idi)
-      {
+    this->LocalGenerator->GetIncludeDirectories(
+      includes, this->GeneratorTarget, "C", config);
+    for (std::vector<std::string>::const_iterator idi = includes.begin();
+         idi != includes.end(); ++idi) {
       std::string flg = modpath_flag;
-      flg += this->Convert(*idi,
-                           cmLocalGenerator::NONE,
-                           cmLocalGenerator::SHELL);
+      flg +=
+        this->Convert(*idi, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
       this->LocalGenerator->AppendFlags(flags, flg);
-      }
     }
+  }
 }
 
-void
-cmCommonTargetGenerator
-::AppendFortranFormatFlags(std::string& flags, cmSourceFile const& source)
+void cmCommonTargetGenerator::AppendFortranFormatFlags(
+  std::string& flags, cmSourceFile const& source)
 {
   const char* srcfmt = source.GetProperty("Fortran_FORMAT");
   cmLocalGenerator::FortranFormat format =
     this->LocalGenerator->GetFortranFormat(srcfmt);
-  if(format == cmLocalGenerator::FortranFormatNone)
-    {
+  if (format == cmLocalGenerator::FortranFormatNone) {
     const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT");
     format = this->LocalGenerator->GetFortranFormat(tgtfmt);
-    }
+  }
   const char* var = 0;
-  switch (format)
-    {
+  switch (format) {
     case cmLocalGenerator::FortranFormatFixed:
-      var = "CMAKE_Fortran_FORMAT_FIXED_FLAG"; break;
+      var = "CMAKE_Fortran_FORMAT_FIXED_FLAG";
+      break;
     case cmLocalGenerator::FortranFormatFree:
-      var = "CMAKE_Fortran_FORMAT_FREE_FLAG"; break;
-    default: break;
-    }
-  if(var)
-    {
-    this->LocalGenerator->AppendFlags(
-      flags, this->Makefile->GetDefinition(var));
-    }
+      var = "CMAKE_Fortran_FORMAT_FREE_FLAG";
+      break;
+    default:
+      break;
+  }
+  if (var) {
+    this->LocalGenerator->AppendFlags(flags,
+                                      this->Makefile->GetDefinition(var));
+  }
 }
 
 std::string cmCommonTargetGenerator::GetFrameworkFlags(std::string const& l)
 {
- if(!this->Makefile->IsOn("APPLE"))
-   {
-   return std::string();
-   }
+  if (!this->Makefile->IsOn("APPLE")) {
+    return std::string();
+  }
 
   std::string fwSearchFlagVar = "CMAKE_" + l + "_FRAMEWORK_SEARCH_FLAG";
-  const char* fwSearchFlag =
-    this->Makefile->GetDefinition(fwSearchFlagVar);
-  if(!(fwSearchFlag && *fwSearchFlag))
-    {
+  const char* fwSearchFlag = this->Makefile->GetDefinition(fwSearchFlagVar);
+  if (!(fwSearchFlag && *fwSearchFlag)) {
     return std::string();
-    }
+  }
 
- std::set<std::string> emitted;
-#ifdef __APPLE__  /* don't insert this when crosscompiling e.g. to iphone */
+  std::set<std::string> emitted;
+#ifdef __APPLE__ /* don't insert this when crosscompiling e.g. to iphone */
   emitted.insert("/System/Library/Frameworks");
 #endif
   std::vector<std::string> includes;
 
   const std::string& config =
     this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
-  this->LocalGenerator->GetIncludeDirectories(includes,
-                                              this->GeneratorTarget,
+  this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
                                               "C", config);
   // check all include directories for frameworks as this
   // will already have added a -F for the framework
-  for(std::vector<std::string>::iterator i = includes.begin();
-      i != includes.end(); ++i)
-    {
-    if(this->GlobalGenerator->NameResolvesToFramework(*i))
-      {
+  for (std::vector<std::string>::iterator i = includes.begin();
+       i != includes.end(); ++i) {
+    if (this->GlobalGenerator->NameResolvesToFramework(*i)) {
       std::string frameworkDir = *i;
       frameworkDir += "/../";
       frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
       emitted.insert(frameworkDir);
-      }
     }
+  }
 
   std::string flags;
   const char* cfg = this->LocalGenerator->GetConfigName().c_str();
-  if(cmComputeLinkInformation* cli =
-     this->GeneratorTarget->GetLinkInformation(cfg))
-    {
+  if (cmComputeLinkInformation* cli =
+        this->GeneratorTarget->GetLinkInformation(cfg)) {
     std::vector<std::string> const& frameworks = cli->GetFrameworkPaths();
-    for(std::vector<std::string>::const_iterator i = frameworks.begin();
-        i != frameworks.end(); ++i)
-      {
-      if(emitted.insert(*i).second)
-        {
+    for (std::vector<std::string>::const_iterator i = frameworks.begin();
+         i != frameworks.end(); ++i) {
+      if (emitted.insert(*i).second) {
         flags += fwSearchFlag;
-        flags += this->LocalGenerator
-                     ->ConvertToOutputFormat(*i, cmLocalGenerator::SHELL);
+        flags += this->LocalGenerator->ConvertToOutputFormat(
+          *i, cmLocalGenerator::SHELL);
         flags += " ";
-        }
       }
     }
+  }
   return flags;
 }
 
-std::string cmCommonTargetGenerator::GetFlags(const std::string &l)
+std::string cmCommonTargetGenerator::GetFlags(const std::string& l)
 {
   ByLanguageMap::iterator i = this->FlagsByLanguage.find(l);
-  if (i == this->FlagsByLanguage.end())
-    {
+  if (i == this->FlagsByLanguage.end()) {
     std::string flags;
-    const char *lang = l.c_str();
+    const char* lang = l.c_str();
 
     // Add language feature flags.
     this->AddFeatureFlags(flags, lang);
@@ -299,104 +266,95 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l)
                                                lang, this->ConfigName);
 
     // Fortran-specific flags computed for this target.
-    if(l == "Fortran")
-      {
+    if (l == "Fortran") {
       this->AddFortranFlags(flags);
-      }
+    }
 
-    this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget,
-                                          lang, this->ConfigName);
+    this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, lang,
+                                          this->ConfigName);
 
-    this->LocalGenerator->AddVisibilityPresetFlags(flags,
-                                                   this->GeneratorTarget,
-                                                   lang);
+    this->LocalGenerator->AddVisibilityPresetFlags(
+      flags, this->GeneratorTarget, lang);
 
     // Append old-style preprocessor definition flags.
-    this->LocalGenerator->
-      AppendFlags(flags, this->Makefile->GetDefineFlags());
+    this->LocalGenerator->AppendFlags(flags, this->Makefile->GetDefineFlags());
 
     // Add framework directory flags.
-    this->LocalGenerator->
-      AppendFlags(flags,this->GetFrameworkFlags(l));
+    this->LocalGenerator->AppendFlags(flags, this->GetFrameworkFlags(l));
 
     // Add target-specific flags.
-    this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
-                                            lang, this->ConfigName);
+    this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, lang,
+                                            this->ConfigName);
 
     ByLanguageMap::value_type entry(l, flags);
     i = this->FlagsByLanguage.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
-std::string cmCommonTargetGenerator::GetDefines(const std::string &l)
+std::string cmCommonTargetGenerator::GetDefines(const std::string& l)
 {
   ByLanguageMap::iterator i = this->DefinesByLanguage.find(l);
-  if (i == this->DefinesByLanguage.end())
-    {
+  if (i == this->DefinesByLanguage.end()) {
     std::set<std::string> defines;
-    const char *lang = l.c_str();
+    const char* lang = l.c_str();
     // Add the export symbol definition for shared library objects.
-    if(const char* exportMacro =
-       this->GeneratorTarget->GetExportMacro())
-      {
+    if (const char* exportMacro = this->GeneratorTarget->GetExportMacro()) {
       this->LocalGenerator->AppendDefines(defines, exportMacro);
-      }
+    }
 
     // Add preprocessor definitions for this target and configuration.
-    this->LocalGenerator->AddCompileDefinitions(defines, this->GeneratorTarget,
-                            this->LocalGenerator->GetConfigName(), l);
+    this->LocalGenerator->AddCompileDefinitions(
+      defines, this->GeneratorTarget, this->LocalGenerator->GetConfigName(),
+      l);
 
     std::string definesString;
     this->LocalGenerator->JoinDefines(defines, definesString, lang);
 
     ByLanguageMap::value_type entry(l, definesString);
     i = this->DefinesByLanguage.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
 std::string cmCommonTargetGenerator::GetIncludes(std::string const& l)
 {
   ByLanguageMap::iterator i = this->IncludesByLanguage.find(l);
-  if (i == this->IncludesByLanguage.end())
-    {
+  if (i == this->IncludesByLanguage.end()) {
     std::string includes;
     this->AddIncludeFlags(includes, l);
     ByLanguageMap::value_type entry(l, includes);
     i = this->IncludesByLanguage.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
-std::vector<std::string>
-cmCommonTargetGenerator::GetLinkedTargetDirectories() const
+std::vector<std::string> cmCommonTargetGenerator::GetLinkedTargetDirectories()
+  const
 {
   std::vector<std::string> dirs;
   std::set<cmGeneratorTarget const*> emitted;
   if (cmComputeLinkInformation* cli =
-      this->GeneratorTarget->GetLinkInformation(this->ConfigName))
-    {
+        this->GeneratorTarget->GetLinkInformation(this->ConfigName)) {
     cmComputeLinkInformation::ItemVector const& items = cli->GetItems();
-    for(cmComputeLinkInformation::ItemVector::const_iterator
-          i = items.begin(); i != items.end(); ++i)
-      {
+    for (cmComputeLinkInformation::ItemVector::const_iterator i =
+           items.begin();
+         i != items.end(); ++i) {
       cmGeneratorTarget const* linkee = i->Target;
-      if(linkee && !linkee->IsImported()
-                // We can ignore the INTERFACE_LIBRARY items because
-                // Target->GetLinkInformation already processed their
-                // link interface and they don't have any output themselves.
-                && linkee->GetType() != cmState::INTERFACE_LIBRARY
-                && emitted.insert(linkee).second)
-        {
+      if (linkee && !linkee->IsImported()
+          // We can ignore the INTERFACE_LIBRARY items because
+          // Target->GetLinkInformation already processed their
+          // link interface and they don't have any output themselves.
+          && linkee->GetType() != cmState::INTERFACE_LIBRARY &&
+          emitted.insert(linkee).second) {
         cmLocalGenerator* lg = linkee->GetLocalGenerator();
         std::string di = lg->GetCurrentBinaryDirectory();
         di += "/";
         di += lg->GetTargetDirectory(linkee);
         dirs.push_back(di);
-        }
       }
     }
+  }
   return dirs;
 }
 
@@ -407,19 +365,17 @@ std::string cmCommonTargetGenerator::GetManifests()
 
   std::vector<std::string> manifests;
   for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
-       mi != manifest_srcs.end(); ++mi)
-    {
-    manifests.push_back(this->Convert((*mi)->GetFullPath(),
-                                      this->WorkingDirectory,
-                                      cmOutputConverter::SHELL));
-    }
+       mi != manifest_srcs.end(); ++mi) {
+    manifests.push_back(this->Convert(
+      (*mi)->GetFullPath(), this->WorkingDirectory, cmOutputConverter::SHELL));
+  }
 
   return cmJoin(manifests, " ");
 }
 
-void cmCommonTargetGenerator
-::AppendOSXVerFlag(std::string& flags, const std::string& lang,
-                   const char* name, bool so)
+void cmCommonTargetGenerator::AppendOSXVerFlag(std::string& flags,
+                                               const std::string& lang,
+                                               const char* name, bool so)
 {
   // Lookup the flag to specify the version.
   std::string fvar = "CMAKE_";
@@ -430,21 +386,19 @@ void cmCommonTargetGenerator
   const char* flag = this->Makefile->GetDefinition(fvar);
 
   // Skip if no such flag.
-  if(!flag)
-    {
+  if (!flag) {
     return;
-    }
+  }
 
   // Lookup the target version information.
   int major;
   int minor;
   int patch;
   this->GeneratorTarget->GetTargetVersion(so, major, minor, patch);
-  if(major > 0 || minor > 0 || patch > 0)
-    {
+  if (major > 0 || minor > 0 || patch > 0) {
     // Append the flag since a non-zero version is specified.
     std::ostringstream vflag;
     vflag << flag << major << "." << minor << "." << patch;
     this->LocalGenerator->AppendFlags(flags, vflag.str());
-    }
+  }
 }
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
index bfb6b79..c5d324f 100644
--- a/Source/cmCommonTargetGenerator.h
+++ b/Source/cmCommonTargetGenerator.h
@@ -35,7 +35,6 @@ public:
   std::string const& GetConfigName() const;
 
 protected:
-
   // Add language feature flags.
   void AddFeatureFlags(std::string& flags, const std::string& lang);
 
@@ -65,10 +64,9 @@ protected:
   // Compute target-specific Fortran language flags.
   void AddFortranFlags(std::string& flags);
 
-  std::string Convert(std::string const& source,
-                      cmLocalGenerator::RelativeRoot relative,
-                      cmLocalGenerator::OutputFormat output =
-                      cmLocalGenerator::UNCHANGED);
+  std::string Convert(
+    std::string const& source, cmLocalGenerator::RelativeRoot relative,
+    cmLocalGenerator::OutputFormat output = cmLocalGenerator::UNCHANGED);
 
   void AppendFortranFormatFlags(std::string& flags,
                                 cmSourceFile const& source);
@@ -83,9 +81,9 @@ protected:
                         const char* name, bool so);
 
   typedef std::map<std::string, std::string> ByLanguageMap;
-  std::string GetFlags(const std::string &l);
+  std::string GetFlags(const std::string& l);
   ByLanguageMap FlagsByLanguage;
-  std::string GetDefines(const std::string &l);
+  std::string GetDefines(const std::string& l);
   ByLanguageMap DefinesByLanguage;
   std::string GetIncludes(std::string const& l);
   ByLanguageMap IncludesByLanguage;
diff --git a/Source/cmComputeComponentGraph.cxx b/Source/cmComputeComponentGraph.cxx
index 9cd780d..4f21c3a 100644
--- a/Source/cmComputeComponentGraph.cxx
+++ b/Source/cmComputeComponentGraph.cxx
@@ -15,8 +15,8 @@
 
 #include <assert.h>
 
-cmComputeComponentGraph::cmComputeComponentGraph(Graph const& input):
-  InputGraph(input)
+cmComputeComponentGraph::cmComputeComponentGraph(Graph const& input)
+  : InputGraph(input)
 {
   // Identify components.
   this->Tarjan();
@@ -34,7 +34,7 @@ cmComputeComponentGraph::~cmComputeComponentGraph()
 void cmComputeComponentGraph::Tarjan()
 {
   int n = static_cast<int>(this->InputGraph.size());
-  TarjanEntry entry = {0,0};
+  TarjanEntry entry = { 0, 0 };
   this->TarjanEntries.resize(0);
   this->TarjanEntries.resize(n, entry);
   this->TarjanComponents.resize(0);
@@ -42,17 +42,15 @@ void cmComputeComponentGraph::Tarjan()
   this->TarjanWalkId = 0;
   this->TarjanVisited.resize(0);
   this->TarjanVisited.resize(n, 0);
-  for(int i = 0; i < n; ++i)
-    {
+  for (int i = 0; i < n; ++i) {
     // Start a new DFS from this node if it has never been visited.
-    if(!this->TarjanVisited[i])
-      {
+    if (!this->TarjanVisited[i]) {
       assert(this->TarjanStack.empty());
       ++this->TarjanWalkId;
       this->TarjanIndex = 0;
       this->TarjanVisit(i);
-      }
     }
+  }
 }
 
 void cmComputeComponentGraph::TarjanVisit(int i)
@@ -68,41 +66,35 @@ void cmComputeComponentGraph::TarjanVisit(int i)
 
   // Follow outgoing edges.
   EdgeList const& nl = this->InputGraph[i];
-  for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-    {
+  for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
     int j = *ni;
 
     // Ignore edges to nodes that have been reached by a previous DFS
     // walk.  Since we did not reach the current node from that walk
     // it must not belong to the same component and it has already
     // been assigned to a component.
-    if(this->TarjanVisited[j] > 0 &&
-       this->TarjanVisited[j] < this->TarjanWalkId)
-      {
+    if (this->TarjanVisited[j] > 0 &&
+        this->TarjanVisited[j] < this->TarjanWalkId) {
       continue;
-      }
+    }
 
     // Visit the destination if it has not yet been visited.
-    if(!this->TarjanVisited[j])
-      {
+    if (!this->TarjanVisited[j]) {
       this->TarjanVisit(j);
-      }
+    }
 
     // If the destination has not yet been assigned to a component,
     // check if it has a better root for the current object.
-    if(this->TarjanComponents[j] < 0)
-      {
-      if(this->TarjanEntries[this->TarjanEntries[j].Root].VisitIndex <
-         this->TarjanEntries[this->TarjanEntries[i].Root].VisitIndex)
-        {
+    if (this->TarjanComponents[j] < 0) {
+      if (this->TarjanEntries[this->TarjanEntries[j].Root].VisitIndex <
+          this->TarjanEntries[this->TarjanEntries[i].Root].VisitIndex) {
         this->TarjanEntries[i].Root = this->TarjanEntries[j].Root;
-        }
       }
     }
+  }
 
   // Check if we have found a component.
-  if(this->TarjanEntries[i].Root == i)
-    {
+  if (this->TarjanEntries[i].Root == i) {
     // Yes.  Create it.
     int c = static_cast<int>(this->Components.size());
     this->Components.push_back(NodeList());
@@ -110,8 +102,7 @@ void cmComputeComponentGraph::TarjanVisit(int i)
 
     // Populate the component list.
     int j;
-    do
-      {
+    do {
       // Get the next member of the component.
       j = this->TarjanStack.top();
       this->TarjanStack.pop();
@@ -122,11 +113,11 @@ void cmComputeComponentGraph::TarjanVisit(int i)
 
       // Store the node in its component.
       component.push_back(j);
-      } while(j != i);
+    } while (j != i);
 
     // Sort the component members for clarity.
     std::sort(component.begin(), component.end());
-    }
+  }
 }
 
 void cmComputeComponentGraph::TransferEdges()
@@ -134,21 +125,18 @@ void cmComputeComponentGraph::TransferEdges()
   // Map inter-component edges in the original graph to edges in the
   // component graph.
   int n = static_cast<int>(this->InputGraph.size());
-  for(int i=0; i < n; ++i)
-    {
+  for (int i = 0; i < n; ++i) {
     int i_component = this->TarjanComponents[i];
     EdgeList const& nl = this->InputGraph[i];
-    for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int j = *ni;
       int j_component = this->TarjanComponents[j];
-      if(i_component != j_component)
-        {
+      if (i_component != j_component) {
         // We do not attempt to combine duplicate edges, but instead
         // store the inter-component edges with suitable multiplicity.
         this->ComponentGraph[i_component].push_back(
           cmGraphEdge(j_component, ni->IsStrong()));
-        }
       }
     }
+  }
 }
diff --git a/Source/cmComputeComponentGraph.h b/Source/cmComputeComponentGraph.h
index 4dbac4a..fb95f9a 100644
--- a/Source/cmComputeComponentGraph.h
+++ b/Source/cmComputeComponentGraph.h
@@ -40,20 +40,24 @@ public:
   ~cmComputeComponentGraph();
 
   /** Get the adjacency list of the component graph.  */
-  Graph const& GetComponentGraph() const
-    { return this->ComponentGraph; }
+  Graph const& GetComponentGraph() const { return this->ComponentGraph; }
   EdgeList const& GetComponentGraphEdges(int c) const
-    { return this->ComponentGraph[c]; }
+  {
+    return this->ComponentGraph[c];
+  }
 
   /** Get map from component index to original node indices.  */
   std::vector<NodeList> const& GetComponents() const
-    { return this->Components; }
-  NodeList const& GetComponent(int c) const
-    { return this->Components[c]; }
+  {
+    return this->Components;
+  }
+  NodeList const& GetComponent(int c) const { return this->Components[c]; }
 
   /** Get map from original node index to component index.  */
   std::vector<int> const& GetComponentMap() const
-    { return this->TarjanComponents; }
+  {
+    return this->TarjanComponents;
+  }
 
 private:
   void TransferEdges();
diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx
index 23ea371..2129394 100644
--- a/Source/cmComputeLinkDepends.cxx
+++ b/Source/cmComputeLinkDepends.cxx
@@ -170,20 +170,19 @@ items that we know the linker will re-use automatically (shared libs).
 
 */
 
-cmComputeLinkDepends
-::cmComputeLinkDepends(const cmGeneratorTarget* target,
-                       const std::string& config)
+cmComputeLinkDepends::cmComputeLinkDepends(const cmGeneratorTarget* target,
+                                           const std::string& config)
 {
   // Store context information.
   this->Target = target;
   this->Makefile = this->Target->Target->GetMakefile();
   this->GlobalGenerator =
-      this->Target->GetLocalGenerator()->GetGlobalGenerator();
+    this->Target->GetLocalGenerator()->GetGlobalGenerator();
   this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance();
 
   // The configuration being linked.
   this->HasConfig = !config.empty();
-  this->Config = (this->HasConfig)? config : std::string();
+  this->Config = (this->HasConfig) ? config : std::string();
   std::vector<std::string> debugConfigs =
     this->Makefile->GetCMakeInstance()->GetDebugConfigs();
   this->LinkType = CMP0003_ComputeLinkType(this->Config, debugConfigs);
@@ -216,23 +215,21 @@ cmComputeLinkDepends::Compute()
   this->AddDirectLinkEntries();
 
   // Complete the breadth-first search of dependencies.
-  while(!this->BFSQueue.empty())
-    {
+  while (!this->BFSQueue.empty()) {
     // Get the next entry.
     BFSEntry qe = this->BFSQueue.front();
     this->BFSQueue.pop();
 
     // Follow the entry's dependencies.
     this->FollowLinkEntry(qe);
-    }
+  }
 
   // Complete the search of shared library dependencies.
-  while(!this->SharedDepQueue.empty())
-    {
+  while (!this->SharedDepQueue.empty()) {
     // Handle the next entry.
     this->HandleSharedDependency(this->SharedDepQueue.front());
     this->SharedDepQueue.pop();
-    }
+  }
 
   // Infer dependencies of targets for which they were not known.
   this->InferDependencies();
@@ -241,16 +238,14 @@ cmComputeLinkDepends::Compute()
   this->CleanConstraintGraph();
 
   // Display the constraint graph.
-  if(this->DebugMode)
-    {
-    fprintf(stderr,
-            "---------------------------------------"
-            "---------------------------------------\n");
+  if (this->DebugMode) {
+    fprintf(stderr, "---------------------------------------"
+                    "---------------------------------------\n");
     fprintf(stderr, "Link dependency analysis for target %s, config %s\n",
             this->Target->GetName().c_str(),
-            this->HasConfig?this->Config.c_str():"noconfig");
+            this->HasConfig ? this->Config.c_str() : "noconfig");
     this->DisplayConstraintGraph();
-    }
+  }
 
   // Compute the final ordering.
   this->OrderLinkEntires();
@@ -259,40 +254,37 @@ cmComputeLinkDepends::Compute()
   // Iterate in reverse order so we can keep only the last occurrence
   // of a shared library.
   std::set<int> emmitted;
-  for(std::vector<int>::const_reverse_iterator
-        li = this->FinalLinkOrder.rbegin(),
-        le = this->FinalLinkOrder.rend();
-      li != le; ++li)
-    {
+  for (std::vector<int>::const_reverse_iterator
+         li = this->FinalLinkOrder.rbegin(),
+         le = this->FinalLinkOrder.rend();
+       li != le; ++li) {
     int i = *li;
     LinkEntry const& e = this->EntryList[i];
     cmGeneratorTarget const* t = e.Target;
     // Entries that we know the linker will re-use do not need to be repeated.
     bool uniquify = t && t->GetType() == cmState::SHARED_LIBRARY;
-    if(!uniquify || emmitted.insert(i).second)
-      {
+    if (!uniquify || emmitted.insert(i).second) {
       this->FinalLinkEntries.push_back(e);
-      }
     }
+  }
   // Reverse the resulting order since we iterated in reverse.
   std::reverse(this->FinalLinkEntries.begin(), this->FinalLinkEntries.end());
 
   // Display the final set.
-  if(this->DebugMode)
-    {
+  if (this->DebugMode) {
     this->DisplayFinalEntries();
-    }
+  }
 
   return this->FinalLinkEntries;
 }
 
-std::map<std::string, int>::iterator
-cmComputeLinkDepends::AllocateLinkEntry(std::string const& item)
+std::map<std::string, int>::iterator cmComputeLinkDepends::AllocateLinkEntry(
+  std::string const& item)
 {
-  std::map<std::string, int>::value_type
-    index_entry(item, static_cast<int>(this->EntryList.size()));
-  std::map<std::string, int>::iterator
-    lei = this->LinkEntryIndex.insert(index_entry).first;
+  std::map<std::string, int>::value_type index_entry(
+    item, static_cast<int>(this->EntryList.size()));
+  std::map<std::string, int>::iterator lei =
+    this->LinkEntryIndex.insert(index_entry).first;
   this->EntryList.push_back(LinkEntry());
   this->InferredDependSets.push_back(0);
   this->EntryConstraintGraph.push_back(EdgeList());
@@ -303,11 +295,10 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
 {
   // Check if the item entry has already been added.
   std::map<std::string, int>::iterator lei = this->LinkEntryIndex.find(item);
-  if(lei != this->LinkEntryIndex.end())
-    {
+  if (lei != this->LinkEntryIndex.end()) {
     // Yes.  We do not need to follow the item's dependencies again.
     return lei->second;
-    }
+  }
 
   // Allocate a spot for the item entry.
   lei = this->AllocateLinkEntry(item);
@@ -321,29 +312,23 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
                   item.substr(0, 10) != "-framework");
 
   // If the item has dependencies queue it to follow them.
-  if(entry.Target)
-    {
+  if (entry.Target) {
     // Target dependencies are always known.  Follow them.
-    BFSEntry qe = {index, 0};
+    BFSEntry qe = { index, 0 };
     this->BFSQueue.push(qe);
-    }
-  else
-    {
+  } else {
     // Look for an old-style <item>_LIB_DEPENDS variable.
     std::string var = entry.Item;
     var += "_LIB_DEPENDS";
-    if(const char* val = this->Makefile->GetDefinition(var))
-      {
+    if (const char* val = this->Makefile->GetDefinition(var)) {
       // The item dependencies are known.  Follow them.
-      BFSEntry qe = {index, val};
+      BFSEntry qe = { index, val };
       this->BFSQueue.push(qe);
-      }
-    else if(!entry.IsFlag)
-      {
+    } else if (!entry.IsFlag) {
       // The item dependencies are not known.  We need to infer them.
       this->InferredDependSets[index] = new DependSetList;
-      }
     }
+  }
 
   return index;
 }
@@ -355,70 +340,58 @@ void cmComputeLinkDepends::FollowLinkEntry(BFSEntry const& qe)
   LinkEntry const& entry = this->EntryList[depender_index];
 
   // Follow the item's dependencies.
-  if(entry.Target)
-    {
+  if (entry.Target) {
     // Follow the target dependencies.
-    if(cmLinkInterface const* iface =
-       entry.Target->GetLinkInterface(this->Config, this->Target))
-      {
+    if (cmLinkInterface const* iface =
+          entry.Target->GetLinkInterface(this->Config, this->Target)) {
       const bool isIface =
-                      entry.Target->GetType() == cmState::INTERFACE_LIBRARY;
+        entry.Target->GetType() == cmState::INTERFACE_LIBRARY;
       // This target provides its own link interface information.
       this->AddLinkEntries(depender_index, iface->Libraries);
 
-      if (isIface)
-        {
+      if (isIface) {
         return;
-        }
+      }
 
       // Handle dependent shared libraries.
       this->FollowSharedDeps(depender_index, iface);
 
       // Support for CMP0003.
-      for(std::vector<cmLinkItem>::const_iterator
-            oi = iface->WrongConfigLibraries.begin();
-          oi != iface->WrongConfigLibraries.end(); ++oi)
-        {
+      for (std::vector<cmLinkItem>::const_iterator oi =
+             iface->WrongConfigLibraries.begin();
+           oi != iface->WrongConfigLibraries.end(); ++oi) {
         this->CheckWrongConfigItem(*oi);
-        }
       }
     }
-  else
-    {
+  } else {
     // Follow the old-style dependency list.
     this->AddVarLinkEntries(depender_index, qe.LibDepends);
-    }
+  }
 }
 
-void
-cmComputeLinkDepends
-::FollowSharedDeps(int depender_index, cmLinkInterface const* iface,
-                   bool follow_interface)
+void cmComputeLinkDepends::FollowSharedDeps(int depender_index,
+                                            cmLinkInterface const* iface,
+                                            bool follow_interface)
 {
   // Follow dependencies if we have not followed them already.
-  if(this->SharedDepFollowed.insert(depender_index).second)
-    {
-    if(follow_interface)
-      {
+  if (this->SharedDepFollowed.insert(depender_index).second) {
+    if (follow_interface) {
       this->QueueSharedDependencies(depender_index, iface->Libraries);
-      }
-    this->QueueSharedDependencies(depender_index, iface->SharedDeps);
     }
+    this->QueueSharedDependencies(depender_index, iface->SharedDeps);
+  }
 }
 
-void
-cmComputeLinkDepends
-::QueueSharedDependencies(int depender_index,
-                          std::vector<cmLinkItem> const& deps)
+void cmComputeLinkDepends::QueueSharedDependencies(
+  int depender_index, std::vector<cmLinkItem> const& deps)
 {
-  for(std::vector<cmLinkItem>::const_iterator li = deps.begin();
-      li != deps.end(); ++li)
-    {
+  for (std::vector<cmLinkItem>::const_iterator li = deps.begin();
+       li != deps.end(); ++li) {
     SharedDepEntry qe;
     qe.Item = *li;
     qe.DependerIndex = depender_index;
     this->SharedDepQueue.push(qe);
-    }
+  }
 }
 
 void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
@@ -426,8 +399,7 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
   // Check if the target already has an entry.
   std::map<std::string, int>::iterator lei =
     this->LinkEntryIndex.find(dep.Item);
-  if(lei == this->LinkEntryIndex.end())
-    {
+  if (lei == this->LinkEntryIndex.end()) {
     // Allocate a spot for the item entry.
     lei = this->AllocateLinkEntry(dep.Item);
 
@@ -440,7 +412,7 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
     // shared library.  It may get special treatment
     // in cmComputeLinkInformation.
     entry.IsSharedDep = true;
-    }
+  }
 
   // Get the link entry for this target.
   int index = lei->second;
@@ -451,15 +423,13 @@ void cmComputeLinkDepends::HandleSharedDependency(SharedDepEntry const& dep)
   this->EntryConstraintGraph[dep.DependerIndex].push_back(index);
 
   // Target items may have their own dependencies.
-  if(entry.Target)
-    {
-    if(cmLinkInterface const* iface =
-       entry.Target->GetLinkInterface(this->Config, this->Target))
-      {
+  if (entry.Target) {
+    if (cmLinkInterface const* iface =
+          entry.Target->GetLinkInterface(this->Config, this->Target)) {
       // Follow public and private dependencies transitively.
       this->FollowSharedDeps(index, iface, true);
-      }
     }
+  }
 }
 
 void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
@@ -475,65 +445,49 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
   std::vector<cmLinkItem> actual_libs;
   cmTargetLinkLibraryType llt = GENERAL_LibraryType;
   bool haveLLT = false;
-  for(std::vector<std::string>::const_iterator di = deplist.begin();
-      di != deplist.end(); ++di)
-    {
-    if(*di == "debug")
-      {
+  for (std::vector<std::string>::const_iterator di = deplist.begin();
+       di != deplist.end(); ++di) {
+    if (*di == "debug") {
       llt = DEBUG_LibraryType;
       haveLLT = true;
-      }
-    else if(*di == "optimized")
-      {
+    } else if (*di == "optimized") {
       llt = OPTIMIZED_LibraryType;
       haveLLT = true;
-      }
-    else if(*di == "general")
-      {
+    } else if (*di == "general") {
       llt = GENERAL_LibraryType;
       haveLLT = true;
-      }
-    else if(!di->empty())
-      {
+    } else if (!di->empty()) {
       // If no explicit link type was given prior to this entry then
       // check if the entry has its own link type variable.  This is
       // needed for compatibility with dependency files generated by
       // the export_library_dependencies command from CMake 2.4 and
       // lower.
-      if(!haveLLT)
-        {
+      if (!haveLLT) {
         std::string var = *di;
         var += "_LINK_TYPE";
-        if(const char* val = this->Makefile->GetDefinition(var))
-          {
-          if(strcmp(val, "debug") == 0)
-            {
+        if (const char* val = this->Makefile->GetDefinition(var)) {
+          if (strcmp(val, "debug") == 0) {
             llt = DEBUG_LibraryType;
-            }
-          else if(strcmp(val, "optimized") == 0)
-            {
+          } else if (strcmp(val, "optimized") == 0) {
             llt = OPTIMIZED_LibraryType;
-            }
           }
         }
+      }
 
       // If the library is meant for this link type then use it.
-      if(llt == GENERAL_LibraryType || llt == this->LinkType)
-        {
+      if (llt == GENERAL_LibraryType || llt == this->LinkType) {
         cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
         actual_libs.push_back(item);
-        }
-      else if(this->OldLinkDirMode)
-        {
+      } else if (this->OldLinkDirMode) {
         cmLinkItem item(*di, this->FindTargetToLink(depender_index, *di));
         this->CheckWrongConfigItem(item);
-        }
+      }
 
       // Reset the link type until another explicit type is given.
       llt = GENERAL_LibraryType;
       haveLLT = false;
-      }
     }
+  }
 
   // Add the entries from this list.
   this->AddLinkEntries(depender_index, actual_libs);
@@ -545,94 +499,80 @@ void cmComputeLinkDepends::AddDirectLinkEntries()
   cmLinkImplementation const* impl =
     this->Target->GetLinkImplementation(this->Config);
   this->AddLinkEntries(-1, impl->Libraries);
-  for(std::vector<cmLinkItem>::const_iterator
-        wi = impl->WrongConfigLibraries.begin();
-      wi != impl->WrongConfigLibraries.end(); ++wi)
-    {
+  for (std::vector<cmLinkItem>::const_iterator wi =
+         impl->WrongConfigLibraries.begin();
+       wi != impl->WrongConfigLibraries.end(); ++wi) {
     this->CheckWrongConfigItem(*wi);
-    }
+  }
 }
 
 template <typename T>
-void
-cmComputeLinkDepends::AddLinkEntries(
-  int depender_index, std::vector<T> const& libs)
+void cmComputeLinkDepends::AddLinkEntries(int depender_index,
+                                          std::vector<T> const& libs)
 {
   // Track inferred dependency sets implied by this list.
   std::map<int, DependSet> dependSets;
 
   // Loop over the libraries linked directly by the depender.
-  for(typename std::vector<T>::const_iterator li = libs.begin();
-      li != libs.end(); ++li)
-    {
+  for (typename std::vector<T>::const_iterator li = libs.begin();
+       li != libs.end(); ++li) {
     // Skip entries that will resolve to the target getting linked or
     // are empty.
     cmLinkItem const& item = *li;
-    if(item == this->Target->GetName() || item.empty())
-      {
+    if (item == this->Target->GetName() || item.empty()) {
       continue;
-      }
+    }
 
     // Add a link entry for this item.
     int dependee_index = this->AddLinkEntry(*li);
 
     // The dependee must come after the depender.
-    if(depender_index >= 0)
-      {
+    if (depender_index >= 0) {
       this->EntryConstraintGraph[depender_index].push_back(dependee_index);
-      }
-    else
-      {
+    } else {
       // This is a direct dependency of the target being linked.
       this->OriginalEntries.push_back(dependee_index);
-      }
+    }
 
     // Update the inferred dependencies for earlier items.
-    for(std::map<int, DependSet>::iterator dsi = dependSets.begin();
-        dsi != dependSets.end(); ++dsi)
-      {
+    for (std::map<int, DependSet>::iterator dsi = dependSets.begin();
+         dsi != dependSets.end(); ++dsi) {
       // Add this item to the inferred dependencies of other items.
       // Target items are never inferred dependees because unknown
       // items are outside libraries that should not be depending on
       // targets.
-      if(!this->EntryList[dependee_index].Target &&
-         !this->EntryList[dependee_index].IsFlag &&
-         dependee_index != dsi->first)
-        {
+      if (!this->EntryList[dependee_index].Target &&
+          !this->EntryList[dependee_index].IsFlag &&
+          dependee_index != dsi->first) {
         dsi->second.insert(dependee_index);
-        }
       }
+    }
 
     // If this item needs to have dependencies inferred, do so.
-    if(this->InferredDependSets[dependee_index])
-      {
+    if (this->InferredDependSets[dependee_index]) {
       // Make sure an entry exists to hold the set for the item.
       dependSets[dependee_index];
-      }
     }
+  }
 
   // Store the inferred dependency sets discovered for this list.
-  for(std::map<int, DependSet>::iterator dsi = dependSets.begin();
-      dsi != dependSets.end(); ++dsi)
-    {
+  for (std::map<int, DependSet>::iterator dsi = dependSets.begin();
+       dsi != dependSets.end(); ++dsi) {
     this->InferredDependSets[dsi->first]->push_back(dsi->second);
-    }
+  }
 }
 
-cmGeneratorTarget const*
-cmComputeLinkDepends::FindTargetToLink(int depender_index,
-                                       const std::string& name)
+cmGeneratorTarget const* cmComputeLinkDepends::FindTargetToLink(
+  int depender_index, const std::string& name)
 {
   // Look for a target in the scope of the depender.
   cmGeneratorTarget const* from = this->Target;
-  if(depender_index >= 0)
-    {
-    if(cmGeneratorTarget const* depender =
-       this->EntryList[depender_index].Target)
-      {
+  if (depender_index >= 0) {
+    if (cmGeneratorTarget const* depender =
+          this->EntryList[depender_index].Target) {
       from = depender;
-      }
     }
+  }
   return from->FindTargetToLink(name);
 }
 
@@ -641,59 +581,53 @@ void cmComputeLinkDepends::InferDependencies()
   // The inferred dependency sets for each item list the possible
   // dependencies.  The intersection of the sets for one item form its
   // inferred dependencies.
-  for(unsigned int depender_index=0;
-      depender_index < this->InferredDependSets.size(); ++depender_index)
-    {
+  for (unsigned int depender_index = 0;
+       depender_index < this->InferredDependSets.size(); ++depender_index) {
     // Skip items for which dependencies do not need to be inferred or
     // for which the inferred dependency sets are empty.
     DependSetList* sets = this->InferredDependSets[depender_index];
-    if(!sets || sets->empty())
-      {
+    if (!sets || sets->empty()) {
       continue;
-      }
+    }
 
     // Intersect the sets for this item.
     DependSetList::const_iterator i = sets->begin();
     DependSet common = *i;
-    for(++i; i != sets->end(); ++i)
-      {
+    for (++i; i != sets->end(); ++i) {
       DependSet intersection;
-      std::set_intersection
-        (common.begin(), common.end(), i->begin(), i->end(),
-         std::inserter(intersection, intersection.begin()));
+      std::set_intersection(common.begin(), common.end(), i->begin(), i->end(),
+                            std::inserter(intersection, intersection.begin()));
       common = intersection;
-      }
+    }
 
     // Add the inferred dependencies to the graph.
     cmGraphEdgeList& edges = this->EntryConstraintGraph[depender_index];
     edges.insert(edges.end(), common.begin(), common.end());
-    }
+  }
 }
 
 void cmComputeLinkDepends::CleanConstraintGraph()
 {
-  for(Graph::iterator i = this->EntryConstraintGraph.begin();
-      i != this->EntryConstraintGraph.end(); ++i)
-    {
+  for (Graph::iterator i = this->EntryConstraintGraph.begin();
+       i != this->EntryConstraintGraph.end(); ++i) {
     // Sort the outgoing edges for each graph node so that the
     // original order will be preserved as much as possible.
     std::sort(i->begin(), i->end());
 
     // Make the edge list unique.
     i->erase(std::unique(i->begin(), i->end()), i->end());
-    }
+  }
 }
 
 void cmComputeLinkDepends::DisplayConstraintGraph()
 {
   // Display the graph nodes and their edges.
   std::ostringstream e;
-  for(unsigned int i=0; i < this->EntryConstraintGraph.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->EntryConstraintGraph.size(); ++i) {
     EdgeList const& nl = this->EntryConstraintGraph[i];
     e << "item " << i << " is [" << this->EntryList[i].Item << "]\n";
     e << cmWrap("  item ", nl, " must follow it", "\n") << "\n";
-    }
+  }
   fprintf(stderr, "%s\n", e.str().c_str());
 }
 
@@ -716,71 +650,60 @@ void cmComputeLinkDepends::OrderLinkEntires()
   this->ComponentOrderId = n;
   // Run in reverse order so the topological order will preserve the
   // original order where there are no constraints.
-  for(int c = n-1; c >= 0; --c)
-    {
+  for (int c = n - 1; c >= 0; --c) {
     this->VisitComponent(c);
-    }
+  }
 
   // Display the component graph.
-  if(this->DebugMode)
-    {
+  if (this->DebugMode) {
     this->DisplayComponents();
-    }
+  }
 
   // Start with the original link line.
-  for(std::vector<int>::const_iterator i = this->OriginalEntries.begin();
-      i != this->OriginalEntries.end(); ++i)
-    {
+  for (std::vector<int>::const_iterator i = this->OriginalEntries.begin();
+       i != this->OriginalEntries.end(); ++i) {
     this->VisitEntry(*i);
-    }
+  }
 
   // Now explore anything left pending.  Since the component graph is
   // guaranteed to be acyclic we know this will terminate.
-  while(!this->PendingComponents.empty())
-    {
+  while (!this->PendingComponents.empty()) {
     // Visit one entry from the first pending component.  The visit
     // logic will update the pending components accordingly.  Since
     // the pending components are kept in topological order this will
     // not repeat one.
     int e = *this->PendingComponents.begin()->second.Entries.begin();
     this->VisitEntry(e);
-    }
+  }
 }
 
-void
-cmComputeLinkDepends::DisplayComponents()
+void cmComputeLinkDepends::DisplayComponents()
 {
   fprintf(stderr, "The strongly connected components are:\n");
   std::vector<NodeList> const& components = this->CCG->GetComponents();
-  for(unsigned int c=0; c < components.size(); ++c)
-    {
+  for (unsigned int c = 0; c < components.size(); ++c) {
     fprintf(stderr, "Component (%u):\n", c);
     NodeList const& nl = components[c];
-    for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int i = *ni;
-      fprintf(stderr, "  item %d [%s]\n", i,
-              this->EntryList[i].Item.c_str());
-      }
+      fprintf(stderr, "  item %d [%s]\n", i, this->EntryList[i].Item.c_str());
+    }
     EdgeList const& ol = this->CCG->GetComponentGraphEdges(c);
-    for(EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi)
-      {
+    for (EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi) {
       int i = *oi;
       fprintf(stderr, "  followed by Component (%d)\n", i);
-      }
-    fprintf(stderr, "  topo order index %d\n",
-            this->ComponentOrder[c]);
     }
+    fprintf(stderr, "  topo order index %d\n", this->ComponentOrder[c]);
+  }
   fprintf(stderr, "\n");
 }
 
 void cmComputeLinkDepends::VisitComponent(unsigned int c)
 {
   // Check if the node has already been visited.
-  if(this->ComponentVisited[c])
-    {
+  if (this->ComponentVisited[c]) {
     return;
-    }
+  }
 
   // We are now visiting this component so mark it.
   this->ComponentVisited[c] = 1;
@@ -789,11 +712,10 @@ void cmComputeLinkDepends::VisitComponent(unsigned int c)
   // Run in reverse order so the topological order will preserve the
   // original order where there are no constraints.
   EdgeList const& nl = this->CCG->GetComponentGraphEdges(c);
-  for(EdgeList::const_reverse_iterator ni = nl.rbegin();
-      ni != nl.rend(); ++ni)
-    {
+  for (EdgeList::const_reverse_iterator ni = nl.rbegin(); ni != nl.rend();
+       ++ni) {
     this->VisitComponent(*ni);
-    }
+  }
 
   // Assign an ordering id to this component.
   this->ComponentOrder[c] = --this->ComponentOrderId;
@@ -809,64 +731,52 @@ void cmComputeLinkDepends::VisitEntry(int index)
   int component = this->CCG->GetComponentMap()[index];
   std::map<int, PendingComponent>::iterator mi =
     this->PendingComponents.find(this->ComponentOrder[component]);
-  if(mi != this->PendingComponents.end())
-    {
+  if (mi != this->PendingComponents.end()) {
     // The entry is in an already pending component.
     PendingComponent& pc = mi->second;
 
     // Remove the entry from those pending in its component.
     pc.Entries.erase(index);
-    if(pc.Entries.empty())
-      {
+    if (pc.Entries.empty()) {
       // The complete component has been seen since it was last needed.
       --pc.Count;
 
-      if(pc.Count == 0)
-        {
+      if (pc.Count == 0) {
         // The component has been completed.
         this->PendingComponents.erase(mi);
         completed = true;
-        }
-      else
-        {
+      } else {
         // The whole component needs to be seen again.
         NodeList const& nl = this->CCG->GetComponent(component);
         assert(nl.size() > 1);
         pc.Entries.insert(nl.begin(), nl.end());
-        }
       }
     }
-  else
-    {
+  } else {
     // The entry is not in an already pending component.
     NodeList const& nl = this->CCG->GetComponent(component);
-    if(nl.size() > 1)
-      {
+    if (nl.size() > 1) {
       // This is a non-trivial component.  It is now pending.
       PendingComponent& pc = this->MakePendingComponent(component);
 
       // The starting entry has already been seen.
       pc.Entries.erase(index);
-      }
-    else
-      {
+    } else {
       // This is a trivial component, so it is already complete.
       completed = true;
-      }
     }
+  }
 
   // If the entry completed a component, the component's dependencies
   // are now pending.
-  if(completed)
-    {
+  if (completed) {
     EdgeList const& ol = this->CCG->GetComponentGraphEdges(component);
-    for(EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi)
-      {
+    for (EdgeList::const_iterator oi = ol.begin(); oi != ol.end(); ++oi) {
       // This entire component is now pending no matter whether it has
       // been partially seen already.
       this->MakePendingComponent(*oi);
-      }
     }
+  }
 }
 
 cmComputeLinkDepends::PendingComponent&
@@ -878,13 +788,10 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
   pc.Id = component;
   NodeList const& nl = this->CCG->GetComponent(component);
 
-  if(nl.size() == 1)
-    {
+  if (nl.size() == 1) {
     // Trivial components need be seen only once.
     pc.Count = 1;
-    }
-  else
-    {
+  } else {
     // This is a non-trivial strongly connected component of the
     // original graph.  It consists of two or more libraries
     // (archives) that mutually require objects from one another.  In
@@ -898,7 +805,7 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
     // this component will come first which minimizes the number of
     // repeats needed.
     pc.Count = this->ComputeComponentCount(nl);
-    }
+  }
 
   // Store the entries to be seen.
   pc.Entries.insert(nl.begin(), nl.end());
@@ -909,54 +816,44 @@ cmComputeLinkDepends::MakePendingComponent(unsigned int component)
 int cmComputeLinkDepends::ComputeComponentCount(NodeList const& nl)
 {
   unsigned int count = 2;
-  for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-    {
-    if(cmGeneratorTarget const* target = this->EntryList[*ni].Target)
-      {
-      if(cmLinkInterface const* iface =
-         target->GetLinkInterface(this->Config, this->Target))
-        {
-        if(iface->Multiplicity > count)
-          {
+  for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
+    if (cmGeneratorTarget const* target = this->EntryList[*ni].Target) {
+      if (cmLinkInterface const* iface =
+            target->GetLinkInterface(this->Config, this->Target)) {
+        if (iface->Multiplicity > count) {
           count = iface->Multiplicity;
-          }
         }
       }
     }
+  }
   return count;
 }
 
 void cmComputeLinkDepends::DisplayFinalEntries()
 {
   fprintf(stderr, "target [%s] links to:\n", this->Target->GetName().c_str());
-  for(std::vector<LinkEntry>::const_iterator lei =
-        this->FinalLinkEntries.begin();
-      lei != this->FinalLinkEntries.end(); ++lei)
-    {
-    if(lei->Target)
-      {
+  for (std::vector<LinkEntry>::const_iterator lei =
+         this->FinalLinkEntries.begin();
+       lei != this->FinalLinkEntries.end(); ++lei) {
+    if (lei->Target) {
       fprintf(stderr, "  target [%s]\n", lei->Target->GetName().c_str());
-      }
-    else
-      {
+    } else {
       fprintf(stderr, "  item [%s]\n", lei->Item.c_str());
-      }
     }
+  }
   fprintf(stderr, "\n");
 }
 
 void cmComputeLinkDepends::CheckWrongConfigItem(cmLinkItem const& item)
 {
-  if(!this->OldLinkDirMode)
-    {
+  if (!this->OldLinkDirMode) {
     return;
-    }
+  }
 
   // For CMake 2.4 bug-compatibility we need to consider the output
   // directories of targets linked in another configuration as link
   // directories.
-  if(item.Target && !item.Target->IsImported())
-    {
+  if (item.Target && !item.Target->IsImported()) {
     this->OldWrongConfigItems.insert(item.Target);
-    }
+  }
 }
diff --git a/Source/cmComputeLinkDepends.h b/Source/cmComputeLinkDepends.h
index ea23308..6aa40c3 100644
--- a/Source/cmComputeLinkDepends.h
+++ b/Source/cmComputeLinkDepends.h
@@ -42,10 +42,20 @@ public:
     cmGeneratorTarget const* Target;
     bool IsSharedDep;
     bool IsFlag;
-    LinkEntry(): Item(), Target(0), IsSharedDep(false), IsFlag(false) {}
-    LinkEntry(LinkEntry const& r):
-      Item(r.Item), Target(r.Target), IsSharedDep(r.IsSharedDep),
-      IsFlag(r.IsFlag) {}
+    LinkEntry()
+      : Item()
+      , Target(0)
+      , IsSharedDep(false)
+      , IsFlag(false)
+    {
+    }
+    LinkEntry(LinkEntry const& r)
+      : Item(r.Item)
+      , Target(r.Target)
+      , IsSharedDep(r.IsSharedDep)
+      , IsFlag(r.IsFlag)
+    {
+    }
   };
 
   typedef std::vector<LinkEntry> EntryVector;
@@ -53,10 +63,11 @@ public:
 
   void SetOldLinkDirMode(bool b);
   std::set<cmGeneratorTarget const*> const& GetOldWrongConfigItems() const
-    { return this->OldWrongConfigItems; }
+  {
+    return this->OldWrongConfigItems;
+  }
 
 private:
-
   // Context information.
   cmGeneratorTarget const* Target;
   cmMakefile* Makefile;
@@ -65,13 +76,13 @@ private:
   std::string Config;
   EntryVector FinalLinkEntries;
 
-  std::map<std::string, int>::iterator
-  AllocateLinkEntry(std::string const& item);
+  std::map<std::string, int>::iterator AllocateLinkEntry(
+    std::string const& item);
   int AddLinkEntry(cmLinkItem const& item);
   void AddVarLinkEntries(int depender_index, const char* value);
   void AddDirectLinkEntries();
   template <typename T>
-    void AddLinkEntries(int depender_index, std::vector<T> const& libs);
+  void AddLinkEntries(int depender_index, std::vector<T> const& libs);
   cmGeneratorTarget const* FindTargetToLink(int depender_index,
                                             const std::string& name);
 
@@ -98,16 +109,19 @@ private:
   };
   std::queue<SharedDepEntry> SharedDepQueue;
   std::set<int> SharedDepFollowed;
-  void FollowSharedDeps(int depender_index,
-                        cmLinkInterface const* iface,
+  void FollowSharedDeps(int depender_index, cmLinkInterface const* iface,
                         bool follow_interface = false);
   void QueueSharedDependencies(int depender_index,
                                std::vector<cmLinkItem> const& deps);
   void HandleSharedDependency(SharedDepEntry const& dep);
 
   // Dependency inferral for each link item.
-  struct DependSet: public std::set<int> {};
-  struct DependSetList: public std::vector<DependSet> {};
+  struct DependSet : public std::set<int>
+  {
+  };
+  struct DependSetList : public std::vector<DependSet>
+  {
+  };
   std::vector<DependSetList*> InferredDependSets;
   void InferDependencies();
 
diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx
index 5b42b1a..e1a7bee 100644
--- a/Source/cmComputeLinkInformation.cxx
+++ b/Source/cmComputeLinkInformation.cxx
@@ -240,45 +240,42 @@ because this need be done only for shared libraries without soname-s.
 
 */
 
-cmComputeLinkInformation
-::cmComputeLinkInformation(const cmGeneratorTarget* target,
-                           const std::string& config)
+cmComputeLinkInformation::cmComputeLinkInformation(
+  const cmGeneratorTarget* target, const std::string& config)
 {
   // Store context information.
   this->Target = target;
   this->Makefile = this->Target->Target->GetMakefile();
   this->GlobalGenerator =
-      this->Target->GetLocalGenerator()->GetGlobalGenerator();
+    this->Target->GetLocalGenerator()->GetGlobalGenerator();
   this->CMakeInstance = this->GlobalGenerator->GetCMakeInstance();
 
   // Check whether to recognize OpenBSD-style library versioned names.
-  this->OpenBSD = this->Makefile->GetState()
-            ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING");
+  this->OpenBSD = this->Makefile->GetState()->GetGlobalPropertyAsBool(
+    "FIND_LIBRARY_USE_OPENBSD_VERSIONING");
 
   // The configuration being linked.
   this->Config = config;
 
   // Allocate internals.
-  this->OrderLinkerSearchPath =
-    new cmOrderDirectories(this->GlobalGenerator, target,
-                           "linker search path");
-  this->OrderRuntimeSearchPath =
-    new cmOrderDirectories(this->GlobalGenerator, target,
-                           "runtime search path");
+  this->OrderLinkerSearchPath = new cmOrderDirectories(
+    this->GlobalGenerator, target, "linker search path");
+  this->OrderRuntimeSearchPath = new cmOrderDirectories(
+    this->GlobalGenerator, target, "runtime search path");
   this->OrderDependentRPath = 0;
 
   // Get the language used for linking this target.
   this->LinkLanguage = this->Target->GetLinkerLanguage(config);
-  if(this->LinkLanguage.empty())
-    {
+  if (this->LinkLanguage.empty()) {
     // The Compute method will do nothing, so skip the rest of the
     // initialization.
     return;
-    }
+  }
 
   // Check whether we should use an import library for linking a target.
   this->UseImportLibrary =
-    this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")?true:false;
+    this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX") ? true
+                                                                 : false;
 
   // Check whether we should skip dependencies on shared library files.
   this->LinkDependsNoShared =
@@ -288,14 +285,13 @@ cmComputeLinkInformation
   // to use when creating a plugin (module) that obtains symbols from
   // the program that will load it.
   this->LoaderFlag = 0;
-  if(!this->UseImportLibrary &&
-     this->Target->GetType() == cmState::MODULE_LIBRARY)
-    {
+  if (!this->UseImportLibrary &&
+      this->Target->GetType() == cmState::MODULE_LIBRARY) {
     std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_";
     loader_flag_var += this->LinkLanguage;
     loader_flag_var += "_FLAG";
     this->LoaderFlag = this->Makefile->GetDefinition(loader_flag_var);
-    }
+  }
 
   // Get options needed to link libraries.
   this->LibLinkFlag =
@@ -307,11 +303,10 @@ cmComputeLinkInformation
 
   // Get options needed to specify RPATHs.
   this->RuntimeUseChrpath = false;
-  if(this->Target->GetType() != cmState::STATIC_LIBRARY)
-    {
+  if (this->Target->GetType() != cmState::STATIC_LIBRARY) {
     const char* tType =
-      ((this->Target->GetType() == cmState::EXECUTABLE)?
-       "EXECUTABLE" : "SHARED_LIBRARY");
+      ((this->Target->GetType() == cmState::EXECUTABLE) ? "EXECUTABLE"
+                                                        : "SHARED_LIBRARY");
     std::string rtVar = "CMAKE_";
     rtVar += tType;
     rtVar += "_RUNTIME_";
@@ -320,9 +315,8 @@ cmComputeLinkInformation
     std::string rtSepVar = rtVar + "_SEP";
     this->RuntimeFlag = this->Makefile->GetSafeDefinition(rtVar);
     this->RuntimeSep = this->Makefile->GetSafeDefinition(rtSepVar);
-    this->RuntimeAlways =
-      (this->Makefile->
-       GetSafeDefinition("CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH"));
+    this->RuntimeAlways = (this->Makefile->GetSafeDefinition(
+      "CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH"));
 
     this->RuntimeUseChrpath = this->Target->IsChrpathUsed(config);
 
@@ -333,14 +327,14 @@ cmComputeLinkInformation
     rlVar += this->LinkLanguage;
     rlVar += "_FLAG";
     this->RPathLinkFlag = this->Makefile->GetSafeDefinition(rlVar);
-    }
+  }
 
   // Check if we need to include the runtime search path at link time.
   {
-  std::string var = "CMAKE_SHARED_LIBRARY_LINK_";
-  var += this->LinkLanguage;
-  var += "_WITH_RUNTIME_PATH";
-  this->LinkWithRuntimePath = this->Makefile->IsOn(var);
+    std::string var = "CMAKE_SHARED_LIBRARY_LINK_";
+    var += this->LinkLanguage;
+    var += "_WITH_RUNTIME_PATH";
+    this->LinkWithRuntimePath = this->Makefile->IsOn(var);
   }
 
   // Check the platform policy for missing soname case.
@@ -358,41 +352,30 @@ cmComputeLinkInformation
 
   // Choose a mode for dealing with shared library dependencies.
   this->SharedDependencyMode = SharedDepModeNone;
-  if(this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES"))
-    {
+  if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_FILES")) {
     this->SharedDependencyMode = SharedDepModeLink;
-    }
-  else if(this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS"))
-    {
+  } else if (this->Makefile->IsOn("CMAKE_LINK_DEPENDENT_LIBRARY_DIRS")) {
     this->SharedDependencyMode = SharedDepModeLibDir;
-    }
-  else if(!this->RPathLinkFlag.empty())
-    {
+  } else if (!this->RPathLinkFlag.empty()) {
     this->SharedDependencyMode = SharedDepModeDir;
-    this->OrderDependentRPath =
-      new cmOrderDirectories(this->GlobalGenerator, target,
-                             "dependent library path");
-    }
+    this->OrderDependentRPath = new cmOrderDirectories(
+      this->GlobalGenerator, target, "dependent library path");
+  }
 
   // Add the search path entries requested by the user to path ordering.
-  this->OrderLinkerSearchPath
-    ->AddUserDirectories(this->Target->GetLinkDirectories());
-  this->OrderRuntimeSearchPath
-    ->AddUserDirectories(this->Target->GetLinkDirectories());
+  this->OrderLinkerSearchPath->AddUserDirectories(
+    this->Target->GetLinkDirectories());
+  this->OrderRuntimeSearchPath->AddUserDirectories(
+    this->Target->GetLinkDirectories());
 
   // Set up the implicit link directories.
   this->LoadImplicitLinkInfo();
-  this->OrderLinkerSearchPath
-    ->SetImplicitDirectories(this->ImplicitLinkDirs);
-  this->OrderRuntimeSearchPath
-    ->SetImplicitDirectories(this->ImplicitLinkDirs);
-  if(this->OrderDependentRPath)
-    {
-    this->OrderDependentRPath
-      ->SetImplicitDirectories(this->ImplicitLinkDirs);
-    this->OrderDependentRPath
-      ->AddLanguageDirectories(this->RuntimeLinkDirs);
-    }
+  this->OrderLinkerSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+  this->OrderRuntimeSearchPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+  if (this->OrderDependentRPath) {
+    this->OrderDependentRPath->SetImplicitDirectories(this->ImplicitLinkDirs);
+    this->OrderDependentRPath->AddLanguageDirectories(this->RuntimeLinkDirs);
+  }
 
   // Decide whether to enable compatible library search path mode.
   // There exists code that effectively does
@@ -407,18 +390,15 @@ cmComputeLinkInformation
   // containing libraries linked with a full path to the -L path.
   this->OldLinkDirMode =
     this->Target->GetPolicyStatusCMP0003() != cmPolicies::NEW;
-  if(this->OldLinkDirMode)
-    {
+  if (this->OldLinkDirMode) {
     // Construct a mask to not bother with this behavior for link
     // directories already specified by the user.
-    std::vector<std::string> const& dirs =
-        this->Target->GetLinkDirectories();
+    std::vector<std::string> const& dirs = this->Target->GetLinkDirectories();
     this->OldLinkDirMask.insert(dirs.begin(), dirs.end());
-    }
+  }
 
-  this->CMP0060Warn =
-    this->Makefile->PolicyOptionalWarningEnabled(
-      "CMAKE_POLICY_WARNING_CMP0060");
+  this->CMP0060Warn = this->Makefile->PolicyOptionalWarningEnabled(
+    "CMAKE_POLICY_WARNING_CMP0060");
 }
 
 cmComputeLinkInformation::~cmComputeLinkInformation()
@@ -443,10 +423,9 @@ std::string cmComputeLinkInformation::GetRPathLinkString()
 {
   // If there is no separate linker runtime search flag (-rpath-link)
   // there is no reason to compute a string.
-  if(!this->OrderDependentRPath)
-    {
+  if (!this->OrderDependentRPath) {
     return "";
-    }
+  }
 
   // Construct the linker runtime search path.
   return cmJoin(this->OrderDependentRPath->GetOrderedDirectories(), ":");
@@ -471,22 +450,20 @@ cmComputeLinkInformation::GetSharedLibrariesLinked()
 bool cmComputeLinkInformation::Compute()
 {
   // Skip targets that do not link.
-  if(!(this->Target->GetType() == cmState::EXECUTABLE ||
-       this->Target->GetType() == cmState::SHARED_LIBRARY ||
-       this->Target->GetType() == cmState::MODULE_LIBRARY ||
-       this->Target->GetType() == cmState::STATIC_LIBRARY))
-    {
+  if (!(this->Target->GetType() == cmState::EXECUTABLE ||
+        this->Target->GetType() == cmState::SHARED_LIBRARY ||
+        this->Target->GetType() == cmState::MODULE_LIBRARY ||
+        this->Target->GetType() == cmState::STATIC_LIBRARY)) {
     return false;
-    }
+  }
 
   // We require a link language for the target.
-  if(this->LinkLanguage.empty())
-    {
-    cmSystemTools::
-      Error("CMake can not determine linker language for target: ",
-            this->Target->GetName().c_str());
+  if (this->LinkLanguage.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      this->Target->GetName().c_str());
     return false;
-    }
+  }
 
   // Compute the ordered link line items.
   cmComputeLinkDepends cld(this->Target, this->Config);
@@ -494,64 +471,52 @@ bool cmComputeLinkInformation::Compute()
   cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();
 
   // Add the link line items.
-  for(cmComputeLinkDepends::EntryVector::const_iterator
-        lei = linkEntries.begin();
-      lei != linkEntries.end(); ++lei)
-    {
-    if(lei->IsSharedDep)
-      {
+  for (cmComputeLinkDepends::EntryVector::const_iterator lei =
+         linkEntries.begin();
+       lei != linkEntries.end(); ++lei) {
+    if (lei->IsSharedDep) {
       this->AddSharedDepItem(lei->Item, lei->Target);
-      }
-    else
-      {
+    } else {
       this->AddItem(lei->Item, lei->Target);
-      }
     }
+  }
 
   // Restore the target link type so the correct system runtime
   // libraries are found.
-  const char* lss =
-      this->Target->GetProperty("LINK_SEARCH_END_STATIC");
-  if(cmSystemTools::IsOn(lss))
-    {
+  const char* lss = this->Target->GetProperty("LINK_SEARCH_END_STATIC");
+  if (cmSystemTools::IsOn(lss)) {
     this->SetCurrentLinkType(LinkStatic);
-    }
-  else
-    {
+  } else {
     this->SetCurrentLinkType(this->StartLinkType);
-    }
+  }
 
   // Finish listing compatibility paths.
-  if(this->OldLinkDirMode)
-    {
+  if (this->OldLinkDirMode) {
     // For CMake 2.4 bug-compatibility we need to consider the output
     // directories of targets linked in another configuration as link
     // directories.
     std::set<cmGeneratorTarget const*> const& wrongItems =
-        cld.GetOldWrongConfigItems();
-    for(std::set<cmGeneratorTarget const*>::const_iterator i =
-        wrongItems.begin(); i != wrongItems.end(); ++i)
-      {
+      cld.GetOldWrongConfigItems();
+    for (std::set<cmGeneratorTarget const*>::const_iterator i =
+           wrongItems.begin();
+         i != wrongItems.end(); ++i) {
       cmGeneratorTarget const* tgt = *i;
-      bool implib =
-        (this->UseImportLibrary &&
-         (tgt->GetType() == cmState::SHARED_LIBRARY));
-      std::string lib = tgt->GetFullPath(this->Config , implib, true);
+      bool implib = (this->UseImportLibrary &&
+                     (tgt->GetType() == cmState::SHARED_LIBRARY));
+      std::string lib = tgt->GetFullPath(this->Config, implib, true);
       this->OldLinkDirItems.push_back(lib);
-      }
     }
+  }
 
   // Finish setting up linker search directories.
-  if(!this->FinishLinkerSearchDirectories())
-    {
+  if (!this->FinishLinkerSearchDirectories()) {
     return false;
-    }
+  }
 
   // Add implicit language runtime libraries and directories.
   this->AddImplicitLinkInfo();
 
-  if (!this->CMP0060WarnItems.empty())
-    {
+  if (!this->CMP0060WarnItems.empty()) {
     std::ostringstream w;
     /* clang-format off */
     w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0060) << "\n"
@@ -565,7 +530,7 @@ bool cmComputeLinkInformation::Compute()
     /* clang-format on */
     this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
                                       this->Target->GetBacktrace());
-    }
+  }
 
   return true;
 }
@@ -574,16 +539,14 @@ void cmComputeLinkInformation::AddImplicitLinkInfo()
 {
   // The link closure lists all languages whose implicit info is needed.
   cmGeneratorTarget::LinkClosure const* lc =
-      this->Target->GetLinkClosure(this->Config);
-  for(std::vector<std::string>::const_iterator li = lc->Languages.begin();
-      li != lc->Languages.end(); ++li)
-    {
+    this->Target->GetLinkClosure(this->Config);
+  for (std::vector<std::string>::const_iterator li = lc->Languages.begin();
+       li != lc->Languages.end(); ++li) {
     // Skip those of the linker language.  They are implicit.
-    if(*li != this->LinkLanguage)
-      {
+    if (*li != this->LinkLanguage) {
       this->AddImplicitLinkInfo(*li);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
@@ -593,31 +556,27 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
   std::string libVar = "CMAKE_";
   libVar += lang;
   libVar += "_IMPLICIT_LINK_LIBRARIES";
-  if(const char* libs = this->Makefile->GetDefinition(libVar))
-    {
+  if (const char* libs = this->Makefile->GetDefinition(libVar)) {
     std::vector<std::string> libsVec;
     cmSystemTools::ExpandListArgument(libs, libsVec);
-    for(std::vector<std::string>::const_iterator i = libsVec.begin();
-        i != libsVec.end(); ++i)
-      {
-      if(this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end())
-        {
+    for (std::vector<std::string>::const_iterator i = libsVec.begin();
+         i != libsVec.end(); ++i) {
+      if (this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end()) {
         this->AddItem(*i, 0);
-        }
       }
     }
+  }
 
   // Add linker search paths for this language that are not
   // implied by the linker language.
   std::string dirVar = "CMAKE_";
   dirVar += lang;
   dirVar += "_IMPLICIT_LINK_DIRECTORIES";
-  if(const char* dirs = this->Makefile->GetDefinition(dirVar))
-    {
+  if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
     std::vector<std::string> dirsVec;
     cmSystemTools::ExpandListArgument(dirs, dirsVec);
     this->OrderLinkerSearchPath->AddLanguageDirectories(dirsVec);
-    }
+  }
 }
 
 void cmComputeLinkInformation::AddItem(std::string const& item,
@@ -626,176 +585,141 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
   // Compute the proper name to use to link this library.
   const std::string& config = this->Config;
   bool impexe = (tgt && tgt->IsExecutableWithExports());
-  if(impexe && !this->UseImportLibrary && !this->LoaderFlag)
-    {
+  if (impexe && !this->UseImportLibrary && !this->LoaderFlag) {
     // Skip linking to executables on platforms with no import
     // libraries or loader flags.
     return;
-    }
+  }
 
-  if(tgt && tgt->IsLinkable())
-    {
+  if (tgt && tgt->IsLinkable()) {
     // This is a CMake target.  Ask the target for its real name.
-    if(impexe && this->LoaderFlag)
-      {
+    if (impexe && this->LoaderFlag) {
       // This link item is an executable that may provide symbols
       // used by this target.  A special flag is needed on this
       // platform.  Add it now.
       std::string linkItem;
       linkItem = this->LoaderFlag;
 
-      std::string exe = tgt->GetFullPath(config, this->UseImportLibrary,
-                                         true);
+      std::string exe = tgt->GetFullPath(config, this->UseImportLibrary, true);
       linkItem += exe;
       this->Items.push_back(Item(linkItem, true, tgt));
       this->Depends.push_back(exe);
-      }
-    else if(tgt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    } else if (tgt->GetType() == cmState::INTERFACE_LIBRARY) {
       // Add the interface library as an item so it can be considered as part
       // of COMPATIBLE_INTERFACE_ enforcement.  The generators will ignore
       // this for the actual link line.
       this->Items.push_back(Item(std::string(), false, tgt));
-      }
-    else
-      {
+    } else {
       // Decide whether to use an import library.
-      bool implib =
-        (this->UseImportLibrary &&
-         (impexe || tgt->GetType() == cmState::SHARED_LIBRARY));
+      bool implib = (this->UseImportLibrary &&
+                     (impexe || tgt->GetType() == cmState::SHARED_LIBRARY));
 
       // Pass the full path to the target file.
       std::string lib = tgt->GetFullPath(config, implib, true);
-      if(!this->LinkDependsNoShared ||
-         tgt->GetType() != cmState::SHARED_LIBRARY)
-        {
+      if (!this->LinkDependsNoShared ||
+          tgt->GetType() != cmState::SHARED_LIBRARY) {
         this->Depends.push_back(lib);
-        }
+      }
 
       this->AddTargetItem(lib, tgt);
       this->AddLibraryRuntimeInfo(lib, tgt);
-      }
     }
-  else
-    {
+  } else {
     // This is not a CMake target.  Use the name given.
-    if(cmSystemTools::FileIsFullPath(item.c_str()))
-      {
-      if(cmSystemTools::FileIsDirectory(item))
-        {
+    if (cmSystemTools::FileIsFullPath(item.c_str())) {
+      if (cmSystemTools::FileIsDirectory(item)) {
         // This is a directory.
         this->AddDirectoryItem(item);
-        }
-      else
-        {
+      } else {
         // Use the full path given to the library file.
         this->Depends.push_back(item);
         this->AddFullItem(item);
         this->AddLibraryRuntimeInfo(item);
-        }
       }
-    else
-      {
+    } else {
       // This is a library or option specified by the user.
       this->AddUserItem(item, true);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::AddSharedDepItem(std::string const& item,
                                                 const cmGeneratorTarget* tgt)
 {
   // If dropping shared library dependencies, ignore them.
-  if(this->SharedDependencyMode == SharedDepModeNone)
-    {
+  if (this->SharedDependencyMode == SharedDepModeNone) {
     return;
-    }
+  }
 
   // The user may have incorrectly named an item.  Skip items that are
   // not full paths to shared libraries.
-  if(tgt)
-    {
+  if (tgt) {
     // The target will provide a full path.  Make sure it is a shared
     // library.
-    if(tgt->GetType() != cmState::SHARED_LIBRARY)
-      {
+    if (tgt->GetType() != cmState::SHARED_LIBRARY) {
       return;
-      }
     }
-  else
-    {
+  } else {
     // Skip items that are not full paths.  We will not be able to
     // reliably specify them.
-    if(!cmSystemTools::FileIsFullPath(item.c_str()))
-      {
+    if (!cmSystemTools::FileIsFullPath(item.c_str())) {
       return;
-      }
+    }
 
     // Get the name of the library from the file name.
     std::string file = cmSystemTools::GetFilenameName(item);
-    if(!this->ExtractSharedLibraryName.find(file.c_str()))
-      {
+    if (!this->ExtractSharedLibraryName.find(file.c_str())) {
       // This is not the name of a shared library.
       return;
-      }
     }
+  }
 
   // If in linking mode, just link to the shared library.
-  if(this->SharedDependencyMode == SharedDepModeLink)
-    {
+  if (this->SharedDependencyMode == SharedDepModeLink) {
     this->AddItem(item, tgt);
     return;
-    }
+  }
 
   // Get a full path to the dependent shared library.
   // Add it to the runtime path computation so that the target being
   // linked will be able to find it.
   std::string lib;
-  if(tgt)
-    {
+  if (tgt) {
     lib = tgt->GetFullPath(this->Config, this->UseImportLibrary);
     this->AddLibraryRuntimeInfo(lib, tgt);
-    }
-  else
-    {
+  } else {
     lib = item;
     this->AddLibraryRuntimeInfo(lib);
-    }
+  }
 
   // Check if we need to include the dependent shared library in other
   // path ordering.
   cmOrderDirectories* order = 0;
-  if(this->SharedDependencyMode == SharedDepModeLibDir &&
-     !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */)
-    {
+  if (this->SharedDependencyMode == SharedDepModeLibDir &&
+      !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */) {
     // Add the item to the linker search path.
     order = this->OrderLinkerSearchPath;
-    }
-  else if(this->SharedDependencyMode == SharedDepModeDir)
-    {
+  } else if (this->SharedDependencyMode == SharedDepModeDir) {
     // Add the item to the separate dependent library search path.
     order = this->OrderDependentRPath;
-    }
-  if(order)
-    {
-    if(tgt)
-      {
+  }
+  if (order) {
+    if (tgt) {
       std::string soName = tgt->GetSOName(this->Config);
-      const char* soname = soName.empty()? 0 : soName.c_str();
+      const char* soname = soName.empty() ? 0 : soName.c_str();
       order->AddRuntimeLibrary(lib, soname);
-      }
-    else
-      {
+    } else {
       order->AddRuntimeLibrary(lib);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::ComputeLinkTypeInfo()
 {
   // Check whether archives may actually be shared libraries.
-  this->ArchivesMayBeShared = this->CMakeInstance->GetState()
-              ->GetGlobalPropertyAsBool("TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
+  this->ArchivesMayBeShared =
+    this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+      "TARGET_ARCHIVES_MAY_BE_SHARED_LIBS");
 
   // First assume we cannot do link type stuff.
   this->LinkTypeEnabled = false;
@@ -804,15 +728,20 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
   const char* static_link_type_flag = 0;
   const char* shared_link_type_flag = 0;
   const char* target_type_str = 0;
-  switch(this->Target->GetType())
-    {
-    case cmState::EXECUTABLE:     target_type_str = "EXE"; break;
-    case cmState::SHARED_LIBRARY: target_type_str = "SHARED_LIBRARY"; break;
-    case cmState::MODULE_LIBRARY: target_type_str = "SHARED_MODULE"; break;
-    default: break;
-    }
-  if(target_type_str)
-    {
+  switch (this->Target->GetType()) {
+    case cmState::EXECUTABLE:
+      target_type_str = "EXE";
+      break;
+    case cmState::SHARED_LIBRARY:
+      target_type_str = "SHARED_LIBRARY";
+      break;
+    case cmState::MODULE_LIBRARY:
+      target_type_str = "SHARED_MODULE";
+      break;
+    default:
+      break;
+  }
+  if (target_type_str) {
     std::string static_link_type_flag_var = "CMAKE_";
     static_link_type_flag_var += target_type_str;
     static_link_type_flag_var += "_LINK_STATIC_";
@@ -828,22 +757,20 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
     shared_link_type_flag_var += "_FLAGS";
     shared_link_type_flag =
       this->Makefile->GetDefinition(shared_link_type_flag_var);
-    }
+  }
 
   // We can support link type switching only if all needed flags are
   // known.
-  if(static_link_type_flag && *static_link_type_flag &&
-     shared_link_type_flag && *shared_link_type_flag)
-    {
+  if (static_link_type_flag && *static_link_type_flag &&
+      shared_link_type_flag && *shared_link_type_flag) {
     this->LinkTypeEnabled = true;
     this->StaticLinkTypeFlag = static_link_type_flag;
     this->SharedLinkTypeFlag = shared_link_type_flag;
-    }
+  }
 
   // Lookup the starting link type from the target (linked statically?).
-  const char* lss =
-      this->Target->GetProperty("LINK_SEARCH_START_STATIC");
-  this->StartLinkType = cmSystemTools::IsOn(lss)? LinkStatic : LinkShared;
+  const char* lss = this->Target->GetProperty("LINK_SEARCH_START_STATIC");
+  this->StartLinkType = cmSystemTools::IsOn(lss) ? LinkStatic : LinkShared;
   this->CurrentLinkType = this->StartLinkType;
 }
 
@@ -864,50 +791,44 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
                          LinkShared);
   this->AddLinkExtension(mf->GetDefinition("CMAKE_LINK_LIBRARY_SUFFIX"),
                          LinkUnknown);
-  if(const char* linkSuffixes =
-     mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS"))
-    {
+  if (const char* linkSuffixes =
+        mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) {
     std::vector<std::string> linkSuffixVec;
     cmSystemTools::ExpandListArgument(linkSuffixes, linkSuffixVec);
-    for(std::vector<std::string>::iterator i = linkSuffixVec.begin();
-        i != linkSuffixVec.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = linkSuffixVec.begin();
+         i != linkSuffixVec.end(); ++i) {
       this->AddLinkExtension(i->c_str(), LinkUnknown);
-      }
     }
-  if(const char* sharedSuffixes =
-     mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES"))
-    {
+  }
+  if (const char* sharedSuffixes =
+        mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) {
     std::vector<std::string> sharedSuffixVec;
     cmSystemTools::ExpandListArgument(sharedSuffixes, sharedSuffixVec);
-    for(std::vector<std::string>::iterator i = sharedSuffixVec.begin();
-        i != sharedSuffixVec.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = sharedSuffixVec.begin();
+         i != sharedSuffixVec.end(); ++i) {
       this->AddLinkExtension(i->c_str(), LinkShared);
-      }
     }
+  }
 
   // Compute a regex to match link extensions.
-  std::string libext = this->CreateExtensionRegex(this->LinkExtensions,
-                                                  LinkUnknown);
+  std::string libext =
+    this->CreateExtensionRegex(this->LinkExtensions, LinkUnknown);
 
   // Create regex to remove any library extension.
   std::string reg("(.*)");
   reg += libext;
-  this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions,
-                                                    reg);
+  this->OrderLinkerSearchPath->SetLinkExtensionInfo(this->LinkExtensions, reg);
 
   // Create a regex to match a library name.  Match index 1 will be
   // the prefix if it exists and empty otherwise.  Match index 2 will
   // be the library name.  Match index 3 will be the library
   // extension.
   reg = "^(";
-  for(std::set<std::string>::iterator p = this->LinkPrefixes.begin();
-      p != this->LinkPrefixes.end(); ++p)
-    {
+  for (std::set<std::string>::iterator p = this->LinkPrefixes.begin();
+       p != this->LinkPrefixes.end(); ++p) {
     reg += *p;
     reg += "|";
-    }
+  }
   reg += ")";
   reg += "([^/:]*)";
 
@@ -920,65 +841,57 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
   this->ExtractAnyLibraryName.compile(reg_any.c_str());
 
   // Create a regex to match static library names.
-  if(!this->StaticLinkExtensions.empty())
-    {
+  if (!this->StaticLinkExtensions.empty()) {
     std::string reg_static = reg;
-    reg_static += this->CreateExtensionRegex(this->StaticLinkExtensions,
-                                             LinkStatic);
+    reg_static +=
+      this->CreateExtensionRegex(this->StaticLinkExtensions, LinkStatic);
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
-  fprintf(stderr, "static regex [%s]\n", reg_static.c_str());
+    fprintf(stderr, "static regex [%s]\n", reg_static.c_str());
 #endif
     this->ExtractStaticLibraryName.compile(reg_static.c_str());
-    }
+  }
 
   // Create a regex to match shared library names.
-  if(!this->SharedLinkExtensions.empty())
-    {
+  if (!this->SharedLinkExtensions.empty()) {
     std::string reg_shared = reg;
     this->SharedRegexString =
       this->CreateExtensionRegex(this->SharedLinkExtensions, LinkShared);
     reg_shared += this->SharedRegexString;
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
-  fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str());
+    fprintf(stderr, "shared regex [%s]\n", reg_shared.c_str());
 #endif
     this->ExtractSharedLibraryName.compile(reg_shared.c_str());
-    }
+  }
 }
 
 void cmComputeLinkInformation::AddLinkPrefix(const char* p)
 {
-  if(p && *p)
-    {
+  if (p && *p) {
     this->LinkPrefixes.insert(p);
-    }
+  }
 }
 
 void cmComputeLinkInformation::AddLinkExtension(const char* e, LinkType type)
 {
-  if(e && *e)
-    {
-    if(type == LinkStatic)
-      {
+  if (e && *e) {
+    if (type == LinkStatic) {
       this->StaticLinkExtensions.push_back(e);
-      }
-    if(type == LinkShared)
-      {
+    }
+    if (type == LinkShared) {
       this->SharedLinkExtensions.push_back(e);
-      }
-    this->LinkExtensions.push_back(e);
     }
+    this->LinkExtensions.push_back(e);
+  }
 }
 
-std::string
-cmComputeLinkInformation
-::CreateExtensionRegex(std::vector<std::string> const& exts, LinkType type)
+std::string cmComputeLinkInformation::CreateExtensionRegex(
+  std::vector<std::string> const& exts, LinkType type)
 {
   // Build a list of extension choices.
   std::string libext = "(";
   const char* sep = "";
-  for(std::vector<std::string>::const_iterator i = exts.begin();
-      i != exts.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = exts.begin();
+       i != exts.end(); ++i) {
     // Separate this choice from the previous one.
     libext += sep;
     sep = "|";
@@ -990,20 +903,17 @@ cmComputeLinkInformation
 #else
     libext += *i;
 #endif
-    }
+  }
 
   // Finish the list.
   libext += ")";
 
   // Add an optional OpenBSD version component.
-  if(this->OpenBSD)
-    {
+  if (this->OpenBSD) {
     libext += "(\\.[0-9]+\\.[0-9]+)?";
-    }
-  else if(type == LinkShared)
-    {
+  } else if (type == LinkShared) {
     libext += "(\\.[0-9]+)?";
-    }
+  }
 
   libext += "$";
   return libext;
@@ -1013,21 +923,17 @@ std::string cmComputeLinkInformation::NoCaseExpression(const char* str)
 {
   std::string ret;
   const char* s = str;
-  while(*s)
-    {
-    if(*s == '.')
-      {
+  while (*s) {
+    if (*s == '.') {
       ret += *s;
-      }
-    else
-      {
+    } else {
       ret += "[";
       ret += static_cast<char>(tolower(*s));
       ret += static_cast<char>(toupper(*s));
       ret += "]";
-      }
-    s++;
     }
+    s++;
+  }
   return ret;
 }
 
@@ -1035,14 +941,11 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
 {
   // If we are changing the current link type add the flag to tell the
   // linker about it.
-  if(this->CurrentLinkType != lt)
-    {
+  if (this->CurrentLinkType != lt) {
     this->CurrentLinkType = lt;
 
-    if(this->LinkTypeEnabled)
-      {
-      switch(this->CurrentLinkType)
-        {
+    if (this->LinkTypeEnabled) {
+      switch (this->CurrentLinkType) {
         case LinkStatic:
           this->Items.push_back(Item(this->StaticLinkTypeFlag, false));
           break;
@@ -1051,9 +954,9 @@ void cmComputeLinkInformation::SetCurrentLinkType(LinkType lt)
           break;
         default:
           break;
-        }
       }
     }
+  }
 }
 
 void cmComputeLinkInformation::AddTargetItem(std::string const& item,
@@ -1065,39 +968,34 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item,
   // shared and static libraries but static-mode can handle only
   // static libraries.  If a previous user item changed the link type
   // to static we need to make sure it is back to shared.
-  if(target->GetType() != cmState::STATIC_LIBRARY)
-    {
+  if (target->GetType() != cmState::STATIC_LIBRARY) {
     this->SetCurrentLinkType(LinkShared);
-    }
+  }
 
   // Keep track of shared library targets linked.
-  if(target->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (target->GetType() == cmState::SHARED_LIBRARY) {
     this->SharedLibrariesLinked.insert(target);
-    }
+  }
 
   // Handle case of an imported shared library with no soname.
-  if(this->NoSONameUsesPath &&
-     target->IsImportedSharedLibWithoutSOName(this->Config))
-    {
+  if (this->NoSONameUsesPath &&
+      target->IsImportedSharedLibWithoutSOName(this->Config)) {
     this->AddSharedLibNoSOName(item);
     return;
-    }
+  }
 
   // If this platform wants a flag before the full path, add it.
-  if(!this->LibLinkFileFlag.empty())
-    {
+  if (!this->LibLinkFileFlag.empty()) {
     this->Items.push_back(Item(this->LibLinkFileFlag, false));
-    }
+  }
 
   // For compatibility with CMake 2.4 include the item's directory in
   // the linker search path.
-  if(this->OldLinkDirMode && !target->IsFrameworkOnApple() &&
-     this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
-     this->OldLinkDirMask.end())
-    {
+  if (this->OldLinkDirMode && !target->IsFrameworkOnApple() &&
+      this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
+        this->OldLinkDirMask.end()) {
     this->OldLinkDirItems.push_back(item);
-    }
+  }
 
   // Now add the full path to the library.
   this->Items.push_back(Item(item, true, target));
@@ -1106,31 +1004,27 @@ void cmComputeLinkInformation::AddTargetItem(std::string const& item,
 void cmComputeLinkInformation::AddFullItem(std::string const& item)
 {
   // Check for the implicit link directory special case.
-  if(this->CheckImplicitDirItem(item))
-    {
+  if (this->CheckImplicitDirItem(item)) {
     return;
-    }
+  }
 
   // Check for case of shared library with no builtin soname.
-  if(this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item))
-    {
+  if (this->NoSONameUsesPath && this->CheckSharedLibNoSOName(item)) {
     return;
-    }
+  }
 
   // Full path libraries should specify a valid library file name.
   // See documentation of CMP0008.
   std::string generator = this->GlobalGenerator->GetName();
-  if(this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
-     (generator.find("Visual Studio") != generator.npos ||
-      generator.find("Xcode") != generator.npos))
-    {
+  if (this->Target->GetPolicyStatusCMP0008() != cmPolicies::NEW &&
+      (generator.find("Visual Studio") != generator.npos ||
+       generator.find("Xcode") != generator.npos)) {
     std::string file = cmSystemTools::GetFilenameName(item);
-    if(!this->ExtractAnyLibraryName.find(file.c_str()))
-      {
+    if (!this->ExtractAnyLibraryName.find(file.c_str())) {
       this->HandleBadFullItem(item, file);
       return;
-      }
     }
+  }
 
   // This is called to handle a link item that is a full path.
   // If the target is not a static library make sure the link type is
@@ -1138,35 +1032,29 @@ void cmComputeLinkInformation::AddFullItem(std::string const& item)
   // shared and static libraries but static-mode can handle only
   // static libraries.  If a previous user item changed the link type
   // to static we need to make sure it is back to shared.
-  if(this->LinkTypeEnabled)
-    {
+  if (this->LinkTypeEnabled) {
     std::string name = cmSystemTools::GetFilenameName(item);
-    if(this->ExtractSharedLibraryName.find(name))
-      {
+    if (this->ExtractSharedLibraryName.find(name)) {
       this->SetCurrentLinkType(LinkShared);
-      }
-    else if(!this->ExtractStaticLibraryName.find(item))
-      {
+    } else if (!this->ExtractStaticLibraryName.find(item)) {
       // We cannot determine the type.  Assume it is the target's
       // default type.
       this->SetCurrentLinkType(this->StartLinkType);
-      }
     }
+  }
 
   // For compatibility with CMake 2.4 include the item's directory in
   // the linker search path.
-  if(this->OldLinkDirMode &&
-     this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
-     this->OldLinkDirMask.end())
-    {
+  if (this->OldLinkDirMode &&
+      this->OldLinkDirMask.find(cmSystemTools::GetFilenamePath(item)) ==
+        this->OldLinkDirMask.end()) {
     this->OldLinkDirItems.push_back(item);
-    }
+  }
 
   // If this platform wants a flag before the full path, add it.
-  if(!this->LibLinkFileFlag.empty())
-    {
+  if (!this->LibLinkFileFlag.empty()) {
     this->Items.push_back(Item(this->LibLinkFileFlag, false));
-    }
+  }
 
   // Now add the full path to the library.
   this->Items.push_back(Item(item, true));
@@ -1177,49 +1065,43 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
   // We only switch to a pathless item if the link type may be
   // enforced.  Fortunately only platforms that support link types
   // seem to have magic per-architecture implicit link directories.
-  if(!this->LinkTypeEnabled)
-    {
+  if (!this->LinkTypeEnabled) {
     return false;
-    }
+  }
 
   // Check if this item is in an implicit link directory.
   std::string dir = cmSystemTools::GetFilenamePath(item);
-  if(this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end())
-    {
+  if (this->ImplicitLinkDirs.find(dir) == this->ImplicitLinkDirs.end()) {
     // Only libraries in implicit link directories are converted to
     // pathless items.
     return false;
-    }
+  }
 
   // Only apply the policy below if the library file is one that can
   // be found by the linker.
   std::string file = cmSystemTools::GetFilenameName(item);
-  if(!this->ExtractAnyLibraryName.find(file))
-    {
+  if (!this->ExtractAnyLibraryName.find(file)) {
     return false;
-    }
+  }
 
   // Check the policy for whether we should use the approach below.
-  switch (this->Target->GetPolicyStatusCMP0060())
-    {
+  switch (this->Target->GetPolicyStatusCMP0060()) {
     case cmPolicies::WARN:
-      if (this->CMP0060Warn)
-        {
+      if (this->CMP0060Warn) {
         // Print the warning at most once for this item.
         std::string const& wid = "CMP0060-WARNING-GIVEN-" + item;
-        if (!this->CMakeInstance->GetPropertyAsBool(wid))
-          {
+        if (!this->CMakeInstance->GetPropertyAsBool(wid)) {
           this->CMakeInstance->SetProperty(wid, "1");
           this->CMP0060WarnItems.insert(item);
-          }
         }
+      }
     case cmPolicies::OLD:
       break;
     case cmPolicies::REQUIRED_ALWAYS:
     case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::NEW:
       return false;
-    }
+  }
 
   // Many system linkers support multiple architectures by
   // automatically selecting the implicit linker search path for the
@@ -1247,17 +1129,15 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
   //   libfoo.a  ==>  -Wl,-Bstatic -lfoo
 
   // Pass flags through untouched.
-  if(item[0] == '-' || item[0] == '$' || item[0] == '`')
-    {
+  if (item[0] == '-' || item[0] == '$' || item[0] == '`') {
     // if this is a -l option then we might need to warn about
     // CMP0003 so put it in OldUserFlagItems, if it is not a -l
     // or -Wl,-l (-framework -pthread), then allow it without a
     // CMP0003 as -L will not affect those other linker flags
-    if(item.find("-l") == 0 ||  item.find("-Wl,-l") == 0)
-      {
+    if (item.find("-l") == 0 || item.find("-Wl,-l") == 0) {
       // This is a linker option provided by the user.
       this->OldUserFlagItems.push_back(item);
-      }
+    }
 
     // Restore the target link type since this item does not specify
     // one.
@@ -1266,7 +1146,7 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
     // Use the item verbatim.
     this->Items.push_back(Item(item, false));
     return;
-    }
+  }
 
   // Parse out the prefix, base, and suffix components of the
   // library name.  If the name matches that of a shared or static
@@ -1279,9 +1159,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
   // libraries.  On AIX a library with the name libfoo.a can be
   // shared!
   std::string lib;
-  if(this->ExtractSharedLibraryName.find(item))
-    {
-    // This matches a shared library file name.
+  if (this->ExtractSharedLibraryName.find(item)) {
+// This matches a shared library file name.
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
     fprintf(stderr, "shared regex matched [%s] [%s] [%s]\n",
             this->ExtractSharedLibraryName.match(1).c_str(),
@@ -1293,10 +1172,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 
     // Use just the library name so the linker will search.
     lib = this->ExtractSharedLibraryName.match(2);
-    }
-  else if(this->ExtractStaticLibraryName.find(item))
-    {
-    // This matches a static library file name.
+  } else if (this->ExtractStaticLibraryName.find(item)) {
+// This matches a static library file name.
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
     fprintf(stderr, "static regex matched [%s] [%s] [%s]\n",
             this->ExtractStaticLibraryName.match(1).c_str(),
@@ -1308,10 +1185,8 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 
     // Use just the library name so the linker will search.
     lib = this->ExtractStaticLibraryName.match(2);
-    }
-  else if(this->ExtractAnyLibraryName.find(item))
-    {
-    // This matches a library file name.
+  } else if (this->ExtractAnyLibraryName.find(item)) {
+// This matches a library file name.
 #ifdef CM_COMPUTE_LINK_INFO_DEBUG
     fprintf(stderr, "any regex matched [%s] [%s] [%s]\n",
             this->ExtractAnyLibraryName.match(1).c_str(),
@@ -1324,21 +1199,18 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 
     // Use just the library name so the linker will search.
     lib = this->ExtractAnyLibraryName.match(2);
-    }
-  else
-    {
+  } else {
     // This is a name specified by the user.
-    if(pathNotKnown)
-      {
+    if (pathNotKnown) {
       this->OldUserFlagItems.push_back(item);
-      }
+    }
 
     // We must ask the linker to search for a library with this name.
     // Restore the target link type since this item does not specify
     // one.
     this->SetCurrentLinkType(this->StartLinkType);
     lib = item;
-    }
+  }
 
   // Create an option to ask the linker to search for the library.
   std::string out = this->LibLinkFlag;
@@ -1355,14 +1227,13 @@ void cmComputeLinkInformation::AddUserItem(std::string const& item,
 void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
 {
   // Try to separate the framework name and path.
-  if(!this->SplitFramework.find(item.c_str()))
-    {
+  if (!this->SplitFramework.find(item.c_str())) {
     std::ostringstream e;
     e << "Could not parse framework path \"" << item << "\" "
       << "linked by target " << this->Target->GetName() << ".";
     cmSystemTools::Error(e.str().c_str());
     return;
-    }
+  }
 
   std::string fw_path = this->SplitFramework.match(1);
   std::string fw = this->SplitFramework.match(2);
@@ -1388,15 +1259,12 @@ void cmComputeLinkInformation::AddFrameworkItem(std::string const& item)
 
 void cmComputeLinkInformation::AddDirectoryItem(std::string const& item)
 {
-  if(this->Makefile->IsOn("APPLE")
-     && cmSystemTools::IsPathToFramework(item.c_str()))
-    {
+  if (this->Makefile->IsOn("APPLE") &&
+      cmSystemTools::IsPathToFramework(item.c_str())) {
     this->AddFrameworkItem(item);
-    }
-  else
-    {
+  } else {
     this->DropDirectoryItem(item);
-    }
+  }
 }
 
 void cmComputeLinkInformation::DropDirectoryItem(std::string const& item)
@@ -1417,21 +1285,19 @@ void cmComputeLinkInformation::ComputeFrameworkInfo()
   std::vector<std::string> implicitDirVec;
 
   // Get platform-wide implicit directories.
-  if(const char* implicitLinks = this->Makefile->GetDefinition
-     ("CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES"))
-    {
+  if (const char* implicitLinks = this->Makefile->GetDefinition(
+        "CMAKE_PLATFORM_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES")) {
     cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec);
-    }
+  }
 
   // Get language-specific implicit directories.
   std::string implicitDirVar = "CMAKE_";
   implicitDirVar += this->LinkLanguage;
   implicitDirVar += "_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES";
-  if(const char* implicitDirs =
-     this->Makefile->GetDefinition(implicitDirVar))
-    {
+  if (const char* implicitDirs =
+        this->Makefile->GetDefinition(implicitDirVar)) {
     cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec);
-    }
+  }
 
   this->FrameworkPathsEmmitted.insert(implicitDirVec.begin(),
                                       implicitDirVec.end());
@@ -1442,10 +1308,9 @@ void cmComputeLinkInformation::ComputeFrameworkInfo()
 
 void cmComputeLinkInformation::AddFrameworkPath(std::string const& p)
 {
-  if(this->FrameworkPathsEmmitted.insert(p).second)
-    {
+  if (this->FrameworkPathsEmmitted.insert(p).second) {
     this->FrameworkPaths.push_back(p);
-    }
+  }
 }
 
 bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
@@ -1454,18 +1319,16 @@ bool cmComputeLinkInformation::CheckSharedLibNoSOName(std::string const& item)
   // library is given via path and was not built with an soname.  If
   // this is a shared library that might be the case.
   std::string file = cmSystemTools::GetFilenameName(item);
-  if(this->ExtractSharedLibraryName.find(file))
-    {
+  if (this->ExtractSharedLibraryName.find(file)) {
     // If we can guess the soname fairly reliably then assume the
     // library has one.  Otherwise assume the library has no builtin
     // soname.
     std::string soname;
-    if(!cmSystemTools::GuessLibrarySOName(item, soname))
-      {
+    if (!cmSystemTools::GuessLibrarySOName(item, soname)) {
       this->AddSharedLibNoSOName(item);
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -1489,10 +1352,9 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
   // Do not depend on things that do not exist.
   std::vector<std::string>::iterator i =
     std::find(this->Depends.begin(), this->Depends.end(), item);
-  if(i != this->Depends.end())
-    {
+  if (i != this->Depends.end()) {
     this->Depends.erase(i);
-    }
+  }
 
   // Tell the linker to search for the item and provide the proper
   // path for it.  Do not contribute to any CMP0003 warning (do not
@@ -1501,16 +1363,12 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
   this->OrderLinkerSearchPath->AddLinkLibrary(item);
 
   // Produce any needed message.
-  switch(this->Target->GetPolicyStatusCMP0008())
-    {
-    case cmPolicies::WARN:
-      {
+  switch (this->Target->GetPolicyStatusCMP0008()) {
+    case cmPolicies::WARN: {
       // Print the warning at most once for this item.
       std::string wid = "CMP0008-WARNING-GIVEN-";
       wid += item;
-      if(!this->CMakeInstance->GetState()
-              ->GetGlobalPropertyAsBool(wid))
-        {
+      if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(wid)) {
         this->CMakeInstance->GetState()->SetGlobalProperty(wid, "1");
         std::ostringstream w;
         /* clang-format off */
@@ -1520,9 +1378,9 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
           << "which is a full-path but not a valid library file name.";
         /* clang-format on */
         this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
-                                        this->Target->GetBacktrace());
-        }
+                                          this->Target->GetBacktrace());
       }
+    }
     case cmPolicies::OLD:
       // OLD behavior does not warn.
       break;
@@ -1530,8 +1388,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
       // NEW behavior will not get here.
       break;
     case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      {
+    case cmPolicies::REQUIRED_ALWAYS: {
       std::ostringstream e;
       /* clang-format off */
       e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0008) << "\n"
@@ -1541,34 +1398,30 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
       /* clang-format on */
       this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
                                         this->Target->GetBacktrace());
-      }
-      break;
-    }
+    } break;
+  }
 }
 
 bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
 {
   // Support broken projects if necessary.
-  if(this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() ||
-     !this->OldLinkDirMode)
-    {
+  if (this->OldLinkDirItems.empty() || this->OldUserFlagItems.empty() ||
+      !this->OldLinkDirMode) {
     return true;
-    }
+  }
 
   // Enforce policy constraints.
-  switch(this->Target->GetPolicyStatusCMP0003())
-    {
+  switch (this->Target->GetPolicyStatusCMP0003()) {
     case cmPolicies::WARN:
-      if(!this->CMakeInstance->GetState()
-              ->GetGlobalPropertyAsBool("CMP0003-WARNING-GIVEN"))
-        {
-        this->CMakeInstance->GetState()
-            ->SetGlobalProperty("CMP0003-WARNING-GIVEN", "1");
+      if (!this->CMakeInstance->GetState()->GetGlobalPropertyAsBool(
+            "CMP0003-WARNING-GIVEN")) {
+        this->CMakeInstance->GetState()->SetGlobalProperty(
+          "CMP0003-WARNING-GIVEN", "1");
         std::ostringstream w;
         this->PrintLinkPolicyDiagnosis(w);
         this->CMakeInstance->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
-                                        this->Target->GetBacktrace());
-        }
+                                          this->Target->GetBacktrace());
+      }
     case cmPolicies::OLD:
       // OLD behavior is to add the paths containing libraries with
       // known full paths as link directories.
@@ -1577,24 +1430,22 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
       // Should never happen due to assignment of OldLinkDirMode
       return true;
     case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      {
+    case cmPolicies::REQUIRED_ALWAYS: {
       std::ostringstream e;
       e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n";
       this->PrintLinkPolicyDiagnosis(e);
       this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
                                         this->Target->GetBacktrace());
       return false;
-      }
     }
+  }
 
   // Add the link directories for full path items.
-  for(std::vector<std::string>::const_iterator
-        i = this->OldLinkDirItems.begin();
-      i != this->OldLinkDirItems.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i =
+         this->OldLinkDirItems.begin();
+       i != this->OldLinkDirItems.end(); ++i) {
     this->OrderLinkerSearchPath->AddLinkLibrary(*i);
-    }
+  }
   return true;
 }
 
@@ -1612,52 +1463,47 @@ void cmComputeLinkInformation::PrintLinkPolicyDiagnosis(std::ostream& os)
   /* clang-format on */
 
   // List the items that might need the old-style paths.
-  os << "This warning appears because target \""
-     << this->Target->GetName() << "\" "
+  os << "This warning appears because target \"" << this->Target->GetName()
+     << "\" "
      << "links to some libraries for which the linker must search:\n";
   {
-  // Format the list of unknown items to be as short as possible while
-  // still fitting in the allowed width (a true solution would be the
-  // bin packing problem if we were allowed to change the order).
-  std::string::size_type max_size = 76;
-  std::string line;
-  const char* sep = "  ";
-  for(std::vector<std::string>::const_iterator
-        i = this->OldUserFlagItems.begin();
-      i != this->OldUserFlagItems.end(); ++i)
-    {
-    // If the addition of another item will exceed the limit then
-    // output the current line and reset it.  Note that the separator
-    // is either " " or ", " which is always 2 characters.
-    if(!line.empty() && (line.size() + i->size() + 2) > max_size)
-      {
-      os << line << "\n";
-      sep = "  ";
-      line = "";
+    // Format the list of unknown items to be as short as possible while
+    // still fitting in the allowed width (a true solution would be the
+    // bin packing problem if we were allowed to change the order).
+    std::string::size_type max_size = 76;
+    std::string line;
+    const char* sep = "  ";
+    for (std::vector<std::string>::const_iterator i =
+           this->OldUserFlagItems.begin();
+         i != this->OldUserFlagItems.end(); ++i) {
+      // If the addition of another item will exceed the limit then
+      // output the current line and reset it.  Note that the separator
+      // is either " " or ", " which is always 2 characters.
+      if (!line.empty() && (line.size() + i->size() + 2) > max_size) {
+        os << line << "\n";
+        sep = "  ";
+        line = "";
       }
-    line += sep;
-    line += *i;
-    // Convert to the other separator.
-    sep = ", ";
+      line += sep;
+      line += *i;
+      // Convert to the other separator.
+      sep = ", ";
     }
-  if(!line.empty())
-    {
-    os << line << "\n";
+    if (!line.empty()) {
+      os << line << "\n";
     }
   }
 
   // List the paths old behavior is adding.
   os << "and other libraries with known full path:\n";
   std::set<std::string> emitted;
-  for(std::vector<std::string>::const_iterator
-        i = this->OldLinkDirItems.begin();
-      i != this->OldLinkDirItems.end(); ++i)
-    {
-    if(emitted.insert(cmSystemTools::GetFilenamePath(*i)).second)
-      {
+  for (std::vector<std::string>::const_iterator i =
+         this->OldLinkDirItems.begin();
+       i != this->OldLinkDirItems.end(); ++i) {
+    if (emitted.insert(cmSystemTools::GetFilenamePath(*i)).second) {
       os << "  " << *i << "\n";
-      }
     }
+  }
 
   // Explain.
   os << "CMake is adding directories in the second list to the linker "
@@ -1673,34 +1519,29 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
   std::vector<std::string> implicitDirVec;
 
   // Get platform-wide implicit directories.
-  if(const char* implicitLinks =
-     (this->Makefile->GetDefinition
-      ("CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES")))
-    {
+  if (const char* implicitLinks = (this->Makefile->GetDefinition(
+        "CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES"))) {
     cmSystemTools::ExpandListArgument(implicitLinks, implicitDirVec);
-    }
+  }
 
   // Append library architecture to all implicit platform directories
   // and add them to the set
-  if(const char* libraryArch =
-     this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE"))
-    {
+  if (const char* libraryArch =
+        this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
     for (std::vector<std::string>::const_iterator i = implicitDirVec.begin();
-         i != implicitDirVec.end(); ++i)
-      {
+         i != implicitDirVec.end(); ++i) {
       this->ImplicitLinkDirs.insert(*i + "/" + libraryArch);
-      }
     }
+  }
 
   // Get language-specific implicit directories.
   std::string implicitDirVar = "CMAKE_";
   implicitDirVar += this->LinkLanguage;
   implicitDirVar += "_IMPLICIT_LINK_DIRECTORIES";
-  if(const char* implicitDirs =
-     this->Makefile->GetDefinition(implicitDirVar))
-    {
+  if (const char* implicitDirs =
+        this->Makefile->GetDefinition(implicitDirVar)) {
     cmSystemTools::ExpandListArgument(implicitDirs, implicitDirVec);
-    }
+  }
 
   // Store implicit link directories.
   this->ImplicitLinkDirs.insert(implicitDirVec.begin(), implicitDirVec.end());
@@ -1710,32 +1551,27 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
   std::string implicitLibVar = "CMAKE_";
   implicitLibVar += this->LinkLanguage;
   implicitLibVar += "_IMPLICIT_LINK_LIBRARIES";
-  if(const char* implicitLibs =
-     this->Makefile->GetDefinition(implicitLibVar))
-    {
+  if (const char* implicitLibs =
+        this->Makefile->GetDefinition(implicitLibVar)) {
     cmSystemTools::ExpandListArgument(implicitLibs, implicitLibVec);
-    }
+  }
 
   // Store implicit link libraries.
-  for(std::vector<std::string>::const_iterator i = implicitLibVec.begin();
-      i != implicitLibVec.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = implicitLibVec.begin();
+       i != implicitLibVec.end(); ++i) {
     // Items starting in '-' but not '-l' are flags, not libraries,
     // and should not be filtered by this implicit list.
     std::string const& item = *i;
-    if(item[0] != '-' || item[1] == 'l')
-      {
+    if (item[0] != '-' || item[1] == 'l') {
       this->ImplicitLinkLibs.insert(item);
-      }
     }
+  }
 
   // Get platform specific rpath link directories
-  if(const char *rpathDirs =
-     (this->Makefile->GetDefinition
-      ("CMAKE_PLATFORM_RUNTIME_PATH")))
-    {
+  if (const char* rpathDirs =
+        (this->Makefile->GetDefinition("CMAKE_PLATFORM_RUNTIME_PATH"))) {
     cmSystemTools::ExpandListArgument(rpathDirs, this->RuntimeLinkDirs);
-    }
+  }
 }
 
 std::vector<std::string> const&
@@ -1744,113 +1580,96 @@ cmComputeLinkInformation::GetRuntimeSearchPath()
   return this->OrderRuntimeSearchPath->GetOrderedDirectories();
 }
 
-void
-cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath,
-                                              cmGeneratorTarget const* target)
+void cmComputeLinkInformation::AddLibraryRuntimeInfo(
+  std::string const& fullPath, cmGeneratorTarget const* target)
 {
   // Ignore targets on Apple where install_name is not @rpath.
   // The dependenty library can be found with other means such as
   // @loader_path or full paths.
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
-    if(!target->HasMacOSXRpathInstallNameDir(this->Config))
-      {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    if (!target->HasMacOSXRpathInstallNameDir(this->Config)) {
       return;
-      }
     }
+  }
 
   // Libraries with unknown type must be handled using just the file
   // on disk.
-  if(target->GetType() == cmState::UNKNOWN_LIBRARY)
-    {
+  if (target->GetType() == cmState::UNKNOWN_LIBRARY) {
     this->AddLibraryRuntimeInfo(fullPath);
     return;
-    }
+  }
 
   // Skip targets that are not shared libraries (modules cannot be linked).
-  if(target->GetType() != cmState::SHARED_LIBRARY)
-    {
+  if (target->GetType() != cmState::SHARED_LIBRARY) {
     return;
-    }
+  }
 
   // Try to get the soname of the library.  Only files with this name
   // could possibly conflict.
   std::string soName = target->GetSOName(this->Config);
-  const char* soname = soName.empty()? 0 : soName.c_str();
+  const char* soname = soName.empty() ? 0 : soName.c_str();
 
   // Include this library in the runtime path ordering.
   this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath, soname);
-  if(this->LinkWithRuntimePath)
-    {
+  if (this->LinkWithRuntimePath) {
     this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath, soname);
-    }
+  }
 }
 
-void
-cmComputeLinkInformation::AddLibraryRuntimeInfo(std::string const& fullPath)
+void cmComputeLinkInformation::AddLibraryRuntimeInfo(
+  std::string const& fullPath)
 {
   // Get the name of the library from the file name.
   bool is_shared_library = false;
   std::string file = cmSystemTools::GetFilenameName(fullPath);
 
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
     // Check that @rpath is part of the install name.
     // If it isn't, return.
     std::string soname;
-    if(!cmSystemTools::GuessLibraryInstallName(fullPath, soname))
-      {
+    if (!cmSystemTools::GuessLibraryInstallName(fullPath, soname)) {
       return;
-      }
+    }
 
-    if(soname.find("@rpath") == std::string::npos)
-      {
+    if (soname.find("@rpath") == std::string::npos) {
       return;
-      }
     }
+  }
 
   is_shared_library = this->ExtractSharedLibraryName.find(file);
 
-  if(!is_shared_library)
-    {
+  if (!is_shared_library) {
     // On some platforms (AIX) a shared library may look static.
-    if(this->ArchivesMayBeShared)
-      {
-      if(this->ExtractStaticLibraryName.find(file.c_str()))
-        {
+    if (this->ArchivesMayBeShared) {
+      if (this->ExtractStaticLibraryName.find(file.c_str())) {
         // This is the name of a shared library or archive.
         is_shared_library = true;
-        }
       }
     }
+  }
 
   // It could be an Apple framework
-  if(!is_shared_library)
-    {
-    if(fullPath.find(".framework") != std::string::npos)
-      {
-      static cmsys::RegularExpression
-        splitFramework("^(.*)/(.*).framework/(.*)$");
-      if(splitFramework.find(fullPath) &&
-        (std::string::npos !=
-         splitFramework.match(3).find(splitFramework.match(2))))
-        {
+  if (!is_shared_library) {
+    if (fullPath.find(".framework") != std::string::npos) {
+      static cmsys::RegularExpression splitFramework(
+        "^(.*)/(.*).framework/(.*)$");
+      if (splitFramework.find(fullPath) &&
+          (std::string::npos !=
+           splitFramework.match(3).find(splitFramework.match(2)))) {
         is_shared_library = true;
-        }
       }
     }
+  }
 
-  if(!is_shared_library)
-    {
+  if (!is_shared_library) {
     return;
-    }
+  }
 
   // Include this library in the runtime path ordering.
   this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath);
-  if(this->LinkWithRuntimePath)
-    {
+  if (this->LinkWithRuntimePath) {
     this->OrderLinkerSearchPath->AddRuntimeLibrary(fullPath);
-    }
+  }
 }
 
 static void cmCLI_ExpandListUnique(const char* str,
@@ -1859,13 +1678,12 @@ static void cmCLI_ExpandListUnique(const char* str,
 {
   std::vector<std::string> tmp;
   cmSystemTools::ExpandListArgument(str, tmp);
-  for(std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end(); ++i)
-    {
-    if(emitted.insert(*i).second)
-      {
+  for (std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end();
+       ++i) {
+    if (emitted.insert(*i).second) {
       out.push_back(*i);
-      }
     }
+  }
 }
 
 void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
@@ -1886,103 +1704,82 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
   bool use_build_rpath =
     (outputRuntime && this->Target->HaveBuildTreeRPATH(this->Config) &&
      !linking_for_install);
-  bool use_link_rpath =
-    outputRuntime && linking_for_install &&
+  bool use_link_rpath = outputRuntime && linking_for_install &&
     !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH") &&
     this->Target->GetPropertyAsBool("INSTALL_RPATH_USE_LINK_PATH");
 
   // Construct the RPATH.
   std::set<std::string> emitted;
-  if(use_install_rpath)
-    {
-    const char* install_rpath =
-        this->Target->GetProperty("INSTALL_RPATH");
+  if (use_install_rpath) {
+    const char* install_rpath = this->Target->GetProperty("INSTALL_RPATH");
     cmCLI_ExpandListUnique(install_rpath, runtimeDirs, emitted);
-    }
-  if(use_build_rpath || use_link_rpath)
-    {
+  }
+  if (use_build_rpath || use_link_rpath) {
     std::string rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
-    const char *stagePath
-                  = this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
-    const char *installPrefix
-                  = this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
+    const char* stagePath =
+      this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
+    const char* installPrefix =
+      this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
     cmSystemTools::ConvertToUnixSlashes(rootPath);
     std::vector<std::string> const& rdirs = this->GetRuntimeSearchPath();
-    for(std::vector<std::string>::const_iterator ri = rdirs.begin();
-        ri != rdirs.end(); ++ri)
-      {
+    for (std::vector<std::string>::const_iterator ri = rdirs.begin();
+         ri != rdirs.end(); ++ri) {
       // Put this directory in the rpath if using build-tree rpath
       // support or if using the link path as an rpath.
-      if(use_build_rpath)
-        {
+      if (use_build_rpath) {
         std::string d = *ri;
-        if (!rootPath.empty() && d.find(rootPath) == 0)
-          {
+        if (!rootPath.empty() && d.find(rootPath) == 0) {
           d = d.substr(rootPath.size());
-          }
-        else if (stagePath && *stagePath && d.find(stagePath) == 0)
-          {
+        } else if (stagePath && *stagePath && d.find(stagePath) == 0) {
           std::string suffix = d.substr(strlen(stagePath));
           d = installPrefix;
           d += "/";
           d += suffix;
           cmSystemTools::ConvertToUnixSlashes(d);
-          }
-        if(emitted.insert(d).second)
-          {
+        }
+        if (emitted.insert(d).second) {
           runtimeDirs.push_back(d);
-          }
         }
-      else if(use_link_rpath)
-        {
+      } else if (use_link_rpath) {
         // Do not add any path inside the source or build tree.
         const char* topSourceDir = this->CMakeInstance->GetHomeDirectory();
         const char* topBinaryDir =
-            this->CMakeInstance->GetHomeOutputDirectory();
-        if(!cmSystemTools::ComparePath(*ri, topSourceDir) &&
-           !cmSystemTools::ComparePath(*ri, topBinaryDir) &&
-           !cmSystemTools::IsSubDirectory(*ri, topSourceDir) &&
-           !cmSystemTools::IsSubDirectory(*ri, topBinaryDir))
-          {
+          this->CMakeInstance->GetHomeOutputDirectory();
+        if (!cmSystemTools::ComparePath(*ri, topSourceDir) &&
+            !cmSystemTools::ComparePath(*ri, topBinaryDir) &&
+            !cmSystemTools::IsSubDirectory(*ri, topSourceDir) &&
+            !cmSystemTools::IsSubDirectory(*ri, topBinaryDir)) {
           std::string d = *ri;
-          if (!rootPath.empty() && d.find(rootPath) == 0)
-            {
+          if (!rootPath.empty() && d.find(rootPath) == 0) {
             d = d.substr(rootPath.size());
-            }
-          else if (stagePath && *stagePath && d.find(stagePath) == 0)
-            {
+          } else if (stagePath && *stagePath && d.find(stagePath) == 0) {
             std::string suffix = d.substr(strlen(stagePath));
             d = installPrefix;
             d += "/";
             d += suffix;
             cmSystemTools::ConvertToUnixSlashes(d);
-            }
-          if(emitted.insert(d).second)
-            {
+          }
+          if (emitted.insert(d).second) {
             runtimeDirs.push_back(d);
-            }
           }
         }
       }
     }
+  }
 
   // Add runtime paths required by the languages to always be
   // present.  This is done even when skipping rpath support.
   {
-  cmGeneratorTarget::LinkClosure const* lc =
-    this->Target->GetLinkClosure(this->Config);
-  for(std::vector<std::string>::const_iterator li = lc->Languages.begin();
-      li != lc->Languages.end(); ++li)
-    {
-    std::string useVar = "CMAKE_" + *li +
-      "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
-    if(this->Makefile->IsOn(useVar))
-      {
-      std::string dirVar = "CMAKE_" + *li +
-        "_IMPLICIT_LINK_DIRECTORIES";
-      if(const char* dirs = this->Makefile->GetDefinition(dirVar))
-        {
-        cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted);
+    cmGeneratorTarget::LinkClosure const* lc =
+      this->Target->GetLinkClosure(this->Config);
+    for (std::vector<std::string>::const_iterator li = lc->Languages.begin();
+         li != lc->Languages.end(); ++li) {
+      std::string useVar =
+        "CMAKE_" + *li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
+      if (this->Makefile->IsOn(useVar)) {
+        std::string dirVar = "CMAKE_" + *li + "_IMPLICIT_LINK_DIRECTORIES";
+        if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
+          cmCLI_ExpandListUnique(dirs, runtimeDirs, emitted);
         }
       }
     }
@@ -2003,33 +1800,29 @@ std::string cmComputeLinkInformation::GetRPathString(bool for_install)
   std::string rpath = cmJoin(runtimeDirs, this->GetRuntimeSep());
 
   // If the rpath will be replaced at install time, prepare space.
-  if(!for_install && this->RuntimeUseChrpath)
-    {
-    if(!rpath.empty())
-      {
+  if (!for_install && this->RuntimeUseChrpath) {
+    if (!rpath.empty()) {
       // Add one trailing separator so the linker does not re-use the
       // rpath .dynstr entry for a symbol name that happens to match
       // the end of the rpath string.
       rpath += this->GetRuntimeSep();
-      }
+    }
 
     // Make sure it is long enough to hold the replacement value.
     std::string::size_type minLength = this->GetChrpathString().length();
-    while(rpath.length() < minLength)
-      {
+    while (rpath.length() < minLength) {
       rpath += this->GetRuntimeSep();
-      }
     }
+  }
 
   return rpath;
 }
 
 std::string cmComputeLinkInformation::GetChrpathString()
 {
-  if(!this->RuntimeUseChrpath)
-    {
+  if (!this->RuntimeUseChrpath) {
     return "";
-    }
+  }
 
   return this->GetRPathString(true);
 }
diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h
index 5eecf7d..c0ddc53 100644
--- a/Source/cmComputeLinkInformation.h
+++ b/Source/cmComputeLinkInformation.h
@@ -35,11 +35,24 @@ public:
 
   struct Item
   {
-    Item(): Value(), IsPath(true), Target(0) {}
-    Item(Item const& item):
-      Value(item.Value), IsPath(item.IsPath), Target(item.Target) {}
-    Item(std::string const& v, bool p, cmGeneratorTarget const* target = 0):
-      Value(v), IsPath(p), Target(target) {}
+    Item()
+      : Value()
+      , IsPath(true)
+      , Target(0)
+    {
+    }
+    Item(Item const& item)
+      : Value(item.Value)
+      , IsPath(item.IsPath)
+      , Target(item.Target)
+    {
+    }
+    Item(std::string const& v, bool p, cmGeneratorTarget const* target = 0)
+      : Value(v)
+      , IsPath(p)
+      , Target(target)
+    {
+    }
     std::string Value;
     bool IsPath;
     cmGeneratorTarget const* Target;
@@ -60,6 +73,7 @@ public:
 
   std::string const& GetRPathLinkFlag() const { return this->RPathLinkFlag; }
   std::string GetRPathLinkString();
+
 private:
   void AddItem(std::string const& item, const cmGeneratorTarget* tgt);
   void AddSharedDepItem(std::string const& item, cmGeneratorTarget const* tgt);
@@ -101,7 +115,12 @@ private:
   std::string RPathLinkFlag;
   SharedDepMode SharedDependencyMode;
 
-  enum LinkType { LinkUnknown, LinkStatic, LinkShared };
+  enum LinkType
+  {
+    LinkUnknown,
+    LinkStatic,
+    LinkShared
+  };
   void SetCurrentLinkType(LinkType lt);
 
   // Link type adjustment.
@@ -184,7 +203,6 @@ private:
   void AddLibraryRuntimeInfo(std::string const& fullPath,
                              const cmGeneratorTarget* target);
   void AddLibraryRuntimeInfo(std::string const& fullPath);
-
 };
 
 #endif
diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx
index 1b5297f..570405a 100644
--- a/Source/cmComputeTargetDepends.cxx
+++ b/Source/cmComputeTargetDepends.cxx
@@ -98,10 +98,10 @@ cmComputeTargetDepends::cmComputeTargetDepends(cmGlobalGenerator* gg)
 {
   this->GlobalGenerator = gg;
   cmake* cm = this->GlobalGenerator->GetCMakeInstance();
-  this->DebugMode = cm->GetState()
-                      ->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_DEBUG_MODE");
-  this->NoCycles = cm->GetState()
-                      ->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_NO_CYCLES");
+  this->DebugMode =
+    cm->GetState()->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_DEBUG_MODE");
+  this->NoCycles =
+    cm->GetState()->GetGlobalPropertyAsBool("GLOBAL_DEPENDS_NO_CYCLES");
 }
 
 cmComputeTargetDepends::~cmComputeTargetDepends()
@@ -113,54 +113,47 @@ bool cmComputeTargetDepends::Compute()
   // Build the original graph.
   this->CollectTargets();
   this->CollectDepends();
-  if(this->DebugMode)
-    {
+  if (this->DebugMode) {
     this->DisplayGraph(this->InitialGraph, "initial");
-    }
+  }
 
   // Identify components.
   cmComputeComponentGraph ccg(this->InitialGraph);
-  if(this->DebugMode)
-    {
+  if (this->DebugMode) {
     this->DisplayComponents(ccg);
-    }
-  if(!this->CheckComponents(ccg))
-    {
+  }
+  if (!this->CheckComponents(ccg)) {
     return false;
-    }
+  }
 
   // Compute the final dependency graph.
-  if(!this->ComputeFinalDepends(ccg))
-    {
+  if (!this->ComputeFinalDepends(ccg)) {
     return false;
-    }
-  if(this->DebugMode)
-    {
+  }
+  if (this->DebugMode) {
     this->DisplayGraph(this->FinalGraph, "final");
-    }
+  }
 
   return true;
 }
 
-void
-cmComputeTargetDepends::GetTargetDirectDepends(cmGeneratorTarget const* t,
-                                               cmTargetDependSet& deps)
+void cmComputeTargetDepends::GetTargetDirectDepends(cmGeneratorTarget const* t,
+                                                    cmTargetDependSet& deps)
 {
   // Lookup the index for this target.  All targets should be known by
   // this point.
-  std::map<cmGeneratorTarget const*, int>::const_iterator tii
-                                                  = this->TargetIndex.find(t);
+  std::map<cmGeneratorTarget const*, int>::const_iterator tii =
+    this->TargetIndex.find(t);
   assert(tii != this->TargetIndex.end());
   int i = tii->second;
 
   // Get its final dependencies.
   EdgeList const& nl = this->FinalGraph[i];
-  for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-    {
+  for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
     cmGeneratorTarget const* dep = this->Targets[*ni];
     cmTargetDependSet::iterator di = deps.insert(dep).first;
     di->SetType(ni->IsStrong());
-    }
+  }
 }
 
 void cmComputeTargetDepends::CollectTargets()
@@ -168,19 +161,17 @@ void cmComputeTargetDepends::CollectTargets()
   // Collect all targets from all generators.
   std::vector<cmLocalGenerator*> const& lgens =
     this->GlobalGenerator->GetLocalGenerators();
-  for(unsigned int i = 0; i < lgens.size(); ++i)
-    {
+  for (unsigned int i = 0; i < lgens.size(); ++i) {
     const std::vector<cmGeneratorTarget*> targets =
-        lgens[i]->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
-        ti != targets.end(); ++ti)
-      {
+      lgens[i]->GetGeneratorTargets();
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
+         ti != targets.end(); ++ti) {
       cmGeneratorTarget* gt = *ti;
       int index = static_cast<int>(this->Targets.size());
       this->TargetIndex[gt] = index;
       this->Targets.push_back(gt);
-      }
     }
+  }
 }
 
 void cmComputeTargetDepends::CollectDepends()
@@ -189,74 +180,66 @@ void cmComputeTargetDepends::CollectDepends()
   this->InitialGraph.resize(this->Targets.size());
 
   // Compute each dependency list.
-  for(unsigned int i=0; i < this->Targets.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->Targets.size(); ++i) {
     this->CollectTargetDepends(i);
-    }
+  }
 }
 
 void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
 {
   // Get the depender.
   cmGeneratorTarget const* depender = this->Targets[depender_index];
-  if (depender->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (depender->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
+  }
 
   // Loop over all targets linked directly in all configs.
   // We need to make targets depend on the union of all config-specific
   // dependencies in all targets, because the generated build-systems can't
   // deal with config-specific dependencies.
   {
-  std::set<std::string> emitted;
+    std::set<std::string> emitted;
 
-  std::vector<std::string> configs;
-  depender->Makefile->GetConfigurations(configs);
-  if (configs.empty())
-    {
-    configs.push_back("");
+    std::vector<std::string> configs;
+    depender->Makefile->GetConfigurations(configs);
+    if (configs.empty()) {
+      configs.push_back("");
     }
-  for (std::vector<std::string>::const_iterator it = configs.begin();
-    it != configs.end(); ++it)
-    {
-    std::vector<cmSourceFile const*> objectFiles;
-    depender->GetExternalObjects(objectFiles, *it);
-    for(std::vector<cmSourceFile const*>::const_iterator
-        oi = objectFiles.begin(); oi != objectFiles.end(); ++oi)
-      {
-      std::string objLib = (*oi)->GetObjectLibrary();
-      if (!objLib.empty() && emitted.insert(objLib).second)
-        {
-        if(depender->GetType() != cmState::EXECUTABLE &&
-            depender->GetType() != cmState::STATIC_LIBRARY &&
-            depender->GetType() != cmState::SHARED_LIBRARY &&
-            depender->GetType() != cmState::MODULE_LIBRARY)
-          {
-          this->GlobalGenerator->GetCMakeInstance()
-            ->IssueMessage(cmake::FATAL_ERROR,
-                            "Only executables and non-OBJECT libraries may "
-                            "reference target objects.",
-                            depender->GetBacktrace());
-          return;
+    for (std::vector<std::string>::const_iterator it = configs.begin();
+         it != configs.end(); ++it) {
+      std::vector<cmSourceFile const*> objectFiles;
+      depender->GetExternalObjects(objectFiles, *it);
+      for (std::vector<cmSourceFile const*>::const_iterator oi =
+             objectFiles.begin();
+           oi != objectFiles.end(); ++oi) {
+        std::string objLib = (*oi)->GetObjectLibrary();
+        if (!objLib.empty() && emitted.insert(objLib).second) {
+          if (depender->GetType() != cmState::EXECUTABLE &&
+              depender->GetType() != cmState::STATIC_LIBRARY &&
+              depender->GetType() != cmState::SHARED_LIBRARY &&
+              depender->GetType() != cmState::MODULE_LIBRARY) {
+            this->GlobalGenerator->GetCMakeInstance()->IssueMessage(
+              cmake::FATAL_ERROR,
+              "Only executables and non-OBJECT libraries may "
+              "reference target objects.",
+              depender->GetBacktrace());
+            return;
           }
-        const_cast<cmGeneratorTarget*>(depender)->Target->AddUtility(objLib);
+          const_cast<cmGeneratorTarget*>(depender)->Target->AddUtility(objLib);
         }
       }
 
-    cmLinkImplementation const* impl = depender->GetLinkImplementation(*it);
+      cmLinkImplementation const* impl = depender->GetLinkImplementation(*it);
 
-    // A target should not depend on itself.
-    emitted.insert(depender->GetName());
-    for(std::vector<cmLinkImplItem>::const_iterator
-          lib = impl->Libraries.begin();
-        lib != impl->Libraries.end(); ++lib)
-      {
-      // Don't emit the same library twice for this target.
-      if(emitted.insert(*lib).second)
-        {
-        this->AddTargetDepend(depender_index, *lib, true);
-        this->AddInterfaceDepends(depender_index, *lib, emitted);
+      // A target should not depend on itself.
+      emitted.insert(depender->GetName());
+      for (std::vector<cmLinkImplItem>::const_iterator lib =
+             impl->Libraries.begin();
+           lib != impl->Libraries.end(); ++lib) {
+        // Don't emit the same library twice for this target.
+        if (emitted.insert(*lib).second) {
+          this->AddTargetDepend(depender_index, *lib, true);
+          this->AddInterfaceDepends(depender_index, *lib, emitted);
         }
       }
     }
@@ -264,80 +247,69 @@ void cmComputeTargetDepends::CollectTargetDepends(int depender_index)
 
   // Loop over all utility dependencies.
   {
-  std::set<cmLinkItem> const& tutils = depender->GetUtilityItems();
-  std::set<std::string> emitted;
-  // A target should not depend on itself.
-  emitted.insert(depender->GetName());
-  for(std::set<cmLinkItem>::const_iterator util = tutils.begin();
-      util != tutils.end(); ++util)
-    {
-    // Don't emit the same utility twice for this target.
-    if(emitted.insert(*util).second)
-      {
-      this->AddTargetDepend(depender_index, *util, false);
+    std::set<cmLinkItem> const& tutils = depender->GetUtilityItems();
+    std::set<std::string> emitted;
+    // A target should not depend on itself.
+    emitted.insert(depender->GetName());
+    for (std::set<cmLinkItem>::const_iterator util = tutils.begin();
+         util != tutils.end(); ++util) {
+      // Don't emit the same utility twice for this target.
+      if (emitted.insert(*util).second) {
+        this->AddTargetDepend(depender_index, *util, false);
       }
     }
   }
 }
 
-void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
-                                             const cmGeneratorTarget* dependee,
-                                             const std::string& config,
-                                             std::set<std::string> &emitted)
+void cmComputeTargetDepends::AddInterfaceDepends(
+  int depender_index, const cmGeneratorTarget* dependee,
+  const std::string& config, std::set<std::string>& emitted)
 {
   cmGeneratorTarget const* depender = this->Targets[depender_index];
-  if(cmLinkInterface const* iface =
-                                dependee->GetLinkInterface(config,
-                                                           depender))
-    {
-    for(std::vector<cmLinkItem>::const_iterator
-        lib = iface->Libraries.begin();
-        lib != iface->Libraries.end(); ++lib)
-      {
+  if (cmLinkInterface const* iface =
+        dependee->GetLinkInterface(config, depender)) {
+    for (std::vector<cmLinkItem>::const_iterator lib =
+           iface->Libraries.begin();
+         lib != iface->Libraries.end(); ++lib) {
       // Don't emit the same library twice for this target.
-      if(emitted.insert(*lib).second)
-        {
+      if (emitted.insert(*lib).second) {
         this->AddTargetDepend(depender_index, *lib, true);
         this->AddInterfaceDepends(depender_index, *lib, emitted);
-        }
       }
     }
+  }
 }
 
-void cmComputeTargetDepends::AddInterfaceDepends(int depender_index,
-                                             cmLinkItem const& dependee_name,
-                                             std::set<std::string> &emitted)
+void cmComputeTargetDepends::AddInterfaceDepends(
+  int depender_index, cmLinkItem const& dependee_name,
+  std::set<std::string>& emitted)
 {
   cmGeneratorTarget const* depender = this->Targets[depender_index];
   cmGeneratorTarget const* dependee = dependee_name.Target;
   // Skip targets that will not really be linked.  This is probably a
   // name conflict between an external library and an executable
   // within the project.
-  if(dependee &&
-     dependee->GetType() == cmState::EXECUTABLE &&
-     !dependee->IsExecutableWithExports())
-    {
+  if (dependee && dependee->GetType() == cmState::EXECUTABLE &&
+      !dependee->IsExecutableWithExports()) {
     dependee = 0;
-    }
+  }
 
-  if(dependee)
-    {
+  if (dependee) {
     this->AddInterfaceDepends(depender_index, dependee, "", emitted);
     std::vector<std::string> configs;
     depender->Makefile->GetConfigurations(configs);
     for (std::vector<std::string>::const_iterator it = configs.begin();
-      it != configs.end(); ++it)
-      {
+         it != configs.end(); ++it) {
       // A target should not depend on itself.
       emitted.insert(depender->GetName());
       this->AddInterfaceDepends(depender_index, dependee, *it, emitted);
-      }
     }
+  }
 }
 
-void cmComputeTargetDepends::AddTargetDepend(
-  int depender_index, cmLinkItem const& dependee_name,
-  bool linking)
+void cmComputeTargetDepends::AddTargetDepend(int depender_index,
+                                             cmLinkItem const& dependee_name,
+                                             bool linking)
 {
   // Get the depender.
   cmGeneratorTarget const* depender = this->Targets[depender_index];
@@ -345,14 +317,12 @@ void cmComputeTargetDepends::AddTargetDepend(
   // Check the target's makefile first.
   cmGeneratorTarget const* dependee = dependee_name.Target;
 
-  if(!dependee && !linking &&
-    (depender->GetType() != cmState::GLOBAL_TARGET))
-    {
+  if (!dependee && !linking &&
+      (depender->GetType() != cmState::GLOBAL_TARGET)) {
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
     bool issueMessage = false;
     std::ostringstream e;
-    switch(depender->GetPolicyStatusCMP0046())
-      {
+    switch (depender->GetPolicyStatusCMP0046()) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0046) << "\n";
         issueMessage = true;
@@ -363,65 +333,52 @@ void cmComputeTargetDepends::AddTargetDepend(
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if(issueMessage)
-      {
+    }
+    if (issueMessage) {
       cmake* cm = this->GlobalGenerator->GetCMakeInstance();
 
-      e << "The dependency target \"" <<  dependee_name
-        << "\" of target \"" << depender->GetName() << "\" does not exist.";
+      e << "The dependency target \"" << dependee_name << "\" of target \""
+        << depender->GetName() << "\" does not exist.";
 
       cmListFileBacktrace const* backtrace =
         depender->GetUtilityBacktrace(dependee_name);
-      if(backtrace)
-        {
+      if (backtrace) {
         cm->IssueMessage(messageType, e.str(), *backtrace);
-        }
-      else
-        {
+      } else {
         cm->IssueMessage(messageType, e.str());
-        }
-
       }
     }
+  }
 
   // Skip targets that will not really be linked.  This is probably a
   // name conflict between an external library and an executable
   // within the project.
-  if(linking && dependee &&
-     dependee->GetType() == cmState::EXECUTABLE &&
-     !dependee->IsExecutableWithExports())
-    {
+  if (linking && dependee && dependee->GetType() == cmState::EXECUTABLE &&
+      !dependee->IsExecutableWithExports()) {
     dependee = 0;
-    }
+  }
 
-  if(dependee)
-    {
+  if (dependee) {
     this->AddTargetDepend(depender_index, dependee, linking);
-    }
+  }
 }
 
 void cmComputeTargetDepends::AddTargetDepend(int depender_index,
                                              const cmGeneratorTarget* dependee,
                                              bool linking)
 {
-  if(dependee->IsImported() ||
-     dependee->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (dependee->IsImported() ||
+      dependee->GetType() == cmState::INTERFACE_LIBRARY) {
     // Skip IMPORTED and INTERFACE targets but follow their utility
     // dependencies.
     std::set<cmLinkItem> const& utils = dependee->GetUtilityItems();
-    for(std::set<cmLinkItem>::const_iterator i = utils.begin();
-        i != utils.end(); ++i)
-      {
-      if(cmGeneratorTarget const* transitive_dependee = i->Target)
-        {
+    for (std::set<cmLinkItem>::const_iterator i = utils.begin();
+         i != utils.end(); ++i) {
+      if (cmGeneratorTarget const* transitive_dependee = i->Target) {
         this->AddTargetDepend(depender_index, transitive_dependee, false);
-        }
       }
     }
-  else
-    {
+  } else {
     // Lookup the index for this target.  All targets should be known by
     // this point.
     std::map<cmGeneratorTarget const*, int>::const_iterator tii =
@@ -432,96 +389,82 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
     // Add this entry to the dependency graph.
     this->InitialGraph[depender_index].push_back(
       cmGraphEdge(dependee_index, !linking));
-    }
+  }
 }
 
-void
-cmComputeTargetDepends::DisplayGraph(Graph const& graph,
-                                     const std::string& name)
+void cmComputeTargetDepends::DisplayGraph(Graph const& graph,
+                                          const std::string& name)
 {
   fprintf(stderr, "The %s target dependency graph is:\n", name.c_str());
   int n = static_cast<int>(graph.size());
-  for(int depender_index = 0; depender_index < n; ++depender_index)
-    {
+  for (int depender_index = 0; depender_index < n; ++depender_index) {
     EdgeList const& nl = graph[depender_index];
     cmGeneratorTarget const* depender = this->Targets[depender_index];
-    fprintf(stderr, "target %d is [%s]\n",
-            depender_index, depender->GetName().c_str());
-    for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    fprintf(stderr, "target %d is [%s]\n", depender_index,
+            depender->GetName().c_str());
+    for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int dependee_index = *ni;
       cmGeneratorTarget const* dependee = this->Targets[dependee_index];
       fprintf(stderr, "  depends on target %d [%s] (%s)\n", dependee_index,
-              dependee->GetName().c_str(), ni->IsStrong()? "strong" : "weak");
-      }
+              dependee->GetName().c_str(), ni->IsStrong() ? "strong" : "weak");
     }
+  }
   fprintf(stderr, "\n");
 }
 
-void
-cmComputeTargetDepends
-::DisplayComponents(cmComputeComponentGraph const& ccg)
+void cmComputeTargetDepends::DisplayComponents(
+  cmComputeComponentGraph const& ccg)
 {
   fprintf(stderr, "The strongly connected components are:\n");
   std::vector<NodeList> const& components = ccg.GetComponents();
   int n = static_cast<int>(components.size());
-  for(int c = 0; c < n; ++c)
-    {
+  for (int c = 0; c < n; ++c) {
     NodeList const& nl = components[c];
     fprintf(stderr, "Component (%d):\n", c);
-    for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int i = *ni;
-      fprintf(stderr, "  contains target %d [%s]\n",
-              i, this->Targets[i]->GetName().c_str());
-      }
+      fprintf(stderr, "  contains target %d [%s]\n", i,
+              this->Targets[i]->GetName().c_str());
     }
+  }
   fprintf(stderr, "\n");
 }
 
-bool
-cmComputeTargetDepends
-::CheckComponents(cmComputeComponentGraph const& ccg)
+bool cmComputeTargetDepends::CheckComponents(
+  cmComputeComponentGraph const& ccg)
 {
   // All non-trivial components should consist only of static
   // libraries.
   std::vector<NodeList> const& components = ccg.GetComponents();
   int nc = static_cast<int>(components.size());
-  for(int c=0; c < nc; ++c)
-    {
+  for (int c = 0; c < nc; ++c) {
     // Get the current component.
     NodeList const& nl = components[c];
 
     // Skip trivial components.
-    if(nl.size() < 2)
-      {
+    if (nl.size() < 2) {
       continue;
-      }
+    }
 
     // Immediately complain if no cycles are allowed at all.
-    if(this->NoCycles)
-      {
+    if (this->NoCycles) {
       this->ComplainAboutBadComponent(ccg, c);
       return false;
-      }
+    }
 
     // Make sure the component is all STATIC_LIBRARY targets.
-    for(NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
-      if(this->Targets[*ni]->GetType() != cmState::STATIC_LIBRARY)
-        {
+    for (NodeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
+      if (this->Targets[*ni]->GetType() != cmState::STATIC_LIBRARY) {
         this->ComplainAboutBadComponent(ccg, c);
         return false;
-        }
       }
     }
+  }
   return true;
 }
 
-void
-cmComputeTargetDepends
-::ComplainAboutBadComponent(cmComputeComponentGraph const& ccg, int c,
-                            bool strong)
+void cmComputeTargetDepends::ComplainAboutBadComponent(
+  cmComputeComponentGraph const& ccg, int c, bool strong)
 {
   // Construct the error message.
   std::ostringstream e;
@@ -530,8 +473,7 @@ cmComputeTargetDepends
   std::vector<NodeList> const& components = ccg.GetComponents();
   std::vector<int> const& cmap = ccg.GetComponentMap();
   NodeList const& cl = components[c];
-  for(NodeList::const_iterator ci = cl.begin(); ci != cl.end(); ++ci)
-    {
+  for (NodeList::const_iterator ci = cl.begin(); ci != cl.end(); ++ci) {
     // Get the depender.
     int i = *ci;
     cmGeneratorTarget const* depender = this->Targets[i];
@@ -542,82 +484,66 @@ cmComputeTargetDepends
 
     // List its dependencies that are inside the component.
     EdgeList const& nl = this->InitialGraph[i];
-    for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int j = *ni;
-      if(cmap[j] == c)
-        {
+      if (cmap[j] == c) {
         cmGeneratorTarget const* dependee = this->Targets[j];
         e << "    depends on \"" << dependee->GetName() << "\""
-          << " (" << (ni->IsStrong()? "strong" : "weak") << ")\n";
-        }
+          << " (" << (ni->IsStrong() ? "strong" : "weak") << ")\n";
       }
     }
-  if(strong)
-    {
+  }
+  if (strong) {
     // Custom command executable dependencies cannot occur within a
     // component of static libraries.  The cycle must appear in calls
     // to add_dependencies.
     e << "The component contains at least one cycle consisting of strong "
       << "dependencies (created by add_dependencies) that cannot be broken.";
-    }
-  else if(this->NoCycles)
-    {
+  } else if (this->NoCycles) {
     e << "The GLOBAL_DEPENDS_NO_CYCLES global property is enabled, so "
       << "cyclic dependencies are not allowed even among static libraries.";
-    }
-  else
-    {
+  } else {
     e << "At least one of these targets is not a STATIC_LIBRARY.  "
       << "Cyclic dependencies are allowed only among static libraries.";
-    }
+  }
   cmSystemTools::Error(e.str().c_str());
 }
 
-bool
-cmComputeTargetDepends
-::IntraComponent(std::vector<int> const& cmap, int c, int i, int* head,
-                 std::set<int>& emitted, std::set<int>& visited)
+bool cmComputeTargetDepends::IntraComponent(std::vector<int> const& cmap,
+                                            int c, int i, int* head,
+                                            std::set<int>& emitted,
+                                            std::set<int>& visited)
 {
-  if(!visited.insert(i).second)
-    {
+  if (!visited.insert(i).second) {
     // Cycle in utility depends!
     return false;
-    }
-  if(emitted.insert(i).second)
-    {
+  }
+  if (emitted.insert(i).second) {
     // Honor strong intra-component edges in the final order.
     EdgeList const& el = this->InitialGraph[i];
-    for(EdgeList::const_iterator ei = el.begin(); ei != el.end(); ++ei)
-      {
+    for (EdgeList::const_iterator ei = el.begin(); ei != el.end(); ++ei) {
       int j = *ei;
-      if(cmap[j] == c && ei->IsStrong())
-        {
+      if (cmap[j] == c && ei->IsStrong()) {
         this->FinalGraph[i].push_back(cmGraphEdge(j, true));
-        if(!this->IntraComponent(cmap, c, j, head, emitted, visited))
-          {
+        if (!this->IntraComponent(cmap, c, j, head, emitted, visited)) {
           return false;
-          }
         }
       }
+    }
 
     // Prepend to a linear linked-list of intra-component edges.
-    if(*head >= 0)
-      {
+    if (*head >= 0) {
       this->FinalGraph[i].push_back(cmGraphEdge(*head, false));
-      }
-    else
-      {
+    } else {
       this->ComponentTail[c] = i;
-      }
-    *head = i;
     }
+    *head = i;
+  }
   return true;
 }
 
-bool
-cmComputeTargetDepends
-::ComputeFinalDepends(cmComputeComponentGraph const& ccg)
+bool cmComputeTargetDepends::ComputeFinalDepends(
+  cmComputeComponentGraph const& ccg)
 {
   // Get the component graph information.
   std::vector<NodeList> const& components = ccg.GetComponents();
@@ -632,38 +558,34 @@ cmComputeTargetDepends
   this->ComponentHead.resize(components.size());
   this->ComponentTail.resize(components.size());
   int nc = static_cast<int>(components.size());
-  for(int c=0; c < nc; ++c)
-    {
+  for (int c = 0; c < nc; ++c) {
     int head = -1;
     std::set<int> emitted;
     NodeList const& nl = components[c];
-    for(NodeList::const_reverse_iterator ni = nl.rbegin();
-        ni != nl.rend(); ++ni)
-      {
+    for (NodeList::const_reverse_iterator ni = nl.rbegin(); ni != nl.rend();
+         ++ni) {
       std::set<int> visited;
-      if(!this->IntraComponent(cmap, c, *ni, &head, emitted, visited))
-        {
+      if (!this->IntraComponent(cmap, c, *ni, &head, emitted, visited)) {
         // Cycle in add_dependencies within component!
         this->ComplainAboutBadComponent(ccg, c, true);
         return false;
-        }
       }
-    this->ComponentHead[c] = head;
     }
+    this->ComponentHead[c] = head;
+  }
 
   // Convert inter-component edges to connect component tails to heads.
   int n = static_cast<int>(cgraph.size());
-  for(int depender_component=0; depender_component < n; ++depender_component)
-    {
+  for (int depender_component = 0; depender_component < n;
+       ++depender_component) {
     int depender_component_tail = this->ComponentTail[depender_component];
     EdgeList const& nl = cgraph[depender_component];
-    for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
-      {
+    for (EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni) {
       int dependee_component = *ni;
       int dependee_component_head = this->ComponentHead[dependee_component];
-      this->FinalGraph[depender_component_tail]
-        .push_back(cmGraphEdge(dependee_component_head, ni->IsStrong()));
-      }
+      this->FinalGraph[depender_component_tail].push_back(
+        cmGraphEdge(dependee_component_head, ni->IsStrong()));
     }
+  }
   return true;
 }
diff --git a/Source/cmComputeTargetDepends.h b/Source/cmComputeTargetDepends.h
index 6100d97..9e51d4d 100644
--- a/Source/cmComputeTargetDepends.h
+++ b/Source/cmComputeTargetDepends.h
@@ -39,27 +39,28 @@ public:
 
   bool Compute();
 
-  std::vector<cmGeneratorTarget const*> const&
-  GetTargets() const { return this->Targets; }
+  std::vector<cmGeneratorTarget const*> const& GetTargets() const
+  {
+    return this->Targets;
+  }
   void GetTargetDirectDepends(cmGeneratorTarget const* t,
                               cmTargetDependSet& deps);
+
 private:
   void CollectTargets();
   void CollectDepends();
   void CollectTargetDepends(int depender_index);
-  void AddTargetDepend(int depender_index,
-                       cmLinkItem const& dependee_name,
+  void AddTargetDepend(int depender_index, cmLinkItem const& dependee_name,
                        bool linking);
   void AddTargetDepend(int depender_index, cmGeneratorTarget const* dependee,
                        bool linking);
   bool ComputeFinalDepends(cmComputeComponentGraph const& ccg);
-  void AddInterfaceDepends(int depender_index,
-                           cmLinkItem const& dependee_name,
-                           std::set<std::string> &emitted);
+  void AddInterfaceDepends(int depender_index, cmLinkItem const& dependee_name,
+                           std::set<std::string>& emitted);
   void AddInterfaceDepends(int depender_index,
                            cmGeneratorTarget const* dependee,
                            const std::string& config,
-                           std::set<std::string> &emitted);
+                           std::set<std::string>& emitted);
   cmGlobalGenerator* GlobalGenerator;
   bool DebugMode;
   bool NoCycles;
diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx
index 3711b9b..7006b62 100644
--- a/Source/cmConditionEvaluator.cxx
+++ b/Source/cmConditionEvaluator.cxx
@@ -43,17 +43,16 @@ static std::string const keyVERSION_GREATER = "VERSION_GREATER";
 static std::string const keyVERSION_LESS = "VERSION_LESS";
 
 cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile,
-                                           const cmListFileContext &context,
-                                           const cmListFileBacktrace& bt):
-  Makefile(makefile),
-  ExecutionContext(context),
-  Backtrace(bt),
-  Policy12Status(makefile.GetPolicyStatus(cmPolicies::CMP0012)),
-  Policy54Status(makefile.GetPolicyStatus(cmPolicies::CMP0054)),
-  Policy57Status(makefile.GetPolicyStatus(cmPolicies::CMP0057)),
-  Policy64Status(makefile.GetPolicyStatus(cmPolicies::CMP0064))
+                                           const cmListFileContext& context,
+                                           const cmListFileBacktrace& bt)
+  : Makefile(makefile)
+  , ExecutionContext(context)
+  , Backtrace(bt)
+  , Policy12Status(makefile.GetPolicyStatus(cmPolicies::CMP0012))
+  , Policy54Status(makefile.GetPolicyStatus(cmPolicies::CMP0054))
+  , Policy57Status(makefile.GetPolicyStatus(cmPolicies::CMP0057))
+  , Policy64Status(makefile.GetPolicyStatus(cmPolicies::CMP0064))
 {
-
 }
 
 //=========================================================================
@@ -73,17 +72,15 @@ cmConditionEvaluator::cmConditionEvaluator(cmMakefile& makefile,
 // directly. AND OR take variables or the values 0 or 1.
 
 bool cmConditionEvaluator::IsTrue(
-  const std::vector<cmExpandedCommandArgument> &args,
-  std::string &errorString,
-  cmake::MessageType &status)
+  const std::vector<cmExpandedCommandArgument>& args, std::string& errorString,
+  cmake::MessageType& status)
 {
   errorString = "";
 
   // handle empty invocation
-  if (args.size() < 1)
-    {
+  if (args.size() < 1) {
     return false;
-    }
+  }
 
   // store the reduced args in this vector
   cmArgumentList newArgs;
@@ -94,123 +91,109 @@ bool cmConditionEvaluator::IsTrue(
   // now loop through the arguments and see if we can reduce any of them
   // we do this multiple times. Once for each level of precedence
   // parens
-  if (!this->HandleLevel0(newArgs, errorString, status))
-    {
+  if (!this->HandleLevel0(newArgs, errorString, status)) {
     return false;
-    }
-  //predicates
-  if (!this->HandleLevel1(newArgs, errorString, status))
-    {
+  }
+  // predicates
+  if (!this->HandleLevel1(newArgs, errorString, status)) {
     return false;
-    }
+  }
   // binary ops
-  if (!this->HandleLevel2(newArgs, errorString, status))
-    {
+  if (!this->HandleLevel2(newArgs, errorString, status)) {
     return false;
-    }
+  }
 
   // NOT
-  if (!this->HandleLevel3(newArgs, errorString, status))
-    {
+  if (!this->HandleLevel3(newArgs, errorString, status)) {
     return false;
-    }
+  }
   // AND OR
-  if (!this->HandleLevel4(newArgs, errorString, status))
-    {
+  if (!this->HandleLevel4(newArgs, errorString, status)) {
     return false;
-    }
+  }
 
   // now at the end there should only be one argument left
-  if (newArgs.size() != 1)
-    {
+  if (newArgs.size() != 1) {
     errorString = "Unknown arguments specified";
     status = cmake::FATAL_ERROR;
     return false;
-    }
+  }
 
   return this->GetBooleanValueWithAutoDereference(*(newArgs.begin()),
-    errorString, status, true);
+                                                  errorString, status, true);
 }
 
 //=========================================================================
 const char* cmConditionEvaluator::GetDefinitionIfUnquoted(
   cmExpandedCommandArgument const& argument) const
 {
-  if((this->Policy54Status != cmPolicies::WARN &&
-     this->Policy54Status != cmPolicies::OLD) &&
-     argument.WasQuoted())
-    {
+  if ((this->Policy54Status != cmPolicies::WARN &&
+       this->Policy54Status != cmPolicies::OLD) &&
+      argument.WasQuoted()) {
     return 0;
-    }
+  }
 
   const char* def = this->Makefile.GetDefinition(argument.GetValue());
 
-  if(def && argument.WasQuoted() && this->Policy54Status == cmPolicies::WARN)
-    {
-    if(!this->Makefile.HasCMP0054AlreadyBeenReported(
-         this->ExecutionContext))
-      {
+  if (def && argument.WasQuoted() &&
+      this->Policy54Status == cmPolicies::WARN) {
+    if (!this->Makefile.HasCMP0054AlreadyBeenReported(
+          this->ExecutionContext)) {
       std::ostringstream e;
       e << (cmPolicies::GetPolicyWarning(cmPolicies::CMP0054)) << "\n";
-      e << "Quoted variables like \"" << argument.GetValue() <<
-        "\" will no longer be dereferenced "
-        "when the policy is set to NEW.  "
-        "Since the policy is not set the OLD behavior will be used.";
-
-      this->Makefile.GetCMakeInstance()
-          ->IssueMessage(cmake::AUTHOR_WARNING, e.str(),
-                         this->Backtrace);
-      }
+      e << "Quoted variables like \"" << argument.GetValue()
+        << "\" will no longer be dereferenced "
+           "when the policy is set to NEW.  "
+           "Since the policy is not set the OLD behavior will be used.";
+
+      this->Makefile.GetCMakeInstance()->IssueMessage(
+        cmake::AUTHOR_WARNING, e.str(), this->Backtrace);
     }
+  }
 
   return def;
 }
 
 //=========================================================================
 const char* cmConditionEvaluator::GetVariableOrString(
-    const cmExpandedCommandArgument& argument) const
+  const cmExpandedCommandArgument& argument) const
 {
   const char* def = this->GetDefinitionIfUnquoted(argument);
 
-  if(!def)
-    {
+  if (!def) {
     def = argument.c_str();
-    }
+  }
 
   return def;
 }
 
 //=========================================================================
 bool cmConditionEvaluator::IsKeyword(std::string const& keyword,
-  cmExpandedCommandArgument& argument) const
+                                     cmExpandedCommandArgument& argument) const
 {
-  if((this->Policy54Status != cmPolicies::WARN &&
-     this->Policy54Status != cmPolicies::OLD) &&
-     argument.WasQuoted())
-    {
+  if ((this->Policy54Status != cmPolicies::WARN &&
+       this->Policy54Status != cmPolicies::OLD) &&
+      argument.WasQuoted()) {
     return false;
-    }
+  }
 
   bool isKeyword = argument.GetValue() == keyword;
 
-  if(isKeyword && argument.WasQuoted() &&
-    this->Policy54Status == cmPolicies::WARN)
-    {
-    if(!this->Makefile.HasCMP0054AlreadyBeenReported(
-         this->ExecutionContext))
-      {
+  if (isKeyword && argument.WasQuoted() &&
+      this->Policy54Status == cmPolicies::WARN) {
+    if (!this->Makefile.HasCMP0054AlreadyBeenReported(
+          this->ExecutionContext)) {
       std::ostringstream e;
       e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0054) << "\n";
-      e << "Quoted keywords like \"" << argument.GetValue() <<
-        "\" will no longer be interpreted as keywords "
-        "when the policy is set to NEW.  "
-        "Since the policy is not set the OLD behavior will be used.";
-
-      this->Makefile.GetCMakeInstance()
-          ->IssueMessage(cmake::AUTHOR_WARNING, e.str(),
-                         this->Backtrace);
-      }
+      e << "Quoted keywords like \"" << argument.GetValue()
+        << "\" will no longer be interpreted as keywords "
+           "when the policy is set to NEW.  "
+           "Since the policy is not set the OLD behavior will be used.";
+
+      this->Makefile.GetCMakeInstance()->IssueMessage(
+        cmake::AUTHOR_WARNING, e.str(), this->Backtrace);
     }
+  }
 
   return isKeyword;
 }
@@ -220,36 +203,30 @@ bool cmConditionEvaluator::GetBooleanValue(
   cmExpandedCommandArgument& arg) const
 {
   // Check basic constants.
-  if (arg == "0")
-    {
+  if (arg == "0") {
     return false;
-    }
-  if (arg == "1")
-    {
+  }
+  if (arg == "1") {
     return true;
-    }
+  }
 
   // Check named constants.
-  if (cmSystemTools::IsOn(arg.c_str()))
-    {
+  if (cmSystemTools::IsOn(arg.c_str())) {
     return true;
-    }
-  if (cmSystemTools::IsOff(arg.c_str()))
-    {
+  }
+  if (cmSystemTools::IsOff(arg.c_str())) {
     return false;
-    }
+  }
 
   // Check for numbers.
-  if(!arg.empty())
-    {
+  if (!arg.empty()) {
     char* end;
     double d = strtod(arg.c_str(), &end);
-    if(*end == '\0')
-      {
+    if (*end == '\0') {
       // The whole string is a number.  Use C conversion to bool.
-      return d? true:false;
-      }
+      return d ? true : false;
     }
+  }
 
   // Check definition.
   const char* def = this->GetDefinitionIfUnquoted(arg);
@@ -261,179 +238,149 @@ bool cmConditionEvaluator::GetBooleanValue(
 bool cmConditionEvaluator::GetBooleanValueOld(
   cmExpandedCommandArgument const& arg, bool one) const
 {
-  if(one)
-    {
+  if (one) {
     // Old IsTrue behavior for single argument.
-    if(arg == "0")
-      { return false; }
-    else if(arg == "1")
-      { return true; }
-    else
-      {
+    if (arg == "0") {
+      return false;
+    } else if (arg == "1") {
+      return true;
+    } else {
       const char* def = this->GetDefinitionIfUnquoted(arg);
       return !cmSystemTools::IsOff(def);
-      }
     }
-  else
-    {
+  } else {
     // Old GetVariableOrNumber behavior.
     const char* def = this->GetDefinitionIfUnquoted(arg);
-    if(!def && atoi(arg.c_str()))
-      {
+    if (!def && atoi(arg.c_str())) {
       def = arg.c_str();
-      }
-    return !cmSystemTools::IsOff(def);
     }
+    return !cmSystemTools::IsOff(def);
+  }
 }
 
 //=========================================================================
 // returns the resulting boolean value
 bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
-  cmExpandedCommandArgument &newArg,
-  std::string &errorString,
-  cmake::MessageType &status,
-  bool oneArg) const
+  cmExpandedCommandArgument& newArg, std::string& errorString,
+  cmake::MessageType& status, bool oneArg) const
 {
   // Use the policy if it is set.
-  if (this->Policy12Status == cmPolicies::NEW)
-    {
+  if (this->Policy12Status == cmPolicies::NEW) {
     return GetBooleanValue(newArg);
-    }
-  else if (this->Policy12Status == cmPolicies::OLD)
-    {
+  } else if (this->Policy12Status == cmPolicies::OLD) {
     return GetBooleanValueOld(newArg, oneArg);
-    }
+  }
 
   // Check policy only if old and new results differ.
   bool newResult = this->GetBooleanValue(newArg);
   bool oldResult = this->GetBooleanValueOld(newArg, oneArg);
-  if(newResult != oldResult)
-    {
-    switch(this->Policy12Status)
-      {
-      case cmPolicies::WARN:
-        {
-        errorString = "An argument named \"" + newArg.GetValue()
-          + "\" appears in a conditional statement.  "
-          + cmPolicies::GetPolicyWarning(cmPolicies::CMP0012);
+  if (newResult != oldResult) {
+    switch (this->Policy12Status) {
+      case cmPolicies::WARN: {
+        errorString = "An argument named \"" + newArg.GetValue() +
+          "\" appears in a conditional statement.  " +
+          cmPolicies::GetPolicyWarning(cmPolicies::CMP0012);
         status = cmake::AUTHOR_WARNING;
-        }
+      }
       case cmPolicies::OLD:
         return oldResult;
       case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        {
-        errorString = "An argument named \"" + newArg.GetValue()
-          + "\" appears in a conditional statement.  "
-          + cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0012);
+      case cmPolicies::REQUIRED_ALWAYS: {
+        errorString = "An argument named \"" + newArg.GetValue() +
+          "\" appears in a conditional statement.  " +
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0012);
         status = cmake::FATAL_ERROR;
-        }
+      }
       case cmPolicies::NEW:
         break;
-      }
     }
+  }
   return newResult;
 }
 
 //=========================================================================
-void cmConditionEvaluator::IncrementArguments(cmArgumentList &newArgs,
-                        cmArgumentList::iterator &argP1,
-                        cmArgumentList::iterator &argP2) const
+void cmConditionEvaluator::IncrementArguments(
+  cmArgumentList& newArgs, cmArgumentList::iterator& argP1,
+  cmArgumentList::iterator& argP2) const
 {
-  if (argP1 != newArgs.end())
-    {
+  if (argP1 != newArgs.end()) {
     argP1++;
     argP2 = argP1;
-    if (argP1 != newArgs.end())
-      {
+    if (argP1 != newArgs.end()) {
       argP2++;
-      }
     }
+  }
 }
 
 //=========================================================================
 // helper function to reduce code duplication
-void cmConditionEvaluator::HandlePredicate(bool value, int &reducible,
-                     cmArgumentList::iterator &arg,
-                     cmArgumentList &newArgs,
-                     cmArgumentList::iterator &argP1,
-                     cmArgumentList::iterator &argP2) const
+void cmConditionEvaluator::HandlePredicate(
+  bool value, int& reducible, cmArgumentList::iterator& arg,
+  cmArgumentList& newArgs, cmArgumentList::iterator& argP1,
+  cmArgumentList::iterator& argP2) const
 {
-  if(value)
-    {
+  if (value) {
     *arg = cmExpandedCommandArgument("1", true);
-    }
-  else
-    {
+  } else {
     *arg = cmExpandedCommandArgument("0", true);
-    }
+  }
   newArgs.erase(argP1);
   argP1 = arg;
-  this->IncrementArguments(newArgs,argP1,argP2);
+  this->IncrementArguments(newArgs, argP1, argP2);
   reducible = 1;
 }
 
 //=========================================================================
 // helper function to reduce code duplication
-void cmConditionEvaluator::HandleBinaryOp(bool value, int &reducible,
-                     cmArgumentList::iterator &arg,
-                     cmArgumentList &newArgs,
-                     cmArgumentList::iterator &argP1,
-                     cmArgumentList::iterator &argP2)
+void cmConditionEvaluator::HandleBinaryOp(bool value, int& reducible,
+                                          cmArgumentList::iterator& arg,
+                                          cmArgumentList& newArgs,
+                                          cmArgumentList::iterator& argP1,
+                                          cmArgumentList::iterator& argP2)
 {
-  if(value)
-    {
+  if (value) {
     *arg = cmExpandedCommandArgument("1", true);
-    }
-  else
-    {
+  } else {
     *arg = cmExpandedCommandArgument("0", true);
-    }
+  }
   newArgs.erase(argP2);
   newArgs.erase(argP1);
   argP1 = arg;
-  this->IncrementArguments(newArgs,argP1,argP2);
+  this->IncrementArguments(newArgs, argP1, argP2);
   reducible = 1;
 }
 
 //=========================================================================
 // level 0 processes parenthetical expressions
-bool cmConditionEvaluator::HandleLevel0(cmArgumentList &newArgs,
-                  std::string &errorString,
-                  cmake::MessageType &status)
+bool cmConditionEvaluator::HandleLevel0(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
 {
   int reducible;
-  do
-    {
+  do {
     reducible = 0;
     cmArgumentList::iterator arg = newArgs.begin();
-    while (arg != newArgs.end())
-      {
-      if (IsKeyword(keyParenL, *arg))
-        {
+    while (arg != newArgs.end()) {
+      if (IsKeyword(keyParenL, *arg)) {
         // search for the closing paren for this opening one
         cmArgumentList::iterator argClose;
         argClose = arg;
         argClose++;
         unsigned int depth = 1;
-        while (argClose != newArgs.end() && depth)
-          {
-          if (this->IsKeyword(keyParenL, *argClose))
-            {
-              depth++;
-            }
-          if (this->IsKeyword(keyParenR, *argClose))
-            {
-              depth--;
-            }
-          argClose++;
+        while (argClose != newArgs.end() && depth) {
+          if (this->IsKeyword(keyParenL, *argClose)) {
+            depth++;
+          }
+          if (this->IsKeyword(keyParenR, *argClose)) {
+            depth--;
           }
-        if (depth)
-          {
+          argClose++;
+        }
+        if (depth) {
           errorString = "mismatched parenthesis in condition";
           status = cmake::FATAL_ERROR;
           return false;
-          }
+        }
         // store the reduced args in this vector
         std::vector<cmExpandedCommandArgument> newArgs2;
 
@@ -444,420 +391,337 @@ bool cmConditionEvaluator::HandleLevel0(cmArgumentList &newArgs,
         newArgs2.pop_back();
         // now recursively invoke IsTrue to handle the values inside the
         // parenthetical expression
-        bool value =
-          this->IsTrue(newArgs2, errorString, status);
-        if(value)
-          {
+        bool value = this->IsTrue(newArgs2, errorString, status);
+        if (value) {
           *arg = cmExpandedCommandArgument("1", true);
-          }
-        else
-          {
+        } else {
           *arg = cmExpandedCommandArgument("0", true);
-          }
+        }
         argP1 = arg;
         argP1++;
         // remove the now evaluated parenthetical expression
-        newArgs.erase(argP1,argClose);
-        }
-      ++arg;
+        newArgs.erase(argP1, argClose);
       }
+      ++arg;
     }
-  while (reducible);
+  } while (reducible);
   return true;
 }
 
 //=========================================================================
 // level one handles most predicates except for NOT
-bool cmConditionEvaluator::HandleLevel1(cmArgumentList &newArgs,
-                  std::string &, cmake::MessageType &)
+bool cmConditionEvaluator::HandleLevel1(cmArgumentList& newArgs, std::string&,
+                                        cmake::MessageType&)
 {
   int reducible;
-  do
-    {
+  do {
     reducible = 0;
     cmArgumentList::iterator arg = newArgs.begin();
     cmArgumentList::iterator argP1;
     cmArgumentList::iterator argP2;
-    while (arg != newArgs.end())
-      {
+    while (arg != newArgs.end()) {
       argP1 = arg;
-      this->IncrementArguments(newArgs,argP1,argP2);
+      this->IncrementArguments(newArgs, argP1, argP2);
       // does a file exist
-      if (this->IsKeyword(keyEXISTS, *arg) && argP1 != newArgs.end())
-        {
-        this->HandlePredicate(
-          cmSystemTools::FileExists(argP1->c_str()),
-          reducible, arg, newArgs, argP1, argP2);
-        }
+      if (this->IsKeyword(keyEXISTS, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileExists(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
       // does a directory with this name exist
-      if (this->IsKeyword(keyIS_DIRECTORY, *arg) && argP1 != newArgs.end())
-        {
-        this->HandlePredicate(
-          cmSystemTools::FileIsDirectory(argP1->c_str()),
-          reducible, arg, newArgs, argP1, argP2);
-        }
+      if (this->IsKeyword(keyIS_DIRECTORY, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileIsDirectory(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
       // does a symlink with this name exist
-      if (this->IsKeyword(keyIS_SYMLINK, *arg) && argP1 != newArgs.end())
-        {
-        this->HandlePredicate(
-          cmSystemTools::FileIsSymlink(argP1->c_str()),
-          reducible, arg, newArgs, argP1, argP2);
-        }
+      if (this->IsKeyword(keyIS_SYMLINK, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileIsSymlink(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
       // is the given path an absolute path ?
-      if (this->IsKeyword(keyIS_ABSOLUTE, *arg) && argP1 != newArgs.end())
-        {
-        this->HandlePredicate(
-          cmSystemTools::FileIsFullPath(argP1->c_str()),
-          reducible, arg, newArgs, argP1, argP2);
-        }
+      if (this->IsKeyword(keyIS_ABSOLUTE, *arg) && argP1 != newArgs.end()) {
+        this->HandlePredicate(cmSystemTools::FileIsFullPath(argP1->c_str()),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
       // does a command exist
-      if (this->IsKeyword(keyCOMMAND, *arg) && argP1 != newArgs.end())
-        {
+      if (this->IsKeyword(keyCOMMAND, *arg) && argP1 != newArgs.end()) {
         cmCommand* command =
-            this->Makefile.GetState()->GetCommand(argP1->c_str());
-        this->HandlePredicate(
-          command ? true : false,
-          reducible, arg, newArgs, argP1, argP2);
-        }
+          this->Makefile.GetState()->GetCommand(argP1->c_str());
+        this->HandlePredicate(command ? true : false, reducible, arg, newArgs,
+                              argP1, argP2);
+      }
       // does a policy exist
-      if (this->IsKeyword(keyPOLICY, *arg) && argP1 != newArgs.end())
-        {
+      if (this->IsKeyword(keyPOLICY, *arg) && argP1 != newArgs.end()) {
         cmPolicies::PolicyID pid;
-        this->HandlePredicate(
-          cmPolicies::GetPolicyID(argP1->c_str(), pid),
-            reducible, arg, newArgs, argP1, argP2);
-        }
+        this->HandlePredicate(cmPolicies::GetPolicyID(argP1->c_str(), pid),
+                              reducible, arg, newArgs, argP1, argP2);
+      }
       // does a target exist
-      if (this->IsKeyword(keyTARGET, *arg) && argP1 != newArgs.end())
-        {
+      if (this->IsKeyword(keyTARGET, *arg) && argP1 != newArgs.end()) {
         this->HandlePredicate(
-          this->Makefile.FindTargetToUse(argP1->GetValue())?true:false,
+          this->Makefile.FindTargetToUse(argP1->GetValue()) ? true : false,
           reducible, arg, newArgs, argP1, argP2);
-        }
+      }
       // does a test exist
-      if(this->Policy64Status != cmPolicies::OLD &&
-        this->Policy64Status != cmPolicies::WARN)
-        {
-        if (this->IsKeyword(keyTEST, *arg) && argP1 != newArgs.end())
-          {
+      if (this->Policy64Status != cmPolicies::OLD &&
+          this->Policy64Status != cmPolicies::WARN) {
+        if (this->IsKeyword(keyTEST, *arg) && argP1 != newArgs.end()) {
           const cmTest* haveTest = this->Makefile.GetTest(argP1->c_str());
-          this->HandlePredicate(
-            haveTest?true:false,
-            reducible, arg, newArgs, argP1, argP2);
-          }
+          this->HandlePredicate(haveTest ? true : false, reducible, arg,
+                                newArgs, argP1, argP2);
         }
-      else if(this->Policy64Status == cmPolicies::WARN &&
-        this->IsKeyword(keyTEST, *arg))
-        {
+      } else if (this->Policy64Status == cmPolicies::WARN &&
+                 this->IsKeyword(keyTEST, *arg)) {
         std::ostringstream e;
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0064) << "\n";
         e << "TEST will be interpreted as an operator "
-          "when the policy is set to NEW.  "
-          "Since the policy is not set the OLD behavior will be used.";
+             "when the policy is set to NEW.  "
+             "Since the policy is not set the OLD behavior will be used.";
 
         this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str());
-        }
+      }
       // is a variable defined
-      if (this->IsKeyword(keyDEFINED, *arg) && argP1 != newArgs.end())
-        {
+      if (this->IsKeyword(keyDEFINED, *arg) && argP1 != newArgs.end()) {
         size_t argP1len = argP1->GetValue().size();
         bool bdef = false;
-        if(argP1len > 4 && argP1->GetValue().substr(0, 4) == "ENV{" &&
-           argP1->GetValue().operator[](argP1len-1) == '}')
-          {
-          std::string env = argP1->GetValue().substr(4, argP1len-5);
-          bdef = cmSystemTools::GetEnv(env.c_str())?true:false;
-          }
-        else
-          {
+        if (argP1len > 4 && argP1->GetValue().substr(0, 4) == "ENV{" &&
+            argP1->GetValue().operator[](argP1len - 1) == '}') {
+          std::string env = argP1->GetValue().substr(4, argP1len - 5);
+          bdef = cmSystemTools::GetEnv(env.c_str()) ? true : false;
+        } else {
           bdef = this->Makefile.IsDefinitionSet(argP1->GetValue());
-          }
-        this->HandlePredicate(bdef, reducible, arg, newArgs, argP1, argP2);
         }
-      ++arg;
+        this->HandlePredicate(bdef, reducible, arg, newArgs, argP1, argP2);
       }
+      ++arg;
     }
-  while (reducible);
+  } while (reducible);
   return true;
 }
 
 //=========================================================================
 // level two handles most binary operations except for AND  OR
-bool cmConditionEvaluator::HandleLevel2(cmArgumentList &newArgs,
-                  std::string &errorString,
-                  cmake::MessageType &status)
+bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
 {
   int reducible;
   std::string def_buf;
-  const char *def;
-  const char *def2;
-  do
-    {
+  const char* def;
+  const char* def2;
+  do {
     reducible = 0;
     cmArgumentList::iterator arg = newArgs.begin();
     cmArgumentList::iterator argP1;
     cmArgumentList::iterator argP2;
-    while (arg != newArgs.end())
-      {
+    while (arg != newArgs.end()) {
       argP1 = arg;
-      this->IncrementArguments(newArgs,argP1,argP2);
+      this->IncrementArguments(newArgs, argP1, argP2);
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-        IsKeyword(keyMATCHES, *argP1))
-        {
+          IsKeyword(keyMATCHES, *argP1)) {
         def = this->GetVariableOrString(*arg);
         if (def != arg->c_str() // yes, we compare the pointer value
-            && cmHasLiteralPrefix(arg->GetValue(), "CMAKE_MATCH_"))
-          {
+            && cmHasLiteralPrefix(arg->GetValue(), "CMAKE_MATCH_")) {
           // The string to match is owned by our match result variables.
           // Move it to our own buffer before clearing them.
           def_buf = def;
           def = def_buf.c_str();
-          }
+        }
         const char* rex = argP2->c_str();
         this->Makefile.ClearMatches();
         cmsys::RegularExpression regEntry;
-        if ( !regEntry.compile(rex) )
-          {
+        if (!regEntry.compile(rex)) {
           std::ostringstream error;
           error << "Regular expression \"" << rex << "\" cannot compile";
           errorString = error.str();
           status = cmake::FATAL_ERROR;
           return false;
-          }
-        if (regEntry.find(def))
-          {
+        }
+        if (regEntry.find(def)) {
           this->Makefile.StoreMatches(regEntry);
           *arg = cmExpandedCommandArgument("1", true);
-          }
-        else
-          {
+        } else {
           *arg = cmExpandedCommandArgument("0", true);
-          }
+        }
         newArgs.erase(argP2);
         newArgs.erase(argP1);
         argP1 = arg;
-        this->IncrementArguments(newArgs,argP1,argP2);
+        this->IncrementArguments(newArgs, argP1, argP2);
         reducible = 1;
-        }
+      }
 
-      if (argP1 != newArgs.end() && this->IsKeyword(keyMATCHES, *arg))
-        {
+      if (argP1 != newArgs.end() && this->IsKeyword(keyMATCHES, *arg)) {
         *arg = cmExpandedCommandArgument("0", true);
         newArgs.erase(argP1);
         argP1 = arg;
-        this->IncrementArguments(newArgs,argP1,argP2);
+        this->IncrementArguments(newArgs, argP1, argP2);
         reducible = 1;
-        }
+      }
 
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-        (this->IsKeyword(keyLESS, *argP1) ||
-         this->IsKeyword(keyGREATER, *argP1) ||
-         this->IsKeyword(keyEQUAL, *argP1)))
-        {
+          (this->IsKeyword(keyLESS, *argP1) ||
+           this->IsKeyword(keyGREATER, *argP1) ||
+           this->IsKeyword(keyEQUAL, *argP1))) {
         def = this->GetVariableOrString(*arg);
         def2 = this->GetVariableOrString(*argP2);
         double lhs;
         double rhs;
         bool result;
-        if(sscanf(def, "%lg", &lhs) != 1 ||
-           sscanf(def2, "%lg", &rhs) != 1)
-          {
+        if (sscanf(def, "%lg", &lhs) != 1 || sscanf(def2, "%lg", &rhs) != 1) {
           result = false;
-          }
-        else if (*(argP1) == keyLESS)
-          {
+        } else if (*(argP1) == keyLESS) {
           result = (lhs < rhs);
-          }
-        else if (*(argP1) == keyGREATER)
-          {
+        } else if (*(argP1) == keyGREATER) {
           result = (lhs > rhs);
-          }
-        else
-          {
+        } else {
           result = (lhs == rhs);
-          }
-        this->HandleBinaryOp(result,
-          reducible, arg, newArgs, argP1, argP2);
         }
+        this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+      }
 
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-        (this->IsKeyword(keySTRLESS, *argP1) ||
-         this->IsKeyword(keySTREQUAL, *argP1) ||
-         this->IsKeyword(keySTRGREATER, *argP1)))
-        {
+          (this->IsKeyword(keySTRLESS, *argP1) ||
+           this->IsKeyword(keySTREQUAL, *argP1) ||
+           this->IsKeyword(keySTRGREATER, *argP1))) {
         def = this->GetVariableOrString(*arg);
         def2 = this->GetVariableOrString(*argP2);
-        int val = strcmp(def,def2);
+        int val = strcmp(def, def2);
         bool result;
-        if (*(argP1) == keySTRLESS)
-          {
+        if (*(argP1) == keySTRLESS) {
           result = (val < 0);
-          }
-        else if (*(argP1) == keySTRGREATER)
-          {
+        } else if (*(argP1) == keySTRGREATER) {
           result = (val > 0);
-          }
-        else // strequal
-          {
+        } else // strequal
+        {
           result = (val == 0);
-          }
-        this->HandleBinaryOp(result,
-          reducible, arg, newArgs, argP1, argP2);
         }
+        this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+      }
 
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-        (this->IsKeyword(keyVERSION_LESS, *argP1) ||
-         this->IsKeyword(keyVERSION_GREATER, *argP1) ||
-         this->IsKeyword(keyVERSION_EQUAL, *argP1)))
-        {
+          (this->IsKeyword(keyVERSION_LESS, *argP1) ||
+           this->IsKeyword(keyVERSION_GREATER, *argP1) ||
+           this->IsKeyword(keyVERSION_EQUAL, *argP1))) {
         def = this->GetVariableOrString(*arg);
         def2 = this->GetVariableOrString(*argP2);
         cmSystemTools::CompareOp op = cmSystemTools::OP_EQUAL;
-        if(*argP1 == keyVERSION_LESS)
-          {
+        if (*argP1 == keyVERSION_LESS) {
           op = cmSystemTools::OP_LESS;
-          }
-        else if(*argP1 == keyVERSION_GREATER)
-          {
+        } else if (*argP1 == keyVERSION_GREATER) {
           op = cmSystemTools::OP_GREATER;
-          }
-        bool result = cmSystemTools::VersionCompare(op, def, def2);
-        this->HandleBinaryOp(result,
-          reducible, arg, newArgs, argP1, argP2);
         }
+        bool result = cmSystemTools::VersionCompare(op, def, def2);
+        this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+      }
 
       // is file A newer than file B
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-          this->IsKeyword(keyIS_NEWER_THAN, *argP1))
-        {
-        int fileIsNewer=0;
-        bool success=cmSystemTools::FileTimeCompare(arg->GetValue(),
-            (argP2)->GetValue(),
-            &fileIsNewer);
+          this->IsKeyword(keyIS_NEWER_THAN, *argP1)) {
+        int fileIsNewer = 0;
+        bool success = cmSystemTools::FileTimeCompare(
+          arg->GetValue(), (argP2)->GetValue(), &fileIsNewer);
         this->HandleBinaryOp(
-          (success==false || fileIsNewer==1 || fileIsNewer==0),
+          (success == false || fileIsNewer == 1 || fileIsNewer == 0),
           reducible, arg, newArgs, argP1, argP2);
-        }
+      }
 
       if (argP1 != newArgs.end() && argP2 != newArgs.end() &&
-          this->IsKeyword(keyIN_LIST, *argP1))
-        {
-        if(this->Policy57Status != cmPolicies::OLD &&
-          this->Policy57Status != cmPolicies::WARN)
-          {
+          this->IsKeyword(keyIN_LIST, *argP1)) {
+        if (this->Policy57Status != cmPolicies::OLD &&
+            this->Policy57Status != cmPolicies::WARN) {
           bool result = false;
 
           def = this->GetVariableOrString(*arg);
           def2 = this->Makefile.GetDefinition(argP2->GetValue());
 
-          if(def2)
-            {
+          if (def2) {
             std::vector<std::string> list;
             cmSystemTools::ExpandListArgument(def2, list, true);
 
             result = std::find(list.begin(), list.end(), def) != list.end();
-            }
-
-          this->HandleBinaryOp(result,
-            reducible, arg, newArgs, argP1, argP2);
           }
-          else if(this->Policy57Status == cmPolicies::WARN)
-            {
-            std::ostringstream e;
-            e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0057) << "\n";
-            e << "IN_LIST will be interpreted as an operator "
-              "when the policy is set to NEW.  "
-              "Since the policy is not set the OLD behavior will be used.";
-
-            this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str());
-            }
+
+          this->HandleBinaryOp(result, reducible, arg, newArgs, argP1, argP2);
+        } else if (this->Policy57Status == cmPolicies::WARN) {
+          std::ostringstream e;
+          e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0057) << "\n";
+          e << "IN_LIST will be interpreted as an operator "
+               "when the policy is set to NEW.  "
+               "Since the policy is not set the OLD behavior will be used.";
+
+          this->Makefile.IssueMessage(cmake::AUTHOR_WARNING, e.str());
         }
+      }
 
       ++arg;
-      }
     }
-  while (reducible);
+  } while (reducible);
   return true;
 }
 
 //=========================================================================
 // level 3 handles NOT
-bool cmConditionEvaluator::HandleLevel3(cmArgumentList &newArgs,
-                  std::string &errorString,
-                  cmake::MessageType &status)
+bool cmConditionEvaluator::HandleLevel3(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
 {
   int reducible;
-  do
-    {
+  do {
     reducible = 0;
     cmArgumentList::iterator arg = newArgs.begin();
     cmArgumentList::iterator argP1;
     cmArgumentList::iterator argP2;
-    while (arg != newArgs.end())
-      {
+    while (arg != newArgs.end()) {
       argP1 = arg;
-      IncrementArguments(newArgs,argP1,argP2);
-      if (argP1 != newArgs.end() && IsKeyword(keyNOT, *arg))
-        {
-        bool rhs = this->GetBooleanValueWithAutoDereference(*argP1,
-                                                      errorString,
-                                                      status);
+      IncrementArguments(newArgs, argP1, argP2);
+      if (argP1 != newArgs.end() && IsKeyword(keyNOT, *arg)) {
+        bool rhs = this->GetBooleanValueWithAutoDereference(
+          *argP1, errorString, status);
         this->HandlePredicate(!rhs, reducible, arg, newArgs, argP1, argP2);
-        }
-      ++arg;
       }
+      ++arg;
     }
-  while (reducible);
+  } while (reducible);
   return true;
 }
 
 //=========================================================================
 // level 4 handles AND OR
-bool cmConditionEvaluator::HandleLevel4(cmArgumentList &newArgs,
-                  std::string &errorString,
-                  cmake::MessageType &status)
+bool cmConditionEvaluator::HandleLevel4(cmArgumentList& newArgs,
+                                        std::string& errorString,
+                                        cmake::MessageType& status)
 {
   int reducible;
   bool lhs;
   bool rhs;
-  do
-    {
+  do {
     reducible = 0;
     cmArgumentList::iterator arg = newArgs.begin();
     cmArgumentList::iterator argP1;
     cmArgumentList::iterator argP2;
-    while (arg != newArgs.end())
-      {
+    while (arg != newArgs.end()) {
       argP1 = arg;
-      IncrementArguments(newArgs,argP1,argP2);
+      IncrementArguments(newArgs, argP1, argP2);
       if (argP1 != newArgs.end() && IsKeyword(keyAND, *argP1) &&
-        argP2 != newArgs.end())
-        {
-        lhs = this->GetBooleanValueWithAutoDereference(*arg,
-                                                 errorString,
-                                                 status);
-        rhs = this->GetBooleanValueWithAutoDereference(*argP2,
-                                                 errorString,
-                                                 status);
-        this->HandleBinaryOp((lhs && rhs),
-          reducible, arg, newArgs, argP1, argP2);
-        }
+          argP2 != newArgs.end()) {
+        lhs =
+          this->GetBooleanValueWithAutoDereference(*arg, errorString, status);
+        rhs = this->GetBooleanValueWithAutoDereference(*argP2, errorString,
+                                                       status);
+        this->HandleBinaryOp((lhs && rhs), reducible, arg, newArgs, argP1,
+                             argP2);
+      }
 
       if (argP1 != newArgs.end() && this->IsKeyword(keyOR, *argP1) &&
-        argP2 != newArgs.end())
-        {
-        lhs = this->GetBooleanValueWithAutoDereference(*arg,
-                                                 errorString,
-                                                 status);
-        rhs = this->GetBooleanValueWithAutoDereference(*argP2,
-                                                 errorString,
-                                                 status);
-        this->HandleBinaryOp((lhs || rhs),
-          reducible, arg, newArgs, argP1, argP2);
-        }
-      ++arg;
+          argP2 != newArgs.end()) {
+        lhs =
+          this->GetBooleanValueWithAutoDereference(*arg, errorString, status);
+        rhs = this->GetBooleanValueWithAutoDereference(*argP2, errorString,
+                                                       status);
+        this->HandleBinaryOp((lhs || rhs), reducible, arg, newArgs, argP1,
+                             argP2);
       }
+      ++arg;
     }
-  while (reducible);
+  } while (reducible);
   return true;
 }
diff --git a/Source/cmConditionEvaluator.h b/Source/cmConditionEvaluator.h
index 3ed512d..3f8c984 100644
--- a/Source/cmConditionEvaluator.h
+++ b/Source/cmConditionEvaluator.h
@@ -22,75 +22,64 @@ class cmConditionEvaluator
 public:
   typedef std::list<cmExpandedCommandArgument> cmArgumentList;
 
-  cmConditionEvaluator(cmMakefile& makefile,
-                       cmListFileContext const& context,
+  cmConditionEvaluator(cmMakefile& makefile, cmListFileContext const& context,
                        cmListFileBacktrace const& bt);
 
   // this is a shared function for both If and Else to determine if the
   // arguments were valid, and if so, was the response true. If there is
   // an error, the errorString will be set.
-  bool IsTrue(const std::vector<cmExpandedCommandArgument> &args,
-      std::string &errorString,
-      cmake::MessageType &status);
+  bool IsTrue(const std::vector<cmExpandedCommandArgument>& args,
+              std::string& errorString, cmake::MessageType& status);
 
 private:
   // Filter the given variable definition based on policy CMP0054.
   const char* GetDefinitionIfUnquoted(
-      const cmExpandedCommandArgument& argument) const;
+    const cmExpandedCommandArgument& argument) const;
 
   const char* GetVariableOrString(
-      const cmExpandedCommandArgument& argument) const;
+    const cmExpandedCommandArgument& argument) const;
 
   bool IsKeyword(std::string const& keyword,
-    cmExpandedCommandArgument& argument) const;
-
-  bool GetBooleanValue(
-    cmExpandedCommandArgument& arg) const;
-
-  bool GetBooleanValueOld(
-    cmExpandedCommandArgument const& arg, bool one) const;
-
-  bool GetBooleanValueWithAutoDereference(
-    cmExpandedCommandArgument &newArg,
-    std::string &errorString,
-    cmake::MessageType &status,
-    bool oneArg = false) const;
-
-  void IncrementArguments(
-    cmArgumentList &newArgs,
-    cmArgumentList::iterator &argP1,
-    cmArgumentList::iterator &argP2) const;
-
-  void HandlePredicate(bool value, int &reducible,
-     cmArgumentList::iterator &arg,
-     cmArgumentList &newArgs,
-     cmArgumentList::iterator &argP1,
-     cmArgumentList::iterator &argP2) const;
-
-  void HandleBinaryOp(bool value, int &reducible,
-     cmArgumentList::iterator &arg,
-     cmArgumentList &newArgs,
-     cmArgumentList::iterator &argP1,
-     cmArgumentList::iterator &argP2);
-
-  bool HandleLevel0(cmArgumentList &newArgs,
-      std::string &errorString,
-      cmake::MessageType &status);
-
-  bool HandleLevel1(cmArgumentList &newArgs,
-      std::string &, cmake::MessageType &);
-
-  bool HandleLevel2(cmArgumentList &newArgs,
-      std::string &errorString,
-      cmake::MessageType &status);
-
-  bool HandleLevel3(cmArgumentList &newArgs,
-      std::string &errorString,
-      cmake::MessageType &status);
-
-  bool HandleLevel4(cmArgumentList &newArgs,
-      std::string &errorString,
-      cmake::MessageType &status);
+                 cmExpandedCommandArgument& argument) const;
+
+  bool GetBooleanValue(cmExpandedCommandArgument& arg) const;
+
+  bool GetBooleanValueOld(cmExpandedCommandArgument const& arg,
+                          bool one) const;
+
+  bool GetBooleanValueWithAutoDereference(cmExpandedCommandArgument& newArg,
+                                          std::string& errorString,
+                                          cmake::MessageType& status,
+                                          bool oneArg = false) const;
+
+  void IncrementArguments(cmArgumentList& newArgs,
+                          cmArgumentList::iterator& argP1,
+                          cmArgumentList::iterator& argP2) const;
+
+  void HandlePredicate(bool value, int& reducible,
+                       cmArgumentList::iterator& arg, cmArgumentList& newArgs,
+                       cmArgumentList::iterator& argP1,
+                       cmArgumentList::iterator& argP2) const;
+
+  void HandleBinaryOp(bool value, int& reducible,
+                      cmArgumentList::iterator& arg, cmArgumentList& newArgs,
+                      cmArgumentList::iterator& argP1,
+                      cmArgumentList::iterator& argP2);
+
+  bool HandleLevel0(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  bool HandleLevel1(cmArgumentList& newArgs, std::string&,
+                    cmake::MessageType&);
+
+  bool HandleLevel2(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  bool HandleLevel3(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
+
+  bool HandleLevel4(cmArgumentList& newArgs, std::string& errorString,
+                    cmake::MessageType& status);
 
   cmMakefile& Makefile;
   cmListFileContext ExecutionContext;
diff --git a/Source/cmConfigureFileCommand.cxx b/Source/cmConfigureFileCommand.cxx
index 94c778b..899a674 100644
--- a/Source/cmConfigureFileCommand.cxx
+++ b/Source/cmConfigureFileCommand.cxx
@@ -14,26 +14,23 @@
 #include <cmsys/RegularExpression.hxx>
 
 // cmConfigureFileCommand
-bool cmConfigureFileCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmConfigureFileCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments, expected 2");
     return false;
-    }
+  }
 
   const char* inFile = args[0].c_str();
-  if(!cmSystemTools::FileIsFullPath(inFile))
-    {
+  if (!cmSystemTools::FileIsFullPath(inFile)) {
     this->InputFile = this->Makefile->GetCurrentSourceDirectory();
     this->InputFile += "/";
-    }
+  }
   this->InputFile += inFile;
 
   // If the input location is a directory, error out.
-  if(cmSystemTools::FileIsDirectory(this->InputFile))
-    {
+  if (cmSystemTools::FileIsDirectory(this->InputFile)) {
     std::ostringstream e;
     /* clang-format off */
     e << "input location\n"
@@ -42,92 +39,72 @@ bool cmConfigureFileCommand
     /* clang-format on */
     this->SetError(e.str());
     return false;
-    }
+  }
 
   const char* outFile = args[1].c_str();
-  if(!cmSystemTools::FileIsFullPath(outFile))
-    {
+  if (!cmSystemTools::FileIsFullPath(outFile)) {
     this->OutputFile = this->Makefile->GetCurrentBinaryDirectory();
     this->OutputFile += "/";
-    }
+  }
   this->OutputFile += outFile;
 
   // If the output location is already a directory put the file in it.
-  if(cmSystemTools::FileIsDirectory(this->OutputFile))
-    {
+  if (cmSystemTools::FileIsDirectory(this->OutputFile)) {
     this->OutputFile += "/";
     this->OutputFile += cmSystemTools::GetFilenameName(inFile);
-    }
+  }
 
-  if ( !this->Makefile->CanIWriteThisFile(this->OutputFile.c_str()) )
-    {
-    std::string e = "attempted to configure a file: " + this->OutputFile
-      + " into a source directory.";
+  if (!this->Makefile->CanIWriteThisFile(this->OutputFile.c_str())) {
+    std::string e = "attempted to configure a file: " + this->OutputFile +
+      " into a source directory.";
     this->SetError(e);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
   std::string errorMessage;
-  if (!this->NewLineStyle.ReadFromArguments(args, errorMessage))
-    {
+  if (!this->NewLineStyle.ReadFromArguments(args, errorMessage)) {
     this->SetError(errorMessage);
     return false;
-    }
+  }
   this->CopyOnly = false;
   this->EscapeQuotes = false;
 
   std::string unknown_args;
   this->AtOnly = false;
-  for(unsigned int i=2;i < args.size();++i)
-    {
-    if(args[i] == "COPYONLY")
-      {
+  for (unsigned int i = 2; i < args.size(); ++i) {
+    if (args[i] == "COPYONLY") {
       this->CopyOnly = true;
-      if (this->NewLineStyle.IsValid())
-        {
+      if (this->NewLineStyle.IsValid()) {
         this->SetError("COPYONLY could not be used in combination "
                        "with NEWLINE_STYLE");
         return false;
-        }
       }
-    else if(args[i] == "ESCAPE_QUOTES")
-      {
+    } else if (args[i] == "ESCAPE_QUOTES") {
       this->EscapeQuotes = true;
-      }
-    else if(args[i] == "@ONLY")
-      {
+    } else if (args[i] == "@ONLY") {
       this->AtOnly = true;
-      }
-    else if(args[i] == "IMMEDIATE")
-      {
+    } else if (args[i] == "IMMEDIATE") {
       /* Ignore legacy option.  */
-      }
-    else if(args[i] == "NEWLINE_STYLE" ||
-            args[i] == "LF" || args[i] == "UNIX" ||
-            args[i] == "CRLF" || args[i] == "WIN32" ||
-            args[i] == "DOS")
-      {
+    } else if (args[i] == "NEWLINE_STYLE" || args[i] == "LF" ||
+               args[i] == "UNIX" || args[i] == "CRLF" || args[i] == "WIN32" ||
+               args[i] == "DOS") {
       /* Options handled by NewLineStyle member above.  */
-      }
-    else
-      {
+    } else {
       unknown_args += " ";
       unknown_args += args[i];
       unknown_args += "\n";
-      }
     }
-  if (!unknown_args.empty())
-    {
+  }
+  if (!unknown_args.empty()) {
     std::string msg = "configure_file called with unknown argument(s):\n";
     msg += unknown_args;
     this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, msg);
-    }
+  }
 
-  if ( !this->ConfigureFile() )
-    {
+  if (!this->ConfigureFile()) {
     this->SetError("Problem configuring file");
     return false;
-    }
+  }
 
   return true;
 }
@@ -135,12 +112,6 @@ bool cmConfigureFileCommand
 int cmConfigureFileCommand::ConfigureFile()
 {
   return this->Makefile->ConfigureFile(
-    this->InputFile.c_str(),
-    this->OutputFile.c_str(),
-    this->CopyOnly,
-    this->AtOnly,
-    this->EscapeQuotes,
-    this->NewLineStyle);
+    this->InputFile.c_str(), this->OutputFile.c_str(), this->CopyOnly,
+    this->AtOnly, this->EscapeQuotes, this->NewLineStyle);
 }
-
-
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
index 8155ef7..79f00bc 100644
--- a/Source/cmConfigureFileCommand.h
+++ b/Source/cmConfigureFileCommand.h
@@ -19,22 +19,19 @@ class cmConfigureFileCommand : public cmCommand
 public:
   cmTypeMacro(cmConfigureFileCommand, cmCommand);
 
-  virtual cmCommand* Clone()
-    {
-      return new cmConfigureFileCommand;
-    }
+  virtual cmCommand* Clone() { return new cmConfigureFileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "configure_file";}
+  virtual std::string GetName() const { return "configure_file"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -53,6 +50,4 @@ private:
   bool AtOnly;
 };
 
-
-
 #endif
diff --git a/Source/cmContinueCommand.cxx b/Source/cmContinueCommand.cxx
index 4a03caa..c8c1b7d 100644
--- a/Source/cmContinueCommand.cxx
+++ b/Source/cmContinueCommand.cxx
@@ -12,28 +12,26 @@
 #include "cmContinueCommand.h"
 
 // cmContinueCommand
-bool cmContinueCommand::InitialPass(std::vector<std::string> const &args,
-                                  cmExecutionStatus &status)
+bool cmContinueCommand::InitialPass(std::vector<std::string> const& args,
+                                    cmExecutionStatus& status)
 {
-  if(!this->Makefile->IsLoopBlock())
-    {
+  if (!this->Makefile->IsLoopBlock()) {
     this->Makefile->IssueMessage(cmake::FATAL_ERROR,
                                  "A CONTINUE command was found outside of a "
                                  "proper FOREACH or WHILE loop scope.");
     cmSystemTools::SetFatalErrorOccured();
     return true;
-    }
+  }
 
   status.SetContinueInvoked(true);
 
-  if(!args.empty())
-    {
+  if (!args.empty()) {
     this->Makefile->IssueMessage(cmake::FATAL_ERROR,
                                  "The CONTINUE command does not accept any "
                                  "arguments.");
     cmSystemTools::SetFatalErrorOccured();
     return true;
-    }
+  }
 
   return true;
 }
diff --git a/Source/cmContinueCommand.h b/Source/cmContinueCommand.h
index 093b14f..63ae59d 100644
--- a/Source/cmContinueCommand.h
+++ b/Source/cmContinueCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmContinueCommand;
-    }
+  virtual cmCommand* Clone() { return new cmContinueCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -50,6 +47,4 @@ public:
   cmTypeMacro(cmContinueCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index 18dca91..9d83624 100644
--- a/Source/cmCoreTryCompile.cxx
+++ b/Source/cmCoreTryCompile.cxx
@@ -31,30 +31,26 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
   cmState::TargetType targetType = cmState::EXECUTABLE;
   const char* tt =
     this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_TARGET_TYPE");
-  if (!isTryRun && tt && *tt)
-    {
-    if (strcmp(tt, cmState::GetTargetTypeName(cmState::EXECUTABLE)) == 0)
-      {
+  if (!isTryRun && tt && *tt) {
+    if (strcmp(tt, cmState::GetTargetTypeName(cmState::EXECUTABLE)) == 0) {
       targetType = cmState::EXECUTABLE;
-      }
-    else if (strcmp(tt,
-                    cmState::GetTargetTypeName(cmState::STATIC_LIBRARY)) == 0)
-      {
+    } else if (strcmp(tt, cmState::GetTargetTypeName(
+                            cmState::STATIC_LIBRARY)) == 0) {
       targetType = cmState::STATIC_LIBRARY;
-      }
-    else
-      {
+    } else {
       this->Makefile->IssueMessage(
-        cmake::FATAL_ERROR,
-        std::string("Invalid value '") + tt + "' for "
-        "CMAKE_TRY_COMPILE_TARGET_TYPE.  Only "
-        "'" + cmState::GetTargetTypeName(cmState::EXECUTABLE) + "' and "
-        "'" + cmState::GetTargetTypeName(cmState::STATIC_LIBRARY) + "' "
-        "are allowed."
-        );
+        cmake::FATAL_ERROR, std::string("Invalid value '") + tt +
+          "' for "
+          "CMAKE_TRY_COMPILE_TARGET_TYPE.  Only "
+          "'" +
+          cmState::GetTargetTypeName(cmState::EXECUTABLE) + "' and "
+                                                            "'" +
+          cmState::GetTargetTypeName(cmState::STATIC_LIBRARY) +
+          "' "
+          "are allowed.");
       return -1;
-      }
     }
+  }
 
   const char* sourceDirectory = argv[2].c_str();
   const char* projectName = 0;
@@ -74,213 +70,176 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
   bool useSources = argv[2] == "SOURCES";
   std::vector<std::string> sources;
 
-  enum Doing { DoingNone, DoingCMakeFlags, DoingCompileDefinitions,
-               DoingLinkLibraries, DoingOutputVariable, DoingCopyFile,
-               DoingCopyFileError, DoingSources };
-  Doing doing = useSources? DoingSources : DoingNone;
-  for(size_t i=3; i < argv.size(); ++i)
-    {
-    if(argv[i] == "CMAKE_FLAGS")
-      {
+  enum Doing
+  {
+    DoingNone,
+    DoingCMakeFlags,
+    DoingCompileDefinitions,
+    DoingLinkLibraries,
+    DoingOutputVariable,
+    DoingCopyFile,
+    DoingCopyFileError,
+    DoingSources
+  };
+  Doing doing = useSources ? DoingSources : DoingNone;
+  for (size_t i = 3; i < argv.size(); ++i) {
+    if (argv[i] == "CMAKE_FLAGS") {
       doing = DoingCMakeFlags;
-      }
-    else if(argv[i] == "COMPILE_DEFINITIONS")
-      {
+    } else if (argv[i] == "COMPILE_DEFINITIONS") {
       doing = DoingCompileDefinitions;
-      }
-    else if(argv[i] == "LINK_LIBRARIES")
-      {
+    } else if (argv[i] == "LINK_LIBRARIES") {
       doing = DoingLinkLibraries;
       useOldLinkLibs = false;
-      }
-    else if(argv[i] == "OUTPUT_VARIABLE")
-      {
+    } else if (argv[i] == "OUTPUT_VARIABLE") {
       doing = DoingOutputVariable;
       didOutputVariable = true;
-      }
-    else if(argv[i] == "COPY_FILE")
-      {
+    } else if (argv[i] == "COPY_FILE") {
       doing = DoingCopyFile;
       didCopyFile = true;
-      }
-    else if(argv[i] == "COPY_FILE_ERROR")
-      {
+    } else if (argv[i] == "COPY_FILE_ERROR") {
       doing = DoingCopyFileError;
       didCopyFileError = true;
-      }
-    else if(doing == DoingCMakeFlags)
-      {
+    } else if (doing == DoingCMakeFlags) {
       cmakeFlags.push_back(argv[i]);
-      }
-    else if(doing == DoingCompileDefinitions)
-      {
+    } else if (doing == DoingCompileDefinitions) {
       compileDefs.push_back(argv[i]);
-      }
-    else if(doing == DoingLinkLibraries)
-      {
+    } else if (doing == DoingLinkLibraries) {
       libsToLink += "\"" + cmSystemTools::TrimWhitespace(argv[i]) + "\" ";
-      if(cmTarget *tgt = this->Makefile->FindTargetToUse(argv[i]))
-        {
-        switch(tgt->GetType())
-          {
+      if (cmTarget* tgt = this->Makefile->FindTargetToUse(argv[i])) {
+        switch (tgt->GetType()) {
           case cmState::SHARED_LIBRARY:
           case cmState::STATIC_LIBRARY:
           case cmState::INTERFACE_LIBRARY:
           case cmState::UNKNOWN_LIBRARY:
             break;
           case cmState::EXECUTABLE:
-            if (tgt->IsExecutableWithExports())
-              {
+            if (tgt->IsExecutableWithExports()) {
               break;
-              }
+            }
           default:
-            this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+            this->Makefile->IssueMessage(
+              cmake::FATAL_ERROR,
               "Only libraries may be used as try_compile or try_run IMPORTED "
-              "LINK_LIBRARIES.  Got " + std::string(tgt->GetName()) + " of "
-              "type " + cmState::GetTargetTypeName(tgt->GetType()) + ".");
+              "LINK_LIBRARIES.  Got " +
+                std::string(tgt->GetName()) + " of "
+                                              "type " +
+                cmState::GetTargetTypeName(tgt->GetType()) + ".");
             return -1;
-          }
-        if (tgt->IsImported())
-          {
+        }
+        if (tgt->IsImported()) {
           targets.push_back(argv[i]);
-          }
         }
       }
-    else if(doing == DoingOutputVariable)
-      {
+    } else if (doing == DoingOutputVariable) {
       outputVariable = argv[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingCopyFile)
-      {
+    } else if (doing == DoingCopyFile) {
       copyFile = argv[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingCopyFileError)
-      {
+    } else if (doing == DoingCopyFileError) {
       copyFileError = argv[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingSources)
-      {
+    } else if (doing == DoingSources) {
       sources.push_back(argv[i]);
-      }
-    else if(i == 3)
-      {
+    } else if (i == 3) {
       this->SrcFileSignature = false;
       projectName = argv[i].c_str();
-      }
-    else if(i == 4 && !this->SrcFileSignature)
-      {
+    } else if (i == 4 && !this->SrcFileSignature) {
       targetName = argv[i].c_str();
-      }
-    else
-      {
+    } else {
       std::ostringstream m;
       m << "try_compile given unknown argument \"" << argv[i] << "\".";
       this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, m.str());
-      }
     }
+  }
 
-  if(didCopyFile && copyFile.empty())
-    {
+  if (didCopyFile && copyFile.empty()) {
     this->Makefile->IssueMessage(cmake::FATAL_ERROR,
-      "COPY_FILE must be followed by a file path");
+                                 "COPY_FILE must be followed by a file path");
     return -1;
-    }
+  }
 
-  if(didCopyFileError && copyFileError.empty())
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+  if (didCopyFileError && copyFileError.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
       "COPY_FILE_ERROR must be followed by a variable name");
     return -1;
-    }
+  }
 
-  if(didCopyFileError && !didCopyFile)
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
-      "COPY_FILE_ERROR may be used only with COPY_FILE");
+  if (didCopyFileError && !didCopyFile) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR, "COPY_FILE_ERROR may be used only with COPY_FILE");
     return -1;
-    }
+  }
 
-  if(didOutputVariable && outputVariable.empty())
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+  if (didOutputVariable && outputVariable.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
       "OUTPUT_VARIABLE must be followed by a variable name");
     return -1;
-    }
+  }
 
-  if(useSources && sources.empty())
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+  if (useSources && sources.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
       "SOURCES must be followed by at least one source file");
     return -1;
-    }
+  }
 
   // compute the binary dir when TRY_COMPILE is called with a src file
   // signature
-  if (this->SrcFileSignature)
-    {
+  if (this->SrcFileSignature) {
     this->BinaryDirectory += cmake::GetCMakeFilesDirectory();
     this->BinaryDirectory += "/CMakeTmp";
-    }
-  else
-    {
+  } else {
     // only valid for srcfile signatures
-    if (!compileDefs.empty())
-      {
-      this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+    if (!compileDefs.empty()) {
+      this->Makefile->IssueMessage(
+        cmake::FATAL_ERROR,
         "COMPILE_DEFINITIONS specified on a srcdir type TRY_COMPILE");
       return -1;
-      }
-    if (!copyFile.empty())
-      {
-      this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+    }
+    if (!copyFile.empty()) {
+      this->Makefile->IssueMessage(
+        cmake::FATAL_ERROR,
         "COPY_FILE specified on a srcdir type TRY_COMPILE");
       return -1;
-      }
     }
+  }
   // make sure the binary directory exists
   cmSystemTools::MakeDirectory(this->BinaryDirectory.c_str());
 
   // do not allow recursive try Compiles
-  if (this->BinaryDirectory == this->Makefile->GetHomeOutputDirectory())
-    {
+  if (this->BinaryDirectory == this->Makefile->GetHomeOutputDirectory()) {
     std::ostringstream e;
     e << "Attempt at a recursive or nested TRY_COMPILE in directory\n"
       << "  " << this->BinaryDirectory << "\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     return -1;
-    }
+  }
 
   std::string outFileName = this->BinaryDirectory + "/CMakeLists.txt";
   // which signature are we using? If we are using var srcfile bindir
-  if (this->SrcFileSignature)
-    {
+  if (this->SrcFileSignature) {
     // remove any CMakeCache.txt files so we will have a clean test
     std::string ccFile = this->BinaryDirectory + "/CMakeCache.txt";
     cmSystemTools::RemoveFile(ccFile);
 
     // Choose sources.
-    if(!useSources)
-      {
+    if (!useSources) {
       sources.push_back(argv[2]);
-      }
+    }
 
     // Detect languages to enable.
     cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
     std::set<std::string> testLangs;
-    for(std::vector<std::string>::iterator si = sources.begin();
-        si != sources.end(); ++si)
-      {
+    for (std::vector<std::string>::iterator si = sources.begin();
+         si != sources.end(); ++si) {
       std::string ext = cmSystemTools::GetFilenameLastExtension(*si);
       std::string lang = gg->GetLanguageFromExtension(ext.c_str());
-      if(!lang.empty())
-        {
+      if (!lang.empty()) {
         testLangs.insert(lang);
-        }
-      else
-        {
+      } else {
         std::ostringstream err;
         err << "Unknown extension \"" << ext << "\" for file\n"
             << "  " << *si << "\n"
@@ -292,8 +251,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
         err << "\nSee project() command to enable other languages.";
         this->Makefile->IssueMessage(cmake::FATAL_ERROR, err.str());
         return -1;
-        }
       }
+    }
 
     std::string const tcConfig =
       this->Makefile->GetSafeDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
@@ -303,9 +262,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
     sourceDirectory = this->BinaryDirectory.c_str();
 
     // now create a CMakeLists.txt file in that directory
-    FILE *fout = cmsys::SystemTools::Fopen(outFileName,"w");
-    if (!fout)
-      {
+    FILE* fout = cmsys::SystemTools::Fopen(outFileName, "w");
+    if (!fout) {
       std::ostringstream e;
       /* clang-format off */
       e << "Failed to open\n"
@@ -314,62 +272,56 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
       /* clang-format on */
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       return -1;
-      }
+    }
 
     const char* def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH");
     fprintf(fout, "cmake_minimum_required(VERSION %u.%u.%u.%u)\n",
             cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion(),
             cmVersion::GetPatchVersion(), cmVersion::GetTweakVersion());
-    if(def)
-      {
+    if (def) {
       fprintf(fout, "set(CMAKE_MODULE_PATH \"%s\")\n", def);
-      }
+    }
 
     std::string projectLangs;
-    for(std::set<std::string>::iterator li = testLangs.begin();
-        li != testLangs.end(); ++li)
-      {
+    for (std::set<std::string>::iterator li = testLangs.begin();
+         li != testLangs.end(); ++li) {
       projectLangs += " " + *li;
       std::string rulesOverrideBase = "CMAKE_USER_MAKE_RULES_OVERRIDE";
       std::string rulesOverrideLang = rulesOverrideBase + "_" + *li;
-      if(const char* rulesOverridePath =
-         this->Makefile->GetDefinition(rulesOverrideLang))
-        {
-        fprintf(fout, "set(%s \"%s\")\n",
-                rulesOverrideLang.c_str(), rulesOverridePath);
-        }
-      else if(const char* rulesOverridePath2 =
-              this->Makefile->GetDefinition(rulesOverrideBase))
-        {
-        fprintf(fout, "set(%s \"%s\")\n",
-                rulesOverrideBase.c_str(), rulesOverridePath2);
-        }
+      if (const char* rulesOverridePath =
+            this->Makefile->GetDefinition(rulesOverrideLang)) {
+        fprintf(fout, "set(%s \"%s\")\n", rulesOverrideLang.c_str(),
+                rulesOverridePath);
+      } else if (const char* rulesOverridePath2 =
+                   this->Makefile->GetDefinition(rulesOverrideBase)) {
+        fprintf(fout, "set(%s \"%s\")\n", rulesOverrideBase.c_str(),
+                rulesOverridePath2);
       }
+    }
     fprintf(fout, "project(CMAKE_TRY_COMPILE%s)\n", projectLangs.c_str());
     fprintf(fout, "set(CMAKE_VERBOSE_MAKEFILE 1)\n");
-    for(std::set<std::string>::iterator li = testLangs.begin();
-        li != testLangs.end(); ++li)
-      {
+    for (std::set<std::string>::iterator li = testLangs.begin();
+         li != testLangs.end(); ++li) {
       std::string langFlags = "CMAKE_" + *li + "_FLAGS";
       const char* flags = this->Makefile->GetDefinition(langFlags);
       fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li->c_str(),
-              cmOutputConverter::EscapeForCMake(flags?flags:"").c_str());
+              cmOutputConverter::EscapeForCMake(flags ? flags : "").c_str());
       fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
-              " ${COMPILE_DEFINITIONS}\")\n", li->c_str(), li->c_str());
+                    " ${COMPILE_DEFINITIONS}\")\n",
+              li->c_str(), li->c_str());
       static std::string const cfgDefault = "DEBUG";
-      std::string const cfg = !tcConfig.empty()?
-        cmSystemTools::UpperCase(tcConfig) : cfgDefault;
+      std::string const cfg =
+        !tcConfig.empty() ? cmSystemTools::UpperCase(tcConfig) : cfgDefault;
       std::string const langFlagsCfg = "CMAKE_" + *li + "_FLAGS_" + cfg;
       const char* flagsCfg = this->Makefile->GetDefinition(langFlagsCfg);
-      fprintf(fout, "set(%s %s)\n", langFlagsCfg.c_str(),
-              cmOutputConverter::EscapeForCMake(flagsCfg?flagsCfg:"").c_str());
-      }
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0056))
-      {
+      fprintf(
+        fout, "set(%s %s)\n", langFlagsCfg.c_str(),
+        cmOutputConverter::EscapeForCMake(flagsCfg ? flagsCfg : "").c_str());
+    }
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0056)) {
       case cmPolicies::WARN:
-        if(this->Makefile->PolicyOptionalWarningEnabled(
-             "CMAKE_POLICY_WARNING_CMP0056"))
-          {
+        if (this->Makefile->PolicyOptionalWarningEnabled(
+              "CMAKE_POLICY_WARNING_CMP0056")) {
           std::ostringstream w;
           /* clang-format off */
           w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0056) << "\n"
@@ -379,7 +331,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
             ;
           /* clang-format on */
           this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-          }
+        }
       case cmPolicies::OLD:
         // OLD behavior is to do nothing.
         break;
@@ -387,53 +339,49 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
       case cmPolicies::REQUIRED_ALWAYS:
         this->Makefile->IssueMessage(
           cmake::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0056)
-          );
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0056));
       case cmPolicies::NEW:
         // NEW behavior is to pass linker flags.
         {
-        const char* exeLinkFlags =
-          this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS");
-        fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n",
-                cmOutputConverter::EscapeForCMake(
-                    exeLinkFlags ? exeLinkFlags : "").c_str());
-        } break;
-      }
+          const char* exeLinkFlags =
+            this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS");
+          fprintf(
+            fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n",
+            cmOutputConverter::EscapeForCMake(exeLinkFlags ? exeLinkFlags : "")
+              .c_str());
+        }
+        break;
+    }
     fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS}"
-            " ${EXE_LINKER_FLAGS}\")\n");
+                  " ${EXE_LINKER_FLAGS}\")\n");
     fprintf(fout, "include_directories(${INCLUDE_DIRECTORIES})\n");
     fprintf(fout, "set(CMAKE_SUPPRESS_REGENERATION 1)\n");
     fprintf(fout, "link_directories(${LINK_DIRECTORIES})\n");
     // handle any compile flags we need to pass on
-    if (!compileDefs.empty())
-      {
+    if (!compileDefs.empty()) {
       fprintf(fout, "add_definitions(%s)\n", cmJoin(compileDefs, " ").c_str());
-      }
+    }
 
     /* Use a random file name to avoid rapid creation and deletion
        of the same executable name (some filesystems fail on that).  */
-    sprintf(targetNameBuf, "cmTC_%05x",
-            cmSystemTools::RandomSeed() & 0xFFFFF);
+    sprintf(targetNameBuf, "cmTC_%05x", cmSystemTools::RandomSeed() & 0xFFFFF);
     targetName = targetNameBuf;
 
-    if (!targets.empty())
-      {
+    if (!targets.empty()) {
       std::string fname = "/" + std::string(targetName) + "Targets.cmake";
       cmExportTryCompileFileGenerator tcfg(gg, targets, this->Makefile);
       tcfg.SetExportFile((this->BinaryDirectory + fname).c_str());
       tcfg.SetConfig(tcConfig);
 
-      if(!tcfg.GenerateImportFile())
-        {
+      if (!tcfg.GenerateImportFile()) {
         this->Makefile->IssueMessage(cmake::FATAL_ERROR,
                                      "could not write export file.");
         fclose(fout);
         return -1;
-        }
-      fprintf(fout,
-              "\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/%s\")\n\n",
-              fname.c_str());
       }
+      fprintf(fout, "\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/%s\")\n\n",
+              fname.c_str());
+    }
 
     /* for the TRY_COMPILEs we want to be able to specify the architecture.
       So the user can set CMAKE_OSX_ARCHITECTURES to i386;ppc and then set
@@ -442,175 +390,144 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
       cmLocalGenerator doesn't allow building for "the other"
       architecture only via CMAKE_OSX_ARCHITECTURES.
       */
-    if(this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_OSX_ARCHITECTURES")!=0)
-      {
-      std::string flag="-DCMAKE_OSX_ARCHITECTURES=";
+    if (this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_OSX_ARCHITECTURES") !=
+        0) {
+      std::string flag = "-DCMAKE_OSX_ARCHITECTURES=";
       flag += this->Makefile->GetSafeDefinition(
-                                        "CMAKE_TRY_COMPILE_OSX_ARCHITECTURES");
+        "CMAKE_TRY_COMPILE_OSX_ARCHITECTURES");
       cmakeFlags.push_back(flag);
-      }
-    else if (this->Makefile->GetDefinition("CMAKE_OSX_ARCHITECTURES")!=0)
-      {
-      std::string flag="-DCMAKE_OSX_ARCHITECTURES=";
+    } else if (this->Makefile->GetDefinition("CMAKE_OSX_ARCHITECTURES") != 0) {
+      std::string flag = "-DCMAKE_OSX_ARCHITECTURES=";
       flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_ARCHITECTURES");
       cmakeFlags.push_back(flag);
-      }
+    }
     /* on APPLE also pass CMAKE_OSX_SYSROOT to the try_compile */
-    if(this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT")!=0)
-      {
-      std::string flag="-DCMAKE_OSX_SYSROOT=";
+    if (this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT") != 0) {
+      std::string flag = "-DCMAKE_OSX_SYSROOT=";
       flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_SYSROOT");
       cmakeFlags.push_back(flag);
-      }
+    }
     /* on APPLE also pass CMAKE_OSX_DEPLOYMENT_TARGET to the try_compile */
-    if(this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET")!=0)
-      {
-      std::string flag="-DCMAKE_OSX_DEPLOYMENT_TARGET=";
+    if (this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET") != 0) {
+      std::string flag = "-DCMAKE_OSX_DEPLOYMENT_TARGET=";
       flag += this->Makefile->GetSafeDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
       cmakeFlags.push_back(flag);
-      }
-    if (const char *cxxDef
-              = this->Makefile->GetDefinition("CMAKE_CXX_COMPILER_TARGET"))
-      {
-      std::string flag="-DCMAKE_CXX_COMPILER_TARGET=";
+    }
+    if (const char* cxxDef =
+          this->Makefile->GetDefinition("CMAKE_CXX_COMPILER_TARGET")) {
+      std::string flag = "-DCMAKE_CXX_COMPILER_TARGET=";
       flag += cxxDef;
       cmakeFlags.push_back(flag);
-      }
-    if (const char *cDef
-                = this->Makefile->GetDefinition("CMAKE_C_COMPILER_TARGET"))
-      {
-      std::string flag="-DCMAKE_C_COMPILER_TARGET=";
+    }
+    if (const char* cDef =
+          this->Makefile->GetDefinition("CMAKE_C_COMPILER_TARGET")) {
+      std::string flag = "-DCMAKE_C_COMPILER_TARGET=";
       flag += cDef;
       cmakeFlags.push_back(flag);
-      }
-    if (const char *tcxxDef = this->Makefile->GetDefinition(
-                                  "CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN"))
-      {
-      std::string flag="-DCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN=";
+    }
+    if (const char* tcxxDef = this->Makefile->GetDefinition(
+          "CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN")) {
+      std::string flag = "-DCMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN=";
       flag += tcxxDef;
       cmakeFlags.push_back(flag);
-      }
-    if (const char *tcDef = this->Makefile->GetDefinition(
-                                    "CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN"))
-      {
-      std::string flag="-DCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN=";
+    }
+    if (const char* tcDef = this->Makefile->GetDefinition(
+          "CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN")) {
+      std::string flag = "-DCMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN=";
       flag += tcDef;
       cmakeFlags.push_back(flag);
-      }
-    if (const char *rootDef
-              = this->Makefile->GetDefinition("CMAKE_SYSROOT"))
-      {
-      std::string flag="-DCMAKE_SYSROOT=";
+    }
+    if (const char* rootDef = this->Makefile->GetDefinition("CMAKE_SYSROOT")) {
+      std::string flag = "-DCMAKE_SYSROOT=";
       flag += rootDef;
       cmakeFlags.push_back(flag);
-      }
-    if(this->Makefile->GetDefinition("CMAKE_POSITION_INDEPENDENT_CODE")!=0)
-      {
+    }
+    if (this->Makefile->GetDefinition("CMAKE_POSITION_INDEPENDENT_CODE") !=
+        0) {
       fprintf(fout, "set(CMAKE_POSITION_INDEPENDENT_CODE \"ON\")\n");
-      }
-    if (const char *lssDef = this->Makefile->GetDefinition(
-        "CMAKE_LINK_SEARCH_START_STATIC"))
-      {
+    }
+    if (const char* lssDef =
+          this->Makefile->GetDefinition("CMAKE_LINK_SEARCH_START_STATIC")) {
       fprintf(fout, "set(CMAKE_LINK_SEARCH_START_STATIC \"%s\")\n", lssDef);
-      }
-    if (const char *lssDef = this->Makefile->GetDefinition(
-        "CMAKE_LINK_SEARCH_END_STATIC"))
-      {
+    }
+    if (const char* lssDef =
+          this->Makefile->GetDefinition("CMAKE_LINK_SEARCH_END_STATIC")) {
       fprintf(fout, "set(CMAKE_LINK_SEARCH_END_STATIC \"%s\")\n", lssDef);
-      }
+    }
 
     /* Set the appropriate policy information for ENABLE_EXPORTS */
     fprintf(fout, "cmake_policy(SET CMP0065 %s)\n",
-       this->Makefile->GetPolicyStatus(cmPolicies::CMP0065) ==
-         cmPolicies::NEW ? "NEW" : "OLD");
-    if(const char *ee = this->Makefile->GetDefinition(
-        "CMAKE_ENABLE_EXPORTS"))
-      {
+            this->Makefile->GetPolicyStatus(cmPolicies::CMP0065) ==
+                cmPolicies::NEW
+              ? "NEW"
+              : "OLD");
+    if (const char* ee =
+          this->Makefile->GetDefinition("CMAKE_ENABLE_EXPORTS")) {
       fprintf(fout, "set(CMAKE_ENABLE_EXPORTS %s)\n", ee);
-      }
+    }
 
-    if (targetType == cmState::EXECUTABLE)
-      {
+    if (targetType == cmState::EXECUTABLE) {
       /* Put the executable at a known location (for COPY_FILE).  */
       fprintf(fout, "set(CMAKE_RUNTIME_OUTPUT_DIRECTORY \"%s\")\n",
               this->BinaryDirectory.c_str());
       /* Create the actual executable.  */
       fprintf(fout, "add_executable(%s", targetName.c_str());
-      }
-    else // if (targetType == cmState::STATIC_LIBRARY)
-      {
+    } else // if (targetType == cmState::STATIC_LIBRARY)
+    {
       /* Put the static library at a known location (for COPY_FILE).  */
       fprintf(fout, "set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY \"%s\")\n",
               this->BinaryDirectory.c_str());
       /* Create the actual static library.  */
       fprintf(fout, "add_library(%s STATIC", targetName.c_str());
-      }
-    for(std::vector<std::string>::iterator si = sources.begin();
-        si != sources.end(); ++si)
-      {
+    }
+    for (std::vector<std::string>::iterator si = sources.begin();
+         si != sources.end(); ++si) {
       fprintf(fout, " \"%s\"", si->c_str());
 
       // Add dependencies on any non-temporary sources.
-      if(si->find("CMakeTmp") == si->npos)
-        {
+      if (si->find("CMakeTmp") == si->npos) {
         this->Makefile->AddCMakeDependFile(*si);
-        }
       }
+    }
     fprintf(fout, ")\n");
-    if (useOldLinkLibs)
-      {
-      fprintf(fout,
-              "target_link_libraries(%s ${LINK_LIBRARIES})\n",
+    if (useOldLinkLibs) {
+      fprintf(fout, "target_link_libraries(%s ${LINK_LIBRARIES})\n",
               targetName.c_str());
-      }
-    else
-      {
-      fprintf(fout, "target_link_libraries(%s %s)\n",
-              targetName.c_str(),
+    } else {
+      fprintf(fout, "target_link_libraries(%s %s)\n", targetName.c_str(),
               libsToLink.c_str());
-      }
+    }
     fclose(fout);
     projectName = "CMAKE_TRY_COMPILE";
-    }
+  }
 
   bool erroroc = cmSystemTools::GetErrorOccuredFlag();
   cmSystemTools::ResetErrorOccuredFlag();
   std::string output;
   // actually do the try compile now that everything is setup
-  int res = this->Makefile->TryCompile(sourceDirectory,
-                                       this->BinaryDirectory,
-                                       projectName,
-                                       targetName,
-                                       this->SrcFileSignature,
-                                       &cmakeFlags,
-                                       output);
-  if ( erroroc )
-    {
+  int res = this->Makefile->TryCompile(
+    sourceDirectory, this->BinaryDirectory, projectName, targetName,
+    this->SrcFileSignature, &cmakeFlags, output);
+  if (erroroc) {
     cmSystemTools::SetErrorOccured();
-    }
+  }
 
   // set the result var to the return value to indicate success or failure
-  this->Makefile->AddCacheDefinition(argv[0],
-                                     (res == 0 ? "TRUE" : "FALSE"),
+  this->Makefile->AddCacheDefinition(argv[0], (res == 0 ? "TRUE" : "FALSE"),
                                      "Result of TRY_COMPILE",
                                      cmState::INTERNAL);
 
-  if (!outputVariable.empty())
-    {
+  if (!outputVariable.empty()) {
     this->Makefile->AddDefinition(outputVariable, output.c_str());
-    }
+  }
 
-  if (this->SrcFileSignature)
-    {
+  if (this->SrcFileSignature) {
     std::string copyFileErrorMessage;
     this->FindOutputFile(targetName, targetType);
 
-    if ((res==0) && !copyFile.empty())
-      {
-      if(this->OutputFile.empty() ||
-         !cmSystemTools::CopyFileAlways(this->OutputFile,
-                                        copyFile))
-        {
+    if ((res == 0) && !copyFile.empty()) {
+      if (this->OutputFile.empty() ||
+          !cmSystemTools::CopyFileAlways(this->OutputFile, copyFile)) {
         std::ostringstream emsg;
         /* clang-format off */
         emsg << "Cannot copy output executable\n"
@@ -618,93 +535,81 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
              << "to destination specified by COPY_FILE:\n"
              << "  '" << copyFile << "'\n";
         /* clang-format on */
-        if(!this->FindErrorMessage.empty())
-          {
+        if (!this->FindErrorMessage.empty()) {
           emsg << this->FindErrorMessage.c_str();
-          }
-        if(copyFileError.empty())
-          {
+        }
+        if (copyFileError.empty()) {
           this->Makefile->IssueMessage(cmake::FATAL_ERROR, emsg.str());
           return -1;
-          }
-        else
-          {
+        } else {
           copyFileErrorMessage = emsg.str();
-          }
         }
       }
+    }
 
-    if(!copyFileError.empty())
-      {
+    if (!copyFileError.empty()) {
       this->Makefile->AddDefinition(copyFileError,
                                     copyFileErrorMessage.c_str());
-      }
     }
+  }
   return res;
 }
 
 void cmCoreTryCompile::CleanupFiles(const char* binDir)
 {
-  if ( !binDir )
-    {
+  if (!binDir) {
     return;
-    }
+  }
 
   std::string bdir = binDir;
-  if(bdir.find("CMakeTmp") == std::string::npos)
-    {
+  if (bdir.find("CMakeTmp") == std::string::npos) {
     cmSystemTools::Error(
       "TRY_COMPILE attempt to remove -rf directory that does not contain "
-      "CMakeTmp:", binDir);
+      "CMakeTmp:",
+      binDir);
     return;
-    }
+  }
 
   cmsys::Directory dir;
   dir.Load(binDir);
   size_t fileNum;
   std::set<std::string> deletedFiles;
-  for (fileNum = 0; fileNum <  dir.GetNumberOfFiles(); ++fileNum)
-    {
-    if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".") &&
-        strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)),".."))
-      {
+  for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) {
+    if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), ".") &&
+        strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), "..")) {
 
-      if(deletedFiles.find( dir.GetFile(static_cast<unsigned long>(fileNum)))
-         == deletedFiles.end())
-        {
+      if (deletedFiles.find(dir.GetFile(
+            static_cast<unsigned long>(fileNum))) == deletedFiles.end()) {
         deletedFiles.insert(dir.GetFile(static_cast<unsigned long>(fileNum)));
         std::string fullPath = binDir;
         fullPath += "/";
         fullPath += dir.GetFile(static_cast<unsigned long>(fileNum));
-        if(cmSystemTools::FileIsDirectory(fullPath))
-          {
+        if (cmSystemTools::FileIsDirectory(fullPath)) {
           this->CleanupFiles(fullPath.c_str());
           cmSystemTools::RemoveADirectory(fullPath);
-          }
-        else
-          {
+        } else {
 #ifdef _WIN32
           // Sometimes anti-virus software hangs on to new files so we
           // cannot delete them immediately.  Try a few times.
           cmSystemTools::WindowsFileRetry retry =
             cmSystemTools::GetWindowsFileRetry();
-          while(!cmSystemTools::RemoveFile(fullPath.c_str()) &&
-                --retry.Count && cmSystemTools::FileExists(fullPath.c_str()))
-            {
+          while (!cmSystemTools::RemoveFile(fullPath.c_str()) &&
+                 --retry.Count &&
+                 cmSystemTools::FileExists(fullPath.c_str())) {
             cmSystemTools::Delay(retry.Delay);
-            }
-          if(retry.Count == 0)
+          }
+          if (retry.Count == 0)
 #else
-          if(!cmSystemTools::RemoveFile(fullPath))
+          if (!cmSystemTools::RemoveFile(fullPath))
 #endif
-            {
+          {
             std::string m = "Remove failed on file: " + fullPath;
             cmSystemTools::ReportLastSystemError(m.c_str());
-            }
           }
         }
       }
     }
+  }
 }
 
 void cmCoreTryCompile::FindOutputFile(const std::string& targetName,
@@ -713,35 +618,32 @@ void cmCoreTryCompile::FindOutputFile(const std::string& targetName,
   this->FindErrorMessage = "";
   this->OutputFile = "";
   std::string tmpOutputFile = "/";
-  if (targetType == cmState::EXECUTABLE)
-    {
+  if (targetType == cmState::EXECUTABLE) {
     tmpOutputFile += targetName;
     tmpOutputFile +=
       this->Makefile->GetSafeDefinition("CMAKE_EXECUTABLE_SUFFIX");
-    }
-  else // if (targetType == cmState::STATIC_LIBRARY)
-    {
+  } else // if (targetType == cmState::STATIC_LIBRARY)
+  {
     tmpOutputFile +=
       this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_PREFIX");
     tmpOutputFile += targetName;
     tmpOutputFile +=
       this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_SUFFIX");
-    }
+  }
 
   // a list of directories where to search for the compilation result
   // at first directly in the binary dir
   std::vector<std::string> searchDirs;
   searchDirs.push_back("");
 
-  const char* config = this->Makefile->GetDefinition(
-                                            "CMAKE_TRY_COMPILE_CONFIGURATION");
+  const char* config =
+    this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
   // if a config was specified try that first
-  if (config && config[0])
-    {
+  if (config && config[0]) {
     std::string tmp = "/";
     tmp += config;
     searchDirs.push_back(tmp);
-    }
+  }
   searchDirs.push_back("/Debug");
 #if defined(__APPLE__)
   std::string app = "/Debug/" + targetName + ".app";
@@ -749,25 +651,21 @@ void cmCoreTryCompile::FindOutputFile(const std::string& targetName,
 #endif
   searchDirs.push_back("/Development");
 
-  for(std::vector<std::string>::const_iterator it = searchDirs.begin();
-      it != searchDirs.end();
-      ++it)
-    {
+  for (std::vector<std::string>::const_iterator it = searchDirs.begin();
+       it != searchDirs.end(); ++it) {
     std::string command = this->BinaryDirectory;
     command += *it;
     command += tmpOutputFile;
-    if(cmSystemTools::FileExists(command.c_str()))
-      {
+    if (cmSystemTools::FileExists(command.c_str())) {
       this->OutputFile = cmSystemTools::CollapseFullPath(command);
       return;
-      }
     }
+  }
 
   std::ostringstream emsg;
   emsg << "Unable to find the executable at any of:\n";
-  emsg << cmWrap("  " + this->BinaryDirectory,
-                 searchDirs,
-                 tmpOutputFile, "\n") << "\n";
+  emsg << cmWrap("  " + this->BinaryDirectory, searchDirs, tmpOutputFile, "\n")
+       << "\n";
   this->FindErrorMessage = emsg.str();
   return;
 }
diff --git a/Source/cmCoreTryCompile.h b/Source/cmCoreTryCompile.h
index c2beea8..6a3b049 100644
--- a/Source/cmCoreTryCompile.h
+++ b/Source/cmCoreTryCompile.h
@@ -23,8 +23,7 @@
 class cmCoreTryCompile : public cmCommand
 {
 public:
-
-  protected:
+protected:
   /**
    * This is the core code for try compile. It is here so that other
    * commands, such as TryRun can access the same logic without
@@ -53,8 +52,6 @@ public:
   std::string OutputFile;
   std::string FindErrorMessage;
   bool SrcFileSignature;
-
 };
 
-
 #endif
diff --git a/Source/cmCreateTestSourceList.cxx b/Source/cmCreateTestSourceList.cxx
index 65eee34..6f7cfbe 100644
--- a/Source/cmCreateTestSourceList.cxx
+++ b/Source/cmCreateTestSourceList.cxx
@@ -14,51 +14,41 @@
 #include "cmSourceFile.h"
 
 // cmCreateTestSourceList
-bool cmCreateTestSourceList
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if (args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("called with wrong number of arguments.");
     return false;
-    }
-
+  }
 
   std::vector<std::string>::const_iterator i = args.begin();
   std::string extraInclude;
   std::string function;
   std::vector<std::string> tests;
   // extract extra include and function ot
-  for(; i != args.end(); i++)
-    {
-    if(*i == "EXTRA_INCLUDE")
-      {
+  for (; i != args.end(); i++) {
+    if (*i == "EXTRA_INCLUDE") {
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("incorrect arguments to EXTRA_INCLUDE");
         return false;
-        }
+      }
       extraInclude = "#include \"";
       extraInclude += *i;
       extraInclude += "\"\n";
-      }
-    else if(*i == "FUNCTION")
-      {
+    } else if (*i == "FUNCTION") {
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("incorrect arguments to FUNCTION");
         return false;
-        }
+      }
       function = *i;
       function += "(&ac, &av);\n";
-      }
-    else
-      {
+    } else {
       tests.push_back(*i);
-      }
     }
+  }
   i = tests.begin();
 
   // Name of the source list
@@ -68,12 +58,11 @@ bool cmCreateTestSourceList
 
   // Name of the test driver
   // make sure they specified an extension
-  if (cmSystemTools::GetFilenameExtension(*i).size() < 2)
-    {
+  if (cmSystemTools::GetFilenameExtension(*i).size() < 2) {
     this->SetError(
       "You must specify a file extension for the test driver file.");
     return false;
-    }
+  }
   std::string driver = this->Makefile->GetCurrentBinaryDirectory();
   driver += "/";
   driver += *i;
@@ -94,22 +83,17 @@ bool cmCreateTestSourceList
   // For the moment:
   //   - replace spaces ' ', ':' and '/' with underscores '_'
   std::string forwardDeclareCode;
-  for(i = testsBegin; i != tests.end(); ++i)
-    {
-    if(*i == "EXTRA_INCLUDE")
-      {
+  for (i = testsBegin; i != tests.end(); ++i) {
+    if (*i == "EXTRA_INCLUDE") {
       break;
-      }
+    }
     std::string func_name;
-    if (!cmSystemTools::GetFilenamePath(*i).empty())
-      {
+    if (!cmSystemTools::GetFilenamePath(*i).empty()) {
       func_name = cmSystemTools::GetFilenamePath(*i) + "/" +
         cmSystemTools::GetFilenameWithoutLastExtension(*i);
-      }
-    else
-      {
+    } else {
       func_name = cmSystemTools::GetFilenameWithoutLastExtension(*i);
-      }
+    }
     cmSystemTools::ConvertToUnixSlashes(func_name);
     cmSystemTools::ReplaceString(func_name, " ", "_");
     cmSystemTools::ReplaceString(func_name, "/", "_");
@@ -118,72 +102,62 @@ bool cmCreateTestSourceList
     forwardDeclareCode += "int ";
     forwardDeclareCode += func_name;
     forwardDeclareCode += "(int, char*[]);\n";
-    }
+  }
 
   std::string functionMapCode;
   int numTests = 0;
   std::vector<std::string>::iterator j;
-  for(i = testsBegin, j = tests_func_name.begin(); i != tests.end(); ++i, ++j)
-    {
+  for (i = testsBegin, j = tests_func_name.begin(); i != tests.end();
+       ++i, ++j) {
     std::string func_name;
-    if (!cmSystemTools::GetFilenamePath(*i).empty())
-      {
+    if (!cmSystemTools::GetFilenamePath(*i).empty()) {
       func_name = cmSystemTools::GetFilenamePath(*i) + "/" +
         cmSystemTools::GetFilenameWithoutLastExtension(*i);
-      }
-    else
-      {
+    } else {
       func_name = cmSystemTools::GetFilenameWithoutLastExtension(*i);
-      }
+    }
     functionMapCode += "  {\n"
-      "    \"";
+                       "    \"";
     functionMapCode += func_name;
     functionMapCode += "\",\n"
-      "    ";
-    functionMapCode +=  *j;
+                       "    ";
+    functionMapCode += *j;
     functionMapCode += "\n"
-      "  },\n";
+                       "  },\n";
     numTests++;
-    }
-  if(!extraInclude.empty())
-    {
+  }
+  if (!extraInclude.empty()) {
     this->Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES",
                                   extraInclude.c_str());
-    }
-  if(!function.empty())
-    {
+  }
+  if (!function.empty()) {
     this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION",
                                   function.c_str());
-    }
+  }
   this->Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS",
-    forwardDeclareCode.c_str());
+                                forwardDeclareCode.c_str());
   this->Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES",
-    functionMapCode.c_str());
+                                functionMapCode.c_str());
   bool res = true;
-  if ( !this->Makefile->ConfigureFile(configFile.c_str(), driver.c_str(),
-      false, true, false) )
-    {
+  if (!this->Makefile->ConfigureFile(configFile.c_str(), driver.c_str(), false,
+                                     true, false)) {
     res = false;
-    }
+  }
 
   // Construct the source list.
   std::string sourceListValue;
   {
-  cmSourceFile* sf = this->Makefile->GetOrCreateSource(driver);
-  sf->SetProperty("ABSTRACT","0");
-  sourceListValue = args[1];
+    cmSourceFile* sf = this->Makefile->GetOrCreateSource(driver);
+    sf->SetProperty("ABSTRACT", "0");
+    sourceListValue = args[1];
   }
-  for(i = testsBegin; i != tests.end(); ++i)
-    {
+  for (i = testsBegin; i != tests.end(); ++i) {
     cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i);
-    sf->SetProperty("ABSTRACT","0");
+    sf->SetProperty("ABSTRACT", "0");
     sourceListValue += ";";
     sourceListValue += *i;
-    }
+  }
 
   this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
   return res;
 }
-
-
-
diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h
index 2f6b541..cfaca2e 100644
--- a/Source/cmCreateTestSourceList.h
+++ b/Source/cmCreateTestSourceList.h
@@ -25,26 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmCreateTestSourceList;
-    }
+  virtual cmCommand* Clone() { return new cmCreateTestSourceList; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "create_test_sourcelist";}
+  virtual std::string GetName() const { return "create_test_sourcelist"; }
 
   cmTypeMacro(cmCreateTestSourceList, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmCryptoHash.cxx b/Source/cmCryptoHash.cxx
index 5eb0239..85049ca 100644
--- a/Source/cmCryptoHash.cxx
+++ b/Source/cmCryptoHash.cxx
@@ -17,20 +17,21 @@
 
 cmsys::auto_ptr<cmCryptoHash> cmCryptoHash::New(const char* algo)
 {
-  if(strcmp(algo,"MD5") == 0)
-    { return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashMD5); }
-  else if(strcmp(algo,"SHA1") == 0)
-    { return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA1); }
-  else if(strcmp(algo,"SHA224") == 0)
-    { return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA224); }
-  else if(strcmp(algo,"SHA256") == 0)
-    { return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA256); }
-  else if(strcmp(algo,"SHA384") == 0)
-    { return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA384); }
-  else if(strcmp(algo,"SHA512") == 0)
-    { return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA512); }
-  else
-    { return cmsys::auto_ptr<cmCryptoHash>(0); }
+  if (strcmp(algo, "MD5") == 0) {
+    return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashMD5);
+  } else if (strcmp(algo, "SHA1") == 0) {
+    return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA1);
+  } else if (strcmp(algo, "SHA224") == 0) {
+    return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA224);
+  } else if (strcmp(algo, "SHA256") == 0) {
+    return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA256);
+  } else if (strcmp(algo, "SHA384") == 0) {
+    return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA384);
+  } else if (strcmp(algo, "SHA512") == 0) {
+    return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA512);
+  } else {
+    return cmsys::auto_ptr<cmCryptoHash>(0);
+  }
 }
 
 std::string cmCryptoHash::HashString(const std::string& input)
@@ -44,10 +45,9 @@ std::string cmCryptoHash::HashString(const std::string& input)
 std::string cmCryptoHash::HashFile(const std::string& file)
 {
   cmsys::ifstream fin(file.c_str(), std::ios::in | std::ios::binary);
-  if(!fin)
-    {
+  if (!fin) {
     return "";
-    }
+  }
 
   this->Initialize();
 
@@ -61,22 +61,20 @@ std::string cmCryptoHash::HashFile(const std::string& file)
   // incorrect to not check the error condition on the fin.read()
   // before using the data, but the fin.gcount() will be zero if an
   // error occurred.  Therefore, the loop should be safe everywhere.
-  while(fin)
-    {
+  while (fin) {
     fin.read(buffer_c, sizeof(buffer));
-    if(int gcount = static_cast<int>(fin.gcount()))
-      {
+    if (int gcount = static_cast<int>(fin.gcount())) {
       this->Append(buffer_uc, gcount);
-      }
     }
-  if(fin.eof())
-    {
+  }
+  if (fin.eof()) {
     return this->Finalize();
-    }
+  }
   return "";
 }
 
-cmCryptoHashMD5::cmCryptoHashMD5(): MD5(cmsysMD5_New())
+cmCryptoHashMD5::cmCryptoHashMD5()
+  : MD5(cmsysMD5_New())
 {
 }
 
@@ -102,22 +100,24 @@ std::string cmCryptoHashMD5::Finalize()
   return std::string(md5out, 32);
 }
 
-
-#define cmCryptoHash_SHA_CLASS_IMPL(SHA) \
-cmCryptoHash##SHA::cmCryptoHash##SHA(): SHA(new SHA_CTX) {} \
-cmCryptoHash##SHA::~cmCryptoHash##SHA() { delete this->SHA; } \
-void cmCryptoHash##SHA::Initialize() { SHA##_Init(this->SHA); } \
-void cmCryptoHash##SHA::Append(unsigned char const* buf, int sz) \
-{ SHA##_Update(this->SHA, buf, sz); } \
-std::string cmCryptoHash##SHA::Finalize() \
-{ \
-  char out[SHA##_DIGEST_STRING_LENGTH]; \
-  SHA##_End(this->SHA, out); \
-  return std::string(out, SHA##_DIGEST_STRING_LENGTH-1); \
-}
-
-cmCryptoHash_SHA_CLASS_IMPL(SHA1)
-cmCryptoHash_SHA_CLASS_IMPL(SHA224)
-cmCryptoHash_SHA_CLASS_IMPL(SHA256)
-cmCryptoHash_SHA_CLASS_IMPL(SHA384)
-cmCryptoHash_SHA_CLASS_IMPL(SHA512)
+#define cmCryptoHash_SHA_CLASS_IMPL(SHA)                                      \
+  cmCryptoHash##SHA::cmCryptoHash##SHA()                                      \
+    : SHA(new SHA_CTX)                                                        \
+  {                                                                           \
+  }                                                                           \
+  cmCryptoHash##SHA::~cmCryptoHash##SHA() { delete this->SHA; }               \
+  void cmCryptoHash##SHA::Initialize() { SHA##_Init(this->SHA); }             \
+  void cmCryptoHash##SHA::Append(unsigned char const* buf, int sz)            \
+  {                                                                           \
+    SHA##_Update(this->SHA, buf, sz);                                         \
+  }                                                                           \
+  std::string cmCryptoHash##SHA::Finalize()                                   \
+  {                                                                           \
+    char out[SHA##_DIGEST_STRING_LENGTH];                                     \
+    SHA##_End(this->SHA, out);                                                \
+    return std::string(out, SHA##_DIGEST_STRING_LENGTH - 1);                  \
+  }
+
+cmCryptoHash_SHA_CLASS_IMPL(SHA1) cmCryptoHash_SHA_CLASS_IMPL(SHA224)
+  cmCryptoHash_SHA_CLASS_IMPL(SHA256) cmCryptoHash_SHA_CLASS_IMPL(SHA384)
+    cmCryptoHash_SHA_CLASS_IMPL(SHA512)
diff --git a/Source/cmCryptoHash.h b/Source/cmCryptoHash.h
index 88cd240..a0c5eab 100644
--- a/Source/cmCryptoHash.h
+++ b/Source/cmCryptoHash.h
@@ -23,35 +23,40 @@ public:
   static cmsys::auto_ptr<cmCryptoHash> New(const char* algo);
   std::string HashString(const std::string& input);
   std::string HashFile(const std::string& file);
+
 protected:
-  virtual void Initialize()=0;
-  virtual void Append(unsigned char const*, int)=0;
-  virtual std::string Finalize()=0;
+  virtual void Initialize() = 0;
+  virtual void Append(unsigned char const*, int) = 0;
+  virtual std::string Finalize() = 0;
 };
 
-class cmCryptoHashMD5: public cmCryptoHash
+class cmCryptoHashMD5 : public cmCryptoHash
 {
   struct cmsysMD5_s* MD5;
+
 public:
   cmCryptoHashMD5();
   ~cmCryptoHashMD5();
+
 protected:
   virtual void Initialize();
   virtual void Append(unsigned char const* buf, int sz);
   virtual std::string Finalize();
 };
 
-#define cmCryptoHash_SHA_CLASS_DECL(SHA) \
-  class cmCryptoHash##SHA: public cmCryptoHash \
-  { \
-    union _SHA_CTX* SHA; \
-  public: \
-    cmCryptoHash##SHA(); \
-    ~cmCryptoHash##SHA(); \
-  protected: \
-    virtual void Initialize(); \
-    virtual void Append(unsigned char const* buf, int sz); \
-    virtual std::string Finalize(); \
+#define cmCryptoHash_SHA_CLASS_DECL(SHA)                                      \
+  class cmCryptoHash##SHA : public cmCryptoHash                               \
+  {                                                                           \
+    union _SHA_CTX* SHA;                                                      \
+                                                                              \
+  public:                                                                     \
+    cmCryptoHash##SHA();                                                      \
+    ~cmCryptoHash##SHA();                                                     \
+                                                                              \
+  protected:                                                                  \
+    virtual void Initialize();                                                \
+    virtual void Append(unsigned char const* buf, int sz);                    \
+    virtual std::string Finalize();                                           \
   }
 
 cmCryptoHash_SHA_CLASS_DECL(SHA1);
diff --git a/Source/cmCurl.cxx b/Source/cmCurl.cxx
index c135f27..5bc4f91 100644
--- a/Source/cmCurl.cxx
+++ b/Source/cmCurl.cxx
@@ -15,55 +15,48 @@
 
 // curl versions before 7.21.5 did not provide this error code
 #if defined(LIBCURL_VERSION_NUM) && LIBCURL_VERSION_NUM < 0x071505
-# define CURLE_NOT_BUILT_IN 4
+#define CURLE_NOT_BUILT_IN 4
 #endif
 
-#define check_curl_result(result, errstr)                               \
-  if (result != CURLE_OK && result != CURLE_NOT_BUILT_IN)               \
-    {                                                                   \
-    e += e.empty()? "" : "\n";                                          \
-    e += errstr;                                                        \
-    e += ::curl_easy_strerror(result);                                  \
-    }
+#define check_curl_result(result, errstr)                                     \
+  if (result != CURLE_OK && result != CURLE_NOT_BUILT_IN) {                   \
+    e += e.empty() ? "" : "\n";                                               \
+    e += errstr;                                                              \
+    e += ::curl_easy_strerror(result);                                        \
+  }
 
-std::string cmCurlSetCAInfo(::CURL *curl, const char* cafile)
+std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile)
 {
   std::string e;
-  if(cafile && *cafile)
-    {
+  if (cafile && *cafile) {
     ::CURLcode res = ::curl_easy_setopt(curl, CURLOPT_CAINFO, cafile);
     check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
-    }
-#if !defined(CMAKE_USE_SYSTEM_CURL) && \
-    !defined(_WIN32) && !defined(__APPLE__) && \
-    !defined(CURL_CA_BUNDLE) && !defined(CURL_CA_PATH)
-# define CMAKE_CAFILE_FEDORA "/etc/pki/tls/certs/ca-bundle.crt"
-  else if(cmSystemTools::FileExists(CMAKE_CAFILE_FEDORA, true))
-    {
+  }
+#if !defined(CMAKE_USE_SYSTEM_CURL) && !defined(_WIN32) &&                    \
+  !defined(__APPLE__) && !defined(CURL_CA_BUNDLE) && !defined(CURL_CA_PATH)
+#define CMAKE_CAFILE_FEDORA "/etc/pki/tls/certs/ca-bundle.crt"
+  else if (cmSystemTools::FileExists(CMAKE_CAFILE_FEDORA, true)) {
     ::CURLcode res =
       ::curl_easy_setopt(curl, CURLOPT_CAINFO, CMAKE_CAFILE_FEDORA);
     check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
-    }
-# undef CMAKE_CAFILE_FEDORA
-  else
-    {
-#   define CMAKE_CAFILE_COMMON "/etc/ssl/certs/ca-certificates.crt"
-    if(cmSystemTools::FileExists(CMAKE_CAFILE_COMMON, true))
-      {
+  }
+#undef CMAKE_CAFILE_FEDORA
+  else {
+#define CMAKE_CAFILE_COMMON "/etc/ssl/certs/ca-certificates.crt"
+    if (cmSystemTools::FileExists(CMAKE_CAFILE_COMMON, true)) {
       ::CURLcode res =
         ::curl_easy_setopt(curl, CURLOPT_CAINFO, CMAKE_CAFILE_COMMON);
       check_curl_result(res, "Unable to set TLS/SSL Verify CAINFO: ");
-      }
-#   undef CMAKE_CAFILE_COMMON
-#   define CMAKE_CAPATH_COMMON "/etc/ssl/certs"
-    if(cmSystemTools::FileIsDirectory(CMAKE_CAPATH_COMMON))
-      {
+    }
+#undef CMAKE_CAFILE_COMMON
+#define CMAKE_CAPATH_COMMON "/etc/ssl/certs"
+    if (cmSystemTools::FileIsDirectory(CMAKE_CAPATH_COMMON)) {
       ::CURLcode res =
         ::curl_easy_setopt(curl, CURLOPT_CAPATH, CMAKE_CAPATH_COMMON);
       check_curl_result(res, "Unable to set TLS/SSL Verify CAPATH: ");
-      }
-#   undef CMAKE_CAPATH_COMMON
     }
+#undef CMAKE_CAPATH_COMMON
+  }
 #endif
   return e;
 }
diff --git a/Source/cmCurl.h b/Source/cmCurl.h
index 2bc54cd..eac7f13 100644
--- a/Source/cmCurl.h
+++ b/Source/cmCurl.h
@@ -16,6 +16,6 @@
 
 #include "cm_curl.h"
 
-std::string cmCurlSetCAInfo(::CURL *curl, const char* cafile = 0);
+std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile = 0);
 
 #endif
diff --git a/Source/cmCustomCommand.cxx b/Source/cmCustomCommand.cxx
index e2bd8b1..7c00c80 100644
--- a/Source/cmCustomCommand.cxx
+++ b/Source/cmCustomCommand.cxx
@@ -30,22 +30,21 @@ cmCustomCommand::cmCustomCommand(cmMakefile const* mf,
                                  const std::vector<std::string>& depends,
                                  const cmCustomCommandLines& commandLines,
                                  const char* comment,
-                                 const char* workingDirectory):
-  Outputs(outputs),
-  Byproducts(byproducts),
-  Depends(depends),
-  CommandLines(commandLines),
-  Backtrace(),
-  Comment(comment?comment:""),
-  WorkingDirectory(workingDirectory?workingDirectory:""),
-  HaveComment(comment?true:false),
-  EscapeAllowMakeVars(false),
-  EscapeOldStyle(true)
-{
-  if(mf)
-    {
+                                 const char* workingDirectory)
+  : Outputs(outputs)
+  , Byproducts(byproducts)
+  , Depends(depends)
+  , CommandLines(commandLines)
+  , Backtrace()
+  , Comment(comment ? comment : "")
+  , WorkingDirectory(workingDirectory ? workingDirectory : "")
+  , HaveComment(comment ? true : false)
+  , EscapeAllowMakeVars(false)
+  , EscapeOldStyle(true)
+{
+  if (mf) {
     this->Backtrace = mf->GetBacktrace();
-    }
+  }
 }
 
 const std::vector<std::string>& cmCustomCommand::GetOutputs() const
@@ -71,13 +70,13 @@ const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const
 const char* cmCustomCommand::GetComment() const
 {
   const char* no_comment = 0;
-  return this->HaveComment? this->Comment.c_str() : no_comment;
+  return this->HaveComment ? this->Comment.c_str() : no_comment;
 }
 
 void cmCustomCommand::AppendCommands(const cmCustomCommandLines& commandLines)
 {
-  this->CommandLines.insert(this->CommandLines.end(),
-                            commandLines.begin(), commandLines.end());
+  this->CommandLines.insert(this->CommandLines.end(), commandLines.begin(),
+                            commandLines.end());
 }
 
 void cmCustomCommand::AppendDepends(const std::vector<std::string>& depends)
@@ -123,8 +122,8 @@ void cmCustomCommand::SetImplicitDepends(ImplicitDependsList const& l)
 
 void cmCustomCommand::AppendImplicitDepends(ImplicitDependsList const& l)
 {
-  this->ImplicitDepends.insert(this->ImplicitDepends.end(),
-                               l.begin(), l.end());
+  this->ImplicitDepends.insert(this->ImplicitDepends.end(), l.begin(),
+                               l.end());
 }
 
 bool cmCustomCommand::GetUsesTerminal() const
diff --git a/Source/cmCustomCommand.h b/Source/cmCustomCommand.h
index 0370497..c2b9738 100644
--- a/Source/cmCustomCommand.h
+++ b/Source/cmCustomCommand.h
@@ -34,8 +34,7 @@ public:
                   const std::vector<std::string>& byproducts,
                   const std::vector<std::string>& depends,
                   const cmCustomCommandLines& commandLines,
-                  const char* comment,
-                  const char* workingDirectory);
+                  const char* comment, const char* workingDirectory);
 
   /** Get the output file produced by the command.  */
   const std::vector<std::string>& GetOutputs() const;
@@ -48,7 +47,9 @@ public:
 
   /** Get the working directory.  */
   std::string const& GetWorkingDirectory() const
-    { return this->WorkingDirectory; }
+  {
+    return this->WorkingDirectory;
+  }
 
   /** Get the list of command lines.  */
   const cmCustomCommandLines& GetCommandLines() const;
@@ -75,7 +76,9 @@ public:
   cmListFileBacktrace const& GetBacktrace() const;
 
   typedef std::pair<std::string, std::string> ImplicitDependsPair;
-  class ImplicitDependsList: public std::vector<ImplicitDependsPair> {};
+  class ImplicitDependsList : public std::vector<ImplicitDependsPair>
+  {
+  };
   void SetImplicitDepends(ImplicitDependsList const&);
   void AppendImplicitDepends(ImplicitDependsList const&);
   ImplicitDependsList const& GetImplicitDepends() const;
diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx
index 4a19160..99bb601 100644
--- a/Source/cmCustomCommandGenerator.cxx
+++ b/Source/cmCustomCommandGenerator.cxx
@@ -17,11 +17,16 @@
 #include "cmMakefile.h"
 #include "cmOutputConverter.h"
 
-cmCustomCommandGenerator::cmCustomCommandGenerator(
-  cmCustomCommand const& cc, const std::string& config, cmLocalGenerator* lg):
-  CC(cc), Config(config), LG(lg),
-  OldStyle(cc.GetEscapeOldStyle()), MakeVars(cc.GetEscapeAllowMakeVars()),
-  GE(new cmGeneratorExpression(cc.GetBacktrace())), DependsDone(false)
+cmCustomCommandGenerator::cmCustomCommandGenerator(cmCustomCommand const& cc,
+                                                   const std::string& config,
+                                                   cmLocalGenerator* lg)
+  : CC(cc)
+  , Config(config)
+  , LG(lg)
+  , OldStyle(cc.GetEscapeOldStyle())
+  , MakeVars(cc.GetEscapeAllowMakeVars())
+  , GE(new cmGeneratorExpression(cc.GetBacktrace()))
+  , DependsDone(false)
 {
 }
 
@@ -38,34 +43,28 @@ unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
 bool cmCustomCommandGenerator::UseCrossCompilingEmulator(unsigned int c) const
 {
   std::string const& argv0 = this->CC.GetCommandLines()[c][0];
-  cmGeneratorTarget* target =
-      this->LG->FindGeneratorTargetToUse(argv0);
-  if(target && target->GetType() == cmState::EXECUTABLE)
-    {
+  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(argv0);
+  if (target && target->GetType() == cmState::EXECUTABLE) {
     return target->GetProperty("CROSSCOMPILING_EMULATOR") != 0;
-    }
+  }
   return false;
 }
 
 std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
 {
   std::string const& argv0 = this->CC.GetCommandLines()[c][0];
-  cmGeneratorTarget* target =
-      this->LG->FindGeneratorTargetToUse(argv0);
-  if(target && target->GetType() == cmState::EXECUTABLE &&
-     (target->IsImported()
-      || !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING")))
-    {
+  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(argv0);
+  if (target && target->GetType() == cmState::EXECUTABLE &&
+      (target->IsImported() ||
+       !this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING"))) {
     return target->GetLocation(this->Config);
-    }
-  if (target && target->GetType() == cmState::EXECUTABLE)
-    {
+  }
+  if (target && target->GetType() == cmState::EXECUTABLE) {
     const char* emulator = target->GetProperty("CROSSCOMPILING_EMULATOR");
-    if (emulator)
-      {
-      return  std::string(emulator);
-      }
+    if (emulator) {
+      return std::string(emulator);
     }
+  }
 
   cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(argv0);
   std::string exe = cge->Evaluate(this->LG, this->Config);
@@ -80,53 +79,43 @@ std::string escapeForShellOldStyle(const std::string& str)
   // if there are spaces
   std::string temp = str;
   if (temp.find(" ") != std::string::npos &&
-      temp.find("\"")==std::string::npos)
-    {
+      temp.find("\"") == std::string::npos) {
     result = "\"";
     result += str;
     result += "\"";
     return result;
-    }
+  }
   return str;
 #else
-  for(const char* ch = str.c_str(); *ch != '\0'; ++ch)
-    {
-    if(*ch == ' ')
-      {
+  for (const char* ch = str.c_str(); *ch != '\0'; ++ch) {
+    if (*ch == ' ') {
       result += '\\';
-      }
-    result += *ch;
     }
+    result += *ch;
+  }
   return result;
 #endif
 }
 
-void
-cmCustomCommandGenerator
-::AppendArguments(unsigned int c, std::string& cmd) const
+void cmCustomCommandGenerator::AppendArguments(unsigned int c,
+                                               std::string& cmd) const
 {
   unsigned int offset = 1;
-  if (this->UseCrossCompilingEmulator(c))
-    {
+  if (this->UseCrossCompilingEmulator(c)) {
     offset = 0;
-    }
+  }
   cmCustomCommandLine const& commandLine = this->CC.GetCommandLines()[c];
-  for(unsigned int j=offset;j < commandLine.size(); ++j)
-    {
+  for (unsigned int j = offset; j < commandLine.size(); ++j) {
     std::string arg =
-        this->GE->Parse(commandLine[j])->Evaluate(this->LG,
-                                                  this->Config);
+      this->GE->Parse(commandLine[j])->Evaluate(this->LG, this->Config);
     cmd += " ";
-    if(this->OldStyle)
-      {
+    if (this->OldStyle) {
       cmd += escapeForShellOldStyle(arg);
-      }
-    else
-      {
+    } else {
       cmOutputConverter converter(this->LG->GetStateSnapshot());
       cmd += converter.EscapeForShell(arg, this->MakeVars);
-      }
     }
+  }
 }
 
 const char* cmCustomCommandGenerator::GetComment() const
@@ -151,29 +140,23 @@ std::vector<std::string> const& cmCustomCommandGenerator::GetByproducts() const
 
 std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const
 {
-  if (!this->DependsDone)
-    {
+  if (!this->DependsDone) {
     this->DependsDone = true;
     std::vector<std::string> depends = this->CC.GetDepends();
-    for(std::vector<std::string>::const_iterator
-          i = depends.begin();
-        i != depends.end(); ++i)
-      {
-      cmsys::auto_ptr<cmCompiledGeneratorExpression> cge
-                                              = this->GE->Parse(*i);
+    for (std::vector<std::string>::const_iterator i = depends.begin();
+         i != depends.end(); ++i) {
+      cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(*i);
       std::vector<std::string> result;
-      cmSystemTools::ExpandListArgument(
-            cge->Evaluate(this->LG, this->Config), result);
+      cmSystemTools::ExpandListArgument(cge->Evaluate(this->LG, this->Config),
+                                        result);
       for (std::vector<std::string>::iterator it = result.begin();
-          it != result.end(); ++it)
-        {
-        if (cmSystemTools::FileIsFullPath(it->c_str()))
-          {
+           it != result.end(); ++it) {
+        if (cmSystemTools::FileIsFullPath(it->c_str())) {
           *it = cmSystemTools::CollapseFullPath(*it);
-          }
         }
-      this->Depends.insert(this->Depends.end(), result.begin(), result.end());
       }
+      this->Depends.insert(this->Depends.end(), result.begin(), result.end());
     }
+  }
   return this->Depends;
 }
diff --git a/Source/cmCustomCommandGenerator.h b/Source/cmCustomCommandGenerator.h
index 65ce031..a361153 100644
--- a/Source/cmCustomCommandGenerator.h
+++ b/Source/cmCustomCommandGenerator.h
@@ -28,10 +28,10 @@ class cmCustomCommandGenerator
   cmGeneratorExpression* GE;
   mutable bool DependsDone;
   mutable std::vector<std::string> Depends;
+
 public:
   cmCustomCommandGenerator(cmCustomCommand const& cc,
-                           const std::string& config,
-                           cmLocalGenerator* lg);
+                           const std::string& config, cmLocalGenerator* lg);
   ~cmCustomCommandGenerator();
   cmCustomCommand const& GetCC() const { return this->CC; }
   unsigned int GetNumberOfCommands() const;
diff --git a/Source/cmDefinePropertyCommand.cxx b/Source/cmDefinePropertyCommand.cxx
index 47fc22e..484a970 100644
--- a/Source/cmDefinePropertyCommand.cxx
+++ b/Source/cmDefinePropertyCommand.cxx
@@ -14,47 +14,31 @@
 #include "cmState.h"
 #include "cmake.h"
 
-bool cmDefinePropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmDefinePropertyCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Get the scope in which to define the property.
   cmProperty::ScopeType scope;
-  if(args[0] == "GLOBAL")
-    {
+  if (args[0] == "GLOBAL") {
     scope = cmProperty::GLOBAL;
-    }
-  else if(args[0] == "DIRECTORY")
-    {
+  } else if (args[0] == "DIRECTORY") {
     scope = cmProperty::DIRECTORY;
-    }
-  else if(args[0] == "TARGET")
-    {
+  } else if (args[0] == "TARGET") {
     scope = cmProperty::TARGET;
-    }
-  else if(args[0] == "SOURCE")
-    {
+  } else if (args[0] == "SOURCE") {
     scope = cmProperty::SOURCE_FILE;
-    }
-  else if(args[0] == "TEST")
-    {
+  } else if (args[0] == "TEST") {
     scope = cmProperty::TEST;
-    }
-  else if(args[0] == "VARIABLE")
-    {
+  } else if (args[0] == "VARIABLE") {
     scope = cmProperty::VARIABLE;
-    }
-  else if (args[0] == "CACHED_VARIABLE")
-    {
+  } else if (args[0] == "CACHED_VARIABLE") {
     scope = cmProperty::CACHED_VARIABLE;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "given invalid scope " << args[0] << ".  "
       << "Valid scopes are "
@@ -62,77 +46,63 @@ bool cmDefinePropertyCommand
       << "TEST, VARIABLE, CACHED_VARIABLE.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Parse remaining arguments.
   bool inherited = false;
-  enum Doing { DoingNone, DoingProperty, DoingBrief, DoingFull };
+  enum Doing
+  {
+    DoingNone,
+    DoingProperty,
+    DoingBrief,
+    DoingFull
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "PROPERTY")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "PROPERTY") {
       doing = DoingProperty;
-      }
-    else if(args[i] == "BRIEF_DOCS")
-      {
+    } else if (args[i] == "BRIEF_DOCS") {
       doing = DoingBrief;
-      }
-    else if(args[i] == "FULL_DOCS")
-      {
+    } else if (args[i] == "FULL_DOCS") {
       doing = DoingFull;
-      }
-    else if(args[i] == "INHERITED")
-      {
+    } else if (args[i] == "INHERITED") {
       doing = DoingNone;
       inherited = true;
-      }
-    else if(doing == DoingProperty)
-      {
+    } else if (doing == DoingProperty) {
       doing = DoingNone;
       this->PropertyName = args[i];
-      }
-    else if(doing == DoingBrief)
-      {
+    } else if (doing == DoingBrief) {
       this->BriefDocs += args[i];
-      }
-    else if(doing == DoingFull)
-      {
+    } else if (doing == DoingFull) {
       this->FullDocs += args[i];
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "given invalid argument \"" << args[i] << "\".";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Make sure a property name was found.
-  if(this->PropertyName.empty())
-    {
+  if (this->PropertyName.empty()) {
     this->SetError("not given a PROPERTY <name> argument.");
     return false;
-    }
+  }
 
   // Make sure documentation was given.
-  if(this->BriefDocs.empty())
-    {
+  if (this->BriefDocs.empty()) {
     this->SetError("not given a BRIEF_DOCS <brief-doc> argument.");
     return false;
-    }
-  if(this->FullDocs.empty())
-    {
+  }
+  if (this->FullDocs.empty()) {
     this->SetError("not given a FULL_DOCS <full-doc> argument.");
     return false;
-    }
+  }
 
   // Actually define the property.
-  this->Makefile->GetState()->DefineProperty
-    (this->PropertyName, scope,
-     this->BriefDocs.c_str(), this->FullDocs.c_str(), inherited);
+  this->Makefile->GetState()->DefineProperty(
+    this->PropertyName, scope, this->BriefDocs.c_str(), this->FullDocs.c_str(),
+    inherited);
 
   return true;
 }
-
diff --git a/Source/cmDefinePropertyCommand.h b/Source/cmDefinePropertyCommand.h
index bc5c8a4..4248bbe 100644
--- a/Source/cmDefinePropertyCommand.h
+++ b/Source/cmDefinePropertyCommand.h
@@ -17,30 +17,26 @@
 class cmDefinePropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmDefinePropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmDefinePropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "define_property";}
+  virtual std::string GetName() const { return "define_property"; }
 
   cmTypeMacro(cmDefinePropertyCommand, cmCommand);
+
 private:
   std::string PropertyName;
   std::string BriefDocs;
   std::string FullDocs;
 };
 
-
-
 #endif
diff --git a/Source/cmDefinitions.cxx b/Source/cmDefinitions.cxx
index e8b898d..28b6677 100644
--- a/Source/cmDefinitions.cxx
+++ b/Source/cmDefinitions.cxx
@@ -15,54 +15,50 @@
 
 cmDefinitions::Def cmDefinitions::NoDef;
 
-cmDefinitions::Def const& cmDefinitions::GetInternal(
-  const std::string& key, StackIter begin, StackIter end, bool raise)
+cmDefinitions::Def const& cmDefinitions::GetInternal(const std::string& key,
+                                                     StackIter begin,
+                                                     StackIter end, bool raise)
 {
   assert(begin != end);
   MapType::iterator i = begin->Map.find(key);
-  if (i != begin->Map.end())
-    {
+  if (i != begin->Map.end()) {
     i->second.Used = true;
     return i->second;
-    }
+  }
   StackIter it = begin;
   ++it;
-  if (it == end)
-    {
+  if (it == end) {
     return cmDefinitions::NoDef;
-    }
+  }
   Def const& def = cmDefinitions::GetInternal(key, it, end, raise);
-  if (!raise)
-    {
+  if (!raise) {
     return def;
-    }
+  }
   return begin->Map.insert(MapType::value_type(key, def)).first->second;
 }
 
-const char* cmDefinitions::Get(const std::string& key,
-    StackIter begin, StackIter end)
+const char* cmDefinitions::Get(const std::string& key, StackIter begin,
+                               StackIter end)
 {
   Def const& def = cmDefinitions::GetInternal(key, begin, end, false);
-  return def.Exists? def.c_str() : 0;
+  return def.Exists ? def.c_str() : 0;
 }
 
-void cmDefinitions::Raise(const std::string& key,
-                          StackIter begin, StackIter end)
+void cmDefinitions::Raise(const std::string& key, StackIter begin,
+                          StackIter end)
 {
   cmDefinitions::GetInternal(key, begin, end, true);
 }
 
-bool cmDefinitions::HasKey(const std::string& key,
-                           StackIter begin, StackIter end)
+bool cmDefinitions::HasKey(const std::string& key, StackIter begin,
+                           StackIter end)
 {
-  for (StackIter it = begin; it != end; ++it)
-    {
+  for (StackIter it = begin; it != end; ++it) {
     MapType::const_iterator i = it->Map.find(key);
-    if (i != it->Map.end())
-      {
+    if (i != it->Map.end()) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -77,65 +73,53 @@ std::vector<std::string> cmDefinitions::UnusedKeys() const
   std::vector<std::string> keys;
   keys.reserve(this->Map.size());
   // Consider local definitions.
-  for(MapType::const_iterator mi = this->Map.begin();
-      mi != this->Map.end(); ++mi)
-    {
-    if (!mi->second.Used)
-      {
+  for (MapType::const_iterator mi = this->Map.begin(); mi != this->Map.end();
+       ++mi) {
+    if (!mi->second.Used) {
       keys.push_back(mi->first);
-      }
     }
+  }
   return keys;
 }
 
-cmDefinitions cmDefinitions::MakeClosure(StackIter begin,
-                                         StackIter end)
+cmDefinitions cmDefinitions::MakeClosure(StackIter begin, StackIter end)
 {
   cmDefinitions closure;
   std::set<std::string> undefined;
-  for (StackIter it = begin; it != end; ++it)
-    {
+  for (StackIter it = begin; it != end; ++it) {
     // Consider local definitions.
-    for(MapType::const_iterator mi = it->Map.begin();
-        mi != it->Map.end(); ++mi)
-      {
+    for (MapType::const_iterator mi = it->Map.begin(); mi != it->Map.end();
+         ++mi) {
       // Use this key if it is not already set or unset.
-      if(closure.Map.find(mi->first) == closure.Map.end() &&
-         undefined.find(mi->first) == undefined.end())
-        {
-        if(mi->second.Exists)
-          {
+      if (closure.Map.find(mi->first) == closure.Map.end() &&
+          undefined.find(mi->first) == undefined.end()) {
+        if (mi->second.Exists) {
           closure.Map.insert(*mi);
-          }
-        else
-          {
+        } else {
           undefined.insert(mi->first);
-          }
         }
       }
     }
+  }
   return closure;
 }
 
-std::vector<std::string>
-cmDefinitions::ClosureKeys(StackIter begin, StackIter end)
+std::vector<std::string> cmDefinitions::ClosureKeys(StackIter begin,
+                                                    StackIter end)
 {
   std::set<std::string> bound;
   std::vector<std::string> defined;
 
-  for (StackIter it = begin; it != end; ++it)
-    {
+  for (StackIter it = begin; it != end; ++it) {
     defined.reserve(defined.size() + it->Map.size());
-    for(MapType::const_iterator mi = it->Map.begin();
-        mi != it->Map.end(); ++mi)
-      {
+    for (MapType::const_iterator mi = it->Map.begin(); mi != it->Map.end();
+         ++mi) {
       // Use this key if it is not already set or unset.
-      if(bound.insert(mi->first).second && mi->second.Exists)
-        {
+      if (bound.insert(mi->first).second && mi->second.Exists) {
         defined.push_back(mi->first);
-        }
       }
     }
+  }
 
   return defined;
 }
diff --git a/Source/cmDefinitions.h b/Source/cmDefinitions.h
index 411867c..7be0098 100644
--- a/Source/cmDefinitions.h
+++ b/Source/cmDefinitions.h
@@ -36,41 +36,56 @@
 class cmDefinitions
 {
   typedef cmLinkedTree<cmDefinitions>::iterator StackIter;
+
 public:
-  static const char* Get(const std::string& key,
-                         StackIter begin, StackIter end);
+  static const char* Get(const std::string& key, StackIter begin,
+                         StackIter end);
 
-  static void Raise(const std::string& key,
-                    StackIter begin, StackIter end);
+  static void Raise(const std::string& key, StackIter begin, StackIter end);
 
-  static bool HasKey(const std::string& key,
-                     StackIter begin, StackIter end);
+  static bool HasKey(const std::string& key, StackIter begin, StackIter end);
 
   /** Set (or unset if null) a value associated with a key.  */
   void Set(const std::string& key, const char* value);
 
   std::vector<std::string> UnusedKeys() const;
 
-  static std::vector<std::string> ClosureKeys(StackIter begin,
-                                              StackIter end);
+  static std::vector<std::string> ClosureKeys(StackIter begin, StackIter end);
 
   static cmDefinitions MakeClosure(StackIter begin, StackIter end);
 
 private:
   // String with existence boolean.
-  struct Def: public std::string
+  struct Def : public std::string
   {
   private:
     typedef std::string std_string;
+
   public:
-    Def(): std_string(), Exists(false), Used(false) {}
+    Def()
+      : std_string()
+      , Exists(false)
+      , Used(false)
+    {
+    }
     Def(const char* v)
-      : std_string(v ? v : ""),
-        Exists(v ? true : false),
-        Used(false)
-    {}
-    Def(const std_string& v): std_string(v), Exists(true), Used(false) {}
-    Def(Def const& d): std_string(d), Exists(d.Exists), Used(d.Used) {}
+      : std_string(v ? v : "")
+      , Exists(v ? true : false)
+      , Used(false)
+    {
+    }
+    Def(const std_string& v)
+      : std_string(v)
+      , Exists(true)
+      , Used(false)
+    {
+    }
+    Def(Def const& d)
+      : std_string(d)
+      , Exists(d.Exists)
+      , Used(d.Used)
+    {
+    }
     bool Exists;
     bool Used;
   };
@@ -87,8 +102,8 @@ private:
 #endif
   MapType Map;
 
-  static Def const& GetInternal(const std::string& key,
-    StackIter begin, StackIter end, bool raise);
+  static Def const& GetInternal(const std::string& key, StackIter begin,
+                                StackIter end, bool raise);
 };
 
 #endif
diff --git a/Source/cmDepends.cxx b/Source/cmDepends.cxx
index 8686bcd..5df3cc1 100644
--- a/Source/cmDepends.cxx
+++ b/Source/cmDepends.cxx
@@ -19,26 +19,25 @@
 #include <cmsys/FStream.hxx>
 #include <string.h>
 
-cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir):
-  CompileDirectory(),
-  LocalGenerator(lg),
-  Verbose(false),
-  FileComparison(0),
-  TargetDirectory(targetDir),
-  MaxPath(16384),
-  Dependee(new char[MaxPath]),
-  Depender(new char[MaxPath])
+cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir)
+  : CompileDirectory()
+  , LocalGenerator(lg)
+  , Verbose(false)
+  , FileComparison(0)
+  , TargetDirectory(targetDir)
+  , MaxPath(16384)
+  , Dependee(new char[MaxPath])
+  , Depender(new char[MaxPath])
 {
 }
 
 cmDepends::~cmDepends()
 {
-  delete [] this->Dependee;
-  delete [] this->Depender;
+  delete[] this->Dependee;
+  delete[] this->Depender;
 }
 
-bool cmDepends::Write(std::ostream &makeDepends,
-                      std::ostream &internalDepends)
+bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
 {
   // Lookup the set of sources to scan.
   std::string srcLang = "CMAKE_DEPENDS_CHECK_";
@@ -49,97 +48,92 @@ bool cmDepends::Write(std::ostream &makeDepends,
   cmSystemTools::ExpandListArgument(srcStr, pairs);
 
   std::map<std::string, std::set<std::string> > dependencies;
-  for(std::vector<std::string>::iterator si = pairs.begin();
-      si != pairs.end();)
-    {
+  for (std::vector<std::string>::iterator si = pairs.begin();
+       si != pairs.end();) {
     // Get the source and object file.
     std::string const& src = *si++;
-    if(si == pairs.end()) { break; }
+    if (si == pairs.end()) {
+      break;
+    }
     std::string const& obj = *si++;
     dependencies[obj].insert(src);
-    }
-  for(std::map<std::string, std::set<std::string> >::const_iterator
-      it = dependencies.begin(); it != dependencies.end(); ++it)
-    {
+  }
+  for (std::map<std::string, std::set<std::string> >::const_iterator it =
+         dependencies.begin();
+       it != dependencies.end(); ++it) {
 
     // Write the dependencies for this pair.
-    if(!this->WriteDependencies(it->second, it->first,
-                                makeDepends, internalDepends))
-      {
+    if (!this->WriteDependencies(it->second, it->first, makeDepends,
+                                 internalDepends)) {
       return false;
-      }
     }
+  }
 
   return this->Finalize(makeDepends, internalDepends);
 }
 
-bool cmDepends::Finalize(std::ostream&,
-                         std::ostream&)
+bool cmDepends::Finalize(std::ostream&, std::ostream&)
 {
   return true;
 }
 
-bool cmDepends::Check(const char *makeFile, const char *internalFile,
+bool cmDepends::Check(const char* makeFile, const char* internalFile,
                       std::map<std::string, DependencyVector>& validDeps)
 {
   // Dependency checks must be done in proper working directory.
   std::string oldcwd = ".";
-  if(this->CompileDirectory != ".")
-    {
+  if (this->CompileDirectory != ".") {
     // Get the CWD but do not call CollapseFullPath because
     // we only need it to cd back, and the form does not matter
     oldcwd = cmSystemTools::GetCurrentWorkingDirectory(false);
     cmSystemTools::ChangeDirectory(this->CompileDirectory);
-    }
+  }
 
   // Check whether dependencies must be regenerated.
   bool okay = true;
   cmsys::ifstream fin(internalFile);
-  if(!(fin && this->CheckDependencies(fin, internalFile, validDeps)))
-    {
+  if (!(fin && this->CheckDependencies(fin, internalFile, validDeps))) {
     // Clear all dependencies so they will be regenerated.
     this->Clear(makeFile);
     cmSystemTools::RemoveFile(internalFile);
     okay = false;
-    }
+  }
 
   // Restore working directory.
-  if(oldcwd != ".")
-    {
+  if (oldcwd != ".") {
     cmSystemTools::ChangeDirectory(oldcwd);
-    }
+  }
 
   return okay;
 }
 
-void cmDepends::Clear(const char *file)
+void cmDepends::Clear(const char* file)
 {
   // Print verbose output.
-  if(this->Verbose)
-    {
+  if (this->Verbose) {
     std::ostringstream msg;
     msg << "Clearing dependencies in \"" << file << "\"." << std::endl;
     cmSystemTools::Stdout(msg.str().c_str());
-    }
+  }
 
   // Write an empty dependency file.
   cmGeneratedFileStream depFileStream(file);
-  depFileStream
-    << "# Empty dependencies file\n"
-    << "# This may be replaced when dependencies are built." << std::endl;
+  depFileStream << "# Empty dependencies file\n"
+                << "# This may be replaced when dependencies are built."
+                << std::endl;
 }
 
-bool cmDepends::WriteDependencies(
-    const std::set<std::string>&, const std::string&,
-    std::ostream&, std::ostream&)
+bool cmDepends::WriteDependencies(const std::set<std::string>&,
+                                  const std::string&, std::ostream&,
+                                  std::ostream&)
 {
   // This should be implemented by the subclass.
   return false;
 }
 
-bool cmDepends::CheckDependencies(std::istream& internalDepends,
-                                  const char* internalDependsFileName,
-                            std::map<std::string, DependencyVector>& validDeps)
+bool cmDepends::CheckDependencies(
+  std::istream& internalDepends, const char* internalDependsFileName,
+  std::map<std::string, DependencyVector>& validDeps)
 {
   // Parse dependencies from the stream.  If any dependee is missing
   // or newer than the depender then dependencies should be
@@ -148,22 +142,18 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends,
   bool dependerExists = false;
   DependencyVector* currentDependencies = 0;
 
-  while(internalDepends.getline(this->Dependee, this->MaxPath))
-    {
-    if ( this->Dependee[0] == 0 || this->Dependee[0] == '#' ||
-         this->Dependee[0] == '\r' )
-      {
+  while (internalDepends.getline(this->Dependee, this->MaxPath)) {
+    if (this->Dependee[0] == 0 || this->Dependee[0] == '#' ||
+        this->Dependee[0] == '\r') {
       continue;
-      }
-    size_t len = internalDepends.gcount()-1;
-    if ( this->Dependee[len-1] == '\r' )
-      {
-      len --;
+    }
+    size_t len = internalDepends.gcount() - 1;
+    if (this->Dependee[len - 1] == '\r') {
+      len--;
       this->Dependee[len] = 0;
-      }
-    if ( this->Dependee[0] != ' ' )
-      {
-      memcpy(this->Depender, this->Dependee, len+1);
+    }
+    if (this->Dependee[0] != ' ') {
+      memcpy(this->Depender, this->Dependee, len + 1);
       // Calling FileExists() for the depender here saves in many cases 50%
       // of the calls to FileExists() further down in the loop. E.g. for
       // kdelibs/khtml this reduces the number of calls from 184k down to 92k,
@@ -175,7 +165,7 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends,
       // access.
       currentDependencies = &validDeps[this->Depender];
       continue;
-      }
+    }
     /*
     // Parse the dependency line.
     if(!this->ParseDependency(line.c_str()))
@@ -190,95 +180,80 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends,
     // * if the depender does not exist, but the dependee is newer than the
     //   depends file
     bool regenerate = false;
-    const char* dependee = this->Dependee+1;
+    const char* dependee = this->Dependee + 1;
     const char* depender = this->Depender;
-    if (currentDependencies != 0)
-      {
+    if (currentDependencies != 0) {
       currentDependencies->push_back(dependee);
-      }
+    }
 
-    if(!cmSystemTools::FileExists(dependee))
-      {
+    if (!cmSystemTools::FileExists(dependee)) {
       // The dependee does not exist.
       regenerate = true;
 
       // Print verbose output.
-      if(this->Verbose)
-        {
+      if (this->Verbose) {
         std::ostringstream msg;
-        msg << "Dependee \"" << dependee
-            << "\" does not exist for depender \""
+        msg << "Dependee \"" << dependee << "\" does not exist for depender \""
             << depender << "\"." << std::endl;
         cmSystemTools::Stdout(msg.str().c_str());
-        }
       }
-    else
-      {
-      if(dependerExists)
-        {
+    } else {
+      if (dependerExists) {
         // The dependee and depender both exist.  Compare file times.
         int result = 0;
-        if((!this->FileComparison->FileTimeCompare(depender, dependee,
-                                              &result) || result < 0))
-          {
+        if ((!this->FileComparison->FileTimeCompare(depender, dependee,
+                                                    &result) ||
+             result < 0)) {
           // The depender is older than the dependee.
           regenerate = true;
 
           // Print verbose output.
-          if(this->Verbose)
-            {
+          if (this->Verbose) {
             std::ostringstream msg;
-            msg << "Dependee \"" << dependee
-                << "\" is newer than depender \""
+            msg << "Dependee \"" << dependee << "\" is newer than depender \""
                 << depender << "\"." << std::endl;
             cmSystemTools::Stdout(msg.str().c_str());
-            }
           }
         }
-      else
-        {
+      } else {
         // The dependee exists, but the depender doesn't. Regenerate if the
         // internalDepends file is older than the dependee.
         int result = 0;
-        if((!this->FileComparison->FileTimeCompare(internalDependsFileName,
-                                             dependee, &result) || result < 0))
-          {
+        if ((!this->FileComparison->FileTimeCompare(internalDependsFileName,
+                                                    dependee, &result) ||
+             result < 0)) {
           // The depends-file is older than the dependee.
           regenerate = true;
 
           // Print verbose output.
-          if(this->Verbose)
-            {
+          if (this->Verbose) {
             std::ostringstream msg;
             msg << "Dependee \"" << dependee
                 << "\" is newer than depends file \""
                 << internalDependsFileName << "\"." << std::endl;
             cmSystemTools::Stdout(msg.str().c_str());
-            }
           }
         }
       }
-    if(regenerate)
-      {
+    }
+    if (regenerate) {
       // Dependencies must be regenerated.
       okay = false;
 
       // Remove the information of this depender from the map, it needs
       // to be rescanned
-      if (currentDependencies != 0)
-        {
+      if (currentDependencies != 0) {
         validDeps.erase(this->Depender);
         currentDependencies = 0;
-        }
+      }
 
       // Remove the depender to be sure it is rebuilt.
-      if (dependerExists)
-        {
+      if (dependerExists) {
         cmSystemTools::RemoveFile(depender);
         dependerExists = false;
-        }
       }
     }
+  }
 
   return okay;
 }
@@ -286,26 +261,22 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends,
 void cmDepends::SetIncludePathFromLanguage(const std::string& lang)
 {
   // Look for the new per "TARGET_" variant first:
-  const char * includePath = 0;
+  const char* includePath = 0;
   std::string includePathVar = "CMAKE_";
   includePathVar += lang;
   includePathVar += "_TARGET_INCLUDE_PATH";
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
   includePath = mf->GetDefinition(includePathVar);
-  if(includePath)
-    {
+  if (includePath) {
     cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
-    }
-  else
-    {
+  } else {
     // Fallback to the old directory level variable if no per-target var:
     includePathVar = "CMAKE_";
     includePathVar += lang;
     includePathVar += "_INCLUDE_PATH";
     includePath = mf->GetDefinition(includePathVar);
-    if(includePath)
-      {
+    if (includePath) {
       cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
-      }
     }
+  }
 }
diff --git a/Source/cmDepends.h b/Source/cmDepends.h
index 4f6517e..a62f8c2 100644
--- a/Source/cmDepends.h
+++ b/Source/cmDepends.h
@@ -29,10 +29,10 @@ class cmDepends
 public:
   /** Instances need to know the build directory name and the relative
       path from the build directory to the target file.  */
-  cmDepends(cmLocalGenerator* lg=0, const char* targetDir="");
+  cmDepends(cmLocalGenerator* lg = 0, const char* targetDir = "");
 
   /** at what level will the compile be done from */
-  void SetCompileDirectory(const char *dir) {this->CompileDirectory = dir;}
+  void SetCompileDirectory(const char* dir) { this->CompileDirectory = dir; }
 
   /** Set the local generator for the directory in which we are
       scanning dependencies.  This is not a full local generator; it
@@ -53,27 +53,30 @@ public:
   virtual ~cmDepends();
 
   /** Write dependencies for the target file.  */
-  bool Write(std::ostream &makeDepends, std::ostream &internalDepends);
+  bool Write(std::ostream& makeDepends, std::ostream& internalDepends);
 
-  class DependencyVector: public std::vector<std::string> {};
+  class DependencyVector : public std::vector<std::string>
+  {
+  };
 
   /** Check dependencies for the target file.  Returns true if
       dependencies are okay and false if they must be generated.  If
       they must be generated Clear has already been called to wipe out
       the old dependencies.
       Dependencies which are still valid will be stored in validDeps. */
-  bool Check(const char *makeFile, const char* internalFile,
+  bool Check(const char* makeFile, const char* internalFile,
              std::map<std::string, DependencyVector>& validDeps);
 
   /** Clear dependencies for the target file so they will be regenerated.  */
-  void Clear(const char *file);
+  void Clear(const char* file);
 
   /** Set the file comparison object */
-  void SetFileComparison(cmFileTimeComparison* fc) {
-    this->FileComparison = fc; }
+  void SetFileComparison(cmFileTimeComparison* fc)
+  {
+    this->FileComparison = fc;
+  }
 
 protected:
-
   // Write dependencies for the target file to the given stream.
   // Return true for success and false for failure.
   virtual bool WriteDependencies(const std::set<std::string>& sources,
@@ -84,9 +87,9 @@ protected:
   // Check dependencies for the target file in the given stream.
   // Return false if dependencies must be regenerated and true
   // otherwise.
-  virtual bool CheckDependencies(std::istream& internalDepends,
-                                 const char* internalDependsFileName,
-                           std::map<std::string, DependencyVector>& validDeps);
+  virtual bool CheckDependencies(
+    std::istream& internalDepends, const char* internalDependsFileName,
+    std::map<std::string, DependencyVector>& validDeps);
 
   // Finalize the dependency information for the target.
   virtual bool Finalize(std::ostream& makeDepends,
@@ -117,7 +120,7 @@ protected:
   void SetIncludePathFromLanguage(const std::string& lang);
 
 private:
-  cmDepends(cmDepends const&); // Purposely not implemented.
+  cmDepends(cmDepends const&);      // Purposely not implemented.
   void operator=(cmDepends const&); // Purposely not implemented.
 };
 
diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx
index 2fab890..0a5c7fa 100644
--- a/Source/cmDependsC.cxx
+++ b/Source/cmDependsC.cxx
@@ -20,8 +20,7 @@
 
 #include <ctype.h> // isspace
 
-
-#define INCLUDE_REGEX_LINE \
+#define INCLUDE_REGEX_LINE                                                    \
   "^[ \t]*#[ \t]*(include|import)[ \t]*[<\"]([^\">]+)([\">])"
 
 #define INCLUDE_REGEX_LINE_MARKER "#IncludeRegexLine: "
@@ -30,16 +29,15 @@
 #define INCLUDE_REGEX_TRANSFORM_MARKER "#IncludeRegexTransform: "
 
 cmDependsC::cmDependsC()
-: ValidDeps(0)
+  : ValidDeps(0)
 {
 }
 
-cmDependsC::cmDependsC(cmLocalGenerator* lg,
-                   const char* targetDir,
-                   const std::string& lang,
-                   const std::map<std::string, DependencyVector>* validDeps)
-: cmDepends(lg, targetDir)
-, ValidDeps(validDeps)
+cmDependsC::cmDependsC(
+  cmLocalGenerator* lg, const char* targetDir, const std::string& lang,
+  const std::map<std::string, DependencyVector>* validDeps)
+  : cmDepends(lg, targetDir)
+  , ValidDeps(validDeps)
 {
   cmMakefile* mf = lg->GetMakefile();
 
@@ -50,19 +48,17 @@ cmDependsC::cmDependsC(cmLocalGenerator* lg,
   std::string scanRegex = "^.*$";
   std::string complainRegex = "^$";
   {
-  std::string scanRegexVar = "CMAKE_";
-  scanRegexVar += lang;
-  scanRegexVar += "_INCLUDE_REGEX_SCAN";
-  if(const char* sr = mf->GetDefinition(scanRegexVar))
-    {
-    scanRegex = sr;
+    std::string scanRegexVar = "CMAKE_";
+    scanRegexVar += lang;
+    scanRegexVar += "_INCLUDE_REGEX_SCAN";
+    if (const char* sr = mf->GetDefinition(scanRegexVar)) {
+      scanRegex = sr;
     }
-  std::string complainRegexVar = "CMAKE_";
-  complainRegexVar += lang;
-  complainRegexVar += "_INCLUDE_REGEX_COMPLAIN";
-  if(const char* cr = mf->GetDefinition(complainRegexVar))
-    {
-    complainRegex = cr;
+    std::string complainRegexVar = "CMAKE_";
+    complainRegexVar += lang;
+    complainRegexVar += "_INCLUDE_REGEX_COMPLAIN";
+    if (const char* cr = mf->GetDefinition(complainRegexVar)) {
+      complainRegex = cr;
     }
   }
 
@@ -97,151 +93,128 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
                                    std::ostream& internalDepends)
 {
   // Make sure this is a scanning instance.
-  if(sources.empty() || sources.begin()->empty())
-    {
+  if (sources.empty() || sources.begin()->empty()) {
     cmSystemTools::Error("Cannot scan dependencies without a source file.");
     return false;
-    }
-  if(obj.empty())
-    {
+  }
+  if (obj.empty()) {
     cmSystemTools::Error("Cannot scan dependencies without an object file.");
     return false;
-    }
+  }
 
   std::set<std::string> dependencies;
   bool haveDeps = false;
 
-  if (this->ValidDeps != 0)
-    {
+  if (this->ValidDeps != 0) {
     std::map<std::string, DependencyVector>::const_iterator tmpIt =
-                                                    this->ValidDeps->find(obj);
-    if (tmpIt!= this->ValidDeps->end())
-      {
+      this->ValidDeps->find(obj);
+    if (tmpIt != this->ValidDeps->end()) {
       dependencies.insert(tmpIt->second.begin(), tmpIt->second.end());
       haveDeps = true;
-      }
     }
+  }
 
-  if (!haveDeps)
-    {
+  if (!haveDeps) {
     // Walk the dependency graph starting with the source file.
     int srcFiles = (int)sources.size();
     this->Encountered.clear();
 
-    for(std::set<std::string>::const_iterator srcIt = sources.begin();
-        srcIt != sources.end(); ++srcIt)
-      {
+    for (std::set<std::string>::const_iterator srcIt = sources.begin();
+         srcIt != sources.end(); ++srcIt) {
       UnscannedEntry root;
       root.FileName = *srcIt;
       this->Unscanned.push(root);
       this->Encountered.insert(*srcIt);
-      }
+    }
 
     std::set<std::string> scanned;
 
     // Use reserve to allocate enough memory for tempPathStr
     // so that during the loops no memory is allocated or freed
     std::string tempPathStr;
-    tempPathStr.reserve(4*1024);
+    tempPathStr.reserve(4 * 1024);
 
-    while(!this->Unscanned.empty())
-      {
+    while (!this->Unscanned.empty()) {
       // Get the next file to scan.
       UnscannedEntry current = this->Unscanned.front();
       this->Unscanned.pop();
 
       // If not a full path, find the file in the include path.
       std::string fullName;
-      if((srcFiles>0)
-         || cmSystemTools::FileIsFullPath(current.FileName.c_str()))
-        {
-        if(cmSystemTools::FileExists(current.FileName.c_str(), true))
-          {
+      if ((srcFiles > 0) ||
+          cmSystemTools::FileIsFullPath(current.FileName.c_str())) {
+        if (cmSystemTools::FileExists(current.FileName.c_str(), true)) {
           fullName = current.FileName;
-          }
         }
-      else if(!current.QuotedLocation.empty() &&
-              cmSystemTools::FileExists(current.QuotedLocation.c_str(), true))
-        {
+      } else if (!current.QuotedLocation.empty() &&
+                 cmSystemTools::FileExists(current.QuotedLocation.c_str(),
+                                           true)) {
         // The include statement producing this entry was a double-quote
         // include and the included file is present in the directory of
         // the source containing the include statement.
         fullName = current.QuotedLocation;
-        }
-      else
-        {
-        std::map<std::string, std::string>::iterator
-          headerLocationIt=this->HeaderLocationCache.find(current.FileName);
-        if (headerLocationIt!=this->HeaderLocationCache.end())
-          {
-          fullName=headerLocationIt->second;
-          }
-        else for(std::vector<std::string>::const_iterator i =
-              this->IncludePath.begin(); i != this->IncludePath.end(); ++i)
-          {
-          // Construct the name of the file as if it were in the current
-          // include directory.  Avoid using a leading "./".
-
-          tempPathStr =
-            cmSystemTools::CollapseCombinedPath(*i, current.FileName);
-
-          // Look for the file in this location.
-          if(cmSystemTools::FileExists(tempPathStr.c_str(), true))
-            {
-            fullName = tempPathStr;
-            HeaderLocationCache[current.FileName]=fullName;
-            break;
+      } else {
+        std::map<std::string, std::string>::iterator headerLocationIt =
+          this->HeaderLocationCache.find(current.FileName);
+        if (headerLocationIt != this->HeaderLocationCache.end()) {
+          fullName = headerLocationIt->second;
+        } else
+          for (std::vector<std::string>::const_iterator i =
+                 this->IncludePath.begin();
+               i != this->IncludePath.end(); ++i) {
+            // Construct the name of the file as if it were in the current
+            // include directory.  Avoid using a leading "./".
+
+            tempPathStr =
+              cmSystemTools::CollapseCombinedPath(*i, current.FileName);
+
+            // Look for the file in this location.
+            if (cmSystemTools::FileExists(tempPathStr.c_str(), true)) {
+              fullName = tempPathStr;
+              HeaderLocationCache[current.FileName] = fullName;
+              break;
             }
           }
-        }
+      }
 
       // Complain if the file cannot be found and matches the complain
       // regex.
-      if(fullName.empty() &&
-        this->IncludeRegexComplain.find(current.FileName.c_str()))
-        {
-        cmSystemTools::Error("Cannot find file \"",
-                            current.FileName.c_str(), "\".");
+      if (fullName.empty() &&
+          this->IncludeRegexComplain.find(current.FileName.c_str())) {
+        cmSystemTools::Error("Cannot find file \"", current.FileName.c_str(),
+                             "\".");
         return false;
-        }
+      }
 
       // Scan the file if it was found and has not been scanned already.
-      if(!fullName.empty() && (scanned.find(fullName) == scanned.end()))
-        {
+      if (!fullName.empty() && (scanned.find(fullName) == scanned.end())) {
         // Record scanned files.
         scanned.insert(fullName);
 
         // Check whether this file is already in the cache
-        std::map<std::string, cmIncludeLines*>::iterator fileIt=
+        std::map<std::string, cmIncludeLines*>::iterator fileIt =
           this->FileCache.find(fullName);
-        if (fileIt!=this->FileCache.end())
-          {
-          fileIt->second->Used=true;
+        if (fileIt != this->FileCache.end()) {
+          fileIt->second->Used = true;
           dependencies.insert(fullName);
-          for (std::vector<UnscannedEntry>::const_iterator incIt=
-                fileIt->second->UnscannedEntries.begin();
-              incIt!=fileIt->second->UnscannedEntries.end(); ++incIt)
-            {
+          for (std::vector<UnscannedEntry>::const_iterator incIt =
+                 fileIt->second->UnscannedEntries.begin();
+               incIt != fileIt->second->UnscannedEntries.end(); ++incIt) {
             if (this->Encountered.find(incIt->FileName) ==
-                this->Encountered.end())
-              {
+                this->Encountered.end()) {
               this->Encountered.insert(incIt->FileName);
               this->Unscanned.push(*incIt);
-              }
             }
           }
-        else
-          {
+        } else {
 
           // Try to scan the file.  Just leave it out if we cannot find
           // it.
           cmsys::ifstream fin(fullName.c_str());
-          if(fin)
-            {
+          if (fin) {
             cmsys::FStream::BOM bom = cmsys::FStream::ReadBOM(fin);
-            if(bom == cmsys::FStream::BOM_None ||
-               bom == cmsys::FStream::BOM_UTF8)
-              {
+            if (bom == cmsys::FStream::BOM_None ||
+                bom == cmsys::FStream::BOM_UTF8) {
               // Add this file as a dependency.
               dependencies.insert(fullName);
 
@@ -249,18 +222,16 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
               // containing the file to handle double-quote includes.
               std::string dir = cmSystemTools::GetFilenamePath(fullName);
               this->Scan(fin, dir.c_str(), fullName);
-              }
-            else
-              {
+            } else {
               // Skip file with encoding we do not implement.
-              }
             }
           }
         }
+      }
 
       srcFiles--;
-      }
     }
+  }
 
   // Write the dependencies to the output stream.  Makefile rules
   // written by the original local generator for this directory
@@ -268,21 +239,19 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
   // directory.  We must do the same here.
   std::string obj_i =
     this->LocalGenerator->Convert(obj, cmLocalGenerator::HOME_OUTPUT);
-  std::string obj_m =
-    this->LocalGenerator->ConvertToOutputFormat(obj_i,
-                                                cmLocalGenerator::MAKERULE);
+  std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
+    obj_i, cmLocalGenerator::MAKERULE);
   internalDepends << obj_i << std::endl;
 
-  for(std::set<std::string>::const_iterator i=dependencies.begin();
-      i != dependencies.end(); ++i)
-    {
-    makeDepends << obj_m << ": " <<
-      this->LocalGenerator->Convert(*i,
-                                    cmLocalGenerator::HOME_OUTPUT,
-                                    cmLocalGenerator::MAKERULE)
+  for (std::set<std::string>::const_iterator i = dependencies.begin();
+       i != dependencies.end(); ++i) {
+    makeDepends << obj_m << ": "
+                << this->LocalGenerator->Convert(*i,
+                                                 cmLocalGenerator::HOME_OUTPUT,
+                                                 cmLocalGenerator::MAKERULE)
                 << std::endl;
     internalDepends << " " << *i << std::endl;
-    }
+  }
   makeDepends << std::endl;
 
   return true;
@@ -290,169 +259,136 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources,
 
 void cmDependsC::ReadCacheFile()
 {
-  if(this->CacheFileName.empty())
-    {
+  if (this->CacheFileName.empty()) {
     return;
-    }
+  }
   cmsys::ifstream fin(this->CacheFileName.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     return;
-    }
+  }
 
   std::string line;
-  cmIncludeLines* cacheEntry=0;
-  bool haveFileName=false;
+  cmIncludeLines* cacheEntry = 0;
+  bool haveFileName = false;
 
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if (line.empty())
-      {
-      cacheEntry=0;
-      haveFileName=false;
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty()) {
+      cacheEntry = 0;
+      haveFileName = false;
       continue;
-      }
-    //the first line after an empty line is the name of the parsed file
-    if (haveFileName==false)
-      {
-      haveFileName=true;
-      int newer=0;
+    }
+    // the first line after an empty line is the name of the parsed file
+    if (haveFileName == false) {
+      haveFileName = true;
+      int newer = 0;
       cmFileTimeComparison comp;
-      bool res=comp.FileTimeCompare(this->CacheFileName.c_str(),
-                                    line.c_str(), &newer);
+      bool res = comp.FileTimeCompare(this->CacheFileName.c_str(),
+                                      line.c_str(), &newer);
 
-      if ((res==true) && (newer==1)) //cache is newer than the parsed file
-        {
-        cacheEntry=new cmIncludeLines;
-        this->FileCache[line]=cacheEntry;
-        }
+      if ((res == true) && (newer == 1)) // cache is newer than the parsed file
+      {
+        cacheEntry = new cmIncludeLines;
+        this->FileCache[line] = cacheEntry;
+      }
       // file doesn't exist, check that the regular expressions
       // haven't changed
-      else if (res==false)
-        {
-        if (line.find(INCLUDE_REGEX_LINE_MARKER) == 0)
-          {
-          if (line != this->IncludeRegexLineString)
-            {
+      else if (res == false) {
+        if (line.find(INCLUDE_REGEX_LINE_MARKER) == 0) {
+          if (line != this->IncludeRegexLineString) {
             return;
-            }
           }
-        else if (line.find(INCLUDE_REGEX_SCAN_MARKER) == 0)
-          {
-          if (line != this->IncludeRegexScanString)
-            {
+        } else if (line.find(INCLUDE_REGEX_SCAN_MARKER) == 0) {
+          if (line != this->IncludeRegexScanString) {
             return;
-            }
           }
-        else if (line.find(INCLUDE_REGEX_COMPLAIN_MARKER) == 0)
-          {
-          if (line != this->IncludeRegexComplainString)
-            {
+        } else if (line.find(INCLUDE_REGEX_COMPLAIN_MARKER) == 0) {
+          if (line != this->IncludeRegexComplainString) {
             return;
-            }
           }
-        else if (line.find(INCLUDE_REGEX_TRANSFORM_MARKER) == 0)
-          {
-          if (line != this->IncludeRegexTransformString)
-            {
+        } else if (line.find(INCLUDE_REGEX_TRANSFORM_MARKER) == 0) {
+          if (line != this->IncludeRegexTransformString) {
             return;
-            }
           }
         }
       }
-    else if (cacheEntry!=0)
-      {
+    } else if (cacheEntry != 0) {
       UnscannedEntry entry;
       entry.FileName = line;
-      if (cmSystemTools::GetLineFromStream(fin, line))
-        {
-        if (line!="-")
-          {
-          entry.QuotedLocation=line;
-          }
-        cacheEntry->UnscannedEntries.push_back(entry);
+      if (cmSystemTools::GetLineFromStream(fin, line)) {
+        if (line != "-") {
+          entry.QuotedLocation = line;
         }
+        cacheEntry->UnscannedEntries.push_back(entry);
       }
     }
+  }
 }
 
 void cmDependsC::WriteCacheFile() const
 {
-  if(this->CacheFileName.empty())
-    {
+  if (this->CacheFileName.empty()) {
     return;
-    }
+  }
   cmsys::ofstream cacheOut(this->CacheFileName.c_str());
-  if(!cacheOut)
-    {
+  if (!cacheOut) {
     return;
-    }
+  }
 
   cacheOut << this->IncludeRegexLineString << "\n\n";
   cacheOut << this->IncludeRegexScanString << "\n\n";
   cacheOut << this->IncludeRegexComplainString << "\n\n";
   cacheOut << this->IncludeRegexTransformString << "\n\n";
 
-  for (std::map<std::string, cmIncludeLines*>::const_iterator fileIt=
+  for (std::map<std::string, cmIncludeLines*>::const_iterator fileIt =
          this->FileCache.begin();
-       fileIt!=this->FileCache.end(); ++fileIt)
-    {
-    if (fileIt->second->Used)
-      {
-      cacheOut<<fileIt->first.c_str()<<std::endl;
-
-      for (std::vector<UnscannedEntry>::const_iterator
-             incIt=fileIt->second->UnscannedEntries.begin();
-           incIt!=fileIt->second->UnscannedEntries.end(); ++incIt)
-        {
-        cacheOut<<incIt->FileName.c_str()<<std::endl;
-        if (incIt->QuotedLocation.empty())
-          {
-          cacheOut<<"-"<<std::endl;
-          }
-        else
-          {
-          cacheOut<<incIt->QuotedLocation.c_str()<<std::endl;
-          }
+       fileIt != this->FileCache.end(); ++fileIt) {
+    if (fileIt->second->Used) {
+      cacheOut << fileIt->first.c_str() << std::endl;
+
+      for (std::vector<UnscannedEntry>::const_iterator incIt =
+             fileIt->second->UnscannedEntries.begin();
+           incIt != fileIt->second->UnscannedEntries.end(); ++incIt) {
+        cacheOut << incIt->FileName.c_str() << std::endl;
+        if (incIt->QuotedLocation.empty()) {
+          cacheOut << "-" << std::endl;
+        } else {
+          cacheOut << incIt->QuotedLocation.c_str() << std::endl;
         }
-      cacheOut<<std::endl;
       }
-   }
+      cacheOut << std::endl;
+    }
+  }
 }
 
 void cmDependsC::Scan(std::istream& is, const char* directory,
-  const std::string& fullName)
+                      const std::string& fullName)
 {
-  cmIncludeLines* newCacheEntry=new cmIncludeLines;
-  newCacheEntry->Used=true;
-  this->FileCache[fullName]=newCacheEntry;
+  cmIncludeLines* newCacheEntry = new cmIncludeLines;
+  newCacheEntry->Used = true;
+  this->FileCache[fullName] = newCacheEntry;
 
   // Read one line at a time.
   std::string line;
-  while(cmSystemTools::GetLineFromStream(is, line))
-    {
+  while (cmSystemTools::GetLineFromStream(is, line)) {
     // Transform the line content first.
-    if(!this->TransformRules.empty())
-      {
+    if (!this->TransformRules.empty()) {
       this->TransformLine(line);
-      }
+    }
 
     // Match include directives.
-    if(this->IncludeRegexLine.find(line.c_str()))
-      {
+    if (this->IncludeRegexLine.find(line.c_str())) {
       // Get the file being included.
       UnscannedEntry entry;
       entry.FileName = this->IncludeRegexLine.match(2);
       cmSystemTools::ConvertToUnixSlashes(entry.FileName);
-      if(this->IncludeRegexLine.match(3) == "\"" &&
-         !cmSystemTools::FileIsFullPath(entry.FileName.c_str()))
-        {
+      if (this->IncludeRegexLine.match(3) == "\"" &&
+          !cmSystemTools::FileIsFullPath(entry.FileName.c_str())) {
         // This was a double-quoted include with a relative path.  We
         // must check for the file in the directory containing the
         // file we are scanning.
         entry.QuotedLocation =
           cmSystemTools::CollapseCombinedPath(directory, entry.FileName);
-        }
+      }
 
       // Queue the file if it has not yet been encountered and it
       // matches the regular expression for recursive scanning.  Note
@@ -464,17 +400,16 @@ void cmDependsC::Scan(std::istream& is, const char* directory,
       // file their own directory by simply using "filename.h" (#12619)
       // This kind of problem will be fixed when a more
       // preprocessor-like implementation of this scanner is created.
-      if (this->IncludeRegexScan.find(entry.FileName.c_str()))
-        {
+      if (this->IncludeRegexScan.find(entry.FileName.c_str())) {
         newCacheEntry->UnscannedEntries.push_back(entry);
-        if(this->Encountered.find(entry.FileName) == this->Encountered.end())
-          {
+        if (this->Encountered.find(entry.FileName) ==
+            this->Encountered.end()) {
           this->Encountered.insert(entry.FileName);
           this->Unscanned.push(entry);
-          }
         }
       }
     }
+  }
 }
 
 void cmDependsC::SetupTransforms()
@@ -482,46 +417,40 @@ void cmDependsC::SetupTransforms()
   // Get the transformation rules.
   std::vector<std::string> transformRules;
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
-  if(const char* xform =
-     mf->GetDefinition("CMAKE_INCLUDE_TRANSFORMS"))
-    {
+  if (const char* xform = mf->GetDefinition("CMAKE_INCLUDE_TRANSFORMS")) {
     cmSystemTools::ExpandListArgument(xform, transformRules, true);
-    }
-  for(std::vector<std::string>::const_iterator tri = transformRules.begin();
-      tri != transformRules.end(); ++tri)
-    {
+  }
+  for (std::vector<std::string>::const_iterator tri = transformRules.begin();
+       tri != transformRules.end(); ++tri) {
     this->ParseTransform(*tri);
-    }
+  }
 
   this->IncludeRegexTransformString = INCLUDE_REGEX_TRANSFORM_MARKER;
-  if(!this->TransformRules.empty())
-    {
+  if (!this->TransformRules.empty()) {
     // Construct the regular expression to match lines to be
     // transformed.
     std::string xform = "^([ \t]*#[ \t]*(include|import)[ \t]*)(";
     const char* sep = "";
-    for(TransformRulesType::const_iterator tri = this->TransformRules.begin();
-        tri != this->TransformRules.end(); ++tri)
-      {
+    for (TransformRulesType::const_iterator tri = this->TransformRules.begin();
+         tri != this->TransformRules.end(); ++tri) {
       xform += sep;
       xform += tri->first;
       sep = "|";
-      }
+    }
     xform += ")[ \t]*\\(([^),]*)\\)";
     this->IncludeRegexTransform.compile(xform.c_str());
 
     // Build a string that encodes all transformation rules and will
     // change when rules are changed.
     this->IncludeRegexTransformString += xform;
-    for(TransformRulesType::const_iterator tri = this->TransformRules.begin();
-        tri != this->TransformRules.end(); ++tri)
-      {
+    for (TransformRulesType::const_iterator tri = this->TransformRules.begin();
+         tri != this->TransformRules.end(); ++tri) {
       this->IncludeRegexTransformString += " ";
       this->IncludeRegexTransformString += tri->first;
       this->IncludeRegexTransformString += "(%)=";
       this->IncludeRegexTransformString += tri->second;
-      }
     }
+  }
 }
 
 void cmDependsC::ParseTransform(std::string const& xform)
@@ -529,43 +458,36 @@ void cmDependsC::ParseTransform(std::string const& xform)
   // A transform rule is of the form SOME_MACRO(%)=value-with-%
   // We can simply separate with "(%)=".
   std::string::size_type pos = xform.find("(%)=");
-  if(pos == xform.npos || pos == 0)
-    {
+  if (pos == xform.npos || pos == 0) {
     return;
-    }
+  }
   std::string name = xform.substr(0, pos);
-  std::string value = xform.substr(pos+4, xform.npos);
+  std::string value = xform.substr(pos + 4, xform.npos);
   this->TransformRules[name] = value;
 }
 
 void cmDependsC::TransformLine(std::string& line)
 {
   // Check for a transform rule match.  Return if none.
-  if(!this->IncludeRegexTransform.find(line.c_str()))
-    {
+  if (!this->IncludeRegexTransform.find(line.c_str())) {
     return;
-    }
+  }
   TransformRulesType::const_iterator tri =
     this->TransformRules.find(this->IncludeRegexTransform.match(3));
-  if(tri == this->TransformRules.end())
-    {
+  if (tri == this->TransformRules.end()) {
     return;
-    }
+  }
 
   // Construct the transformed line.
   std::string newline = this->IncludeRegexTransform.match(1);
   std::string arg = this->IncludeRegexTransform.match(4);
-  for(const char* c = tri->second.c_str(); *c; ++c)
-    {
-    if(*c == '%')
-      {
+  for (const char* c = tri->second.c_str(); *c; ++c) {
+    if (*c == '%') {
       newline += arg;
-      }
-    else
-      {
+    } else {
       newline += *c;
-      }
     }
+  }
 
   // Return the transformed line.
   line = newline;
diff --git a/Source/cmDependsC.h b/Source/cmDependsC.h
index cf0a423..e830aa8 100644
--- a/Source/cmDependsC.h
+++ b/Source/cmDependsC.h
@@ -20,7 +20,7 @@
 /** \class cmDependsC
  * \brief Dependency scanner for C and C++ object files.
  */
-class cmDependsC: public cmDepends
+class cmDependsC : public cmDepends
 {
 public:
   /** Checking instances need to know the build directory name and the
@@ -36,13 +36,13 @@ public:
 protected:
   // Implement writing/checking methods required by superclass.
   virtual bool WriteDependencies(const std::set<std::string>& sources,
-                                 const std::string&           obj,
+                                 const std::string& obj,
                                  std::ostream& makeDepends,
                                  std::ostream& internalDepends);
 
   // Method to scan a single file.
   void Scan(std::istream& is, const char* directory,
-    const std::string& fullName);
+            const std::string& fullName);
 
   // Regular expression to identify C preprocessor include directives.
   cmsys::RegularExpression IncludeRegexLine;
@@ -74,24 +74,29 @@ public:
 
   struct cmIncludeLines
   {
-    cmIncludeLines(): Used(false) {}
+    cmIncludeLines()
+      : Used(false)
+    {
+    }
     std::vector<UnscannedEntry> UnscannedEntries;
     bool Used;
   };
+
 protected:
   const std::map<std::string, DependencyVector>* ValidDeps;
   std::set<std::string> Encountered;
   std::queue<UnscannedEntry> Unscanned;
 
-  std::map<std::string, cmIncludeLines *> FileCache;
+  std::map<std::string, cmIncludeLines*> FileCache;
   std::map<std::string, std::string> HeaderLocationCache;
 
   std::string CacheFileName;
 
   void WriteCacheFile() const;
   void ReadCacheFile();
+
 private:
-  cmDependsC(cmDependsC const&); // Purposely not implemented.
+  cmDependsC(cmDependsC const&);     // Purposely not implemented.
   void operator=(cmDependsC const&); // Purposely not implemented.
 };
 
diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx
index 2e4a276..b8af178 100644
--- a/Source/cmDependsFortran.cxx
+++ b/Source/cmDependsFortran.cxx
@@ -38,31 +38,28 @@ public:
   typedef std::map<std::string, cmFortranSourceInfo> ObjectInfoMap;
   ObjectInfoMap ObjectInfo;
 
-  cmFortranSourceInfo& CreateObjectInfo(const char* obj,
-                                               const char* src)
-    {
+  cmFortranSourceInfo& CreateObjectInfo(const char* obj, const char* src)
+  {
     std::map<std::string, cmFortranSourceInfo>::iterator i =
       this->ObjectInfo.find(obj);
-    if(i == this->ObjectInfo.end())
-      {
-      std::map<std::string, cmFortranSourceInfo>::value_type
-        entry(obj, cmFortranSourceInfo());
+    if (i == this->ObjectInfo.end()) {
+      std::map<std::string, cmFortranSourceInfo>::value_type entry(
+        obj, cmFortranSourceInfo());
       i = this->ObjectInfo.insert(entry).first;
       i->second.Source = src;
-      }
-    return i->second;
     }
+    return i->second;
+  }
 };
 
-cmDependsFortran::cmDependsFortran():
-  Internal(0)
+cmDependsFortran::cmDependsFortran()
+  : Internal(0)
 {
 }
 
-cmDependsFortran
-::cmDependsFortran(cmLocalGenerator* lg):
-  cmDepends(lg),
-  Internal(new cmDependsFortranInternals)
+cmDependsFortran::cmDependsFortran(cmLocalGenerator* lg)
+  : cmDepends(lg)
+  , Internal(new cmDependsFortranInternals)
 {
   // Configure the include file search path.
   this->SetIncludePathFromLanguage("Fortran");
@@ -70,25 +67,22 @@ cmDependsFortran
   // Get the list of definitions.
   std::vector<std::string> definitions;
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
-  if(const char* c_defines =
-     mf->GetDefinition("CMAKE_TARGET_DEFINITIONS_Fortran"))
-    {
+  if (const char* c_defines =
+        mf->GetDefinition("CMAKE_TARGET_DEFINITIONS_Fortran")) {
     cmSystemTools::ExpandListArgument(c_defines, definitions);
-    }
+  }
 
   // translate i.e. FOO=BAR to FOO and add it to the list of defined
   // preprocessor symbols
-  for(std::vector<std::string>::const_iterator
-      it = definitions.begin(); it != definitions.end(); ++it)
-    {
+  for (std::vector<std::string>::const_iterator it = definitions.begin();
+       it != definitions.end(); ++it) {
     std::string def = *it;
     std::string::size_type assignment = def.find("=");
-    if(assignment != std::string::npos)
-      {
+    if (assignment != std::string::npos) {
       def = it->substr(0, assignment);
-      }
-    this->PPDefinitions.insert(def);
     }
+    this->PPDefinitions.insert(def);
+  }
 }
 
 cmDependsFortran::~cmDependsFortran()
@@ -96,26 +90,23 @@ cmDependsFortran::~cmDependsFortran()
   delete this->Internal;
 }
 
-bool cmDependsFortran::WriteDependencies(
-    const std::set<std::string>& sources, const std::string& obj,
-    std::ostream&, std::ostream&)
+bool cmDependsFortran::WriteDependencies(const std::set<std::string>& sources,
+                                         const std::string& obj, std::ostream&,
+                                         std::ostream&)
 {
   // Make sure this is a scanning instance.
-  if(sources.empty() || sources.begin()->empty())
-    {
+  if (sources.empty() || sources.begin()->empty()) {
     cmSystemTools::Error("Cannot scan dependencies without a source file.");
     return false;
-    }
-  if(obj.empty())
-    {
+  }
+  if (obj.empty()) {
     cmSystemTools::Error("Cannot scan dependencies without an object file.");
     return false;
-    }
+  }
 
   bool okay = true;
-  for(std::set<std::string>::const_iterator it = sources.begin();
-      it != sources.end(); ++it)
-    {
+  for (std::set<std::string>::const_iterator it = sources.begin();
+       it != sources.end(); ++it) {
     const std::string& src = *it;
     // Get the information object for this source.
     cmFortranSourceInfo& info =
@@ -129,12 +120,11 @@ bool cmDependsFortran::WriteDependencies(
     cmFortranParser_FilePush(&parser, src.c_str());
 
     // Parse the translation unit.
-    if(cmFortran_yyparse(parser.Scanner) != 0)
-      {
+    if (cmFortran_yyparse(parser.Scanner) != 0) {
       // Failed to parse the file.  Report failure to write dependencies.
       okay = false;
-      }
     }
+  }
   return okay;
 }
 
@@ -151,25 +141,21 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
   std::string mod_dir =
     mf->GetSafeDefinition("CMAKE_Fortran_TARGET_MODULE_DIR");
-  if (mod_dir.empty())
-    {
-    mod_dir =
-      this->LocalGenerator->GetCurrentBinaryDirectory();
-    }
+  if (mod_dir.empty()) {
+    mod_dir = this->LocalGenerator->GetCurrentBinaryDirectory();
+  }
 
   // Actually write dependencies to the streams.
   typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap;
   ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
-  for(ObjectInfoMap::const_iterator i = objInfo.begin();
-      i != objInfo.end(); ++i)
-    {
-    if(!this->WriteDependenciesReal(i->first.c_str(), i->second,
-                                    mod_dir, stamp_dir,
-                                    makeDepends, internalDepends))
-      {
+  for (ObjectInfoMap::const_iterator i = objInfo.begin(); i != objInfo.end();
+       ++i) {
+    if (!this->WriteDependenciesReal(i->first.c_str(), i->second, mod_dir,
+                                     stamp_dir, makeDepends,
+                                     internalDepends)) {
       return false;
-      }
     }
+  }
 
   // Store the list of modules provided by this target.
   std::string fiName = this->TargetDirectory;
@@ -178,23 +164,20 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
   fiStream << "# The fortran modules provided by this target.\n";
   fiStream << "provides\n";
   std::set<std::string> const& provides = this->Internal->TargetProvides;
-  for(std::set<std::string>::const_iterator i = provides.begin();
-      i != provides.end(); ++i)
-    {
+  for (std::set<std::string>::const_iterator i = provides.begin();
+       i != provides.end(); ++i) {
     fiStream << " " << *i << "\n";
-    }
+  }
 
   // Create a script to clean the modules.
-  if(!provides.empty())
-    {
+  if (!provides.empty()) {
     std::string fcName = this->TargetDirectory;
     fcName += "/cmake_clean_Fortran.cmake";
     cmGeneratedFileStream fcStream(fcName.c_str());
     fcStream << "# Remove fortran modules provided by this target.\n";
     fcStream << "FILE(REMOVE";
-    for(std::set<std::string>::const_iterator i = provides.begin();
-        i != provides.end(); ++i)
-      {
+    for (std::set<std::string>::const_iterator i = provides.begin();
+         i != provides.end(); ++i) {
       std::string mod_upper = mod_dir;
       mod_upper += "/";
       mod_upper += cmSystemTools::UpperCase(*i);
@@ -208,21 +191,21 @@ bool cmDependsFortran::Finalize(std::ostream& makeDepends,
       stamp += *i;
       stamp += ".mod.stamp";
       fcStream << "\n";
-      fcStream << "  \"" <<
-        this->LocalGenerator->Convert(mod_lower,
-                                      cmLocalGenerator::START_OUTPUT)
+      fcStream << "  \""
+               << this->LocalGenerator->Convert(mod_lower,
+                                                cmLocalGenerator::START_OUTPUT)
                << "\"\n";
-      fcStream << "  \"" <<
-        this->LocalGenerator->Convert(mod_upper,
-                                      cmLocalGenerator::START_OUTPUT)
+      fcStream << "  \""
+               << this->LocalGenerator->Convert(mod_upper,
+                                                cmLocalGenerator::START_OUTPUT)
                << "\"\n";
-      fcStream << "  \"" <<
-        this->LocalGenerator->Convert(stamp,
-                                      cmLocalGenerator::START_OUTPUT)
+      fcStream << "  \""
+               << this->LocalGenerator->Convert(stamp,
+                                                cmLocalGenerator::START_OUTPUT)
                << "\"\n";
-      }
-    fcStream << "  )\n";
     }
+    fcStream << "  )\n";
+  }
   return true;
 }
 
@@ -231,26 +214,23 @@ void cmDependsFortran::LocateModules()
   // Collect the set of modules provided and required by all sources.
   typedef cmDependsFortranInternals::ObjectInfoMap ObjectInfoMap;
   ObjectInfoMap const& objInfo = this->Internal->ObjectInfo;
-  for(ObjectInfoMap::const_iterator infoI = objInfo.begin();
-      infoI != objInfo.end(); ++infoI)
-    {
+  for (ObjectInfoMap::const_iterator infoI = objInfo.begin();
+       infoI != objInfo.end(); ++infoI) {
     cmFortranSourceInfo const& info = infoI->second;
     // Include this module in the set provided by this target.
     this->Internal->TargetProvides.insert(info.Provides.begin(),
                                           info.Provides.end());
 
-    for(std::set<std::string>::const_iterator i = info.Requires.begin();
-        i != info.Requires.end(); ++i)
-      {
+    for (std::set<std::string>::const_iterator i = info.Requires.begin();
+         i != info.Requires.end(); ++i) {
       this->Internal->TargetRequires[*i] = "";
-      }
     }
+  }
 
   // Short-circuit for simple targets.
-  if(this->Internal->TargetRequires.empty())
-    {
+  if (this->Internal->TargetRequires.empty()) {
     return;
-    }
+  }
 
   // Match modules provided by this target to those it requires.
   this->MatchLocalModules();
@@ -258,33 +238,29 @@ void cmDependsFortran::LocateModules()
   // Load information about other targets.
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
   std::vector<std::string> infoFiles;
-  if(const char* infoFilesValue =
-     mf->GetDefinition("CMAKE_TARGET_LINKED_INFO_FILES"))
-    {
+  if (const char* infoFilesValue =
+        mf->GetDefinition("CMAKE_TARGET_LINKED_INFO_FILES")) {
     cmSystemTools::ExpandListArgument(infoFilesValue, infoFiles);
-    }
-  for(std::vector<std::string>::const_iterator i = infoFiles.begin();
-      i != infoFiles.end(); ++i)
-    {
+  }
+  for (std::vector<std::string>::const_iterator i = infoFiles.begin();
+       i != infoFiles.end(); ++i) {
     std::string targetDir = cmSystemTools::GetFilenamePath(*i);
     std::string fname = targetDir + "/fortran.internal";
     cmsys::ifstream fin(fname.c_str());
-    if(fin)
-      {
+    if (fin) {
       this->MatchRemoteModules(fin, targetDir.c_str());
-      }
     }
+  }
 }
 
 void cmDependsFortran::MatchLocalModules()
 {
   const char* stampDir = this->TargetDirectory.c_str();
   std::set<std::string> const& provides = this->Internal->TargetProvides;
-  for(std::set<std::string>::const_iterator i = provides.begin();
-      i != provides.end(); ++i)
-    {
+  for (std::set<std::string>::const_iterator i = provides.begin();
+       i != provides.end(); ++i) {
     this->ConsiderModule(i->c_str(), stampDir);
-    }
+  }
 }
 
 void cmDependsFortran::MatchRemoteModules(std::istream& fin,
@@ -292,59 +268,47 @@ void cmDependsFortran::MatchRemoteModules(std::istream& fin,
 {
   std::string line;
   bool doing_provides = false;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
     // Ignore comments and empty lines.
-    if(line.empty() || line[0] == '#' || line[0] == '\r')
-      {
+    if (line.empty() || line[0] == '#' || line[0] == '\r') {
       continue;
-      }
+    }
 
-    if(line[0] == ' ')
-      {
-      if(doing_provides)
-        {
-        this->ConsiderModule(line.c_str()+1, stampDir);
-        }
+    if (line[0] == ' ') {
+      if (doing_provides) {
+        this->ConsiderModule(line.c_str() + 1, stampDir);
       }
-    else if(line == "provides")
-      {
+    } else if (line == "provides") {
       doing_provides = true;
-      }
-    else
-      {
+    } else {
       doing_provides = false;
-      }
     }
+  }
 }
 
-void cmDependsFortran::ConsiderModule(const char* name,
-                                      const char* stampDir)
+void cmDependsFortran::ConsiderModule(const char* name, const char* stampDir)
 {
   // Locate each required module.
   typedef cmDependsFortranInternals::TargetRequiresMap TargetRequiresMap;
   TargetRequiresMap::iterator required =
     this->Internal->TargetRequires.find(name);
-  if(required != this->Internal->TargetRequires.end() &&
-     required->second.empty())
-    {
+  if (required != this->Internal->TargetRequires.end() &&
+      required->second.empty()) {
     // The module is provided by a CMake target.  It will have a stamp file.
     std::string stampFile = stampDir;
     stampFile += "/";
     stampFile += name;
     stampFile += ".mod.stamp";
     required->second = stampFile;
-    }
+  }
 }
 
-bool
-cmDependsFortran
-::WriteDependenciesReal(const char *obj,
-                        cmFortranSourceInfo const& info,
-                        std::string const& mod_dir,
-                        const char* stamp_dir,
-                        std::ostream& makeDepends,
-                        std::ostream& internalDepends)
+bool cmDependsFortran::WriteDependenciesReal(const char* obj,
+                                             cmFortranSourceInfo const& info,
+                                             std::string const& mod_dir,
+                                             const char* stamp_dir,
+                                             std::ostream& makeDepends,
+                                             std::ostream& internalDepends)
 {
   typedef cmDependsFortranInternals::TargetRequiresMap TargetRequiresMap;
 
@@ -354,39 +318,34 @@ cmDependsFortran
   // Write the include dependencies to the output stream.
   std::string obj_i =
     this->LocalGenerator->Convert(obj, cmLocalGenerator::HOME_OUTPUT);
-  std::string obj_m =
-    this->LocalGenerator->ConvertToOutputFormat(obj_i,
-                                                cmLocalGenerator::MAKERULE);
+  std::string obj_m = this->LocalGenerator->ConvertToOutputFormat(
+    obj_i, cmLocalGenerator::MAKERULE);
   internalDepends << obj_i << std::endl;
   internalDepends << " " << src << std::endl;
-  for(std::set<std::string>::const_iterator i = info.Includes.begin();
-      i != info.Includes.end(); ++i)
-    {
-    makeDepends << obj_m << ": " <<
-      this->LocalGenerator->Convert(*i,
-                                    cmLocalGenerator::HOME_OUTPUT,
-                                    cmLocalGenerator::MAKERULE)
+  for (std::set<std::string>::const_iterator i = info.Includes.begin();
+       i != info.Includes.end(); ++i) {
+    makeDepends << obj_m << ": "
+                << this->LocalGenerator->Convert(*i,
+                                                 cmLocalGenerator::HOME_OUTPUT,
+                                                 cmLocalGenerator::MAKERULE)
                 << std::endl;
     internalDepends << " " << *i << std::endl;
-    }
+  }
   makeDepends << std::endl;
 
   // Write module requirements to the output stream.
-  for(std::set<std::string>::const_iterator i = info.Requires.begin();
-      i != info.Requires.end(); ++i)
-    {
+  for (std::set<std::string>::const_iterator i = info.Requires.begin();
+       i != info.Requires.end(); ++i) {
     // Require only modules not provided in the same source.
-    if(std::set<std::string>::const_iterator(info.Provides.find(*i)) !=
-       info.Provides.end())
-      {
+    if (std::set<std::string>::const_iterator(info.Provides.find(*i)) !=
+        info.Provides.end()) {
       continue;
-      }
+    }
 
     // If the module is provided in this target special handling is
     // needed.
-    if(this->Internal->TargetProvides.find(*i) !=
-       this->Internal->TargetProvides.end())
-      {
+    if (this->Internal->TargetProvides.find(*i) !=
+        this->Internal->TargetProvides.end()) {
       // The module is provided by a different source in the same
       // target.  Add the proxy dependency to make sure the other
       // source builds first.
@@ -394,67 +353,57 @@ cmDependsFortran
       proxy += "/";
       proxy += *i;
       proxy += ".mod.proxy";
-      proxy = this->LocalGenerator->Convert(proxy,
-                                            cmLocalGenerator::HOME_OUTPUT,
-                                            cmLocalGenerator::MAKERULE);
+      proxy = this->LocalGenerator->Convert(
+        proxy, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE);
 
       // since we require some things add them to our list of requirements
       makeDepends << obj_m << ".requires: " << proxy << std::endl;
-      }
+    }
 
     // The object file should depend on timestamped files for the
     // modules it uses.
     TargetRequiresMap::const_iterator required =
       this->Internal->TargetRequires.find(*i);
-    if(required == this->Internal->TargetRequires.end()) { abort(); }
-    if(!required->second.empty())
-      {
+    if (required == this->Internal->TargetRequires.end()) {
+      abort();
+    }
+    if (!required->second.empty()) {
       // This module is known.  Depend on its timestamp file.
-      std::string stampFile =
-        this->LocalGenerator->Convert(required->second,
-                                      cmLocalGenerator::HOME_OUTPUT,
-                                      cmLocalGenerator::MAKERULE);
+      std::string stampFile = this->LocalGenerator->Convert(
+        required->second, cmLocalGenerator::HOME_OUTPUT,
+        cmLocalGenerator::MAKERULE);
       makeDepends << obj_m << ": " << stampFile << "\n";
-      }
-    else
-      {
+    } else {
       // This module is not known to CMake.  Try to locate it where
       // the compiler will and depend on that.
       std::string module;
-      if(this->FindModule(*i, module))
-        {
-        module =
-          this->LocalGenerator->Convert(module,
-                                        cmLocalGenerator::HOME_OUTPUT,
-                                        cmLocalGenerator::MAKERULE);
+      if (this->FindModule(*i, module)) {
+        module = this->LocalGenerator->Convert(
+          module, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE);
         makeDepends << obj_m << ": " << module << "\n";
-        }
       }
     }
+  }
 
   // Write provided modules to the output stream.
-  for(std::set<std::string>::const_iterator i = info.Provides.begin();
-      i != info.Provides.end(); ++i)
-    {
+  for (std::set<std::string>::const_iterator i = info.Provides.begin();
+       i != info.Provides.end(); ++i) {
     std::string proxy = stamp_dir;
     proxy += "/";
     proxy += *i;
     proxy += ".mod.proxy";
-    proxy = this->LocalGenerator->Convert(proxy,
-                                          cmLocalGenerator::HOME_OUTPUT,
+    proxy = this->LocalGenerator->Convert(proxy, cmLocalGenerator::HOME_OUTPUT,
                                           cmLocalGenerator::MAKERULE);
     makeDepends << proxy << ": " << obj_m << ".provides" << std::endl;
-    }
+  }
 
   // If any modules are provided then they must be converted to stamp files.
-  if(!info.Provides.empty())
-    {
+  if (!info.Provides.empty()) {
     // Create a target to copy the module after the object file
     // changes.
     makeDepends << obj_m << ".provides.build:\n";
-    for(std::set<std::string>::const_iterator i = info.Provides.begin();
-        i != info.Provides.end(); ++i)
-      {
+    for (std::set<std::string>::const_iterator i = info.Provides.begin();
+         i != info.Provides.end(); ++i) {
       // Include this module in the set provided by this target.
       this->Internal->TargetProvides.insert(*i);
 
@@ -465,28 +414,23 @@ cmDependsFortran
       std::string modFile = mod_dir;
       modFile += "/";
       modFile += *i;
-      modFile =
-        this->LocalGenerator->Convert(modFile,
-                                      cmLocalGenerator::HOME_OUTPUT,
-                                      cmLocalGenerator::SHELL);
+      modFile = this->LocalGenerator->Convert(
+        modFile, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::SHELL);
       std::string stampFile = stamp_dir;
       stampFile += "/";
       stampFile += m;
       stampFile += ".mod.stamp";
-      stampFile =
-        this->LocalGenerator->Convert(stampFile,
-                                      cmLocalGenerator::HOME_OUTPUT,
-                                      cmLocalGenerator::SHELL);
-      makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod "
-                  << modFile << " " << stampFile;
+      stampFile = this->LocalGenerator->Convert(
+        stampFile, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::SHELL);
+      makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " << modFile
+                  << " " << stampFile;
       cmMakefile* mf = this->LocalGenerator->GetMakefile();
       const char* cid = mf->GetDefinition("CMAKE_Fortran_COMPILER_ID");
-      if(cid && *cid)
-        {
+      if (cid && *cid) {
         makeDepends << " " << cid;
-        }
-      makeDepends << "\n";
       }
+      makeDepends << "\n";
+    }
     // After copying the modules update the timestamp file so that
     // copying will not be done again until the source rebuilds.
     makeDepends << "\t$(CMAKE_COMMAND) -E touch " << obj_m
@@ -496,17 +440,15 @@ cmDependsFortran
     // the target finishes building.
     std::string driver = this->TargetDirectory;
     driver += "/build";
-    driver = this->LocalGenerator->Convert(driver,
-                                           cmLocalGenerator::HOME_OUTPUT,
-                                           cmLocalGenerator::MAKERULE);
+    driver = this->LocalGenerator->Convert(
+      driver, cmLocalGenerator::HOME_OUTPUT, cmLocalGenerator::MAKERULE);
     makeDepends << driver << ": " << obj_m << ".provides.build\n";
-    }
+  }
 
   return true;
 }
 
-bool cmDependsFortran::FindModule(std::string const& name,
-                                  std::string& module)
+bool cmDependsFortran::FindModule(std::string const& name, std::string& module)
 {
   // Construct possible names for the module file.
   std::string mod_upper = cmSystemTools::UpperCase(name);
@@ -516,29 +458,26 @@ bool cmDependsFortran::FindModule(std::string const& name,
 
   // Search the include path for the module.
   std::string fullName;
-  for(std::vector<std::string>::const_iterator i =
-        this->IncludePath.begin(); i != this->IncludePath.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = this->IncludePath.begin();
+       i != this->IncludePath.end(); ++i) {
     // Try the lower-case name.
     fullName = *i;
     fullName += "/";
     fullName += mod_lower;
-    if(cmSystemTools::FileExists(fullName.c_str(), true))
-      {
+    if (cmSystemTools::FileExists(fullName.c_str(), true)) {
       module = fullName;
       return true;
-      }
+    }
 
     // Try the upper-case name.
     fullName = *i;
     fullName += "/";
     fullName += mod_upper;
-    if(cmSystemTools::FileExists(fullName.c_str(), true))
-      {
+    if (cmSystemTools::FileExists(fullName.c_str(), true)) {
       module = fullName;
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -557,12 +496,13 @@ bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
   std::string mod = args[2];
   std::string stamp = args[3];
   std::string compilerId;
-  if(args.size() >= 5)
-    {
+  if (args.size() >= 5) {
     compilerId = args[4];
-    }
+  }
   std::string mod_dir = cmSystemTools::GetFilenamePath(mod);
-  if(!mod_dir.empty()) { mod_dir += "/"; }
+  if (!mod_dir.empty()) {
+    mod_dir += "/";
+  }
   std::string mod_upper = mod_dir;
   mod_upper += cmSystemTools::UpperCase(cmSystemTools::GetFilenameName(mod));
   std::string mod_lower = mod_dir;
@@ -570,101 +510,81 @@ bool cmDependsFortran::CopyModule(const std::vector<std::string>& args)
   mod += ".mod";
   mod_upper += ".mod";
   mod_lower += ".mod";
-  if(cmSystemTools::FileExists(mod_upper.c_str(), true))
-    {
-    if(cmDependsFortran::ModulesDiffer(mod_upper.c_str(), stamp.c_str(),
-                                       compilerId.c_str()))
-      {
-      if(!cmSystemTools::CopyFileAlways(mod_upper, stamp))
-        {
-        std::cerr << "Error copying Fortran module from \""
-                  << mod_upper << "\" to \"" << stamp
-                  << "\".\n";
+  if (cmSystemTools::FileExists(mod_upper.c_str(), true)) {
+    if (cmDependsFortran::ModulesDiffer(mod_upper.c_str(), stamp.c_str(),
+                                        compilerId.c_str())) {
+      if (!cmSystemTools::CopyFileAlways(mod_upper, stamp)) {
+        std::cerr << "Error copying Fortran module from \"" << mod_upper
+                  << "\" to \"" << stamp << "\".\n";
         return false;
-        }
       }
-    return true;
     }
-  else if(cmSystemTools::FileExists(mod_lower.c_str(), true))
-    {
-    if(cmDependsFortran::ModulesDiffer(mod_lower.c_str(), stamp.c_str(),
-                                       compilerId.c_str()))
-      {
-      if(!cmSystemTools::CopyFileAlways(mod_lower, stamp))
-        {
-        std::cerr << "Error copying Fortran module from \""
-                  << mod_lower << "\" to \"" << stamp
-                  << "\".\n";
+    return true;
+  } else if (cmSystemTools::FileExists(mod_lower.c_str(), true)) {
+    if (cmDependsFortran::ModulesDiffer(mod_lower.c_str(), stamp.c_str(),
+                                        compilerId.c_str())) {
+      if (!cmSystemTools::CopyFileAlways(mod_lower, stamp)) {
+        std::cerr << "Error copying Fortran module from \"" << mod_lower
+                  << "\" to \"" << stamp << "\".\n";
         return false;
-        }
       }
-    return true;
     }
+    return true;
+  }
 
-  std::cerr << "Error copying Fortran module \"" << args[2]
-            << "\".  Tried \"" << mod_upper
-            << "\" and \"" << mod_lower << "\".\n";
+  std::cerr << "Error copying Fortran module \"" << args[2] << "\".  Tried \""
+            << mod_upper << "\" and \"" << mod_lower << "\".\n";
   return false;
 }
 
 // Helper function to look for a short sequence in a stream.  If this
 // is later used for longer sequences it should be re-written using an
 // efficient string search algorithm such as Boyer-Moore.
-static
-bool cmFortranStreamContainsSequence(std::istream& ifs,
-                                            const char* seq, int len)
+static bool cmFortranStreamContainsSequence(std::istream& ifs, const char* seq,
+                                            int len)
 {
   assert(len > 0);
 
   int cur = 0;
-  while(cur < len)
-    {
+  while (cur < len) {
     // Get the next character.
     int token = ifs.get();
-    if(!ifs)
-      {
+    if (!ifs) {
       return false;
-      }
+    }
 
     // Check the character.
-    if(token == static_cast<int>(seq[cur]))
-      {
+    if (token == static_cast<int>(seq[cur])) {
       ++cur;
-      }
-    else
-      {
+    } else {
       // Assume the sequence has no repeating subsequence.
       cur = 0;
-      }
     }
+  }
 
   // The entire sequence was matched.
   return true;
 }
 
 // Helper function to compare the remaining content in two streams.
-static bool cmFortranStreamsDiffer(std::istream& ifs1,
-                                          std::istream& ifs2)
+static bool cmFortranStreamsDiffer(std::istream& ifs1, std::istream& ifs2)
 {
   // Compare the remaining content.
-  for(;;)
-    {
+  for (;;) {
     int ifs1_c = ifs1.get();
     int ifs2_c = ifs2.get();
-    if(!ifs1 && !ifs2)
-      {
+    if (!ifs1 && !ifs2) {
       // We have reached the end of both streams simultaneously.
       // The streams are identical.
       return false;
-      }
+    }
 
-    if(!ifs1 || !ifs2 || ifs1_c != ifs2_c)
-      {
+    if (!ifs1 || !ifs2 || ifs1_c != ifs2_c) {
       // We have reached the end of one stream before the other or
       // found differing content.  The streams are different.
       break;
-      }
     }
+  }
 
   return true;
 }
@@ -701,15 +621,13 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
     TODO ...
   */
 
-
   /* Compilers which do _not_ produce different mod content when the same
    * source is compiled twice
    *   -SunPro
    */
-  if(strcmp(compilerId, "SunPro") == 0)
-    {
+  if (strcmp(compilerId, "SunPro") == 0) {
     return cmSystemTools::FilesDiffer(modFile, stampFile);
-    }
+  }
 
 #if defined(_WIN32) || defined(__CYGWIN__)
   cmsys::ifstream finModFile(modFile, std::ios::in | std::ios::binary);
@@ -718,11 +636,10 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
   cmsys::ifstream finModFile(modFile, std::ios::in);
   cmsys::ifstream finStampFile(stampFile, std::ios::in);
 #endif
-  if(!finModFile || !finStampFile)
-    {
+  if (!finModFile || !finStampFile) {
     // At least one of the files does not exist.  The modules differ.
     return true;
-    }
+  }
 
   /* Compilers which _do_ produce different mod content when the same
    * source is compiled twice
@@ -732,62 +649,54 @@ bool cmDependsFortran::ModulesDiffer(const char* modFile,
    * Eat the stream content until all recompile only related changes
    * are left behind.
    */
-  if (strcmp(compilerId, "GNU") == 0 )
-    {
+  if (strcmp(compilerId, "GNU") == 0) {
     // GNU Fortran 4.9 and later compress .mod files with gzip
     // but also do not include a date so we can fall through to
     // compare them without skipping any prefix.
     unsigned char hdr[2];
-    bool okay = finModFile.read(reinterpret_cast<char*>(hdr), 2)? true:false;
+    bool okay =
+      finModFile.read(reinterpret_cast<char*>(hdr), 2) ? true : false;
     finModFile.seekg(0);
-    if(!(okay && hdr[0] == 0x1f && hdr[1] == 0x8b))
-      {
-      const char seq[1] = {'\n'};
+    if (!(okay && hdr[0] == 0x1f && hdr[1] == 0x8b)) {
+      const char seq[1] = { '\n' };
       const int seqlen = 1;
 
-      if(!cmFortranStreamContainsSequence(finModFile, seq, seqlen))
-        {
+      if (!cmFortranStreamContainsSequence(finModFile, seq, seqlen)) {
         // The module is of unexpected format.  Assume it is different.
         std::cerr << compilerId << " fortran module " << modFile
                   << " has unexpected format." << std::endl;
         return true;
-        }
+      }
 
-      if(!cmFortranStreamContainsSequence(finStampFile, seq, seqlen))
-        {
+      if (!cmFortranStreamContainsSequence(finStampFile, seq, seqlen)) {
         // The stamp must differ if the sequence is not contained.
         return true;
-        }
       }
     }
-  else if(strcmp(compilerId, "Intel") == 0)
-    {
-    const char seq[2] = {'\n', '\0'};
+  } else if (strcmp(compilerId, "Intel") == 0) {
+    const char seq[2] = { '\n', '\0' };
     const int seqlen = 2;
 
-    if(!cmFortranStreamContainsSequence(finModFile, seq, seqlen))
-      {
+    if (!cmFortranStreamContainsSequence(finModFile, seq, seqlen)) {
       // The module is of unexpected format.  Assume it is different.
       std::cerr << compilerId << " fortran module " << modFile
                 << " has unexpected format." << std::endl;
       return true;
-      }
+    }
 
-    if(!cmFortranStreamContainsSequence(finStampFile, seq, seqlen))
-      {
+    if (!cmFortranStreamContainsSequence(finStampFile, seq, seqlen)) {
       // The stamp must differ if the sequence is not contained.
       return true;
-      }
     }
+  }
 
   // Compare the remaining content.  If no compiler id matched above,
   // including the case none was given, this will compare the whole
   // content.
-  if(!cmFortranStreamsDiffer(finModFile, finStampFile))
-    {
+  if (!cmFortranStreamsDiffer(finModFile, finStampFile)) {
     return false;
-    }
+  }
 
-   // The modules are different.
-   return true;
+  // The modules are different.
+  return true;
 }
diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h
index a8a4013..5ff0b6c 100644
--- a/Source/cmDependsFortran.h
+++ b/Source/cmDependsFortran.h
@@ -20,7 +20,7 @@ class cmFortranSourceInfo;
 /** \class cmDependsFortran
  * \brief Dependency scanner for Fortran object files.
  */
-class cmDependsFortran: public cmDepends
+class cmDependsFortran : public cmDepends
 {
 public:
   /** Checking instances need to know the build directory name and the
@@ -43,8 +43,8 @@ public:
 
   /** Determine if a mod file and the corresponding mod.stamp file
       are representing  different module information. */
-  static bool  ModulesDiffer(const char* modFile, const char* stampFile,
-                             const char* compilerId);
+  static bool ModulesDiffer(const char* modFile, const char* stampFile,
+                            const char* compilerId);
 
 protected:
   // Finalize the dependency information for the target.
@@ -59,15 +59,14 @@ protected:
   bool FindModule(std::string const& name, std::string& module);
 
   // Implement writing/checking methods required by superclass.
-  virtual bool WriteDependencies(
-    const std::set<std::string>& sources, const std::string& file,
-    std::ostream& makeDepends, std::ostream& internalDepends);
+  virtual bool WriteDependencies(const std::set<std::string>& sources,
+                                 const std::string& file,
+                                 std::ostream& makeDepends,
+                                 std::ostream& internalDepends);
 
   // Actually write the depenencies to the streams.
-  bool WriteDependenciesReal(const char *obj,
-                             cmFortranSourceInfo const& info,
-                             std::string const& mod_dir,
-                             const char* stamp_dir,
+  bool WriteDependenciesReal(const char* obj, cmFortranSourceInfo const& info,
+                             std::string const& mod_dir, const char* stamp_dir,
                              std::ostream& makeDepends,
                              std::ostream& internalDepends);
 
@@ -81,7 +80,7 @@ protected:
 
 private:
   cmDependsFortran(cmDependsFortran const&); // Purposely not implemented.
-  void operator=(cmDependsFortran const&); // Purposely not implemented.
+  void operator=(cmDependsFortran const&);   // Purposely not implemented.
 };
 
 #endif
diff --git a/Source/cmDependsJava.cxx b/Source/cmDependsJava.cxx
index 96f98dc..4f5e2ae 100644
--- a/Source/cmDependsJava.cxx
+++ b/Source/cmDependsJava.cxx
@@ -23,20 +23,20 @@ cmDependsJava::~cmDependsJava()
 }
 
 bool cmDependsJava::WriteDependencies(const std::set<std::string>& sources,
-    const std::string&, std::ostream&, std::ostream&)
+                                      const std::string&, std::ostream&,
+                                      std::ostream&)
 {
   // Make sure this is a scanning instance.
-  if(sources.empty() || sources.begin()->empty())
-    {
+  if (sources.empty() || sources.begin()->empty()) {
     cmSystemTools::Error("Cannot scan dependencies without an source file.");
     return false;
-    }
+  }
 
   return true;
 }
 
 bool cmDependsJava::CheckDependencies(std::istream&, const char*,
-                             std::map<std::string, DependencyVector >&)
+                                      std::map<std::string, DependencyVector>&)
 {
   return true;
 }
diff --git a/Source/cmDependsJava.h b/Source/cmDependsJava.h
index 22af53f..44723fa 100644
--- a/Source/cmDependsJava.h
+++ b/Source/cmDependsJava.h
@@ -17,7 +17,7 @@
 /** \class cmDependsJava
  * \brief Dependency scanner for Java class files.
  */
-class cmDependsJava: public cmDepends
+class cmDependsJava : public cmDepends
 {
 public:
   /** Checking instances need to know the build directory name and the
@@ -29,15 +29,16 @@ public:
 
 protected:
   // Implement writing/checking methods required by superclass.
-  virtual bool WriteDependencies(
-    const std::set<std::string>& sources, const std::string& file,
-    std::ostream& makeDepends, std::ostream& internalDepends);
-  virtual bool CheckDependencies(std::istream& internalDepends,
-                                 const char* internalDependsFileName,
-                           std::map<std::string, DependencyVector>& validDeps);
+  virtual bool WriteDependencies(const std::set<std::string>& sources,
+                                 const std::string& file,
+                                 std::ostream& makeDepends,
+                                 std::ostream& internalDepends);
+  virtual bool CheckDependencies(
+    std::istream& internalDepends, const char* internalDependsFileName,
+    std::map<std::string, DependencyVector>& validDeps);
 
 private:
-  cmDependsJava(cmDependsJava const&); // Purposely not implemented.
+  cmDependsJava(cmDependsJava const&);  // Purposely not implemented.
   void operator=(cmDependsJava const&); // Purposely not implemented.
 };
 
diff --git a/Source/cmDependsJavaParserHelper.cxx b/Source/cmDependsJavaParserHelper.cxx
index 51a1cb4..bd3ee4d 100644
--- a/Source/cmDependsJavaParserHelper.cxx
+++ b/Source/cmDependsJavaParserHelper.cxx
@@ -15,7 +15,7 @@
 #include "cmSystemTools.h"
 #include <cmsys/FStream.hxx>
 
-int cmDependsJava_yyparse( yyscan_t yyscanner );
+int cmDependsJava_yyparse(yyscan_t yyscanner);
 
 cmDependsJavaParserHelper::cmDependsJavaParserHelper()
 {
@@ -29,185 +29,152 @@ cmDependsJavaParserHelper::cmDependsJavaParserHelper()
   this->ClassStack.push_back(tl);
 }
 
-
 cmDependsJavaParserHelper::~cmDependsJavaParserHelper()
 {
   this->CleanupParser();
 }
 
-void cmDependsJavaParserHelper::CurrentClass
-::AddFileNamesForPrinting(std::vector<std::string> *files,
-                          const char* prefix, const char* sep)
+void cmDependsJavaParserHelper::CurrentClass::AddFileNamesForPrinting(
+  std::vector<std::string>* files, const char* prefix, const char* sep)
 {
   std::string rname = "";
-  if ( prefix )
-    {
+  if (prefix) {
     rname += prefix;
     rname += sep;
-    }
+  }
   rname += this->Name;
   files->push_back(rname);
   std::vector<CurrentClass>::iterator it;
-  for ( it = this->NestedClasses->begin();
-    it != this->NestedClasses->end();
-    ++ it )
-    {
+  for (it = this->NestedClasses->begin(); it != this->NestedClasses->end();
+       ++it) {
     it->AddFileNamesForPrinting(files, rname.c_str(), sep);
-    }
+  }
 }
 
 void cmDependsJavaParserHelper::DeallocateParserType(char** pt)
 {
-  if (!pt)
-    {
+  if (!pt) {
     return;
-    }
-  if (!*pt)
-    {
+  }
+  if (!*pt) {
     return;
-    }
+  }
   *pt = 0;
-  this->UnionsAvailable --;
+  this->UnionsAvailable--;
 }
 
 void cmDependsJavaParserHelper::AddClassFound(const char* sclass)
 {
-  if( ! sclass )
-    {
+  if (!sclass) {
     return;
-    }
+  }
   std::vector<std::string>::iterator it;
-  for ( it = this->ClassesFound.begin();
-    it != this->ClassesFound.end();
-    it ++ )
-    {
-    if ( *it == sclass )
-      {
+  for (it = this->ClassesFound.begin(); it != this->ClassesFound.end(); it++) {
+    if (*it == sclass) {
       return;
-      }
     }
+  }
   this->ClassesFound.push_back(sclass);
 }
 
 void cmDependsJavaParserHelper::AddPackagesImport(const char* sclass)
 {
   std::vector<std::string>::iterator it;
-  for ( it = this->PackagesImport.begin();
-    it != this->PackagesImport.end();
-    it ++ )
-    {
-    if ( *it == sclass )
-      {
+  for (it = this->PackagesImport.begin(); it != this->PackagesImport.end();
+       it++) {
+    if (*it == sclass) {
       return;
-      }
     }
+  }
   this->PackagesImport.push_back(sclass);
 }
 
-void cmDependsJavaParserHelper::SafePrintMissing(const char* str,
-                                                 int line, int cnt)
+void cmDependsJavaParserHelper::SafePrintMissing(const char* str, int line,
+                                                 int cnt)
 {
-  if ( str )
-    {
+  if (str) {
     std::cout << line << " String " << cnt << " exists: ";
     unsigned int cc;
-    for ( cc = 0; cc < strlen(str); cc ++ )
-      {
+    for (cc = 0; cc < strlen(str); cc++) {
       unsigned char ch = str[cc];
-      if ( ch >= 32 && ch <= 126 )
-        {
+      if (ch >= 32 && ch <= 126) {
         std::cout << (char)ch;
-        }
-      else
-        {
+      } else {
         std::cout << "<" << (int)ch << ">";
         break;
-        }
       }
-    std::cout << "- " << strlen(str) << std::endl;
     }
+    std::cout << "- " << strlen(str) << std::endl;
+  }
 }
 void cmDependsJavaParserHelper::Print(const char* place, const char* str)
 {
-  if ( this->Verbose )
-    {
+  if (this->Verbose) {
     std::cout << "[" << place << "=" << str << "]" << std::endl;
-    }
+  }
 }
 
-void cmDependsJavaParserHelper::CombineUnions(char** out,
-                                              const char* in1, char** in2,
-                                              const char* sep)
+void cmDependsJavaParserHelper::CombineUnions(char** out, const char* in1,
+                                              char** in2, const char* sep)
 {
   size_t len = 1;
-  if ( in1 )
-    {
+  if (in1) {
     len += strlen(in1);
-    }
-  if ( *in2 )
-    {
+  }
+  if (*in2) {
     len += strlen(*in2);
-    }
-  if ( sep )
-    {
+  }
+  if (sep) {
     len += strlen(sep);
-    }
-  *out = new char [ len ];
+  }
+  *out = new char[len];
   *out[0] = 0;
-  if ( in1 )
-    {
+  if (in1) {
     strcat(*out, in1);
-    }
-  if ( sep )
-    {
+  }
+  if (sep) {
     strcat(*out, sep);
-    }
-  if ( *in2 )
-    {
+  }
+  if (*in2) {
     strcat(*out, *in2);
-    }
-  if ( *in2 )
-    {
+  }
+  if (*in2) {
     this->DeallocateParserType(in2);
-    }
-  this->UnionsAvailable ++;
+  }
+  this->UnionsAvailable++;
 }
 
-void cmDependsJavaParserHelper
-::CheckEmpty(int line, int cnt, cmDependsJavaParserHelper::ParserType* pt)
+void cmDependsJavaParserHelper::CheckEmpty(
+  int line, int cnt, cmDependsJavaParserHelper::ParserType* pt)
 {
   int cc;
   int kk = -cnt + 1;
-  for ( cc = 1; cc <= cnt; cc ++)
-    {
+  for (cc = 1; cc <= cnt; cc++) {
     cmDependsJavaParserHelper::ParserType* cpt = pt + kk;
     this->SafePrintMissing(cpt->str, line, cc);
-    kk ++;
-    }
+    kk++;
+  }
 }
 
-void cmDependsJavaParserHelper
-::PrepareElement(cmDependsJavaParserHelper::ParserType* me)
+void cmDependsJavaParserHelper::PrepareElement(
+  cmDependsJavaParserHelper::ParserType* me)
 {
   // Inititalize self
   me->str = 0;
 }
 
-void cmDependsJavaParserHelper
-::AllocateParserType(cmDependsJavaParserHelper::ParserType* pt,
-                     const char* str, int len)
+void cmDependsJavaParserHelper::AllocateParserType(
+  cmDependsJavaParserHelper::ParserType* pt, const char* str, int len)
 {
   pt->str = 0;
-  if ( len == 0 )
-    {
+  if (len == 0) {
     len = (int)strlen(str);
-    }
-  if ( len == 0 )
-    {
+  }
+  if (len == 0) {
     return;
-    }
-  this->UnionsAvailable ++;
-  pt->str = new char[ len + 1 ];
+  }
+  this->UnionsAvailable++;
+  pt->str = new char[len + 1];
   strncpy(pt->str, str, len);
   pt->str[len] = 0;
   this->Allocates.push_back(pt->str);
@@ -219,51 +186,43 @@ void cmDependsJavaParserHelper::StartClass(const char* cls)
   cl.Name = cls;
   this->ClassStack.push_back(cl);
 
-  this->CurrentDepth ++;
+  this->CurrentDepth++;
 }
 
 void cmDependsJavaParserHelper::EndClass()
 {
   CurrentClass* parent = 0;
   CurrentClass* current = 0;
-  if (!this->ClassStack.empty())
-    {
+  if (!this->ClassStack.empty()) {
     current = &(*(this->ClassStack.end() - 1));
-    if ( this->ClassStack.size() > 1 )
-      {
+    if (this->ClassStack.size() > 1) {
       parent = &(*(this->ClassStack.end() - 2));
-      }
     }
-  if ( current == 0 )
-    {
+  }
+  if (current == 0) {
     std::cerr << "Error when parsing. Current class is null" << std::endl;
     abort();
-    }
-  if ( parent == 0 )
-    {
+  }
+  if (parent == 0) {
     std::cerr << "Error when parsing. Parent class is null" << std::endl;
     abort();
-    }
-  this->CurrentDepth --;
+  }
+  this->CurrentDepth--;
   parent->NestedClasses->push_back(*current);
-  this->ClassStack.erase(this->ClassStack.end()-1, this->ClassStack.end());
+  this->ClassStack.erase(this->ClassStack.end() - 1, this->ClassStack.end());
 }
 
 void cmDependsJavaParserHelper::PrintClasses()
 {
-  if (this->ClassStack.empty())
-    {
+  if (this->ClassStack.empty()) {
     std::cerr << "Error when parsing. No classes on class stack" << std::endl;
     abort();
-    }
+  }
   std::vector<std::string> files = this->GetFilesProduced();
   std::vector<std::string>::iterator sit;
-  for ( sit = files.begin();
-    sit != files.end();
-    ++ sit )
-    {
+  for (sit = files.begin(); sit != files.end(); ++sit) {
     std::cout << "  " << *sit << ".class" << std::endl;
-    }
+  }
 }
 
 std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced()
@@ -271,77 +230,62 @@ std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced()
   std::vector<std::string> files;
   CurrentClass* toplevel = &(*(this->ClassStack.begin()));
   std::vector<CurrentClass>::iterator it;
-  for ( it = toplevel->NestedClasses->begin();
-    it != toplevel->NestedClasses->end();
-    ++ it )
-    {
+  for (it = toplevel->NestedClasses->begin();
+       it != toplevel->NestedClasses->end(); ++it) {
     it->AddFileNamesForPrinting(&files, 0, "$");
-    }
+  }
   return files;
 }
 
 int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
 {
-  if ( !str)
-    {
+  if (!str) {
     return 0;
-    }
+  }
   this->Verbose = verb;
   this->InputBuffer = str;
   this->InputBufferPos = 0;
   this->CurrentLine = 0;
 
-
   yyscan_t yyscanner;
   cmDependsJava_yylex_init(&yyscanner);
   cmDependsJava_yyset_extra(this, yyscanner);
   int res = cmDependsJava_yyparse(yyscanner);
   cmDependsJava_yylex_destroy(yyscanner);
-  if ( res != 0 )
-    {
+  if (res != 0) {
     std::cout << "JP_Parse returned: " << res << std::endl;
     return 0;
-    }
+  }
 
-  if ( verb )
-    {
-    if (!this->CurrentPackage.empty())
-      {
-      std::cout << "Current package is: " <<
-        this->CurrentPackage << std::endl;
-      }
+  if (verb) {
+    if (!this->CurrentPackage.empty()) {
+      std::cout << "Current package is: " << this->CurrentPackage << std::endl;
+    }
     std::cout << "Imports packages:";
-    if (!this->PackagesImport.empty())
-      {
+    if (!this->PackagesImport.empty()) {
       std::vector<std::string>::iterator it;
-      for ( it = this->PackagesImport.begin();
-        it != this->PackagesImport.end();
-        ++ it )
-        {
+      for (it = this->PackagesImport.begin(); it != this->PackagesImport.end();
+           ++it) {
         std::cout << " " << *it;
-        }
       }
+    }
     std::cout << std::endl;
     std::cout << "Depends on:";
-    if (!this->ClassesFound.empty())
-      {
+    if (!this->ClassesFound.empty()) {
       std::vector<std::string>::iterator it;
-      for ( it = this->ClassesFound.begin();
-        it != this->ClassesFound.end();
-        ++ it )
-        {
+      for (it = this->ClassesFound.begin(); it != this->ClassesFound.end();
+           ++it) {
         std::cout << " " << *it;
-        }
       }
+    }
     std::cout << std::endl;
     std::cout << "Generated files:" << std::endl;
     this->PrintClasses();
-    if ( this->UnionsAvailable != 0 )
-      {
-      std::cout << "There are still " <<
-        this->UnionsAvailable << " unions available" << std::endl;
-      }
+    if (this->UnionsAvailable != 0) {
+      std::cout << "There are still " << this->UnionsAvailable
+                << " unions available" << std::endl;
     }
+  }
   this->CleanupParser();
   return 1;
 }
@@ -349,82 +293,67 @@ int cmDependsJavaParserHelper::ParseString(const char* str, int verb)
 void cmDependsJavaParserHelper::CleanupParser()
 {
   std::vector<char*>::iterator it;
-  for ( it = this->Allocates.begin();
-    it != this->Allocates.end();
-    ++ it )
-    {
-    delete [] *it;
-    }
-  this->Allocates.erase(this->Allocates.begin(),
-    this->Allocates.end());
+  for (it = this->Allocates.begin(); it != this->Allocates.end(); ++it) {
+    delete[] * it;
+  }
+  this->Allocates.erase(this->Allocates.begin(), this->Allocates.end());
 }
 
 int cmDependsJavaParserHelper::LexInput(char* buf, int maxlen)
 {
-  if ( maxlen < 1 )
-    {
+  if (maxlen < 1) {
     return 0;
-    }
-  if ( this->InputBufferPos < this->InputBuffer.size() )
-    {
-    buf[0] = this->InputBuffer[ this->InputBufferPos++ ];
-    if ( buf[0] == '\n' )
-      {
-      this->CurrentLine ++;
-      }
-    return(1);
-    }
-  else
-    {
+  }
+  if (this->InputBufferPos < this->InputBuffer.size()) {
+    buf[0] = this->InputBuffer[this->InputBufferPos++];
+    if (buf[0] == '\n') {
+      this->CurrentLine++;
+    }
+    return (1);
+  } else {
     buf[0] = '\n';
-    return( 0 );
-    }
+    return (0);
+  }
 }
 void cmDependsJavaParserHelper::Error(const char* str)
 {
   unsigned long pos = static_cast<unsigned long>(this->InputBufferPos);
-  fprintf(stderr, "JPError: %s (%lu / Line: %d)\n",
-          str, pos, this->CurrentLine);
+  fprintf(stderr, "JPError: %s (%lu / Line: %d)\n", str, pos,
+          this->CurrentLine);
   int cc;
   std::cerr << "String: [";
-  for ( cc = 0;
-        cc < 30 && *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
-        cc ++ )
-    {
+  for (cc = 0;
+       cc < 30 && *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
+       cc++) {
     std::cerr << *(this->InputBuffer.c_str() + this->InputBufferPos + cc);
-    }
+  }
   std::cerr << "]" << std::endl;
 }
 
 void cmDependsJavaParserHelper::UpdateCombine(const char* str1,
                                               const char* str2)
 {
-  if ( this->CurrentCombine == "" && str1 != 0)
-    {
+  if (this->CurrentCombine == "" && str1 != 0) {
     this->CurrentCombine = str1;
-    }
+  }
   this->CurrentCombine += ".";
   this->CurrentCombine += str2;
 }
 
 int cmDependsJavaParserHelper::ParseFile(const char* file)
 {
-  if ( !cmSystemTools::FileExists(file))
-    {
+  if (!cmSystemTools::FileExists(file)) {
     return 0;
-    }
+  }
   cmsys::ifstream ifs(file);
-  if ( !ifs )
-    {
+  if (!ifs) {
     return 0;
-    }
+  }
 
   std::string fullfile = "";
   std::string line;
-  while ( cmSystemTools::GetLineFromStream(ifs, line) )
-    {
+  while (cmSystemTools::GetLineFromStream(ifs, line)) {
     fullfile += line + "\n";
-    }
+  }
   return this->ParseString(fullfile.c_str(), 0);
 }
-
diff --git a/Source/cmDependsJavaParserHelper.h b/Source/cmDependsJavaParserHelper.h
index 5542018..a13d023 100644
--- a/Source/cmDependsJavaParserHelper.h
+++ b/Source/cmDependsJavaParserHelper.h
@@ -28,7 +28,8 @@
 class cmDependsJavaParserHelper
 {
 public:
-  typedef struct {
+  typedef struct
+  {
     char* str;
   } ParserType;
 
@@ -40,7 +41,7 @@ public:
 
   // For the lexer:
   void AllocateParserType(cmDependsJavaParserHelper::ParserType* pt,
-    const char* str, int len = 0);
+                          const char* str, int len = 0);
 
   int LexInput(char* buf, int maxlen);
   void Error(const char* str);
@@ -69,31 +70,18 @@ private:
   public:
     std::string Name;
     std::vector<CurrentClass>* NestedClasses;
-    CurrentClass()
-      {
-        this->NestedClasses = new std::vector<CurrentClass>;
-      }
-    ~CurrentClass()
-      {
-        delete this->NestedClasses;
-      }
+    CurrentClass() { this->NestedClasses = new std::vector<CurrentClass>; }
+    ~CurrentClass() { delete this->NestedClasses; }
     CurrentClass& operator=(CurrentClass const& c)
-      {
-        this->NestedClasses->clear();
-        this->Name = c.Name;
-        std::copy(
-          c.NestedClasses->begin(),
-          c.NestedClasses->end(),
-          std::back_inserter(
-            *this->NestedClasses)
-          );
-        return *this;
-      }
-    CurrentClass(CurrentClass const& c)
-      {
-        (*this) = c;
-      }
-    void AddFileNamesForPrinting(std::vector<std::string> *files,
+    {
+      this->NestedClasses->clear();
+      this->Name = c.Name;
+      std::copy(c.NestedClasses->begin(), c.NestedClasses->end(),
+                std::back_inserter(*this->NestedClasses));
+      return *this;
+    }
+    CurrentClass(CurrentClass const& c) { (*this) = c; }
+    void AddFileNamesForPrinting(std::vector<std::string>* files,
                                  const char* prefix, const char* sep);
   };
   std::string CurrentPackage;
@@ -117,12 +105,10 @@ private:
   void PrintClasses();
 
   void Print(const char* place, const char* str);
-  void CombineUnions(char** out, const char* in1, char** in2,
-                     const char* sep);
+  void CombineUnions(char** out, const char* in1, char** in2, const char* sep);
   void SafePrintMissing(const char* str, int line, int cnt);
 
   void CleanupParser();
 };
 
 #endif
-
diff --git a/Source/cmDocumentation.cxx b/Source/cmDocumentation.cxx
index d3793c2..68a8488 100644
--- a/Source/cmDocumentation.cxx
+++ b/Source/cmDocumentation.cxx
@@ -24,56 +24,37 @@
 
 #include <algorithm>
 
-static const char *cmDocumentationStandardOptions[][2] =
-{
-  {"--help,-help,-usage,-h,-H,/?",
-   "Print usage information and exit."},
-  {"--version,-version,/V [<f>]",
-   "Print version number and exit."},
-  {"--help-full [<f>]",
-   "Print all help manuals and exit."},
-  {"--help-manual <man> [<f>]",
-   "Print one help manual and exit."},
-  {"--help-manual-list [<f>]",
-   "List help manuals available and exit."},
-  {"--help-command <cmd> [<f>]",
-   "Print help for one command and exit."},
-  {"--help-command-list [<f>]",
-   "List commands with help available and exit."},
-  {"--help-commands [<f>]",
-   "Print cmake-commands manual and exit."},
-  {"--help-module <mod> [<f>]",
-   "Print help for one module and exit."},
-  {"--help-module-list [<f>]",
-   "List modules with help available and exit."},
-  {"--help-modules [<f>]",
-   "Print cmake-modules manual and exit."},
-  {"--help-policy <cmp> [<f>]",
-   "Print help for one policy and exit."},
-  {"--help-policy-list [<f>]",
-   "List policies with help available and exit."},
-  {"--help-policies [<f>]",
-   "Print cmake-policies manual and exit."},
-  {"--help-property <prop> [<f>]",
-   "Print help for one property and exit."},
-  {"--help-property-list [<f>]",
-   "List properties with help available and exit."},
-  {"--help-properties [<f>]",
-   "Print cmake-properties manual and exit."},
-  {"--help-variable var [<f>]",
-   "Print help for one variable and exit."},
-  {"--help-variable-list [<f>]",
-   "List variables with help available and exit."},
-  {"--help-variables [<f>]",
-   "Print cmake-variables manual and exit."},
-  {0,0}
+static const char* cmDocumentationStandardOptions[][2] = {
+  { "--help,-help,-usage,-h,-H,/?", "Print usage information and exit." },
+  { "--version,-version,/V [<f>]", "Print version number and exit." },
+  { "--help-full [<f>]", "Print all help manuals and exit." },
+  { "--help-manual <man> [<f>]", "Print one help manual and exit." },
+  { "--help-manual-list [<f>]", "List help manuals available and exit." },
+  { "--help-command <cmd> [<f>]", "Print help for one command and exit." },
+  { "--help-command-list [<f>]",
+    "List commands with help available and exit." },
+  { "--help-commands [<f>]", "Print cmake-commands manual and exit." },
+  { "--help-module <mod> [<f>]", "Print help for one module and exit." },
+  { "--help-module-list [<f>]", "List modules with help available and exit." },
+  { "--help-modules [<f>]", "Print cmake-modules manual and exit." },
+  { "--help-policy <cmp> [<f>]", "Print help for one policy and exit." },
+  { "--help-policy-list [<f>]",
+    "List policies with help available and exit." },
+  { "--help-policies [<f>]", "Print cmake-policies manual and exit." },
+  { "--help-property <prop> [<f>]", "Print help for one property and exit." },
+  { "--help-property-list [<f>]",
+    "List properties with help available and exit." },
+  { "--help-properties [<f>]", "Print cmake-properties manual and exit." },
+  { "--help-variable var [<f>]", "Print help for one variable and exit." },
+  { "--help-variable-list [<f>]",
+    "List variables with help available and exit." },
+  { "--help-variables [<f>]", "Print cmake-variables manual and exit." },
+  { 0, 0 }
 };
 
-static const char *cmDocumentationGeneratorsHeader[][2] =
-{
-  {0,
-   "The following generators are available on this platform:"},
-  {0,0}
+static const char* cmDocumentationGeneratorsHeader[][2] = {
+  { 0, "The following generators are available on this platform:" },
+  { 0, 0 }
 };
 
 cmDocumentation::cmDocumentation()
@@ -102,8 +83,7 @@ bool cmDocumentation::PrintVersion(std::ostream& os)
 
 bool cmDocumentation::PrintDocumentation(Type ht, std::ostream& os)
 {
-  switch (ht)
-    {
+  switch (ht) {
     case cmDocumentation::Usage:
       return this->PrintUsage(os);
     case cmDocumentation::Help:
@@ -140,8 +120,9 @@ bool cmDocumentation::PrintDocumentation(Type ht, std::ostream& os)
       return this->PrintVersion(os);
     case cmDocumentation::OldCustomModules:
       return this->PrintOldCustomModules(os);
-    default: return false;
-    }
+    default:
+      return false;
+  }
 }
 
 bool cmDocumentation::PrintRequestedDocumentation(std::ostream& os)
@@ -150,323 +131,249 @@ bool cmDocumentation::PrintRequestedDocumentation(std::ostream& os)
   bool result = true;
 
   // Loop over requested documentation types.
-  for(std::vector<RequestedHelpItem>::const_iterator
-      i = this->RequestedHelpItems.begin();
-      i != this->RequestedHelpItems.end();
-      ++i)
-    {
+  for (std::vector<RequestedHelpItem>::const_iterator i =
+         this->RequestedHelpItems.begin();
+       i != this->RequestedHelpItems.end(); ++i) {
     this->CurrentArgument = i->Argument;
     // If a file name was given, use it.  Otherwise, default to the
     // given stream.
     cmsys::ofstream* fout = 0;
     std::ostream* s = &os;
-    if(!i->Filename.empty())
-      {
+    if (!i->Filename.empty()) {
       fout = new cmsys::ofstream(i->Filename.c_str(), std::ios::out);
-      if(fout)
-        {
+      if (fout) {
         s = fout;
-        }
-      else
-        {
+      } else {
         result = false;
-        }
       }
-    else if(++count > 1)
-      {
+    } else if (++count > 1) {
       os << "\n\n";
-      }
+    }
 
     // Print this documentation type to the stream.
-    if(!this->PrintDocumentation(i->HelpType, *s) || !*s)
-      {
+    if (!this->PrintDocumentation(i->HelpType, *s) || !*s) {
       result = false;
-      }
+    }
 
     // Close the file if we wrote one.
-    if(fout)
-      {
+    if (fout) {
       delete fout;
-      }
     }
+  }
   return result;
 }
 
-#define GET_OPT_ARGUMENT(target)                      \
-     if((i+1 < argc) && !this->IsOption(argv[i+1]))   \
-        {                                             \
-        target = argv[i+1];                           \
-        i = i+1;                                      \
-        };
-
+#define GET_OPT_ARGUMENT(target)                                              \
+  if ((i + 1 < argc) && !this->IsOption(argv[i + 1])) {                       \
+    target = argv[i + 1];                                                     \
+    i = i + 1;                                                                \
+  };
 
 void cmDocumentation::WarnFormFromFilename(
   cmDocumentation::RequestedHelpItem& request, bool& result)
 {
   std::string ext = cmSystemTools::GetFilenameLastExtension(request.Filename);
   ext = cmSystemTools::UpperCase(ext);
-  if ((ext == ".HTM") || (ext == ".HTML"))
-    {
+  if ((ext == ".HTM") || (ext == ".HTML")) {
     request.HelpType = cmDocumentation::None;
     result = true;
     cmSystemTools::Message("Warning: HTML help format no longer supported");
-    }
-  else if (ext == ".DOCBOOK")
-    {
+  } else if (ext == ".DOCBOOK") {
     request.HelpType = cmDocumentation::None;
     result = true;
     cmSystemTools::Message("Warning: Docbook help format no longer supported");
-    }
+  }
   // ".1" to ".9" should be manpages
-  else if ((ext.length()==2) && (ext[1] >='1') && (ext[1]<='9'))
-    {
+  else if ((ext.length() == 2) && (ext[1] >= '1') && (ext[1] <= '9')) {
     request.HelpType = cmDocumentation::None;
     result = true;
     cmSystemTools::Message("Warning: Man help format no longer supported");
-    }
+  }
 }
 
 void cmDocumentation::addCommonStandardDocSections()
 {
-    cmDocumentationSection *sec;
+  cmDocumentationSection* sec;
 
-    sec = new cmDocumentationSection("Options","OPTIONS");
-    sec->Append(cmDocumentationStandardOptions);
-    this->AllSections["Options"] = sec;
+  sec = new cmDocumentationSection("Options", "OPTIONS");
+  sec->Append(cmDocumentationStandardOptions);
+  this->AllSections["Options"] = sec;
 }
 
 void cmDocumentation::addCMakeStandardDocSections()
 {
-    cmDocumentationSection *sec;
+  cmDocumentationSection* sec;
 
-    sec = new cmDocumentationSection("Generators","GENERATORS");
-    sec->Append(cmDocumentationGeneratorsHeader);
-    this->AllSections["Generators"] = sec;
+  sec = new cmDocumentationSection("Generators", "GENERATORS");
+  sec->Append(cmDocumentationGeneratorsHeader);
+  this->AllSections["Generators"] = sec;
 }
 
 void cmDocumentation::addCTestStandardDocSections()
 {
-    // This is currently done for backward compatibility reason
-    // We may suppress some of these.
-    addCMakeStandardDocSections();
+  // This is currently done for backward compatibility reason
+  // We may suppress some of these.
+  addCMakeStandardDocSections();
 }
 
 void cmDocumentation::addCPackStandardDocSections()
 {
-    cmDocumentationSection *sec;
+  cmDocumentationSection* sec;
 
-    sec = new cmDocumentationSection("Generators","GENERATORS");
-    sec->Append(cmDocumentationGeneratorsHeader);
-    this->AllSections["Generators"] = sec;
+  sec = new cmDocumentationSection("Generators", "GENERATORS");
+  sec->Append(cmDocumentationGeneratorsHeader);
+  this->AllSections["Generators"] = sec;
 }
 
 bool cmDocumentation::CheckOptions(int argc, const char* const* argv,
                                    const char* exitOpt)
 {
   // Providing zero arguments gives usage information.
-  if(argc == 1)
-    {
+  if (argc == 1) {
     RequestedHelpItem help;
     help.HelpType = cmDocumentation::Usage;
     this->RequestedHelpItems.push_back(help);
     return true;
-    }
+  }
 
   // Search for supported help options.
 
   bool result = false;
-  for(int i=1; i < argc; ++i)
-    {
-    if(exitOpt && strcmp(argv[i], exitOpt) == 0)
-      {
+  for (int i = 1; i < argc; ++i) {
+    if (exitOpt && strcmp(argv[i], exitOpt) == 0) {
       return result;
-      }
+    }
     RequestedHelpItem help;
     // Check if this is a supported help option.
-    if((strcmp(argv[i], "-help") == 0) ||
-       (strcmp(argv[i], "--help") == 0) ||
-       (strcmp(argv[i], "/?") == 0) ||
-       (strcmp(argv[i], "-usage") == 0) ||
-       (strcmp(argv[i], "-h") == 0) ||
-       (strcmp(argv[i], "-H") == 0))
-      {
+    if ((strcmp(argv[i], "-help") == 0) || (strcmp(argv[i], "--help") == 0) ||
+        (strcmp(argv[i], "/?") == 0) || (strcmp(argv[i], "-usage") == 0) ||
+        (strcmp(argv[i], "-h") == 0) || (strcmp(argv[i], "-H") == 0)) {
       help.HelpType = cmDocumentation::Help;
       GET_OPT_ARGUMENT(help.Argument);
       help.Argument = cmSystemTools::LowerCase(help.Argument);
       // special case for single command
-      if (!help.Argument.empty())
-        {
+      if (!help.Argument.empty()) {
         help.HelpType = cmDocumentation::OneCommand;
-        }
       }
-    else if(strcmp(argv[i], "--help-properties") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-properties") == 0) {
       help.HelpType = cmDocumentation::OneManual;
       help.Argument = "cmake-properties.7";
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-policies") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-policies") == 0) {
       help.HelpType = cmDocumentation::OneManual;
       help.Argument = "cmake-policies.7";
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-variables") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-variables") == 0) {
       help.HelpType = cmDocumentation::OneManual;
       help.Argument = "cmake-variables.7";
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-modules") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-modules") == 0) {
       help.HelpType = cmDocumentation::OneManual;
       help.Argument = "cmake-modules.7";
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-custom-modules") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-custom-modules") == 0) {
       GET_OPT_ARGUMENT(help.Filename);
       cmSystemTools::Message(
         "Warning: --help-custom-modules no longer supported");
-      if(help.Filename.empty())
-        {
+      if (help.Filename.empty()) {
         return true;
-        }
+      }
       // Avoid breaking old project builds completely by at least generating
       // the output file.  Abuse help.Argument to give the file name to
       // PrintOldCustomModules without disrupting our internal API.
       help.HelpType = cmDocumentation::OldCustomModules;
       help.Argument = cmSystemTools::GetFilenameName(help.Filename);
-      }
-    else if(strcmp(argv[i], "--help-commands") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-commands") == 0) {
       help.HelpType = cmDocumentation::OneManual;
       help.Argument = "cmake-commands.7";
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-compatcommands") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-compatcommands") == 0) {
       GET_OPT_ARGUMENT(help.Filename);
       cmSystemTools::Message(
         "Warning: --help-compatcommands no longer supported");
       return true;
-      }
-    else if(strcmp(argv[i], "--help-full") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-full") == 0) {
       help.HelpType = cmDocumentation::Full;
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-html") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-html") == 0) {
       GET_OPT_ARGUMENT(help.Filename);
       cmSystemTools::Message("Warning: --help-html no longer supported");
       return true;
-      }
-    else if(strcmp(argv[i], "--help-man") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-man") == 0) {
       GET_OPT_ARGUMENT(help.Filename);
       cmSystemTools::Message("Warning: --help-man no longer supported");
       return true;
-      }
-    else if(strcmp(argv[i], "--help-command") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-command") == 0) {
       help.HelpType = cmDocumentation::OneCommand;
       GET_OPT_ARGUMENT(help.Argument);
       GET_OPT_ARGUMENT(help.Filename);
       help.Argument = cmSystemTools::LowerCase(help.Argument);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-module") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-module") == 0) {
       help.HelpType = cmDocumentation::OneModule;
       GET_OPT_ARGUMENT(help.Argument);
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-property") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-property") == 0) {
       help.HelpType = cmDocumentation::OneProperty;
       GET_OPT_ARGUMENT(help.Argument);
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-policy") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-policy") == 0) {
       help.HelpType = cmDocumentation::OnePolicy;
       GET_OPT_ARGUMENT(help.Argument);
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-variable") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-variable") == 0) {
       help.HelpType = cmDocumentation::OneVariable;
       GET_OPT_ARGUMENT(help.Argument);
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-manual") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-manual") == 0) {
       help.HelpType = cmDocumentation::OneManual;
       GET_OPT_ARGUMENT(help.Argument);
       GET_OPT_ARGUMENT(help.Filename);
       this->WarnFormFromFilename(help, result);
-      }
-    else if(strcmp(argv[i], "--help-command-list") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-command-list") == 0) {
       help.HelpType = cmDocumentation::ListCommands;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    else if(strcmp(argv[i], "--help-module-list") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-module-list") == 0) {
       help.HelpType = cmDocumentation::ListModules;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    else if(strcmp(argv[i], "--help-property-list") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-property-list") == 0) {
       help.HelpType = cmDocumentation::ListProperties;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    else if(strcmp(argv[i], "--help-variable-list") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-variable-list") == 0) {
       help.HelpType = cmDocumentation::ListVariables;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    else if(strcmp(argv[i], "--help-policy-list") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-policy-list") == 0) {
       help.HelpType = cmDocumentation::ListPolicies;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    else if(strcmp(argv[i], "--help-manual-list") == 0)
-      {
+    } else if (strcmp(argv[i], "--help-manual-list") == 0) {
       help.HelpType = cmDocumentation::ListManuals;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    else if(strcmp(argv[i], "--copyright") == 0)
-      {
+    } else if (strcmp(argv[i], "--copyright") == 0) {
       GET_OPT_ARGUMENT(help.Filename);
       cmSystemTools::Message("Warning: --copyright no longer supported");
       return true;
-      }
-    else if((strcmp(argv[i], "--version") == 0) ||
-            (strcmp(argv[i], "-version") == 0) ||
-            (strcmp(argv[i], "/V") == 0))
-      {
+    } else if ((strcmp(argv[i], "--version") == 0) ||
+               (strcmp(argv[i], "-version") == 0) ||
+               (strcmp(argv[i], "/V") == 0)) {
       help.HelpType = cmDocumentation::Version;
       GET_OPT_ARGUMENT(help.Filename);
-      }
-    if(help.HelpType != None)
-      {
+    }
+    if (help.HelpType != None) {
       // This is a help option.  See if there is a file name given.
       result = true;
       this->RequestedHelpItems.push_back(help);
-      }
     }
+  }
   return result;
 }
 
@@ -475,130 +382,112 @@ void cmDocumentation::SetName(const std::string& name)
   this->NameString = name;
 }
 
-void cmDocumentation::SetSection(const char *name,
-                                 cmDocumentationSection *section)
+void cmDocumentation::SetSection(const char* name,
+                                 cmDocumentationSection* section)
 {
-  if (this->AllSections.find(name) != this->AllSections.end())
-    {
+  if (this->AllSections.find(name) != this->AllSections.end()) {
     delete this->AllSections[name];
-    }
+  }
   this->AllSections[name] = section;
 }
 
-void cmDocumentation::SetSection(const char *name,
-                                 std::vector<cmDocumentationEntry> &docs)
+void cmDocumentation::SetSection(const char* name,
+                                 std::vector<cmDocumentationEntry>& docs)
 {
-  cmDocumentationSection *sec =
-    new cmDocumentationSection(name,
-                               cmSystemTools::UpperCase(name).c_str());
+  cmDocumentationSection* sec =
+    new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
   sec->Append(docs);
-  this->SetSection(name,sec);
+  this->SetSection(name, sec);
 }
 
-void cmDocumentation::SetSection(const char *name,
-                                 const char *docs[][2])
+void cmDocumentation::SetSection(const char* name, const char* docs[][2])
 {
-  cmDocumentationSection *sec =
-    new cmDocumentationSection(name,
-                               cmSystemTools::UpperCase(name).c_str());
+  cmDocumentationSection* sec =
+    new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
   sec->Append(docs);
-  this->SetSection(name,sec);
+  this->SetSection(name, sec);
 }
 
-void cmDocumentation
-::SetSections(std::map<std::string,cmDocumentationSection *> &sections)
+void cmDocumentation::SetSections(
+  std::map<std::string, cmDocumentationSection*>& sections)
 {
-  for (std::map<std::string,cmDocumentationSection *>::const_iterator
-         it = sections.begin(); it != sections.end(); ++it)
-    {
-    this->SetSection(it->first.c_str(),it->second);
-    }
+  for (std::map<std::string, cmDocumentationSection*>::const_iterator it =
+         sections.begin();
+       it != sections.end(); ++it) {
+    this->SetSection(it->first.c_str(), it->second);
+  }
 }
 
-void cmDocumentation::PrependSection(const char *name,
-                                     const char *docs[][2])
+void cmDocumentation::PrependSection(const char* name, const char* docs[][2])
 {
-  cmDocumentationSection *sec = 0;
-  if (this->AllSections.find(name) == this->AllSections.end())
-    {
-    sec = new cmDocumentationSection
-      (name, cmSystemTools::UpperCase(name).c_str());
-    this->SetSection(name,sec);
-    }
-  else
-    {
+  cmDocumentationSection* sec = 0;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
     sec = this->AllSections[name];
-    }
+  }
   sec->Prepend(docs);
 }
 
-void cmDocumentation::PrependSection(const char *name,
-                                     std::vector<cmDocumentationEntry> &docs)
+void cmDocumentation::PrependSection(const char* name,
+                                     std::vector<cmDocumentationEntry>& docs)
 {
-  cmDocumentationSection *sec = 0;
-  if (this->AllSections.find(name) == this->AllSections.end())
-    {
-    sec = new cmDocumentationSection
-      (name, cmSystemTools::UpperCase(name).c_str());
-    this->SetSection(name,sec);
-    }
-  else
-    {
+  cmDocumentationSection* sec = 0;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
     sec = this->AllSections[name];
-    }
+  }
   sec->Prepend(docs);
 }
 
-void cmDocumentation::AppendSection(const char *name,
-                                    const char *docs[][2])
+void cmDocumentation::AppendSection(const char* name, const char* docs[][2])
 {
-  cmDocumentationSection *sec = 0;
-  if (this->AllSections.find(name) == this->AllSections.end())
-    {
-    sec = new cmDocumentationSection
-      (name, cmSystemTools::UpperCase(name).c_str());
-    this->SetSection(name,sec);
-    }
-  else
-    {
+  cmDocumentationSection* sec = 0;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
     sec = this->AllSections[name];
-    }
+  }
   sec->Append(docs);
 }
 
-void cmDocumentation::AppendSection(const char *name,
-                                    std::vector<cmDocumentationEntry> &docs)
+void cmDocumentation::AppendSection(const char* name,
+                                    std::vector<cmDocumentationEntry>& docs)
 {
-  cmDocumentationSection *sec = 0;
-  if (this->AllSections.find(name) == this->AllSections.end())
-    {
-    sec = new cmDocumentationSection
-      (name, cmSystemTools::UpperCase(name).c_str());
-    this->SetSection(name,sec);
-    }
-  else
-    {
+  cmDocumentationSection* sec = 0;
+  if (this->AllSections.find(name) == this->AllSections.end()) {
+    sec =
+      new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str());
+    this->SetSection(name, sec);
+  } else {
     sec = this->AllSections[name];
-    }
+  }
   sec->Append(docs);
 }
 
-void cmDocumentation::AppendSection(const char *name,
-                                    cmDocumentationEntry &docs)
+void cmDocumentation::AppendSection(const char* name,
+                                    cmDocumentationEntry& docs)
 {
 
   std::vector<cmDocumentationEntry> docsVec;
   docsVec.push_back(docs);
-  this->AppendSection(name,docsVec);
+  this->AppendSection(name, docsVec);
 }
 
-void cmDocumentation::PrependSection(const char *name,
-                                     cmDocumentationEntry &docs)
+void cmDocumentation::PrependSection(const char* name,
+                                     cmDocumentationEntry& docs)
 {
 
   std::vector<cmDocumentationEntry> docsVec;
   docsVec.push_back(docs);
-  this->PrependSection(name,docsVec);
+  this->PrependSection(name, docsVec);
 }
 
 void cmDocumentation::GlobHelp(std::vector<std::string>& files,
@@ -607,42 +496,35 @@ void cmDocumentation::GlobHelp(std::vector<std::string>& files,
   cmsys::Glob gl;
   std::string findExpr =
     cmSystemTools::GetCMakeRoot() + "/Help/" + pattern + ".rst";
-  if(gl.FindFiles(findExpr))
-    {
+  if (gl.FindFiles(findExpr)) {
     files = gl.GetFiles();
-    }
+  }
 }
 
-void cmDocumentation::PrintNames(std::ostream& os,
-                                 std::string const& pattern)
+void cmDocumentation::PrintNames(std::ostream& os, std::string const& pattern)
 {
   std::vector<std::string> files;
   this->GlobHelp(files, pattern);
   std::vector<std::string> names;
   for (std::vector<std::string>::const_iterator i = files.begin();
-       i != files.end(); ++i)
-    {
+       i != files.end(); ++i) {
     std::string line;
     cmsys::ifstream fin(i->c_str());
-    while(fin && cmSystemTools::GetLineFromStream(fin, line))
-      {
-      if(!line.empty() && (isalnum(line[0]) || line[0] == '<'))
-        {
+    while (fin && cmSystemTools::GetLineFromStream(fin, line)) {
+      if (!line.empty() && (isalnum(line[0]) || line[0] == '<')) {
         names.push_back(line);
         break;
-        }
       }
     }
+  }
   std::sort(names.begin(), names.end());
-  for (std::vector<std::string>::iterator i = names.begin();
-       i != names.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = names.begin(); i != names.end();
+       ++i) {
     os << *i << "\n";
-    }
+  }
 }
 
-bool cmDocumentation::PrintFiles(std::ostream& os,
-                                 std::string const& pattern)
+bool cmDocumentation::PrintFiles(std::ostream& os, std::string const& pattern)
 {
   bool found = false;
   std::vector<std::string> files;
@@ -650,10 +532,9 @@ bool cmDocumentation::PrintFiles(std::ostream& os,
   std::sort(files.begin(), files.end());
   cmRST r(os, cmSystemTools::GetCMakeRoot() + "/Help");
   for (std::vector<std::string>::const_iterator i = files.begin();
-       i != files.end(); ++i)
-    {
+       i != files.end(); ++i) {
     found = r.ProcessFile(*i) || found;
-    }
+  }
   return found;
 }
 
@@ -666,16 +547,13 @@ bool cmDocumentation::PrintHelpOneManual(std::ostream& os)
 {
   std::string mname = this->CurrentArgument;
   std::string::size_type mlen = mname.length();
-  if(mlen > 3 && mname[mlen-3] == '(' &&
-                 mname[mlen-1] == ')')
-    {
-    mname = mname.substr(0, mlen-3) + "." + mname[mlen-2];
-    }
-  if(this->PrintFiles(os, "manual/" + mname) ||
-     this->PrintFiles(os, "manual/" + mname + ".[0-9]"))
-    {
+  if (mlen > 3 && mname[mlen - 3] == '(' && mname[mlen - 1] == ')') {
+    mname = mname.substr(0, mlen - 3) + "." + mname[mlen - 2];
+  }
+  if (this->PrintFiles(os, "manual/" + mname) ||
+      this->PrintFiles(os, "manual/" + mname + ".[0-9]")) {
     return true;
-    }
+  }
   // Argument was not a manual.  Complain.
   os << "Argument \"" << this->CurrentArgument
      << "\" to --help-manual is not an available manual.  "
@@ -692,10 +570,9 @@ bool cmDocumentation::PrintHelpListManuals(std::ostream& os)
 bool cmDocumentation::PrintHelpOneCommand(std::ostream& os)
 {
   std::string cname = cmSystemTools::LowerCase(this->CurrentArgument);
-  if(this->PrintFiles(os, "command/" + cname))
-    {
+  if (this->PrintFiles(os, "command/" + cname)) {
     return true;
-    }
+  }
   // Argument was not a command.  Complain.
   os << "Argument \"" << this->CurrentArgument
      << "\" to --help-command is not a CMake command.  "
@@ -712,10 +589,9 @@ bool cmDocumentation::PrintHelpListCommands(std::ostream& os)
 bool cmDocumentation::PrintHelpOneModule(std::ostream& os)
 {
   std::string mname = this->CurrentArgument;
-  if(this->PrintFiles(os, "module/" + mname))
-    {
+  if (this->PrintFiles(os, "module/" + mname)) {
     return true;
-    }
+  }
   // Argument was not a module.  Complain.
   os << "Argument \"" << this->CurrentArgument
      << "\" to --help-module is not a CMake module.\n";
@@ -728,27 +604,24 @@ bool cmDocumentation::PrintHelpListModules(std::ostream& os)
   this->GlobHelp(files, "module/*");
   std::vector<std::string> modules;
   for (std::vector<std::string>::iterator fi = files.begin();
-       fi != files.end(); ++fi)
-    {
+       fi != files.end(); ++fi) {
     std::string module = cmSystemTools::GetFilenameName(*fi);
-    modules.push_back(module.substr(0, module.size()-4));
-    }
+    modules.push_back(module.substr(0, module.size() - 4));
+  }
   std::sort(modules.begin(), modules.end());
   for (std::vector<std::string>::iterator i = modules.begin();
-       i != modules.end(); ++i)
-    {
+       i != modules.end(); ++i) {
     os << *i << "\n";
-    }
+  }
   return true;
 }
 
 bool cmDocumentation::PrintHelpOneProperty(std::ostream& os)
 {
   std::string pname = cmSystemTools::HelpFileName(this->CurrentArgument);
-  if(this->PrintFiles(os, "prop_*/" + pname))
-    {
+  if (this->PrintFiles(os, "prop_*/" + pname)) {
     return true;
-    }
+  }
   // Argument was not a property.  Complain.
   os << "Argument \"" << this->CurrentArgument
      << "\" to --help-property is not a CMake property.  "
@@ -766,10 +639,9 @@ bool cmDocumentation::PrintHelpOnePolicy(std::ostream& os)
 {
   std::string pname = this->CurrentArgument;
   std::vector<std::string> files;
-  if(this->PrintFiles(os, "policy/" + pname))
-    {
+  if (this->PrintFiles(os, "policy/" + pname)) {
     return true;
-    }
+  }
 
   // Argument was not a policy.  Complain.
   os << "Argument \"" << this->CurrentArgument
@@ -785,23 +657,21 @@ bool cmDocumentation::PrintHelpListPolicies(std::ostream& os)
 
 bool cmDocumentation::PrintHelpListGenerators(std::ostream& os)
 {
-  std::map<std::string,cmDocumentationSection*>::iterator si;
+  std::map<std::string, cmDocumentationSection*>::iterator si;
   si = this->AllSections.find("Generators");
-  if(si != this->AllSections.end())
-    {
+  if (si != this->AllSections.end()) {
     this->Formatter.SetIndent("  ");
     this->Formatter.PrintSection(os, *si->second);
-    }
+  }
   return true;
 }
 
 bool cmDocumentation::PrintHelpOneVariable(std::ostream& os)
 {
   std::string vname = cmSystemTools::HelpFileName(this->CurrentArgument);
-  if(this->PrintFiles(os, "variable/" + vname))
-    {
+  if (this->PrintFiles(os, "variable/" + vname)) {
     return true;
-    }
+  }
   // Argument was not a variable.  Complain.
   os << "Argument \"" << this->CurrentArgument
      << "\" to --help-variable is not a defined variable.  "
@@ -817,49 +687,41 @@ bool cmDocumentation::PrintHelpListVariables(std::ostream& os)
 
 bool cmDocumentation::PrintUsage(std::ostream& os)
 {
-  std::map<std::string,cmDocumentationSection*>::iterator si;
+  std::map<std::string, cmDocumentationSection*>::iterator si;
   si = this->AllSections.find("Usage");
-  if(si != this->AllSections.end())
-    {
+  if (si != this->AllSections.end()) {
     this->Formatter.PrintSection(os, *si->second);
-    }
+  }
   return true;
 }
 
 bool cmDocumentation::PrintHelp(std::ostream& os)
 {
-  std::map<std::string,cmDocumentationSection*>::iterator si;
+  std::map<std::string, cmDocumentationSection*>::iterator si;
   si = this->AllSections.find("Usage");
-  if(si != this->AllSections.end())
-    {
+  if (si != this->AllSections.end()) {
     this->Formatter.PrintSection(os, *si->second);
-    }
+  }
   si = this->AllSections.find("Options");
-  if(si != this->AllSections.end())
-    {
+  if (si != this->AllSections.end()) {
     this->Formatter.PrintSection(os, *si->second);
-    }
-  if(this->ShowGenerators)
-    {
+  }
+  if (this->ShowGenerators) {
     si = this->AllSections.find("Generators");
-    if(si != this->AllSections.end())
-      {
+    if (si != this->AllSections.end()) {
       this->Formatter.PrintSection(os, *si->second);
-      }
     }
+  }
   return true;
 }
 
 const char* cmDocumentation::GetNameString() const
 {
-  if(!this->NameString.empty())
-    {
+  if (!this->NameString.empty()) {
     return this->NameString.c_str();
-    }
-  else
-    {
+  } else {
     return "CMake";
-    }
+  }
 }
 
 bool cmDocumentation::IsOption(const char* arg) const
@@ -883,15 +745,12 @@ bool cmDocumentation::PrintOldCustomModules(std::ostream& os)
     "CMake versions 3.0 and above use other means to generate their module\n"
     "help pages so this functionality is no longer available to be exposed.\n"
     "\n"
-    "This file was generated as a placeholder to provide this information.\n"
-    ;
-  if((ext == ".HTM") || (ext == ".HTML"))
-    {
+    "This file was generated as a placeholder to provide this information.\n";
+  if ((ext == ".HTM") || (ext == ".HTML")) {
     os << "<html><title>" << name << "</title><body>\n"
-       << summary << "<p/>\n" << detail << "</body></html>\n";
-    }
-  else if((ext.length()==2) && (ext[1] >='1') && (ext[1]<='9'))
-    {
+       << summary << "<p/>\n"
+       << detail << "</body></html>\n";
+  } else if ((ext.length() == 2) && (ext[1] >= '1') && (ext[1] <= '9')) {
     /* clang-format off */
     os <<
       ".TH " << name << " " << ext[1] << " \"" <<
@@ -906,10 +765,8 @@ bool cmDocumentation::PrintOldCustomModules(std::ostream& os)
       detail
       ;
     /* clang-format on */
-    }
-  else
-    {
+  } else {
     os << name << "\n\n" << summary << "\n" << detail;
-    }
+  }
   return true;
 }
diff --git a/Source/cmDocumentation.h b/Source/cmDocumentation.h
index a1d73f5..dd99ca8 100644
--- a/Source/cmDocumentation.h
+++ b/Source/cmDocumentation.h
@@ -18,13 +18,12 @@
 #include "cmDocumentationSection.h"
 #include "cmake.h"
 
-namespace cmsys
-{
-  class Directory;
+namespace cmsys {
+class Directory;
 }
 
 /** Class to generate documentation.  */
-class cmDocumentation: public cmDocumentationEnums
+class cmDocumentation : public cmDocumentationEnums
 {
 public:
   cmDocumentation();
@@ -40,7 +39,7 @@ public:
    * help arguments.
    */
   bool CheckOptions(int argc, const char* const* argv,
-                    const char* exitOpt =0);
+                    const char* exitOpt = 0);
 
   /**
    * Print help requested on the command line.  Call after
@@ -60,28 +59,21 @@ public:
 
   /** Set a section of the documentation. Typical sections include Name,
       Usage, Description, Options */
-  void SetSection(const char *sectionName,
-                  cmDocumentationSection *section);
-  void SetSection(const char *sectionName,
-                  std::vector<cmDocumentationEntry> &docs);
-  void SetSection(const char *sectionName,
-                  const char *docs[][2]);
-  void SetSections(std::map<std::string,cmDocumentationSection *>
-                   &sections);
+  void SetSection(const char* sectionName, cmDocumentationSection* section);
+  void SetSection(const char* sectionName,
+                  std::vector<cmDocumentationEntry>& docs);
+  void SetSection(const char* sectionName, const char* docs[][2]);
+  void SetSections(std::map<std::string, cmDocumentationSection*>& sections);
 
   /** Add the documentation to the beginning/end of the section */
-  void PrependSection(const char *sectionName,
-                      const char *docs[][2]);
-  void PrependSection(const char *sectionName,
-                      std::vector<cmDocumentationEntry> &docs);
-  void PrependSection(const char *sectionName,
-                      cmDocumentationEntry &docs);
-  void AppendSection(const char *sectionName,
-                     const char *docs[][2]);
-  void AppendSection(const char *sectionName,
-                     std::vector<cmDocumentationEntry> &docs);
-  void AppendSection(const char *sectionName,
-                     cmDocumentationEntry &docs);
+  void PrependSection(const char* sectionName, const char* docs[][2]);
+  void PrependSection(const char* sectionName,
+                      std::vector<cmDocumentationEntry>& docs);
+  void PrependSection(const char* sectionName, cmDocumentationEntry& docs);
+  void AppendSection(const char* sectionName, const char* docs[][2]);
+  void AppendSection(const char* sectionName,
+                     std::vector<cmDocumentationEntry>& docs);
+  void AppendSection(const char* sectionName, cmDocumentationEntry& docs);
 
   /** Add common (to all tools) documentation section(s) */
   void addCommonStandardDocSections();
@@ -96,7 +88,6 @@ public:
   void addCPackStandardDocSections();
 
 private:
-
   void GlobHelp(std::vector<std::string>& files, std::string const& pattern);
   void PrintNames(std::ostream& os, std::string const& pattern);
   bool PrintFiles(std::ostream& os, std::string const& pattern);
@@ -126,13 +117,16 @@ private:
   bool ShowGenerators;
 
   std::string NameString;
-  std::map<std::string,cmDocumentationSection*> AllSections;
+  std::map<std::string, cmDocumentationSection*> AllSections;
 
   std::string CurrentArgument;
 
   struct RequestedHelpItem
   {
-    RequestedHelpItem(): HelpType(None) {}
+    RequestedHelpItem()
+      : HelpType(None)
+    {
+    }
     cmDocumentationEnums::Type HelpType;
     std::string Filename;
     std::string Argument;
diff --git a/Source/cmDocumentationFormatter.cxx b/Source/cmDocumentationFormatter.cxx
index 6869e2f..4816bb9 100644
--- a/Source/cmDocumentationFormatter.cxx
+++ b/Source/cmDocumentationFormatter.cxx
@@ -13,8 +13,9 @@
 
 #include "cmDocumentationSection.h"
 
-cmDocumentationFormatter::cmDocumentationFormatter():
-  TextWidth(77), TextIndent("")
+cmDocumentationFormatter::cmDocumentationFormatter()
+  : TextWidth(77)
+  , TextIndent("")
 {
 }
 
@@ -25,67 +26,55 @@ cmDocumentationFormatter::~cmDocumentationFormatter()
 void cmDocumentationFormatter::PrintFormatted(std::ostream& os,
                                               const char* text)
 {
-  if(!text)
-    {
+  if (!text) {
     return;
-    }
+  }
   const char* ptr = text;
-  while(*ptr)
-    {
+  while (*ptr) {
     // Any ptrs starting in a space are treated as preformatted text.
     std::string preformatted;
-    while(*ptr == ' ')
-      {
-      for(char ch = *ptr; ch && ch != '\n'; ++ptr, ch = *ptr)
-        {
+    while (*ptr == ' ') {
+      for (char ch = *ptr; ch && ch != '\n'; ++ptr, ch = *ptr) {
         preformatted.append(1, ch);
-        }
-      if(*ptr)
-        {
+      }
+      if (*ptr) {
         ++ptr;
         preformatted.append(1, '\n');
-        }
       }
-    if(!preformatted.empty())
-      {
+    }
+    if (!preformatted.empty()) {
       this->PrintPreformatted(os, preformatted.c_str());
-      }
+    }
 
     // Other ptrs are treated as paragraphs.
     std::string paragraph;
-    for(char ch = *ptr; ch && ch != '\n'; ++ptr, ch = *ptr)
-      {
+    for (char ch = *ptr; ch && ch != '\n'; ++ptr, ch = *ptr) {
       paragraph.append(1, ch);
-      }
-    if(*ptr)
-      {
+    }
+    if (*ptr) {
       ++ptr;
       paragraph.append(1, '\n');
-      }
-    if(!paragraph.empty())
-      {
+    }
+    if (!paragraph.empty()) {
       this->PrintParagraph(os, paragraph.c_str());
-      }
     }
+  }
 }
 
 void cmDocumentationFormatter::PrintPreformatted(std::ostream& os,
-                                                     const char* text)
+                                                 const char* text)
 {
   bool newline = true;
-  for(const char* ptr = text; *ptr; ++ptr)
-    {
-    if(newline && *ptr != '\n')
-      {
+  for (const char* ptr = text; *ptr; ++ptr) {
+    if (newline && *ptr != '\n') {
       os << this->TextIndent;
       newline = false;
-      }
+    }
     os << *ptr;
-    if(*ptr == '\n')
-      {
+    if (*ptr == '\n') {
       newline = true;
-      }
     }
+  }
   os << "\n";
 }
 
@@ -102,8 +91,7 @@ void cmDocumentationFormatter::SetIndent(const char* indent)
   this->TextIndent = indent;
 }
 
-void cmDocumentationFormatter::PrintColumn(std::ostream& os,
-                                           const char* text)
+void cmDocumentationFormatter::PrintColumn(std::ostream& os, const char* text)
 {
   // Print text arranged in an indented column of fixed witdh.
   const char* l = text;
@@ -113,118 +101,97 @@ void cmDocumentationFormatter::PrintColumn(std::ostream& os,
   int width = this->TextWidth - static_cast<int>(strlen(this->TextIndent));
 
   // Loop until the end of the text.
-  while(*l)
-    {
+  while (*l) {
     // Parse the next word.
     const char* r = l;
-    while(*r && (*r != '\n') && (*r != ' ')) { ++r; }
+    while (*r && (*r != '\n') && (*r != ' ')) {
+      ++r;
+    }
 
     // Does it fit on this line?
-    if(r-l < (width-column-(newSentence?1:0)))
-      {
+    if (r - l < (width - column - (newSentence ? 1 : 0))) {
       // Word fits on this line.
-      if(r > l)
-        {
-        if(column)
-          {
+      if (r > l) {
+        if (column) {
           // Not first word on line.  Separate from the previous word
           // by a space, or two if this is a new sentence.
-          if(newSentence)
-            {
+          if (newSentence) {
             os << "  ";
             column += 2;
-            }
-          else
-            {
+          } else {
             os << " ";
             column += 1;
-            }
           }
-        else
-          {
+        } else {
           // First word on line.  Print indentation unless this is the
           // first line.
-          os << (firstLine?"":this->TextIndent);
-          }
+          os << (firstLine ? "" : this->TextIndent);
+        }
 
         // Print the word.
-        os.write(l, static_cast<long>(r-l));
-        newSentence = (*(r-1) == '.');
-        }
+        os.write(l, static_cast<long>(r - l));
+        newSentence = (*(r - 1) == '.');
+      }
 
-      if(*r == '\n')
-        {
+      if (*r == '\n') {
         // Text provided a newline.  Start a new line.
         os << "\n";
         ++r;
         column = 0;
         firstLine = false;
-        }
-      else
-        {
+      } else {
         // No provided newline.  Continue this line.
-        column += static_cast<long>(r-l);
-        }
+        column += static_cast<long>(r - l);
       }
-    else
-      {
+    } else {
       // Word does not fit on this line.  Start a new line.
       os << "\n";
       firstLine = false;
-      if(r > l)
-        {
+      if (r > l) {
         os << this->TextIndent;
-        os.write(l, static_cast<long>(r-l));
-        column = static_cast<long>(r-l);
-        newSentence = (*(r-1) == '.');
-        }
-      else
-        {
+        os.write(l, static_cast<long>(r - l));
+        column = static_cast<long>(r - l);
+        newSentence = (*(r - 1) == '.');
+      } else {
         column = 0;
-        }
       }
+    }
 
     // Move to beginning of next word.  Skip over whitespace.
     l = r;
-    while(*l && (*l == ' ')) { ++l; }
+    while (*l && (*l == ' ')) {
+      ++l;
     }
+  }
 }
 
-void cmDocumentationFormatter
-::PrintSection(std::ostream& os,
-               cmDocumentationSection const& section)
+void cmDocumentationFormatter::PrintSection(
+  std::ostream& os, cmDocumentationSection const& section)
 {
   os << section.GetName() << "\n";
 
-  const std::vector<cmDocumentationEntry> &entries =
-    section.GetEntries();
-  for(std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
-      op != entries.end(); ++op)
-    {
-    if(!op->Name.empty())
-      {
+  const std::vector<cmDocumentationEntry>& entries = section.GetEntries();
+  for (std::vector<cmDocumentationEntry>::const_iterator op = entries.begin();
+       op != entries.end(); ++op) {
+    if (!op->Name.empty()) {
       os << "  " << op->Name;
       this->TextIndent = "                                 ";
-      int align = static_cast<int>(strlen(this->TextIndent))-4;
-      for(int i = static_cast<int>(op->Name.size()); i < align; ++i)
-        {
+      int align = static_cast<int>(strlen(this->TextIndent)) - 4;
+      for (int i = static_cast<int>(op->Name.size()); i < align; ++i) {
         os << " ";
-        }
-      if (op->Name.size() > strlen(this->TextIndent)-4 )
-        {
+      }
+      if (op->Name.size() > strlen(this->TextIndent) - 4) {
         os << "\n";
-        os.write(this->TextIndent, strlen(this->TextIndent)-2);
-        }
+        os.write(this->TextIndent, strlen(this->TextIndent) - 2);
+      }
       os << "= ";
       this->PrintColumn(os, op->Brief.c_str());
       os << "\n";
-      }
-    else
-      {
+    } else {
       os << "\n";
       this->TextIndent = "";
       this->PrintFormatted(os, op->Brief.c_str());
-      }
     }
+  }
   os << "\n";
 }
diff --git a/Source/cmDocumentationFormatter.h b/Source/cmDocumentationFormatter.h
index 6e19b7d..7c4c35b 100644
--- a/Source/cmDocumentationFormatter.h
+++ b/Source/cmDocumentationFormatter.h
@@ -26,9 +26,24 @@ public:
   /** Types of help provided.  */
   enum Type
   {
-    None, Version, Usage, Help, Full, ListManuals, ListCommands,
-    ListModules, ListProperties, ListVariables, ListPolicies, ListGenerators,
-    OneManual, OneCommand, OneModule, OneProperty, OneVariable, OnePolicy,
+    None,
+    Version,
+    Usage,
+    Help,
+    Full,
+    ListManuals,
+    ListCommands,
+    ListModules,
+    ListProperties,
+    ListVariables,
+    ListPolicies,
+    ListGenerators,
+    OneManual,
+    OneCommand,
+    OneModule,
+    OneProperty,
+    OneVariable,
+    OnePolicy,
     OldCustomModules
   };
 };
@@ -49,6 +64,7 @@ public:
   virtual void PrintParagraph(std::ostream& os, const char* text);
   void PrintColumn(std::ostream& os, const char* text);
   void SetIndent(const char* indent);
+
 private:
   int TextWidth;
   const char* TextIndent;
diff --git a/Source/cmDocumentationSection.cxx b/Source/cmDocumentationSection.cxx
index 2fbc50e..c6c87f4 100644
--- a/Source/cmDocumentationSection.cxx
+++ b/Source/cmDocumentationSection.cxx
@@ -11,32 +11,27 @@
 ============================================================================*/
 #include "cmDocumentationSection.h"
 
-
-void cmDocumentationSection::Append(const char *data[][2])
+void cmDocumentationSection::Append(const char* data[][2])
 {
   int i = 0;
-  while(data[i][1])
-    {
-    this->Entries.push_back(cmDocumentationEntry(data[i][0],
-                                                 data[i][1]));
+  while (data[i][1]) {
+    this->Entries.push_back(cmDocumentationEntry(data[i][0], data[i][1]));
     data += 1;
-    }
+  }
 }
 
-void cmDocumentationSection::Prepend(const char *data[][2])
+void cmDocumentationSection::Prepend(const char* data[][2])
 {
   std::vector<cmDocumentationEntry> tmp;
   int i = 0;
-  while(data[i][1])
-    {
-    tmp.push_back(cmDocumentationEntry(data[i][0],
-                                       data[i][1]));
+  while (data[i][1]) {
+    tmp.push_back(cmDocumentationEntry(data[i][0], data[i][1]));
     data += 1;
-    }
-  this->Entries.insert(this->Entries.begin(),tmp.begin(),tmp.end());
+  }
+  this->Entries.insert(this->Entries.begin(), tmp.begin(), tmp.end());
 }
 
-void cmDocumentationSection::Append(const char *n, const char *b)
+void cmDocumentationSection::Append(const char* n, const char* b)
 {
-  this->Entries.push_back(cmDocumentationEntry(n,b));
+  this->Entries.push_back(cmDocumentationEntry(n, b));
 }
diff --git a/Source/cmDocumentationSection.h b/Source/cmDocumentationSection.h
index 66b94c2..161a731 100644
--- a/Source/cmDocumentationSection.h
+++ b/Source/cmDocumentationSection.h
@@ -24,7 +24,9 @@ class cmDocumentationSection
 public:
   /** Create a cmSection, with a special name for man-output mode. */
   cmDocumentationSection(const char* name, const char*)
-    :Name(name) {}
+    : Name(name)
+  {
+  }
 
   /** Has any content been added to this section or is it empty ? */
   bool IsEmpty() const { return this->Entries.empty(); }
@@ -33,29 +35,35 @@ public:
   void Clear() { this->Entries.clear(); }
 
   /** Return the name of this section. */
-  std::string GetName() const
-  { return this->Name; }
+  std::string GetName() const { return this->Name; }
 
   /** Return a pointer to the first entry of this section. */
-  const std::vector<cmDocumentationEntry> &GetEntries() const
-  { return this->Entries; }
+  const std::vector<cmDocumentationEntry>& GetEntries() const
+  {
+    return this->Entries;
+  }
 
   /** Append an entry to this section. */
   void Append(const cmDocumentationEntry& entry)
-  { this->Entries.push_back(entry); }
-  void Append(const std::vector<cmDocumentationEntry> &entries)
-  { this->Entries.insert(this->Entries.end(),entries.begin(),entries.end()); }
+  {
+    this->Entries.push_back(entry);
+  }
+  void Append(const std::vector<cmDocumentationEntry>& entries)
+  {
+    this->Entries.insert(this->Entries.end(), entries.begin(), entries.end());
+  }
 
   /** Append an entry to this section using NULL terminated chars */
-  void Append(const char *[][2]);
-  void Append(const char *n, const char *b);
+  void Append(const char* [][2]);
+  void Append(const char* n, const char* b);
 
   /** prepend some documentation to this section */
-  void Prepend(const char *[][2]);
-  void Prepend(const std::vector<cmDocumentationEntry> &entries)
-  { this->Entries.insert(this->Entries.begin(),
-                         entries.begin(),entries.end()); }
-
+  void Prepend(const char* [][2]);
+  void Prepend(const std::vector<cmDocumentationEntry>& entries)
+  {
+    this->Entries.insert(this->Entries.begin(), entries.begin(),
+                         entries.end());
+  }
 
 private:
   std::string Name;
diff --git a/Source/cmDynamicLoader.cxx b/Source/cmDynamicLoader.cxx
index 944a000..7d0bbdc 100644
--- a/Source/cmDynamicLoader.cxx
+++ b/Source/cmDynamicLoader.cxx
@@ -15,8 +15,7 @@ class cmDynamicLoaderCache
 {
 public:
   ~cmDynamicLoaderCache();
-  void CacheFile(const char* path,
-    const cmsys::DynamicLoader::LibraryHandle&);
+  void CacheFile(const char* path, const cmsys::DynamicLoader::LibraryHandle&);
   bool GetCacheFile(const char* path, cmsys::DynamicLoader::LibraryHandle&);
   bool FlushCache(const char* path);
   void FlushCache();
@@ -33,74 +32,67 @@ cmDynamicLoaderCache::~cmDynamicLoaderCache()
 {
 }
 
-void cmDynamicLoaderCache::CacheFile(const char* path,
-  const cmsys::DynamicLoader::LibraryHandle& p)
+void cmDynamicLoaderCache::CacheFile(
+  const char* path, const cmsys::DynamicLoader::LibraryHandle& p)
 {
   cmsys::DynamicLoader::LibraryHandle h;
-  if ( this->GetCacheFile(path, h) )
-    {
+  if (this->GetCacheFile(path, h)) {
     this->FlushCache(path);
-    }
+  }
   this->CacheMap[path] = p;
 }
 
 bool cmDynamicLoaderCache::GetCacheFile(const char* path,
-  cmsys::DynamicLoader::LibraryHandle& p)
+                                        cmsys::DynamicLoader::LibraryHandle& p)
 {
-  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it
-    = this->CacheMap.find(path);
-  if ( it != this->CacheMap.end() )
-    {
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it =
+    this->CacheMap.find(path);
+  if (it != this->CacheMap.end()) {
     p = it->second;
     return true;
-    }
+  }
   return false;
 }
 
 bool cmDynamicLoaderCache::FlushCache(const char* path)
 {
-  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it
-    = this->CacheMap.find(path);
+  std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator it =
+    this->CacheMap.find(path);
   bool ret = false;
-  if ( it != this->CacheMap.end() )
-    {
+  if (it != this->CacheMap.end()) {
     cmsys::DynamicLoader::CloseLibrary(it->second);
     this->CacheMap.erase(it);
     ret = true;
-    }
+  }
   return ret;
 }
 
 void cmDynamicLoaderCache::FlushCache()
 {
-  for ( std::map<std::string,
-    cmsys::DynamicLoader::LibraryHandle>::iterator it
-    = this->CacheMap.begin();
-        it != this->CacheMap.end(); it++ )
-    {
+  for (std::map<std::string, cmsys::DynamicLoader::LibraryHandle>::iterator
+         it = this->CacheMap.begin();
+       it != this->CacheMap.end(); it++) {
     cmsys::DynamicLoader::CloseLibrary(it->second);
-    }
+  }
   delete cmDynamicLoaderCache::Instance;
   cmDynamicLoaderCache::Instance = 0;
 }
 
 cmDynamicLoaderCache* cmDynamicLoaderCache::GetInstance()
 {
-  if ( !cmDynamicLoaderCache::Instance )
-    {
+  if (!cmDynamicLoaderCache::Instance) {
     cmDynamicLoaderCache::Instance = new cmDynamicLoaderCache;
-    }
+  }
   return cmDynamicLoaderCache::Instance;
 }
 
 cmsys::DynamicLoader::LibraryHandle cmDynamicLoader::OpenLibrary(
-  const char* libname )
+  const char* libname)
 {
   cmsys::DynamicLoader::LibraryHandle lh;
-  if ( cmDynamicLoaderCache::GetInstance()->GetCacheFile(libname, lh) )
-    {
+  if (cmDynamicLoaderCache::GetInstance()->GetCacheFile(libname, lh)) {
     return lh;
-    }
+  }
   lh = cmsys::DynamicLoader::OpenLibrary(libname);
   cmDynamicLoaderCache::GetInstance()->CacheFile(libname, lh);
   return lh;
diff --git a/Source/cmDynamicLoader.h b/Source/cmDynamicLoader.h
index 84bc9bc..58d9ae9 100644
--- a/Source/cmDynamicLoader.h
+++ b/Source/cmDynamicLoader.h
@@ -14,7 +14,6 @@
 // cmDynamicLoader provides a portable interface to loading dynamic
 // libraries into a process.
 
-
 #ifndef cmDynamicLoader_h
 #define cmDynamicLoader_h
 
@@ -40,7 +39,7 @@ protected:
   ~cmDynamicLoader() {}
 
 private:
-  cmDynamicLoader(const cmDynamicLoader&);  // Not implemented.
+  cmDynamicLoader(const cmDynamicLoader&); // Not implemented.
   void operator=(const cmDynamicLoader&);  // Not implemented.
 };
 
diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx
index c6ae205..26f1a44 100644
--- a/Source/cmELF.cxx
+++ b/Source/cmELF.cxx
@@ -18,58 +18,75 @@
 
 // Include the ELF format information system header.
 #if defined(__OpenBSD__)
-# include <elf_abi.h>
-# include <stdint.h>
+#include <elf_abi.h>
+#include <stdint.h>
 #elif defined(__HAIKU__)
-# include <elf32.h>
-# include <elf64.h>
-  typedef struct Elf32_Ehdr Elf32_Ehdr;
-  typedef struct Elf32_Shdr Elf32_Shdr;
-  typedef struct Elf32_Sym Elf32_Sym;
-  typedef struct Elf32_Rel Elf32_Rel;
-  typedef struct Elf32_Rela Elf32_Rela;
-# define ELFMAG0 0x7F
-# define ELFMAG1 'E'
-# define ELFMAG2 'L'
-# define ELFMAG3 'F'
-# define ET_NONE 0
-# define ET_REL 1
-# define ET_EXEC 2
-# define ET_DYN 3
-# define ET_CORE 4
-# define EM_386 3
-# define EM_SPARC 2
-# define EM_PPC 20
+#include <elf32.h>
+#include <elf64.h>
+typedef struct Elf32_Ehdr Elf32_Ehdr;
+typedef struct Elf32_Shdr Elf32_Shdr;
+typedef struct Elf32_Sym Elf32_Sym;
+typedef struct Elf32_Rel Elf32_Rel;
+typedef struct Elf32_Rela Elf32_Rela;
+#define ELFMAG0 0x7F
+#define ELFMAG1 'E'
+#define ELFMAG2 'L'
+#define ELFMAG3 'F'
+#define ET_NONE 0
+#define ET_REL 1
+#define ET_EXEC 2
+#define ET_DYN 3
+#define ET_CORE 4
+#define EM_386 3
+#define EM_SPARC 2
+#define EM_PPC 20
 #else
-# include <elf.h>
+#include <elf.h>
 #endif
 #if defined(__sun)
-# include <sys/link.h> // For dynamic section information
+#include <sys/link.h> // For dynamic section information
 #endif
 
 // Low-level byte swapping implementation.
-template <size_t s> struct cmELFByteSwapSize {};
+template <size_t s>
+struct cmELFByteSwapSize
+{
+};
 void cmELFByteSwap(char*, cmELFByteSwapSize<1> const&)
 {
 }
 void cmELFByteSwap(char* data, cmELFByteSwapSize<2> const&)
 {
   char one_byte;
-  one_byte = data[0]; data[0] = data[1]; data[1] = one_byte;
+  one_byte = data[0];
+  data[0] = data[1];
+  data[1] = one_byte;
 }
 void cmELFByteSwap(char* data, cmELFByteSwapSize<4> const&)
 {
   char one_byte;
-  one_byte = data[0]; data[0] = data[3]; data[3] = one_byte;
-  one_byte = data[1]; data[1] = data[2]; data[2] = one_byte;
+  one_byte = data[0];
+  data[0] = data[3];
+  data[3] = one_byte;
+  one_byte = data[1];
+  data[1] = data[2];
+  data[2] = one_byte;
 }
 void cmELFByteSwap(char* data, cmELFByteSwapSize<8> const&)
 {
   char one_byte;
-  one_byte = data[0]; data[0] = data[7]; data[7] = one_byte;
-  one_byte = data[1]; data[1] = data[6]; data[6] = one_byte;
-  one_byte = data[2]; data[2] = data[5]; data[5] = one_byte;
-  one_byte = data[3]; data[3] = data[4]; data[4] = one_byte;
+  one_byte = data[0];
+  data[0] = data[7];
+  data[7] = one_byte;
+  one_byte = data[1];
+  data[1] = data[6];
+  data[6] = one_byte;
+  one_byte = data[2];
+  data[2] = data[5];
+  data[5] = one_byte;
+  one_byte = data[3];
+  data[3] = data[4];
+  data[4] = one_byte;
 }
 
 // Low-level byte swapping interface.
@@ -83,20 +100,23 @@ class cmELFInternal
 {
 public:
   typedef cmELF::StringEntry StringEntry;
-  enum ByteOrderType { ByteOrderMSB, ByteOrderLSB };
+  enum ByteOrderType
+  {
+    ByteOrderMSB,
+    ByteOrderLSB
+  };
 
   // Construct and take ownership of the file stream object.
-  cmELFInternal(cmELF* external,
-                cmsys::auto_ptr<cmsys::ifstream>& fin,
-                ByteOrderType order):
-    External(external),
-    Stream(*fin.release()),
-    ByteOrder(order),
-    ELFType(cmELF::FileTypeInvalid)
-    {
-    // In most cases the processor-specific byte order will match that
-    // of the target execution environment.  If we choose wrong here
-    // it is fixed when the header is read.
+  cmELFInternal(cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin,
+                ByteOrderType order)
+    : External(external)
+    , Stream(*fin.release())
+    , ByteOrder(order)
+    , ELFType(cmELF::FileTypeInvalid)
+  {
+// In most cases the processor-specific byte order will match that
+// of the target execution environment.  If we choose wrong here
+// it is fixed when the header is read.
 #if KWIML_ABI_ENDIAN_ID == KWIML_ABI_ENDIAN_ID_LITTLE
     this->NeedSwap = (this->ByteOrder == ByteOrderMSB);
 #elif KWIML_ABI_ENDIAN_ID == KWIML_ABI_ENDIAN_ID_BIG
@@ -107,13 +127,10 @@ public:
 
     // We have not yet loaded the section info.
     this->DynamicSectionIndex = -1;
-    }
+  }
 
   // Destruct and delete the file stream object.
-  virtual ~cmELFInternal()
-    {
-    delete &this->Stream;
-    }
+  virtual ~cmELFInternal() { delete &this->Stream; }
 
   // Forward to the per-class implementation.
   virtual unsigned int GetNumberOfSections() const = 0;
@@ -123,33 +140,33 @@ public:
   virtual void PrintInfo(std::ostream& os) const = 0;
 
   bool ReadBytes(unsigned long pos, unsigned long size, char* buf)
-    {
+  {
     this->Stream.seekg(pos);
     this->Stream.read(buf, size);
-    return this->Stream?true:false;
-    }
+    return this->Stream ? true : false;
+  }
 
   // Lookup the SONAME in the DYNAMIC section.
   StringEntry const* GetSOName()
-    {
+  {
     return this->GetDynamicSectionString(DT_SONAME);
-    }
+  }
 
   // Lookup the RPATH in the DYNAMIC section.
   StringEntry const* GetRPath()
-    {
+  {
     return this->GetDynamicSectionString(DT_RPATH);
-    }
+  }
 
   // Lookup the RUNPATH in the DYNAMIC section.
   StringEntry const* GetRunPath()
-    {
+  {
 #if defined(DT_RUNPATH)
     return this->GetDynamicSectionString(DT_RUNPATH);
 #else
     return 0;
 #endif
-    }
+  }
 
   // Return the recorded ELF type.
   cmELF::FileType GetFileType() const { return this->ELFType; }
@@ -176,10 +193,10 @@ protected:
 
   // Helper methods for subclasses.
   void SetErrorMessage(const char* msg)
-    {
+  {
     this->External->ErrorMessage = msg;
     this->ELFType = cmELF::FileTypeInvalid;
-    }
+  }
 
   // Store string table entry states.
   std::map<unsigned int, StringEntry> DynamicSectionStrings;
@@ -190,7 +207,7 @@ struct cmELFTypes32
 {
   typedef Elf32_Ehdr ELF_Ehdr;
   typedef Elf32_Shdr ELF_Shdr;
-  typedef Elf32_Dyn  ELF_Dyn;
+  typedef Elf32_Dyn ELF_Dyn;
   typedef Elf32_Half ELF_Half;
   typedef KWIML_INT_uint32_t tagtype;
   static const char* GetName() { return "32-bit"; }
@@ -201,7 +218,7 @@ struct cmELFTypes64
 {
   typedef Elf64_Ehdr ELF_Ehdr;
   typedef Elf64_Shdr ELF_Shdr;
-  typedef Elf64_Dyn  ELF_Dyn;
+  typedef Elf64_Dyn ELF_Dyn;
   typedef Elf64_Half ELF_Half;
   typedef KWIML_INT_uint64_t tagtype;
   static const char* GetName() { return "64-bit"; }
@@ -209,26 +226,25 @@ struct cmELFTypes64
 
 // Parser implementation template.
 template <class Types>
-class cmELFInternalImpl: public cmELFInternal
+class cmELFInternalImpl : public cmELFInternal
 {
 public:
   // Copy the ELF file format types from our configuration parameter.
   typedef typename Types::ELF_Ehdr ELF_Ehdr;
   typedef typename Types::ELF_Shdr ELF_Shdr;
-  typedef typename Types::ELF_Dyn  ELF_Dyn;
+  typedef typename Types::ELF_Dyn ELF_Dyn;
   typedef typename Types::ELF_Half ELF_Half;
   typedef typename Types::tagtype tagtype;
 
   // Construct with a stream and byte swap indicator.
-  cmELFInternalImpl(cmELF* external,
-                    cmsys::auto_ptr<cmsys::ifstream>& fin,
+  cmELFInternalImpl(cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin,
                     ByteOrderType order);
 
   // Return the number of sections as specified by the ELF header.
   virtual unsigned int GetNumberOfSections() const
-    {
+  {
     return static_cast<unsigned int>(this->ELFHeader.e_shnum);
-    }
+  }
 
   // Get the file position and size of a dynamic section entry.
   virtual unsigned int GetDynamicEntryCount();
@@ -239,18 +255,14 @@ public:
 
   // Print information about the ELF file.
   virtual void PrintInfo(std::ostream& os) const
-    {
+  {
     os << "ELF " << Types::GetName();
-    if(this->ByteOrder == ByteOrderMSB)
-      {
+    if (this->ByteOrder == ByteOrderMSB) {
       os << " MSB";
-      }
-    else if(this->ByteOrder == ByteOrderLSB)
-      {
+    } else if (this->ByteOrder == ByteOrderLSB) {
       os << " LSB";
-      }
-    switch(this->ELFType)
-      {
+    }
+    switch (this->ELFType) {
       case cmELF::FileTypeInvalid:
         os << " invalid file";
         break;
@@ -272,13 +284,13 @@ public:
       case cmELF::FileTypeSpecificProc:
         os << " processor-specific type";
         break;
-      }
-    os << "\n";
     }
+    os << "\n";
+  }
 
 private:
   void ByteSwap(ELF_Ehdr& elf_header)
-    {
+  {
     cmELFByteSwap(elf_header.e_type);
     cmELFByteSwap(elf_header.e_machine);
     cmELFByteSwap(elf_header.e_version);
@@ -292,10 +304,10 @@ private:
     cmELFByteSwap(elf_header.e_shentsize);
     cmELFByteSwap(elf_header.e_shnum);
     cmELFByteSwap(elf_header.e_shstrndx);
-    }
+  }
 
   void ByteSwap(ELF_Shdr& sec_header)
-    {
+  {
     cmELFByteSwap(sec_header.sh_name);
     cmELFByteSwap(sec_header.sh_type);
     cmELFByteSwap(sec_header.sh_flags);
@@ -306,97 +318,154 @@ private:
     cmELFByteSwap(sec_header.sh_info);
     cmELFByteSwap(sec_header.sh_addralign);
     cmELFByteSwap(sec_header.sh_entsize);
-    }
+  }
 
   void ByteSwap(ELF_Dyn& dyn)
-    {
+  {
     cmELFByteSwap(dyn.d_tag);
-    switch (dyn.d_tag)
-      {
-      case DT_NULL:     /* dyn.d_un ignored */         break;
-      case DT_NEEDED:   cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_PLTRELSZ: cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_PLTGOT:   cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_HASH:     cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_STRTAB:   cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_SYMTAB:   cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_RELA:     cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_RELASZ:   cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_RELAENT:  cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_STRSZ:    cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_SYMENT:   cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_INIT:     cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_FINI:     cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_SONAME:   cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_RPATH:    cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_SYMBOLIC: /* dyn.d_un ignored */         break;
-      case DT_REL:      cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_RELSZ:    cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_RELENT:   cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_PLTREL:   cmELFByteSwap(dyn.d_un.d_val); break;
-      case DT_DEBUG:    cmELFByteSwap(dyn.d_un.d_ptr); break;
-      case DT_TEXTREL:  /* dyn.d_un ignored */         break;
-      case DT_JMPREL:   cmELFByteSwap(dyn.d_un.d_ptr); break;
+    switch (dyn.d_tag) {
+      case DT_NULL: /* dyn.d_un ignored */
+        break;
+      case DT_NEEDED:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_PLTRELSZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_PLTGOT:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_HASH:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_STRTAB:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_SYMTAB:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_RELA:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_RELASZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_RELAENT:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_STRSZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_SYMENT:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_INIT:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_FINI:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_SONAME:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_RPATH:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_SYMBOLIC: /* dyn.d_un ignored */
+        break;
+      case DT_REL:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_RELSZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_RELENT:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_PLTREL:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
+      case DT_DEBUG:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
+      case DT_TEXTREL: /* dyn.d_un ignored */
+        break;
+      case DT_JMPREL:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
 #ifdef T_BIND_NOW
-      case T_BIND_NOW:         /* dyn.d_un ignored */         break;
+      case T_BIND_NOW: /* dyn.d_un ignored */
+        break;
 #endif
 #ifdef DT_INIT_ARRAY
-      case DT_INIT_ARRAY:      cmELFByteSwap(dyn.d_un.d_ptr); break;
+      case DT_INIT_ARRAY:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
 #endif
 #ifdef DT_FINI_ARRAY
-      case DT_FINI_ARRAY:      cmELFByteSwap(dyn.d_un.d_ptr); break;
+      case DT_FINI_ARRAY:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
 #endif
 #ifdef DT_INIT_ARRAYSZ
-      case DT_INIT_ARRAYSZ:    cmELFByteSwap(dyn.d_un.d_val); break;
+      case DT_INIT_ARRAYSZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
 #endif
 #ifdef DT_FINI_ARRAYSZ
-      case DT_FINI_ARRAYSZ:    cmELFByteSwap(dyn.d_un.d_val); break;
+      case DT_FINI_ARRAYSZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
 #endif
 #ifdef DT_RUNPATH
-      case DT_RUNPATH:         cmELFByteSwap(dyn.d_un.d_val); break;
+      case DT_RUNPATH:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
 #endif
 #ifdef DT_FLAGS
-      case DT_FLAGS:           cmELFByteSwap(dyn.d_un.d_val); break;
+      case DT_FLAGS:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
 #endif
 #ifdef DT_PREINIT_ARRAY
-      case DT_PREINIT_ARRAY:   cmELFByteSwap(dyn.d_un.d_ptr); break;
+      case DT_PREINIT_ARRAY:
+        cmELFByteSwap(dyn.d_un.d_ptr);
+        break;
 #endif
 #ifdef DT_PREINIT_ARRAYSZ
-      case DT_PREINIT_ARRAYSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+      case DT_PREINIT_ARRAYSZ:
+        cmELFByteSwap(dyn.d_un.d_val);
+        break;
 #endif
-      }
     }
+  }
 
   bool FileTypeValid(ELF_Half et)
-    {
+  {
     unsigned int eti = static_cast<unsigned int>(et);
-    if(eti == ET_NONE || eti == ET_REL || eti == ET_EXEC ||
-       eti == ET_DYN || eti == ET_CORE)
-      {
+    if (eti == ET_NONE || eti == ET_REL || eti == ET_EXEC || eti == ET_DYN ||
+        eti == ET_CORE) {
       return true;
-      }
+    }
 #if defined(ET_LOOS) && defined(ET_HIOS)
-    if(eti >= ET_LOOS && eti <= ET_HIOS)
-      {
+    if (eti >= ET_LOOS && eti <= ET_HIOS) {
       return true;
-      }
+    }
 #endif
 #if defined(ET_LOPROC) && defined(ET_HIPROC)
-    if(eti >= ET_LOPROC && eti <= ET_HIPROC)
-      {
+    if (eti >= ET_LOPROC && eti <= ET_HIPROC) {
       return true;
-      }
+    }
 #endif
     return false;
-    }
+  }
 
   bool Read(ELF_Ehdr& x)
-    {
+  {
     // Read the header from the file.
-    if(!this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)))
-      {
+    if (!this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x))) {
       return false;
-      }
+    }
 
     // The byte order of ELF header fields may not match that of the
     // processor-specific data.  The header fields are ordered to
@@ -405,63 +474,55 @@ private:
     // value.  As a heuristic, if the type is invalid but its
     // swapped value is okay then flip our swap mode.
     ELF_Half et = x.e_type;
-    if(this->NeedSwap)
-      {
+    if (this->NeedSwap) {
       cmELFByteSwap(et);
-      }
-    if(!this->FileTypeValid(et))
-      {
+    }
+    if (!this->FileTypeValid(et)) {
       cmELFByteSwap(et);
-      if(this->FileTypeValid(et))
-        {
+      if (this->FileTypeValid(et)) {
         // The previous byte order guess was wrong.  Flip it.
         this->NeedSwap = !this->NeedSwap;
-        }
       }
+    }
 
     // Fix the byte order of the header.
-    if(this->NeedSwap)
-      {
+    if (this->NeedSwap) {
       ByteSwap(x);
-      }
-    return true;
     }
+    return true;
+  }
   bool Read(ELF_Shdr& x)
-    {
-    if(this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
-       this->NeedSwap)
-      {
+  {
+    if (this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
+        this->NeedSwap) {
       ByteSwap(x);
-      }
-    return this->Stream? true:false;
     }
+    return this->Stream ? true : false;
+  }
   bool Read(ELF_Dyn& x)
-    {
-    if(this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
-       this->NeedSwap)
-      {
+  {
+    if (this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
+        this->NeedSwap) {
       ByteSwap(x);
-      }
-    return this->Stream? true:false;
     }
+    return this->Stream ? true : false;
+  }
 
   bool LoadSectionHeader(ELF_Half i)
-    {
+  {
     // Read the section header from the file.
     this->Stream.seekg(this->ELFHeader.e_shoff +
                        this->ELFHeader.e_shentsize * i);
-    if(!this->Read(this->SectionHeaders[i]))
-      {
+    if (!this->Read(this->SectionHeaders[i])) {
       return false;
-      }
+    }
 
     // Identify some important sections.
-    if(this->SectionHeaders[i].sh_type == SHT_DYNAMIC)
-      {
+    if (this->SectionHeaders[i].sh_type == SHT_DYNAMIC) {
       this->DynamicSectionIndex = i;
-      }
-    return true;
     }
+    return true;
+  }
 
   bool LoadDynamicSection();
 
@@ -476,22 +537,18 @@ private:
 };
 
 template <class Types>
-cmELFInternalImpl<Types>
-::cmELFInternalImpl(cmELF* external,
-                    cmsys::auto_ptr<cmsys::ifstream>& fin,
-                    ByteOrderType order):
-  cmELFInternal(external, fin, order)
+cmELFInternalImpl<Types>::cmELFInternalImpl(
+  cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin, ByteOrderType order)
+  : cmELFInternal(external, fin, order)
 {
   // Read the main header.
-  if(!this->Read(this->ELFHeader))
-    {
+  if (!this->Read(this->ELFHeader)) {
     this->SetErrorMessage("Failed to read main ELF header.");
     return;
-    }
+  }
 
   // Determine the ELF file type.
-  switch(this->ELFHeader.e_type)
-    {
+  switch (this->ELFHeader.e_type) {
     case ET_NONE:
       this->SetErrorMessage("ELF file type is NONE.");
       return;
@@ -507,133 +564,116 @@ cmELFInternalImpl<Types>
     case ET_CORE:
       this->ELFType = cmELF::FileTypeCore;
       break;
-    default:
-      {
+    default: {
       unsigned int eti = static_cast<unsigned int>(this->ELFHeader.e_type);
 #if defined(ET_LOOS) && defined(ET_HIOS)
-      if(eti >= ET_LOOS && eti <= ET_HIOS)
-        {
+      if (eti >= ET_LOOS && eti <= ET_HIOS) {
         this->ELFType = cmELF::FileTypeSpecificOS;
         break;
-        }
+      }
 #endif
 #if defined(ET_LOPROC) && defined(ET_HIPROC)
-      if(eti >= ET_LOPROC && eti <= ET_HIPROC)
-        {
+      if (eti >= ET_LOPROC && eti <= ET_HIPROC) {
         this->ELFType = cmELF::FileTypeSpecificProc;
         break;
-        }
+      }
 #endif
       std::ostringstream e;
       e << "Unknown ELF file type " << eti;
       this->SetErrorMessage(e.str().c_str());
       return;
-      }
     }
+  }
 
   // Load the section headers.
   this->SectionHeaders.resize(this->ELFHeader.e_shnum);
-  for(ELF_Half i=0; i < this->ELFHeader.e_shnum; ++i)
-    {
-    if(!this->LoadSectionHeader(i))
-      {
+  for (ELF_Half i = 0; i < this->ELFHeader.e_shnum; ++i) {
+    if (!this->LoadSectionHeader(i)) {
       this->SetErrorMessage("Failed to load section headers.");
       return;
-      }
     }
+  }
 }
 
 template <class Types>
 bool cmELFInternalImpl<Types>::LoadDynamicSection()
 {
   // If there is no dynamic section we are done.
-  if(this->DynamicSectionIndex < 0)
-    {
+  if (this->DynamicSectionIndex < 0) {
     return false;
-    }
+  }
 
   // If the section was already loaded we are done.
-  if(!this->DynamicSectionEntries.empty())
-    {
+  if (!this->DynamicSectionEntries.empty()) {
     return true;
-    }
+  }
 
   // If there are no entries we are done.
   ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
-  if(sec.sh_entsize == 0)
-    {
+  if (sec.sh_entsize == 0) {
     return false;
-    }
+  }
 
   // Allocate the dynamic section entries.
   int n = static_cast<int>(sec.sh_size / sec.sh_entsize);
   this->DynamicSectionEntries.resize(n);
 
   // Read each entry.
-  for(int j=0; j < n; ++j)
-    {
+  for (int j = 0; j < n; ++j) {
     // Seek to the beginning of the section entry.
-    this->Stream.seekg(sec.sh_offset + sec.sh_entsize*j);
+    this->Stream.seekg(sec.sh_offset + sec.sh_entsize * j);
     ELF_Dyn& dyn = this->DynamicSectionEntries[j];
 
     // Try reading the entry.
-    if(!this->Read(dyn))
-      {
+    if (!this->Read(dyn)) {
       this->SetErrorMessage("Error reading entry from DYNAMIC section.");
       this->DynamicSectionIndex = -1;
       return false;
-      }
     }
+  }
   return true;
 }
 
 template <class Types>
 unsigned int cmELFInternalImpl<Types>::GetDynamicEntryCount()
 {
-  if(!this->LoadDynamicSection())
-    {
+  if (!this->LoadDynamicSection()) {
     return 0;
-    }
-  for(unsigned int i = 0; i < this->DynamicSectionEntries.size(); ++i)
-    {
-    if(this->DynamicSectionEntries[i].d_tag == DT_NULL)
-      {
+  }
+  for (unsigned int i = 0; i < this->DynamicSectionEntries.size(); ++i) {
+    if (this->DynamicSectionEntries[i].d_tag == DT_NULL) {
       return i;
-      }
     }
+  }
   return static_cast<unsigned int>(this->DynamicSectionEntries.size());
 }
 
 template <class Types>
 unsigned long cmELFInternalImpl<Types>::GetDynamicEntryPosition(int j)
 {
-  if(!this->LoadDynamicSection())
-    {
+  if (!this->LoadDynamicSection()) {
     return 0;
-    }
-  if(j < 0 || j >= static_cast<int>(this->DynamicSectionEntries.size()))
-    {
+  }
+  if (j < 0 || j >= static_cast<int>(this->DynamicSectionEntries.size())) {
     return 0;
-    }
+  }
   ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
-  return static_cast<unsigned long>(sec.sh_offset + sec.sh_entsize*j);
+  return static_cast<unsigned long>(sec.sh_offset + sec.sh_entsize * j);
 }
 
 template <class Types>
-cmELF::StringEntry const*
-cmELFInternalImpl<Types>::GetDynamicSectionString(unsigned int tag)
+cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString(
+  unsigned int tag)
 {
   // Short-circuit if already checked.
   std::map<unsigned int, StringEntry>::iterator dssi =
     this->DynamicSectionStrings.find(tag);
-  if(dssi != this->DynamicSectionStrings.end())
-    {
-    if(dssi->second.Position > 0)
-      {
+  if (dssi != this->DynamicSectionStrings.end()) {
+    if (dssi->second.Position > 0) {
       return &dssi->second;
-      }
-    return 0;
     }
+    return 0;
+  }
 
   // Create an entry for this tag.  Assume it is missing until found.
   StringEntry& se = this->DynamicSectionStrings[tag];
@@ -642,36 +682,31 @@ cmELFInternalImpl<Types>::GetDynamicSectionString(unsigned int tag)
   se.IndexInSection = -1;
 
   // Try reading the dynamic section.
-  if(!this->LoadDynamicSection())
-    {
+  if (!this->LoadDynamicSection()) {
     return 0;
-    }
+  }
 
   // Get the string table referenced by the DYNAMIC section.
   ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
-  if(sec.sh_link >= this->SectionHeaders.size())
-    {
+  if (sec.sh_link >= this->SectionHeaders.size()) {
     this->SetErrorMessage("Section DYNAMIC has invalid string table index.");
     return 0;
-    }
+  }
   ELF_Shdr const& strtab = this->SectionHeaders[sec.sh_link];
 
   // Look for the requested entry.
-  for(typename std::vector<ELF_Dyn>::iterator
-        di = this->DynamicSectionEntries.begin();
-      di != this->DynamicSectionEntries.end(); ++di)
-    {
+  for (typename std::vector<ELF_Dyn>::iterator di =
+         this->DynamicSectionEntries.begin();
+       di != this->DynamicSectionEntries.end(); ++di) {
     ELF_Dyn& dyn = *di;
-    if(static_cast<tagtype>(dyn.d_tag) == static_cast<tagtype>(tag))
-      {
+    if (static_cast<tagtype>(dyn.d_tag) == static_cast<tagtype>(tag)) {
       // We found the tag requested.
       // Make sure the position given is within the string section.
-      if(dyn.d_un.d_val >= strtab.sh_size)
-        {
+      if (dyn.d_un.d_val >= strtab.sh_size) {
         this->SetErrorMessage("Section DYNAMIC references string beyond "
                               "the end of its string section.");
         return 0;
-        }
+      }
 
       // Seek to the position reported by the entry.
       unsigned long first = static_cast<unsigned long>(dyn.d_un.d_val);
@@ -686,26 +721,21 @@ cmELFInternalImpl<Types>::GetDynamicSectionString(unsigned int tag)
       // assumption.
       bool terminated = false;
       char c;
-      while(last != end && this->Stream.get(c) && !(terminated && c))
-        {
+      while (last != end && this->Stream.get(c) && !(terminated && c)) {
         ++last;
-        if(c)
-          {
+        if (c) {
           se.Value += c;
-          }
-        else
-          {
+        } else {
           terminated = true;
-          }
         }
+      }
 
       // Make sure the whole value was read.
-      if(!this->Stream)
-        {
+      if (!this->Stream) {
         this->SetErrorMessage("Dynamic section specifies unreadable RPATH.");
         se.Value = "";
         return 0;
-        }
+      }
 
       // The value has been read successfully.  Report it.
       se.Position = static_cast<unsigned long>(strtab.sh_offset + first);
@@ -713,84 +743,69 @@ cmELFInternalImpl<Types>::GetDynamicSectionString(unsigned int tag)
       se.IndexInSection =
         static_cast<int>(di - this->DynamicSectionEntries.begin());
       return &se;
-      }
     }
+  }
   return 0;
 }
 
 //============================================================================
 // External class implementation.
 
-cmELF::cmELF(const char* fname): Internal(0)
+cmELF::cmELF(const char* fname)
+  : Internal(0)
 {
   // Try to open the file.
   cmsys::auto_ptr<cmsys::ifstream> fin(new cmsys::ifstream(fname));
 
   // Quit now if the file could not be opened.
-  if(!fin.get() || !*fin)
-    {
+  if (!fin.get() || !*fin) {
     this->ErrorMessage = "Error opening input file.";
     return;
-    }
+  }
 
   // Read the ELF identification block.
   char ident[EI_NIDENT];
-  if(!fin->read(ident, EI_NIDENT))
-    {
+  if (!fin->read(ident, EI_NIDENT)) {
     this->ErrorMessage = "Error reading ELF identification.";
     return;
-    }
-  if(!fin->seekg(0))
-    {
+  }
+  if (!fin->seekg(0)) {
     this->ErrorMessage = "Error seeking to beginning of file.";
     return;
-    }
+  }
 
   // Verify the ELF identification.
-  if(!(ident[EI_MAG0] == ELFMAG0 &&
-       ident[EI_MAG1] == ELFMAG1 &&
-       ident[EI_MAG2] == ELFMAG2 &&
-       ident[EI_MAG3] == ELFMAG3))
-    {
+  if (!(ident[EI_MAG0] == ELFMAG0 && ident[EI_MAG1] == ELFMAG1 &&
+        ident[EI_MAG2] == ELFMAG2 && ident[EI_MAG3] == ELFMAG3)) {
     this->ErrorMessage = "File does not have a valid ELF identification.";
     return;
-    }
+  }
 
   // Check the byte order in which the rest of the file is encoded.
   cmELFInternal::ByteOrderType order;
-  if(ident[EI_DATA] == ELFDATA2LSB)
-    {
+  if (ident[EI_DATA] == ELFDATA2LSB) {
     // File is LSB.
-    order =  cmELFInternal::ByteOrderLSB;
-    }
-  else if(ident[EI_DATA] == ELFDATA2MSB)
-    {
+    order = cmELFInternal::ByteOrderLSB;
+  } else if (ident[EI_DATA] == ELFDATA2MSB) {
     // File is MSB.
-    order =  cmELFInternal::ByteOrderMSB;
-    }
-  else
-    {
+    order = cmELFInternal::ByteOrderMSB;
+  } else {
     this->ErrorMessage = "ELF file is not LSB or MSB encoded.";
     return;
-    }
+  }
 
   // Check the class of the file and construct the corresponding
   // parser implementation.
-  if(ident[EI_CLASS] == ELFCLASS32)
-    {
+  if (ident[EI_CLASS] == ELFCLASS32) {
     // 32-bit ELF
     this->Internal = new cmELFInternalImpl<cmELFTypes32>(this, fin, order);
-    }
-  else if(ident[EI_CLASS] == ELFCLASS64)
-    {
+  } else if (ident[EI_CLASS] == ELFCLASS64) {
     // 64-bit ELF
     this->Internal = new cmELFInternalImpl<cmELFTypes64>(this, fin, order);
-    }
-  else
-    {
+  } else {
     this->ErrorMessage = "ELF file class is not 32-bit or 64-bit.";
     return;
-    }
+  }
 }
 
 cmELF::~cmELF()
@@ -805,126 +820,96 @@ bool cmELF::Valid() const
 
 cmELF::FileType cmELF::GetFileType() const
 {
-  if(this->Valid())
-    {
+  if (this->Valid()) {
     return this->Internal->GetFileType();
-    }
-  else
-    {
+  } else {
     return FileTypeInvalid;
-    }
+  }
 }
 
 unsigned int cmELF::GetNumberOfSections() const
 {
-  if(this->Valid())
-    {
+  if (this->Valid()) {
     return this->Internal->GetNumberOfSections();
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 unsigned int cmELF::GetDynamicEntryCount() const
 {
-  if(this->Valid())
-    {
+  if (this->Valid()) {
     return this->Internal->GetDynamicEntryCount();
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 unsigned long cmELF::GetDynamicEntryPosition(int index) const
 {
-  if(this->Valid())
-    {
+  if (this->Valid()) {
     return this->Internal->GetDynamicEntryPosition(index);
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 bool cmELF::ReadBytes(unsigned long pos, unsigned long size, char* buf) const
 {
-  if(this->Valid())
-    {
+  if (this->Valid()) {
     return this->Internal->ReadBytes(pos, size, buf);
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
 
 bool cmELF::GetSOName(std::string& soname)
 {
-  if(StringEntry const* se = this->GetSOName())
-    {
+  if (StringEntry const* se = this->GetSOName()) {
     soname = se->Value;
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
 
 cmELF::StringEntry const* cmELF::GetSOName()
 {
-  if(this->Valid() &&
-     this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)
-    {
+  if (this->Valid() &&
+      this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary) {
     return this->Internal->GetSOName();
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 cmELF::StringEntry const* cmELF::GetRPath()
 {
-  if(this->Valid() &&
-     (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
-      this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary))
-    {
+  if (this->Valid() &&
+      (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
+       this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) {
     return this->Internal->GetRPath();
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 cmELF::StringEntry const* cmELF::GetRunPath()
 {
-  if(this->Valid() &&
-     (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
-      this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary))
-    {
+  if (this->Valid() &&
+      (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
+       this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) {
     return this->Internal->GetRunPath();
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 void cmELF::PrintInfo(std::ostream& os) const
 {
-  if(this->Valid())
-    {
+  if (this->Valid()) {
     this->Internal->PrintInfo(os);
-    }
-  else
-    {
+  } else {
     os << "Not a valid ELF file.\n";
-    }
+  }
 }
diff --git a/Source/cmELF.h b/Source/cmELF.h
index ab9be42..80832ad 100644
--- a/Source/cmELF.h
+++ b/Source/cmELF.h
@@ -13,7 +13,7 @@
 #define cmELF_h
 
 #if !defined(CMAKE_USE_ELF_PARSER)
-# error "This file may be included only if CMAKE_USE_ELF_PARSER is enabled."
+#error "This file may be included only if CMAKE_USE_ELF_PARSER is enabled."
 #endif
 
 class cmELFInternal;
@@ -31,10 +31,7 @@ public:
   ~cmELF();
 
   /** Get the error message if any.  */
-  std::string const& GetErrorMessage() const
-    {
-    return this->ErrorMessage;
-    }
+  std::string const& GetErrorMessage() const { return this->ErrorMessage; }
 
   /** Boolean conversion.  True if the ELF file is valid.  */
   operator bool() const { return this->Valid(); }
diff --git a/Source/cmElseCommand.cxx b/Source/cmElseCommand.cxx
index 163d006..6db6f8d 100644
--- a/Source/cmElseCommand.cxx
+++ b/Source/cmElseCommand.cxx
@@ -12,7 +12,7 @@
 #include "cmElseCommand.h"
 
 bool cmElseCommand::InitialPass(std::vector<std::string> const&,
-                                cmExecutionStatus &)
+                                cmExecutionStatus&)
 {
   this->SetError("An ELSE command was found outside of a proper "
                  "IF ENDIF structure. Or its arguments did not match "
diff --git a/Source/cmElseCommand.h b/Source/cmElseCommand.h
index dde5fcc..815825e 100644
--- a/Source/cmElseCommand.h
+++ b/Source/cmElseCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmElseCommand;
-    }
+  virtual cmCommand* Clone() { return new cmElseCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,10 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "else";}
+  virtual std::string GetName() const { return "else"; }
 
   cmTypeMacro(cmElseCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmElseIfCommand.cxx b/Source/cmElseIfCommand.cxx
index cd9742b..dc89e24 100644
--- a/Source/cmElseIfCommand.cxx
+++ b/Source/cmElseIfCommand.cxx
@@ -12,7 +12,7 @@
 #include "cmElseIfCommand.h"
 
 bool cmElseIfCommand::InitialPass(std::vector<std::string> const&,
-                                  cmExecutionStatus &)
+                                  cmExecutionStatus&)
 {
   this->SetError("An ELSEIF command was found outside of a proper "
                  "IF ENDIF structure.");
diff --git a/Source/cmElseIfCommand.h b/Source/cmElseIfCommand.h
index c627cbe..d0ffa5d 100644
--- a/Source/cmElseIfCommand.h
+++ b/Source/cmElseIfCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmElseIfCommand;
-    }
+  virtual cmCommand* Clone() { return new cmElseIfCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,10 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "elseif";}
+  virtual std::string GetName() const { return "elseif"; }
 
   cmTypeMacro(cmElseIfCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmEnableLanguageCommand.cxx b/Source/cmEnableLanguageCommand.cxx
index dcabf6a..0ebe778 100644
--- a/Source/cmEnableLanguageCommand.cxx
+++ b/Source/cmEnableLanguageCommand.cxx
@@ -12,32 +12,24 @@
 #include "cmEnableLanguageCommand.h"
 
 // cmEnableLanguageCommand
-bool cmEnableLanguageCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmEnableLanguageCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
   bool optional = false;
   std::vector<std::string> languages;
-  if(args.size() < 1 )
-    {
-    this->SetError
-      ("called with incorrect number of arguments");
+  if (args.size() < 1) {
+    this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   for (std::vector<std::string>::const_iterator it = args.begin();
-       it != args.end();
-       ++it)
-    {
-    if ((*it) == "OPTIONAL")
-      {
+       it != args.end(); ++it) {
+    if ((*it) == "OPTIONAL") {
       optional = true;
-      }
-    else
-      {
+    } else {
       languages.push_back(*it);
-      }
     }
+  }
 
   this->Makefile->EnableLanguage(languages, optional);
   return true;
 }
-
diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h
index 2b09e11..657e4e5 100644
--- a/Source/cmEnableLanguageCommand.h
+++ b/Source/cmEnableLanguageCommand.h
@@ -28,26 +28,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEnableLanguageCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEnableLanguageCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "enable_language";}
+  virtual std::string GetName() const { return "enable_language"; }
 
   cmTypeMacro(cmEnableLanguageCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx
index 6a7fd46..a9c60a8 100644
--- a/Source/cmEnableTestingCommand.cxx
+++ b/Source/cmEnableTestingCommand.cxx
@@ -14,8 +14,8 @@
 // we do this in the final pass so that we now the subdirs have all
 // been defined
 bool cmEnableTestingCommand::InitialPass(std::vector<std::string> const&,
-                                         cmExecutionStatus &)
+                                         cmExecutionStatus&)
 {
-  this->Makefile->AddDefinition("CMAKE_TESTING_ENABLED","1");
+  this->Makefile->AddDefinition("CMAKE_TESTING_ENABLED", "1");
   return true;
 }
diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h
index d028c59..a518f18 100644
--- a/Source/cmEnableTestingCommand.h
+++ b/Source/cmEnableTestingCommand.h
@@ -33,26 +33,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEnableTestingCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEnableTestingCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &);
+                           cmExecutionStatus&);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "enable_testing";}
+  virtual std::string GetName() const { return "enable_testing"; }
 
   cmTypeMacro(cmEnableTestingCommand, cmCommand);
-
 };
 
-
 #endif
diff --git a/Source/cmEndForEachCommand.cxx b/Source/cmEndForEachCommand.cxx
index 7f11ae5..104b39a 100644
--- a/Source/cmEndForEachCommand.cxx
+++ b/Source/cmEndForEachCommand.cxx
@@ -11,13 +11,11 @@
 ============================================================================*/
 #include "cmEndForEachCommand.h"
 
-bool cmEndForEachCommand
-::InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                    cmExecutionStatus &)
+bool cmEndForEachCommand::InvokeInitialPass(
+  std::vector<cmListFileArgument> const&, cmExecutionStatus&)
 {
   this->SetError("An ENDFOREACH command was found outside of a proper "
                  "FOREACH ENDFOREACH structure. Or its arguments did "
                  "not match the opening FOREACH command.");
   return false;
 }
-
diff --git a/Source/cmEndForEachCommand.h b/Source/cmEndForEachCommand.h
index c3be387..ebc794f 100644
--- a/Source/cmEndForEachCommand.h
+++ b/Source/cmEndForEachCommand.h
@@ -25,24 +25,23 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEndForEachCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEndForEachCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
   virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) {return false;}
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -52,10 +51,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endforeach";}
+  virtual std::string GetName() const { return "endforeach"; }
 
   cmTypeMacro(cmEndForEachCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmEndFunctionCommand.cxx b/Source/cmEndFunctionCommand.cxx
index 04b242d..b4bfa2d 100644
--- a/Source/cmEndFunctionCommand.cxx
+++ b/Source/cmEndFunctionCommand.cxx
@@ -11,13 +11,11 @@
 ============================================================================*/
 #include "cmEndFunctionCommand.h"
 
-bool cmEndFunctionCommand
-::InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                    cmExecutionStatus &)
+bool cmEndFunctionCommand::InvokeInitialPass(
+  std::vector<cmListFileArgument> const&, cmExecutionStatus&)
 {
   this->SetError("An ENDFUNCTION command was found outside of a proper "
                  "FUNCTION ENDFUNCTION structure. Or its arguments did not "
                  "match the opening FUNCTION command.");
   return false;
 }
-
diff --git a/Source/cmEndFunctionCommand.h b/Source/cmEndFunctionCommand.h
index 3a42c17..b69dec0 100644
--- a/Source/cmEndFunctionCommand.h
+++ b/Source/cmEndFunctionCommand.h
@@ -25,24 +25,23 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEndFunctionCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEndFunctionCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
   virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) {return false;}
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -52,10 +51,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endfunction";}
+  virtual std::string GetName() const { return "endfunction"; }
 
   cmTypeMacro(cmEndFunctionCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmEndIfCommand.cxx b/Source/cmEndIfCommand.cxx
index 05f23c4..1ae3a78 100644
--- a/Source/cmEndIfCommand.cxx
+++ b/Source/cmEndIfCommand.cxx
@@ -13,18 +13,16 @@
 
 #include <stdlib.h> // required for atof
 bool cmEndIfCommand::InitialPass(std::vector<std::string> const&,
-                                 cmExecutionStatus &)
+                                 cmExecutionStatus&)
 {
-  const char* versionValue
-    = this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
-  if (!versionValue || (atof(versionValue) <= 1.4))
-    {
+  const char* versionValue =
+    this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
+  if (!versionValue || (atof(versionValue) <= 1.4)) {
     return true;
-    }
+  }
 
   this->SetError("An ENDIF command was found outside of a proper "
                  "IF ENDIF structure. Or its arguments did not match "
                  "the opening IF command.");
   return false;
 }
-
diff --git a/Source/cmEndIfCommand.h b/Source/cmEndIfCommand.h
index a8248c8..457dfd3 100644
--- a/Source/cmEndIfCommand.h
+++ b/Source/cmEndIfCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEndIfCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEndIfCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,10 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endif";}
+  virtual std::string GetName() const { return "endif"; }
 
   cmTypeMacro(cmEndIfCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmEndMacroCommand.cxx b/Source/cmEndMacroCommand.cxx
index 86d907b..435c05f 100644
--- a/Source/cmEndMacroCommand.cxx
+++ b/Source/cmEndMacroCommand.cxx
@@ -11,13 +11,11 @@
 ============================================================================*/
 #include "cmEndMacroCommand.h"
 
-bool cmEndMacroCommand
-::InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                    cmExecutionStatus &)
+bool cmEndMacroCommand::InvokeInitialPass(
+  std::vector<cmListFileArgument> const&, cmExecutionStatus&)
 {
   this->SetError("An ENDMACRO command was found outside of a proper "
                  "MACRO ENDMACRO structure. Or its arguments did not "
                  "match the opening MACRO command.");
   return false;
 }
-
diff --git a/Source/cmEndMacroCommand.h b/Source/cmEndMacroCommand.h
index fdc04ee..615e8dc 100644
--- a/Source/cmEndMacroCommand.h
+++ b/Source/cmEndMacroCommand.h
@@ -25,24 +25,23 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEndMacroCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEndMacroCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
   virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) {return false;}
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -52,10 +51,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endmacro";}
+  virtual std::string GetName() const { return "endmacro"; }
 
   cmTypeMacro(cmEndMacroCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmEndWhileCommand.cxx b/Source/cmEndWhileCommand.cxx
index abb9e5e..33507de 100644
--- a/Source/cmEndWhileCommand.cxx
+++ b/Source/cmEndWhileCommand.cxx
@@ -11,22 +11,17 @@
 ============================================================================*/
 #include "cmEndWhileCommand.h"
 
-bool cmEndWhileCommand
-::InvokeInitialPass(std::vector<cmListFileArgument> const& args,
-                    cmExecutionStatus &)
+bool cmEndWhileCommand::InvokeInitialPass(
+  std::vector<cmListFileArgument> const& args, cmExecutionStatus&)
 {
-  if (args.empty())
-    {
+  if (args.empty()) {
     this->SetError("An ENDWHILE command was found outside of a proper "
                    "WHILE ENDWHILE structure.");
-    }
-  else
-    {
+  } else {
     this->SetError("An ENDWHILE command was found outside of a proper "
                    "WHILE ENDWHILE structure. Or its arguments did not "
                    "match the opening WHILE command.");
-    }
+  }
 
   return false;
 }
-
diff --git a/Source/cmEndWhileCommand.h b/Source/cmEndWhileCommand.h
index ec1cb65..5eda7af 100644
--- a/Source/cmEndWhileCommand.h
+++ b/Source/cmEndWhileCommand.h
@@ -25,24 +25,23 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmEndWhileCommand;
-    }
+  virtual cmCommand* Clone() { return new cmEndWhileCommand; }
 
   /**
    * Override cmCommand::InvokeInitialPass to get arguments before
    * expansion.
    */
   virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const& args,
-                                 cmExecutionStatus &status);
+                                 cmExecutionStatus& status);
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) {return false;}
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -52,10 +51,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "endwhile";}
+  virtual std::string GetName() const { return "endwhile"; }
 
   cmTypeMacro(cmEndWhileCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmExecProgramCommand.cxx b/Source/cmExecProgramCommand.cxx
index 1109737..f3f8c2f 100644
--- a/Source/cmExecProgramCommand.cxx
+++ b/Source/cmExecProgramCommand.cxx
@@ -16,14 +16,13 @@
 #include <cmsys/Process.h>
 
 // cmExecProgramCommand
-bool cmExecProgramCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::string arguments;
   bool doingargs = false;
   int count = 0;
@@ -31,131 +30,102 @@ bool cmExecProgramCommand
   bool haveoutput_variable = false;
   std::string return_variable;
   bool havereturn_variable = false;
-  for(size_t i=0; i < args.size(); ++i)
-    {
-    if(args[i] == "OUTPUT_VARIABLE")
-      {
+  for (size_t i = 0; i < args.size(); ++i) {
+    if (args[i] == "OUTPUT_VARIABLE") {
       count++;
       doingargs = false;
       havereturn_variable = false;
       haveoutput_variable = true;
-      }
-    else if ( haveoutput_variable )
-      {
-      if (!output_variable.empty())
-        {
+    } else if (haveoutput_variable) {
+      if (!output_variable.empty()) {
         this->SetError("called with incorrect number of arguments");
         return false;
-        }
+      }
       output_variable = args[i];
       haveoutput_variable = false;
-      count ++;
-      }
-    else if(args[i] == "RETURN_VALUE")
-      {
+      count++;
+    } else if (args[i] == "RETURN_VALUE") {
       count++;
       doingargs = false;
       haveoutput_variable = false;
       havereturn_variable = true;
-      }
-    else if ( havereturn_variable )
-      {
-      if (!return_variable.empty())
-        {
+    } else if (havereturn_variable) {
+      if (!return_variable.empty()) {
         this->SetError("called with incorrect number of arguments");
         return false;
-        }
+      }
       return_variable = args[i];
       havereturn_variable = false;
-      count ++;
-      }
-    else if(args[i] == "ARGS")
-      {
+      count++;
+    } else if (args[i] == "ARGS") {
       count++;
       havereturn_variable = false;
       haveoutput_variable = false;
       doingargs = true;
-      }
-    else if(doingargs)
-      {
+    } else if (doingargs) {
       arguments += args[i];
       arguments += " ";
       count++;
-      }
     }
+  }
 
   std::string command;
-  if(!arguments.empty())
-    {
+  if (!arguments.empty()) {
     command = cmSystemTools::ConvertToRunCommandPath(args[0].c_str());
     command += " ";
     command += arguments;
-    }
-  else
-    {
+  } else {
     command = args[0];
-    }
+  }
   bool verbose = true;
-  if(!output_variable.empty())
-    {
+  if (!output_variable.empty()) {
     verbose = false;
-    }
+  }
   int retVal = 0;
   std::string output;
   bool result = true;
-  if(args.size() - count == 2)
-    {
+  if (args.size() - count == 2) {
     cmSystemTools::MakeDirectory(args[1].c_str());
     result = cmExecProgramCommand::RunCommand(command.c_str(), output, retVal,
                                               args[1].c_str(), verbose);
-    }
-  else
-    {
-    result = cmExecProgramCommand::RunCommand(command.c_str(), output,
-                                              retVal, 0, verbose);
-    }
-  if(!result)
-    {
+  } else {
+    result = cmExecProgramCommand::RunCommand(command.c_str(), output, retVal,
+                                              0, verbose);
+  }
+  if (!result) {
     retVal = -1;
-    }
+  }
 
-  if (!output_variable.empty())
-    {
+  if (!output_variable.empty()) {
     std::string::size_type first = output.find_first_not_of(" \n\t\r");
     std::string::size_type last = output.find_last_not_of(" \n\t\r");
-    if(first == std::string::npos)
-      {
+    if (first == std::string::npos) {
       first = 0;
-      }
-    if(last == std::string::npos)
-      {
-      last = output.size()-1;
-      }
+    }
+    if (last == std::string::npos) {
+      last = output.size() - 1;
+    }
 
-    std::string coutput = std::string(output, first, last-first+1);
+    std::string coutput = std::string(output, first, last - first + 1);
     this->Makefile->AddDefinition(output_variable, coutput.c_str());
-    }
+  }
 
-  if (!return_variable.empty())
-    {
+  if (!return_variable.empty()) {
     char buffer[100];
     sprintf(buffer, "%d", retVal);
     this->Makefile->AddDefinition(return_variable, buffer);
-    }
+  }
 
   return true;
 }
 
-bool cmExecProgramCommand::RunCommand(const char* command,
-                                      std::string& output,
-                                      int &retVal,
-                                      const char* dir,
+bool cmExecProgramCommand::RunCommand(const char* command, std::string& output,
+                                      int& retVal, const char* dir,
                                       bool verbose)
 {
-  if(cmSystemTools::GetRunCommandOutput())
-    {
+  if (cmSystemTools::GetRunCommandOutput()) {
     verbose = false;
-    }
+  }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
   // if the command does not start with a quote, then
@@ -164,100 +134,82 @@ bool cmExecProgramCommand::RunCommand(const char* command,
   // shell command like echo or dir
   int count = 0;
   std::string shortCmd;
-  if(command[0] == '\"')
-    {
+  if (command[0] == '\"') {
     // count the number of quotes
-    for(const char* s = command; *s != 0; ++s)
-      {
-      if(*s == '\"')
-        {
+    for (const char* s = command; *s != 0; ++s) {
+      if (*s == '\"') {
         count++;
-        if(count > 2)
-          {
+        if (count > 2) {
           break;
-          }
         }
       }
+    }
     // if there are more than two double quotes use
     // GetShortPathName, the cmd.exe program in windows which
     // is used by system fails to execute if there are more than
     // one set of quotes in the arguments
-    if(count > 2)
-      {
+    if (count > 2) {
       cmsys::RegularExpression quoted("^\"([^\"]*)\"[ \t](.*)");
-      if(quoted.find(command))
-        {
+      if (quoted.find(command)) {
         std::string cmd = quoted.match(1);
         std::string args = quoted.match(2);
-        if(! cmSystemTools::FileExists(cmd.c_str()) )
-          {
+        if (!cmSystemTools::FileExists(cmd.c_str())) {
           shortCmd = cmd;
-          }
-        else if(!cmSystemTools::GetShortPath(cmd.c_str(), shortCmd))
-          {
-         cmSystemTools::Error("GetShortPath failed for " , cmd.c_str());
+        } else if (!cmSystemTools::GetShortPath(cmd.c_str(), shortCmd)) {
+          cmSystemTools::Error("GetShortPath failed for ", cmd.c_str());
           return false;
-          }
+        }
         shortCmd += " ";
         shortCmd += args;
 
         command = shortCmd.c_str();
-        }
-      else
-        {
+      } else {
         cmSystemTools::Error("Could not parse command line with quotes ",
                              command);
-        }
       }
     }
+  }
 #endif
 
   // Allocate a process instance.
   cmsysProcess* cp = cmsysProcess_New();
-  if(!cp)
-    {
+  if (!cp) {
     cmSystemTools::Error("Error allocating process instance.");
     return false;
-    }
+  }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  if(dir)
-    {
+  if (dir) {
     cmsysProcess_SetWorkingDirectory(cp, dir);
-    }
-  if(cmSystemTools::GetRunCommandHideConsole())
-    {
+  }
+  if (cmSystemTools::GetRunCommandHideConsole()) {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
-    }
+  }
   cmsysProcess_SetOption(cp, cmsysProcess_Option_Verbatim, 1);
-  const char* cmd[] = {command, 0};
+  const char* cmd[] = { command, 0 };
   cmsysProcess_SetCommand(cp, cmd);
 #else
   std::string commandInDir;
-  if(dir)
-    {
+  if (dir) {
     commandInDir = "cd \"";
     commandInDir += dir;
     commandInDir += "\" && ";
     commandInDir += command;
-    }
-  else
-    {
+  } else {
     commandInDir = command;
-    }
+  }
 #ifndef __VMS
   commandInDir += " 2>&1";
 #endif
   command = commandInDir.c_str();
-  if(verbose)
-    {
+  if (verbose) {
     cmSystemTools::Stdout("running ");
     cmSystemTools::Stdout(command);
     cmSystemTools::Stdout("\n");
-    }
+  }
   fflush(stdout);
   fflush(stderr);
-  const char* cmd[] = {"/bin/sh", "-c", command, 0};
+  const char* cmd[] = { "/bin/sh", "-c", command, 0 };
   cmsysProcess_SetCommand(cp, cmd);
 #endif
 
@@ -267,25 +219,21 @@ bool cmExecProgramCommand::RunCommand(const char* command,
   int length;
   char* data;
   int p;
-  while((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p))
-    {
-    if(p == cmsysProcess_Pipe_STDOUT || p == cmsysProcess_Pipe_STDERR)
-      {
-      if(verbose)
-        {
+  while ((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p)) {
+    if (p == cmsysProcess_Pipe_STDOUT || p == cmsysProcess_Pipe_STDERR) {
+      if (verbose) {
         cmSystemTools::Stdout(data, length);
-        }
-      output.append(data, length);
       }
+      output.append(data, length);
     }
+  }
 
   // All output has been read.  Wait for the process to exit.
   cmsysProcess_WaitForExit(cp, 0);
 
   // Check the result of running the process.
   std::string msg;
-  switch(cmsysProcess_GetState(cp))
-    {
+  switch (cmsysProcess_GetState(cp)) {
     case cmsysProcess_State_Exited:
       retVal = cmsysProcess_GetExitValue(cp);
       break;
@@ -303,29 +251,26 @@ bool cmExecProgramCommand::RunCommand(const char* command,
       retVal = -1;
       msg += "\nProcess terminated due to timeout.";
       break;
-    }
-  if(!msg.empty())
-    {
+  }
+  if (!msg.empty()) {
 #if defined(_WIN32) && !defined(__CYGWIN__)
     // Old Windows process execution printed this info.
     msg += "\n\nfor command: ";
     msg += command;
-    if(dir)
-      {
+    if (dir) {
       msg += "\nin dir: ";
       msg += dir;
-      }
+    }
     msg += "\n";
-    if(verbose)
-      {
+    if (verbose) {
       cmSystemTools::Stdout(msg.c_str());
-      }
+    }
     output += msg;
 #else
     // Old UNIX process execution only put message in output.
     output += msg;
 #endif
-    }
+  }
 
   // Delete the process instance.
   cmsysProcess_Delete(cp);
diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h
index adefdf9..e6e76d2 100644
--- a/Source/cmExecProgramCommand.h
+++ b/Source/cmExecProgramCommand.h
@@ -27,23 +27,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmExecProgramCommand;
-    }
+  virtual cmCommand* Clone() { return new cmExecProgramCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const
-    {return "exec_program";}
+  virtual std::string GetName() const { return "exec_program"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -51,10 +47,10 @@ public:
   virtual bool IsScriptable() const { return true; }
 
   cmTypeMacro(cmExecProgramCommand, cmCommand);
+
 private:
-  static bool RunCommand(const char* command, std::string& output,
-                         int &retVal, const char* directory = 0,
-                         bool verbose = true);
+  static bool RunCommand(const char* command, std::string& output, int& retVal,
+                         const char* directory = 0, bool verbose = true);
 };
 
 #endif
diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx
index a1e5010..575cdc3 100644
--- a/Source/cmExecuteProcessCommand.cxx
+++ b/Source/cmExecuteProcessCommand.cxx
@@ -24,19 +24,18 @@ static bool cmExecuteProcessCommandIsWhitespace(char c)
 
 void cmExecuteProcessCommandFixText(std::vector<char>& output,
                                     bool strip_trailing_whitespace);
-void cmExecuteProcessCommandAppend(std::vector<char>& output,
-                                   const char* data, int length);
+void cmExecuteProcessCommandAppend(std::vector<char>& output, const char* data,
+                                   int length);
 
 // cmExecuteProcessCommand
-bool cmExecuteProcessCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
-  std::vector< std::vector<const char*> > cmds;
+  }
+  std::vector<std::vector<const char*> > cmds;
   std::string arguments;
   bool doing_command = false;
   size_t command_index = 0;
@@ -52,246 +51,173 @@ bool cmExecuteProcessCommand
   std::string error_variable;
   std::string result_variable;
   std::string working_directory;
-  for(size_t i=0; i < args.size(); ++i)
-    {
-    if(args[i] == "COMMAND")
-      {
+  for (size_t i = 0; i < args.size(); ++i) {
+    if (args[i] == "COMMAND") {
       doing_command = true;
       command_index = cmds.size();
       cmds.push_back(std::vector<const char*>());
-      }
-    else if(args[i] == "OUTPUT_VARIABLE")
-      {
+    } else if (args[i] == "OUTPUT_VARIABLE") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         output_variable = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for OUTPUT_VARIABLE.");
         return false;
-        }
       }
-    else if(args[i] == "ERROR_VARIABLE")
-      {
+    } else if (args[i] == "ERROR_VARIABLE") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         error_variable = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for ERROR_VARIABLE.");
         return false;
-        }
       }
-    else if(args[i] == "RESULT_VARIABLE")
-      {
+    } else if (args[i] == "RESULT_VARIABLE") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         result_variable = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for RESULT_VARIABLE.");
         return false;
-        }
       }
-    else if(args[i] == "WORKING_DIRECTORY")
-      {
+    } else if (args[i] == "WORKING_DIRECTORY") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         working_directory = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for WORKING_DIRECTORY.");
         return false;
-        }
       }
-    else if(args[i] == "INPUT_FILE")
-      {
+    } else if (args[i] == "INPUT_FILE") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         input_file = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for INPUT_FILE.");
         return false;
-        }
       }
-    else if(args[i] == "OUTPUT_FILE")
-      {
+    } else if (args[i] == "OUTPUT_FILE") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         output_file = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for OUTPUT_FILE.");
         return false;
-        }
       }
-    else if(args[i] == "ERROR_FILE")
-      {
+    } else if (args[i] == "ERROR_FILE") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         error_file = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for ERROR_FILE.");
         return false;
-        }
       }
-    else if(args[i] == "TIMEOUT")
-      {
+    } else if (args[i] == "TIMEOUT") {
       doing_command = false;
-      if(++i < args.size())
-        {
+      if (++i < args.size()) {
         timeout_string = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError(" called with no value for TIMEOUT.");
         return false;
-        }
       }
-    else if(args[i] == "OUTPUT_QUIET")
-      {
+    } else if (args[i] == "OUTPUT_QUIET") {
       doing_command = false;
       output_quiet = true;
-      }
-    else if(args[i] == "ERROR_QUIET")
-      {
+    } else if (args[i] == "ERROR_QUIET") {
       doing_command = false;
       error_quiet = true;
-      }
-    else if(args[i] == "OUTPUT_STRIP_TRAILING_WHITESPACE")
-      {
+    } else if (args[i] == "OUTPUT_STRIP_TRAILING_WHITESPACE") {
       doing_command = false;
       output_strip_trailing_whitespace = true;
-      }
-    else if(args[i] == "ERROR_STRIP_TRAILING_WHITESPACE")
-      {
+    } else if (args[i] == "ERROR_STRIP_TRAILING_WHITESPACE") {
       doing_command = false;
       error_strip_trailing_whitespace = true;
-      }
-    else if(doing_command)
-      {
+    } else if (doing_command) {
       cmds[command_index].push_back(args[i].c_str());
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << " given unknown argument \"" << args[i] << "\".";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
-  if ( !this->Makefile->CanIWriteThisFile(output_file.c_str()) )
-    {
-    std::string e = "attempted to output into a file: " + output_file
-      + " into a source directory.";
+  if (!this->Makefile->CanIWriteThisFile(output_file.c_str())) {
+    std::string e = "attempted to output into a file: " + output_file +
+      " into a source directory.";
     this->SetError(e);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 
   // Check for commands given.
-  if(cmds.empty())
-    {
+  if (cmds.empty()) {
     this->SetError(" called with no COMMAND argument.");
     return false;
-    }
-  for(unsigned int i=0; i < cmds.size(); ++i)
-    {
-    if(cmds[i].empty())
-      {
+  }
+  for (unsigned int i = 0; i < cmds.size(); ++i) {
+    if (cmds[i].empty()) {
       this->SetError(" given COMMAND argument with no value.");
       return false;
-      }
-    else
-      {
+    } else {
       // Add the null terminating pointer to the command argument list.
       cmds[i].push_back(0);
-      }
     }
+  }
 
   // Parse the timeout string.
   double timeout = -1;
-  if(!timeout_string.empty())
-    {
-    if(sscanf(timeout_string.c_str(), "%lg", &timeout) != 1)
-      {
+  if (!timeout_string.empty()) {
+    if (sscanf(timeout_string.c_str(), "%lg", &timeout) != 1) {
       this->SetError(" called with TIMEOUT value that could not be parsed.");
       return false;
-      }
     }
+  }
 
   // Create a process instance.
   cmsysProcess* cp = cmsysProcess_New();
 
   // Set the command sequence.
-  for(unsigned int i=0; i < cmds.size(); ++i)
-    {
+  for (unsigned int i = 0; i < cmds.size(); ++i) {
     cmsysProcess_AddCommand(cp, &*cmds[i].begin());
-    }
+  }
 
   // Set the process working directory.
-  if(!working_directory.empty())
-    {
+  if (!working_directory.empty()) {
     cmsysProcess_SetWorkingDirectory(cp, working_directory.c_str());
-    }
+  }
 
   // Always hide the process window.
   cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
 
   // Check the output variables.
   bool merge_output = false;
-  if(!input_file.empty())
-    {
+  if (!input_file.empty()) {
     cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDIN, input_file.c_str());
-    }
-  if(!output_file.empty())
-    {
+  }
+  if (!output_file.empty()) {
     cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDOUT,
                              output_file.c_str());
-    }
-  if(!error_file.empty())
-    {
-    if (error_file == output_file)
-      {
+  }
+  if (!error_file.empty()) {
+    if (error_file == output_file) {
       merge_output = true;
-      }
-    else
-      {
+    } else {
       cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDERR,
                                error_file.c_str());
-      }
     }
-  if (!output_variable.empty() && output_variable == error_variable)
-    {
+  }
+  if (!output_variable.empty() && output_variable == error_variable) {
     merge_output = true;
-    }
-  if (merge_output)
-    {
+  }
+  if (merge_output) {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_MergeOutput, 1);
-    }
+  }
 
   // Set the timeout if any.
-  if(timeout >= 0)
-    {
+  if (timeout >= 0) {
     cmsysProcess_SetTimeout(cp, timeout);
-    }
+  }
 
   // Start the process.
   cmsysProcess_Execute(cp);
@@ -302,81 +228,61 @@ bool cmExecuteProcessCommand
   int length;
   char* data;
   int p;
-  while((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p))
-    {
+  while ((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p)) {
     // Put the output in the right place.
-    if (p == cmsysProcess_Pipe_STDOUT && !output_quiet)
-      {
-      if(output_variable.empty())
-        {
+    if (p == cmsysProcess_Pipe_STDOUT && !output_quiet) {
+      if (output_variable.empty()) {
         cmSystemTools::Stdout(data, length);
-        }
-      else
-        {
+      } else {
         cmExecuteProcessCommandAppend(tempOutput, data, length);
-        }
       }
-    else if(p == cmsysProcess_Pipe_STDERR && !error_quiet)
-      {
-      if(error_variable.empty())
-        {
+    } else if (p == cmsysProcess_Pipe_STDERR && !error_quiet) {
+      if (error_variable.empty()) {
         cmSystemTools::Stderr(data, length);
-        }
-      else
-        {
+      } else {
         cmExecuteProcessCommandAppend(tempError, data, length);
-        }
       }
     }
+  }
 
   // All output has been read.  Wait for the process to exit.
   cmsysProcess_WaitForExit(cp, 0);
 
   // Fix the text in the output strings.
-  cmExecuteProcessCommandFixText(tempOutput,
-                                 output_strip_trailing_whitespace);
-  cmExecuteProcessCommandFixText(tempError,
-                                 error_strip_trailing_whitespace);
+  cmExecuteProcessCommandFixText(tempOutput, output_strip_trailing_whitespace);
+  cmExecuteProcessCommandFixText(tempError, error_strip_trailing_whitespace);
 
   // Store the output obtained.
-  if(!output_variable.empty() && !tempOutput.empty())
-    {
-    this->Makefile->AddDefinition(output_variable,
-                                  &*tempOutput.begin());
-    }
-  if(!merge_output && !error_variable.empty() && !tempError.empty())
-    {
-    this->Makefile->AddDefinition(error_variable,
-                                  &*tempError.begin());
-    }
+  if (!output_variable.empty() && !tempOutput.empty()) {
+    this->Makefile->AddDefinition(output_variable, &*tempOutput.begin());
+  }
+  if (!merge_output && !error_variable.empty() && !tempError.empty()) {
+    this->Makefile->AddDefinition(error_variable, &*tempError.begin());
+  }
 
   // Store the result of running the process.
-  if(!result_variable.empty())
-    {
-    switch(cmsysProcess_GetState(cp))
-      {
-      case cmsysProcess_State_Exited:
-        {
+  if (!result_variable.empty()) {
+    switch (cmsysProcess_GetState(cp)) {
+      case cmsysProcess_State_Exited: {
         int v = cmsysProcess_GetExitValue(cp);
         char buf[100];
         sprintf(buf, "%d", v);
         this->Makefile->AddDefinition(result_variable, buf);
-        }
-        break;
+      } break;
       case cmsysProcess_State_Exception:
         this->Makefile->AddDefinition(result_variable,
-                                  cmsysProcess_GetExceptionString(cp));
+                                      cmsysProcess_GetExceptionString(cp));
         break;
       case cmsysProcess_State_Error:
         this->Makefile->AddDefinition(result_variable,
-                                  cmsysProcess_GetErrorString(cp));
+                                      cmsysProcess_GetErrorString(cp));
         break;
       case cmsysProcess_State_Expired:
         this->Makefile->AddDefinition(result_variable,
-                                  "Process terminated due to timeout");
+                                      "Process terminated due to timeout");
         break;
-      }
     }
+  }
 
   // Delete the process instance.
   cmsysProcess_Delete(cp);
@@ -390,25 +296,22 @@ void cmExecuteProcessCommandFixText(std::vector<char>& output,
   // Remove \0 characters and the \r part of \r\n pairs.
   unsigned int in_index = 0;
   unsigned int out_index = 0;
-  while(in_index < output.size())
-    {
+  while (in_index < output.size()) {
     char c = output[in_index++];
-    if((c != '\r' || !(in_index < output.size() && output[in_index] == '\n'))
-       && c != '\0')
-      {
+    if ((c != '\r' ||
+         !(in_index < output.size() && output[in_index] == '\n')) &&
+        c != '\0') {
       output[out_index++] = c;
-      }
     }
+  }
 
   // Remove trailing whitespace if requested.
-  if(strip_trailing_whitespace)
-    {
-    while(out_index > 0 &&
-          cmExecuteProcessCommandIsWhitespace(output[out_index-1]))
-      {
+  if (strip_trailing_whitespace) {
+    while (out_index > 0 &&
+           cmExecuteProcessCommandIsWhitespace(output[out_index - 1])) {
       --out_index;
-      }
     }
+  }
 
   // Shrink the vector to the size needed.
   output.resize(out_index);
@@ -417,19 +320,18 @@ void cmExecuteProcessCommandFixText(std::vector<char>& output,
   output.push_back('\0');
 }
 
-void cmExecuteProcessCommandAppend(std::vector<char>& output,
-                                   const char* data, int length)
+void cmExecuteProcessCommandAppend(std::vector<char>& output, const char* data,
+                                   int length)
 {
 #if defined(__APPLE__)
   // HACK on Apple to work around bug with inserting at the
   // end of an empty vector.  This resulted in random failures
   // that were hard to reproduce.
-  if(output.empty() && length > 0)
-    {
+  if (output.empty() && length > 0) {
     output.push_back(data[0]);
     ++data;
     --length;
-    }
+  }
 #endif
-  output.insert(output.end(), data, data+length);
+  output.insert(output.end(), data, data + length);
 }
diff --git a/Source/cmExecuteProcessCommand.h b/Source/cmExecuteProcessCommand.h
index 6906a08..a89e705 100644
--- a/Source/cmExecuteProcessCommand.h
+++ b/Source/cmExecuteProcessCommand.h
@@ -26,23 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmExecuteProcessCommand;
-    }
+  virtual cmCommand* Clone() { return new cmExecuteProcessCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const
-    {return "execute_process";}
+  virtual std::string GetName() const { return "execute_process"; }
 
   /**
    * This determines if the command is invoked when in script mode.
diff --git a/Source/cmExecutionStatus.h b/Source/cmExecutionStatus.h
index 201465d..508c6bd 100644
--- a/Source/cmExecutionStatus.h
+++ b/Source/cmExecutionStatus.h
@@ -24,28 +24,22 @@ class cmExecutionStatus
 public:
   cmExecutionStatus() { this->Clear(); }
 
-  void SetReturnInvoked(bool val)
-  { this->ReturnInvoked = val; }
-  bool GetReturnInvoked()
-  { return this->ReturnInvoked; }
+  void SetReturnInvoked(bool val) { this->ReturnInvoked = val; }
+  bool GetReturnInvoked() { return this->ReturnInvoked; }
 
-  void SetBreakInvoked(bool val)
-  { this->BreakInvoked = val; }
-  bool GetBreakInvoked()
-  { return this->BreakInvoked; }
+  void SetBreakInvoked(bool val) { this->BreakInvoked = val; }
+  bool GetBreakInvoked() { return this->BreakInvoked; }
 
-  void SetContinueInvoked(bool val)
-  { this->ContinueInvoked = val; }
-  bool GetContinueInvoked()
-  { return this->ContinueInvoked; }
+  void SetContinueInvoked(bool val) { this->ContinueInvoked = val; }
+  bool GetContinueInvoked() { return this->ContinueInvoked; }
 
   void Clear()
-    {
+  {
     this->ReturnInvoked = false;
     this->BreakInvoked = false;
     this->ContinueInvoked = false;
     this->NestedError = false;
-    }
+  }
   void SetNestedError(bool val) { this->NestedError = val; }
   bool GetNestedError() { return this->NestedError; }
 
diff --git a/Source/cmExpandedCommandArgument.cxx b/Source/cmExpandedCommandArgument.cxx
index 4477cf5..df7fba1 100644
--- a/Source/cmExpandedCommandArgument.cxx
+++ b/Source/cmExpandedCommandArgument.cxx
@@ -12,17 +12,16 @@
 
 #include "cmExpandedCommandArgument.h"
 
-cmExpandedCommandArgument::cmExpandedCommandArgument():
-  Quoted(false)
+cmExpandedCommandArgument::cmExpandedCommandArgument()
+  : Quoted(false)
 {
-
 }
 
-cmExpandedCommandArgument::cmExpandedCommandArgument(
-  std::string const& value, bool quoted):
-    Value(value), Quoted(quoted)
+cmExpandedCommandArgument::cmExpandedCommandArgument(std::string const& value,
+                                                     bool quoted)
+  : Value(value)
+  , Quoted(quoted)
 {
-
 }
 
 std::string const& cmExpandedCommandArgument::GetValue() const
@@ -35,7 +34,7 @@ bool cmExpandedCommandArgument::WasQuoted() const
   return this->Quoted;
 }
 
-bool cmExpandedCommandArgument::operator== (std::string const& value) const
+bool cmExpandedCommandArgument::operator==(std::string const& value) const
 {
   return this->Value == value;
 }
diff --git a/Source/cmExpandedCommandArgument.h b/Source/cmExpandedCommandArgument.h
index f4e1517..1f8e405 100644
--- a/Source/cmExpandedCommandArgument.h
+++ b/Source/cmExpandedCommandArgument.h
@@ -31,7 +31,7 @@ public:
 
   bool WasQuoted() const;
 
-  bool operator== (std::string const& value) const;
+  bool operator==(std::string const& value) const;
 
   bool empty() const;
 
diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx
index c1fa54b..8ca7a11 100644
--- a/Source/cmExportBuildFileGenerator.cxx
+++ b/Source/cmExportBuildFileGenerator.cxx
@@ -25,56 +25,47 @@ cmExportBuildFileGenerator::cmExportBuildFileGenerator()
 void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg)
 {
   this->LG = lg;
-  if (this->ExportSet)
-    {
+  if (this->ExportSet) {
     this->ExportSet->Compute(lg);
-    }
+  }
 }
 
 bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
 {
   {
-  std::string expectedTargets;
-  std::string sep;
-  std::vector<std::string> targets;
-  this->GetTargets(targets);
-  for(std::vector<std::string>::const_iterator
-        tei = targets.begin();
-      tei != targets.end(); ++tei)
-    {
-    cmGeneratorTarget *te = this->LG
-                                ->FindGeneratorTargetToUse(*tei);
-    expectedTargets += sep + this->Namespace + te->GetExportName();
-    sep = " ";
-    if(this->ExportedTargets.insert(te).second)
-      {
-      this->Exports.push_back(te);
-      }
-    else
-      {
-      std::ostringstream e;
-      e << "given target \"" << te->GetName() << "\" more than once.";
-      this->LG->GetGlobalGenerator()->GetCMakeInstance()
-          ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                         this->LG->GetMakefile()->GetBacktrace());
-      return false;
+    std::string expectedTargets;
+    std::string sep;
+    std::vector<std::string> targets;
+    this->GetTargets(targets);
+    for (std::vector<std::string>::const_iterator tei = targets.begin();
+         tei != targets.end(); ++tei) {
+      cmGeneratorTarget* te = this->LG->FindGeneratorTargetToUse(*tei);
+      expectedTargets += sep + this->Namespace + te->GetExportName();
+      sep = " ";
+      if (this->ExportedTargets.insert(te).second) {
+        this->Exports.push_back(te);
+      } else {
+        std::ostringstream e;
+        e << "given target \"" << te->GetName() << "\" more than once.";
+        this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+          cmake::FATAL_ERROR, e.str(),
+          this->LG->GetMakefile()->GetBacktrace());
+        return false;
       }
-    if (te->GetType() == cmState::INTERFACE_LIBRARY)
-      {
-      this->GenerateRequiredCMakeVersion(os, "3.0.0");
+      if (te->GetType() == cmState::INTERFACE_LIBRARY) {
+        this->GenerateRequiredCMakeVersion(os, "3.0.0");
       }
     }
 
-  this->GenerateExpectedTargetsCode(os, expectedTargets);
+    this->GenerateExpectedTargetsCode(os, expectedTargets);
   }
 
   std::vector<std::string> missingTargets;
 
   // Create all the imported targets.
-  for(std::vector<cmGeneratorTarget*>::const_iterator
-        tei = this->Exports.begin();
-      tei != this->Exports.end(); ++tei)
-    {
+  for (std::vector<cmGeneratorTarget*>::const_iterator tei =
+         this->Exports.begin();
+       tei != this->Exports.end(); ++tei) {
     cmGeneratorTarget* gte = *tei;
     this->GenerateImportTargetCode(os, gte);
 
@@ -100,67 +91,56 @@ bool cmExportBuildFileGenerator::GenerateMainFile(std::ostream& os)
     this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gte,
                                     cmGeneratorExpression::BuildInterface,
                                     properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
-                                  gte, properties);
+    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gte,
+                                    properties);
     const bool newCMP0022Behavior =
-        gte->GetPolicyStatusCMP0022() != cmPolicies::WARN
-        && gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
-    if (newCMP0022Behavior)
-      {
-      this->PopulateInterfaceLinkLibrariesProperty(gte,
-                                    cmGeneratorExpression::BuildInterface,
-                                    properties, missingTargets);
-      }
+      gte->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+      gte->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+    if (newCMP0022Behavior) {
+      this->PopulateInterfaceLinkLibrariesProperty(
+        gte, cmGeneratorExpression::BuildInterface, properties,
+        missingTargets);
+    }
     this->PopulateCompatibleInterfaceProperties(gte, properties);
 
     this->GenerateInterfaceProperties(gte, os, properties);
-    }
+  }
 
   // Generate import file content for each configuration.
-  for(std::vector<std::string>::const_iterator
-        ci = this->Configurations.begin();
-      ci != this->Configurations.end(); ++ci)
-    {
+  for (std::vector<std::string>::const_iterator ci =
+         this->Configurations.begin();
+       ci != this->Configurations.end(); ++ci) {
     this->GenerateImportConfig(os, *ci, missingTargets);
-    }
+  }
 
   this->GenerateMissingTargetsCheckCode(os, missingTargets);
 
   return true;
 }
 
-void
-cmExportBuildFileGenerator
-::GenerateImportTargetsConfig(std::ostream& os,
-                              const std::string& config,
-                              std::string const& suffix,
-                              std::vector<std::string> &missingTargets)
+void cmExportBuildFileGenerator::GenerateImportTargetsConfig(
+  std::ostream& os, const std::string& config, std::string const& suffix,
+  std::vector<std::string>& missingTargets)
 {
-  for(std::vector<cmGeneratorTarget*>::const_iterator
-        tei = this->Exports.begin();
-      tei != this->Exports.end(); ++tei)
-    {
+  for (std::vector<cmGeneratorTarget*>::const_iterator tei =
+         this->Exports.begin();
+       tei != this->Exports.end(); ++tei) {
     // Collect import properties for this target.
     cmGeneratorTarget* target = *tei;
     ImportPropertyMap properties;
 
-    if (target->GetType() != cmState::INTERFACE_LIBRARY)
-      {
+    if (target->GetType() != cmState::INTERFACE_LIBRARY) {
       this->SetImportLocationProperty(config, suffix, target, properties);
-      }
-    if(!properties.empty())
-      {
+    }
+    if (!properties.empty()) {
       // Get the rest of the target details.
-      if (target->GetType() != cmState::INTERFACE_LIBRARY)
-        {
-        this->SetImportDetailProperties(config, suffix,
-                                        target,
-                                        properties, missingTargets);
+      if (target->GetType() != cmState::INTERFACE_LIBRARY) {
+        this->SetImportDetailProperties(config, suffix, target, properties,
+                                        missingTargets);
         this->SetImportLinkInterface(config, suffix,
                                      cmGeneratorExpression::BuildInterface,
-                                     target,
-                                     properties, missingTargets);
-        }
+                                     target, properties, missingTargets);
+      }
 
       // TOOD: PUBLIC_HEADER_LOCATION
       // This should wait until the build feature propagation stuff
@@ -169,179 +149,148 @@ cmExportBuildFileGenerator
       //                              properties);
 
       // Generate code in the export file.
-      this->GenerateImportPropertyCode(os, config, target,
-                                       properties);
-      }
+      this->GenerateImportPropertyCode(os, config, target, properties);
     }
+  }
 }
 
-void cmExportBuildFileGenerator::SetExportSet(cmExportSet *exportSet)
+void cmExportBuildFileGenerator::SetExportSet(cmExportSet* exportSet)
 {
   this->ExportSet = exportSet;
 }
 
-void
-cmExportBuildFileGenerator
-::SetImportLocationProperty(const std::string& config,
-                            std::string const& suffix,
-                            cmGeneratorTarget* target,
-                            ImportPropertyMap& properties)
+void cmExportBuildFileGenerator::SetImportLocationProperty(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorTarget* target, ImportPropertyMap& properties)
 {
   // Get the makefile in which to lookup target information.
   cmMakefile* mf = target->Makefile;
 
   // Add the main target file.
   {
-  std::string prop = "IMPORTED_LOCATION";
-  prop += suffix;
-  std::string value;
-  if(target->IsAppBundleOnApple())
-    {
-    value = target->GetFullPath(config, false);
-    }
-  else
-    {
-    value = target->GetFullPath(config, false, true);
+    std::string prop = "IMPORTED_LOCATION";
+    prop += suffix;
+    std::string value;
+    if (target->IsAppBundleOnApple()) {
+      value = target->GetFullPath(config, false);
+    } else {
+      value = target->GetFullPath(config, false, true);
     }
-  properties[prop] = value;
+    properties[prop] = value;
   }
 
   // Add the import library for windows DLLs.
-  if(target->IsDLLPlatform() &&
-     (target->GetType() == cmState::SHARED_LIBRARY ||
-      target->IsExecutableWithExports()) &&
-     mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"))
-    {
+  if (target->IsDLLPlatform() &&
+      (target->GetType() == cmState::SHARED_LIBRARY ||
+       target->IsExecutableWithExports()) &&
+      mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
     std::string prop = "IMPORTED_IMPLIB";
     prop += suffix;
     std::string value = target->GetFullPath(config, true);
-    target->GetImplibGNUtoMS(value, value,
-                             "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+    target->GetImplibGNUtoMS(value, value, "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
     properties[prop] = value;
-    }
+  }
 }
 
-void
-cmExportBuildFileGenerator::HandleMissingTarget(
-    std::string& link_libs,
-    std::vector<std::string>& missingTargets,
-    cmGeneratorTarget* depender,
-    cmGeneratorTarget* dependee)
+void cmExportBuildFileGenerator::HandleMissingTarget(
+  std::string& link_libs, std::vector<std::string>& missingTargets,
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
 {
   // The target is not in the export.
-  if(!this->AppendMode)
-    {
+  if (!this->AppendMode) {
     const std::string name = dependee->GetName();
     cmGlobalGenerator* gg =
-        dependee->GetLocalGenerator()->GetGlobalGenerator();
+      dependee->GetLocalGenerator()->GetGlobalGenerator();
     std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
 
     int targetOccurrences = (int)namespaces.size();
-    if (targetOccurrences == 1)
-      {
+    if (targetOccurrences == 1) {
       std::string missingTarget = namespaces[0];
 
       missingTarget += dependee->GetExportName();
       link_libs += missingTarget;
       missingTargets.push_back(missingTarget);
       return;
-      }
-    else
-      {
+    } else {
       // We are not appending, so all exported targets should be
       // known here.  This is probably user-error.
       this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
-      }
     }
+  }
   // Assume the target will be exported by another command.
   // Append it with the export namespace.
   link_libs += this->Namespace;
   link_libs += dependee->GetExportName();
 }
 
-void cmExportBuildFileGenerator
-::GetTargets(std::vector<std::string> &targets) const
+void cmExportBuildFileGenerator::GetTargets(
+  std::vector<std::string>& targets) const
 {
-  if (this->ExportSet)
-    {
-    for(std::vector<cmTargetExport*>::const_iterator
-          tei = this->ExportSet->GetTargetExports()->begin();
-          tei != this->ExportSet->GetTargetExports()->end(); ++tei)
-      {
+  if (this->ExportSet) {
+    for (std::vector<cmTargetExport*>::const_iterator tei =
+           this->ExportSet->GetTargetExports()->begin();
+         tei != this->ExportSet->GetTargetExports()->end(); ++tei) {
       targets.push_back((*tei)->TargetName);
-      }
-    return;
     }
+    return;
+  }
   targets = this->Targets;
 }
 
-std::vector<std::string>
-cmExportBuildFileGenerator
-::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
+std::vector<std::string> cmExportBuildFileGenerator::FindNamespaces(
+  cmGlobalGenerator* gg, const std::string& name)
 {
   std::vector<std::string> namespaces;
 
-  std::map<std::string, cmExportBuildFileGenerator*>& exportSets
-                                                  = gg->GetBuildExportSets();
+  std::map<std::string, cmExportBuildFileGenerator*>& exportSets =
+    gg->GetBuildExportSets();
 
-  for(std::map<std::string, cmExportBuildFileGenerator*>::const_iterator
-      expIt = exportSets.begin(); expIt != exportSets.end(); ++expIt)
-    {
+  for (std::map<std::string, cmExportBuildFileGenerator*>::const_iterator
+         expIt = exportSets.begin();
+       expIt != exportSets.end(); ++expIt) {
     const cmExportBuildFileGenerator* exportSet = expIt->second;
     std::vector<std::string> targets;
     exportSet->GetTargets(targets);
-    if (std::find(targets.begin(), targets.end(), name) != targets.end())
-      {
+    if (std::find(targets.begin(), targets.end(), name) != targets.end()) {
       namespaces.push_back(exportSet->GetNamespace());
-      }
     }
+  }
 
   return namespaces;
 }
 
-void
-cmExportBuildFileGenerator
-::ComplainAboutMissingTarget(cmGeneratorTarget* depender,
-                             cmGeneratorTarget* dependee,
-                             int occurrences)
+void cmExportBuildFileGenerator::ComplainAboutMissingTarget(
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee, int occurrences)
 {
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return;
-    }
+  }
 
   std::ostringstream e;
   e << "export called with target \"" << depender->GetName()
     << "\" which requires target \"" << dependee->GetName() << "\" ";
-  if (occurrences == 0)
-    {
+  if (occurrences == 0) {
     e << "that is not in the export set.\n";
-    }
-  else
-    {
+  } else {
     e << "that is not in this export set, but " << occurrences
-    << " times in others.\n";
-    }
+      << " times in others.\n";
+  }
   e << "If the required target is not easy to reference in this call, "
     << "consider using the APPEND option with multiple separate calls.";
 
-  this->LG->GetGlobalGenerator()->GetCMakeInstance()
-      ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                     this->LG->GetMakefile()->GetBacktrace());
+  this->LG->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+    cmake::FATAL_ERROR, e.str(), this->LG->GetMakefile()->GetBacktrace());
 }
 
-std::string
-cmExportBuildFileGenerator::InstallNameDir(cmGeneratorTarget* target,
-                                           const std::string& config)
+std::string cmExportBuildFileGenerator::InstallNameDir(
+  cmGeneratorTarget* target, const std::string& config)
 {
   std::string install_name_dir;
 
   cmMakefile* mf = target->Target->GetMakefile();
-  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
-    install_name_dir =
-      target->GetInstallNameDirForBuildTree(config);
-    }
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    install_name_dir = target->GetInstallNameDirForBuildTree(config);
+  }
 
   return install_name_dir;
 }
diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h
index 85aae2f..be3c70a 100644
--- a/Source/cmExportBuildFileGenerator.h
+++ b/Source/cmExportBuildFileGenerator.h
@@ -26,18 +26,21 @@ class cmExportSet;
  *
  * This is used to implement the EXPORT() command.
  */
-class cmExportBuildFileGenerator: public cmExportFileGenerator
+class cmExportBuildFileGenerator : public cmExportFileGenerator
 {
 public:
   cmExportBuildFileGenerator();
 
   /** Set the list of targets to export.  */
   void SetTargets(std::vector<std::string> const& targets)
-    { this->Targets = targets; }
-  void GetTargets(std::vector<std::string> &targets) const;
+  {
+    this->Targets = targets;
+  }
+  void GetTargets(std::vector<std::string>& targets) const;
   void AppendTargets(std::vector<std::string> const& targets)
-    { this->Targets.insert(this->Targets.end(),
-      targets.begin(), targets.end()); }
+  {
+    this->Targets.insert(this->Targets.end(), targets.begin(), targets.end());
+  }
   void SetExportSet(cmExportSet*);
 
   /** Set whether to append generated code to the output file.  */
@@ -48,10 +51,9 @@ public:
 protected:
   // Implement virtual methods from the superclass.
   virtual bool GenerateMainFile(std::ostream& os);
-  virtual void GenerateImportTargetsConfig(std::ostream& os,
-                                           const std::string& config,
-                                           std::string const& suffix,
-                            std::vector<std::string> &missingTargets);
+  virtual void GenerateImportTargetsConfig(
+    std::ostream& os, const std::string& config, std::string const& suffix,
+    std::vector<std::string>& missingTargets);
   virtual void HandleMissingTarget(std::string& link_libs,
                                    std::vector<std::string>& missingTargets,
                                    cmGeneratorTarget* depender,
@@ -70,11 +72,11 @@ protected:
   std::string InstallNameDir(cmGeneratorTarget* target,
                              const std::string& config);
 
-  std::vector<std::string>
-  FindNamespaces(cmGlobalGenerator* gg, const std::string& name);
+  std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
+                                          const std::string& name);
 
   std::vector<std::string> Targets;
-  cmExportSet *ExportSet;
+  cmExportSet* ExportSet;
   std::vector<cmGeneratorTarget*> Exports;
   cmLocalGenerator* LG;
 };
diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx
index ee8865e..a0e7e45 100644
--- a/Source/cmExportCommand.cxx
+++ b/Source/cmExportCommand.cxx
@@ -26,226 +26,184 @@
 #endif
 
 cmExportCommand::cmExportCommand()
-:cmCommand()
-,ArgumentGroup()
-,Targets(&Helper, "TARGETS")
-,Append(&Helper, "APPEND", &ArgumentGroup)
-,ExportSetName(&Helper, "EXPORT", &ArgumentGroup)
-,Namespace(&Helper, "NAMESPACE", &ArgumentGroup)
-,Filename(&Helper, "FILE", &ArgumentGroup)
-,ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup)
+  : cmCommand()
+  , ArgumentGroup()
+  , Targets(&Helper, "TARGETS")
+  , Append(&Helper, "APPEND", &ArgumentGroup)
+  , ExportSetName(&Helper, "EXPORT", &ArgumentGroup)
+  , Namespace(&Helper, "NAMESPACE", &ArgumentGroup)
+  , Filename(&Helper, "FILE", &ArgumentGroup)
+  , ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup)
 {
   this->ExportSet = 0;
 }
 
-
 // cmExportCommand
-bool cmExportCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
+                                  cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with too few arguments");
     return false;
-    }
+  }
 
-  if(args[0] == "PACKAGE")
-    {
+  if (args[0] == "PACKAGE") {
     return this->HandlePackage(args);
-    }
-  else if (args[0] == "EXPORT")
-    {
+  } else if (args[0] == "EXPORT") {
     this->ExportSetName.Follows(0);
     this->ArgumentGroup.Follows(&this->ExportSetName);
-    }
-  else
-    {
+  } else {
     this->Targets.Follows(0);
     this->ArgumentGroup.Follows(&this->Targets);
-    }
+  }
 
   std::vector<std::string> unknownArgs;
   this->Helper.Parse(&args, &unknownArgs);
 
-  if (!unknownArgs.empty())
-    {
+  if (!unknownArgs.empty()) {
     this->SetError("Unknown arguments.");
     return false;
-    }
+  }
 
   std::string fname;
-  if(!this->Filename.WasFound())
-    {
-    if (args[0] != "EXPORT")
-      {
+  if (!this->Filename.WasFound()) {
+    if (args[0] != "EXPORT") {
       this->SetError("FILE <filename> option missing.");
       return false;
-      }
-    fname = this->ExportSetName.GetString() + ".cmake";
     }
-  else
-    {
+    fname = this->ExportSetName.GetString() + ".cmake";
+  } else {
     // Make sure the file has a .cmake extension.
-    if(cmSystemTools::GetFilenameLastExtension(this->Filename.GetCString())
-      != ".cmake")
-      {
+    if (cmSystemTools::GetFilenameLastExtension(this->Filename.GetCString()) !=
+        ".cmake") {
       std::ostringstream e;
       e << "FILE option given filename \"" << this->Filename.GetString()
         << "\" which does not have an extension of \".cmake\".\n";
       this->SetError(e.str());
       return false;
-      }
-    fname = this->Filename.GetString();
     }
+    fname = this->Filename.GetString();
+  }
 
   // Get the file to write.
-  if(cmSystemTools::FileIsFullPath(fname.c_str()))
-    {
-    if(!this->Makefile->CanIWriteThisFile(fname.c_str()))
-      {
+  if (cmSystemTools::FileIsFullPath(fname.c_str())) {
+    if (!this->Makefile->CanIWriteThisFile(fname.c_str())) {
       std::ostringstream e;
       e << "FILE option given filename \"" << fname
         << "\" which is in the source tree.\n";
       this->SetError(e.str());
       return false;
-      }
     }
-  else
-    {
+  } else {
     // Interpret relative paths with respect to the current build dir.
     std::string dir = this->Makefile->GetCurrentBinaryDirectory();
     fname = dir + "/" + fname;
-    }
+  }
 
   std::vector<std::string> targets;
 
-  cmGlobalGenerator *gg = this->Makefile->GetGlobalGenerator();
+  cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
 
-  if(args[0] == "EXPORT")
-    {
-    if (this->Append.IsEnabled())
-      {
+  if (args[0] == "EXPORT") {
+    if (this->Append.IsEnabled()) {
       std::ostringstream e;
       e << "EXPORT signature does not recognise the APPEND option.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    if (this->ExportOld.IsEnabled())
-      {
+    if (this->ExportOld.IsEnabled()) {
       std::ostringstream e;
       e << "EXPORT signature does not recognise the "
-        "EXPORT_LINK_INTERFACE_LIBRARIES option.";
+           "EXPORT_LINK_INTERFACE_LIBRARIES option.";
       this->SetError(e.str());
       return false;
-      }
+    }
 
-    cmExportSetMap &setMap = gg->GetExportSets();
+    cmExportSetMap& setMap = gg->GetExportSets();
     std::string setName = this->ExportSetName.GetString();
-    if (setMap.find(setName) == setMap.end())
-      {
+    if (setMap.find(setName) == setMap.end()) {
       std::ostringstream e;
       e << "Export set \"" << setName << "\" not found.";
       this->SetError(e.str());
       return false;
-      }
-    this->ExportSet = setMap[setName];
     }
-  else if (this->Targets.WasFound())
-    {
-    for(std::vector<std::string>::const_iterator
-        currentTarget = this->Targets.GetVector().begin();
-        currentTarget != this->Targets.GetVector().end();
-        ++currentTarget)
-      {
-      if (this->Makefile->IsAlias(*currentTarget))
-        {
+    this->ExportSet = setMap[setName];
+  } else if (this->Targets.WasFound()) {
+    for (std::vector<std::string>::const_iterator currentTarget =
+           this->Targets.GetVector().begin();
+         currentTarget != this->Targets.GetVector().end(); ++currentTarget) {
+      if (this->Makefile->IsAlias(*currentTarget)) {
         std::ostringstream e;
         e << "given ALIAS target \"" << *currentTarget
           << "\" which may not be exported.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
-      if(cmTarget* target = gg->FindTarget(*currentTarget))
-        {
-        if(target->GetType() == cmState::OBJECT_LIBRARY)
-          {
+      if (cmTarget* target = gg->FindTarget(*currentTarget)) {
+        if (target->GetType() == cmState::OBJECT_LIBRARY) {
           std::ostringstream e;
           e << "given OBJECT library \"" << *currentTarget
             << "\" which may not be exported.";
           this->SetError(e.str());
           return false;
-          }
-        if (target->GetType() == cmState::UTILITY)
-          {
-          this->SetError("given custom target \"" + *currentTarget
-                         + "\" which may not be exported.");
+        }
+        if (target->GetType() == cmState::UTILITY) {
+          this->SetError("given custom target \"" + *currentTarget +
+                         "\" which may not be exported.");
           return false;
-          }
         }
-      else
-        {
+      } else {
         std::ostringstream e;
         e << "given target \"" << *currentTarget
           << "\" which is not built by this project.";
         this->SetError(e.str());
         return false;
-        }
-      targets.push_back(*currentTarget);
       }
-    if (this->Append.IsEnabled())
-      {
-      if (cmExportBuildFileGenerator *ebfg = gg->GetExportedTargetsFile(fname))
-        {
+      targets.push_back(*currentTarget);
+    }
+    if (this->Append.IsEnabled()) {
+      if (cmExportBuildFileGenerator* ebfg =
+            gg->GetExportedTargetsFile(fname)) {
         ebfg->AppendTargets(targets);
         return true;
-        }
       }
     }
-  else
-    {
+  } else {
     this->SetError("EXPORT or TARGETS specifier missing.");
     return false;
-    }
+  }
 
   // Setup export file generation.
-  cmExportBuildFileGenerator *ebfg = new cmExportBuildFileGenerator;
+  cmExportBuildFileGenerator* ebfg = new cmExportBuildFileGenerator;
   ebfg->SetExportFile(fname.c_str());
   ebfg->SetNamespace(this->Namespace.GetCString());
   ebfg->SetAppendMode(this->Append.IsEnabled());
-  if (this->ExportSet)
-    {
+  if (this->ExportSet) {
     ebfg->SetExportSet(this->ExportSet);
-    }
-  else
-    {
+  } else {
     ebfg->SetTargets(targets);
-    }
+  }
   this->Makefile->AddExportBuildFileGenerator(ebfg);
   ebfg->SetExportOld(this->ExportOld.IsEnabled());
 
   // Compute the set of configurations exported.
   std::vector<std::string> configurationTypes;
   this->Makefile->GetConfigurations(configurationTypes);
-  if(configurationTypes.empty())
-    {
+  if (configurationTypes.empty()) {
     configurationTypes.push_back("");
-    }
-  for(std::vector<std::string>::const_iterator
-        ci = configurationTypes.begin();
-      ci != configurationTypes.end(); ++ci)
-    {
+  }
+  for (std::vector<std::string>::const_iterator ci =
+         configurationTypes.begin();
+       ci != configurationTypes.end(); ++ci) {
     ebfg->AddConfiguration(*ci);
-    }
-  if (this->ExportSet)
-    {
+  }
+  if (this->ExportSet) {
     gg->AddBuildExportExportSet(ebfg);
-    }
-  else
-    {
+  } else {
     gg->AddBuildExportSet(ebfg);
-    }
+  }
 
   return true;
 }
@@ -253,48 +211,45 @@ bool cmExportCommand
 bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
 {
   // Parse PACKAGE mode arguments.
-  enum Doing { DoingNone, DoingPackage };
+  enum Doing
+  {
+    DoingNone,
+    DoingPackage
+  };
   Doing doing = DoingPackage;
   std::string package;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(doing == DoingPackage)
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (doing == DoingPackage) {
       package = args[i];
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "PACKAGE given unknown argument: " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Verify the package name.
-  if(package.empty())
-    {
+  if (package.empty()) {
     this->SetError("PACKAGE must be given a package name.");
     return false;
-    }
+  }
   const char* packageExpr = "^[A-Za-z0-9_.-]+$";
   cmsys::RegularExpression packageRegex(packageExpr);
-  if(!packageRegex.find(package.c_str()))
-    {
+  if (!packageRegex.find(package.c_str())) {
     std::ostringstream e;
     e << "PACKAGE given invalid package name \"" << package << "\".  "
       << "Package names must match \"" << packageExpr << "\".";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // If the CMAKE_EXPORT_NO_PACKAGE_REGISTRY variable is set the command
   // export(PACKAGE) does nothing.
-  if(this->Makefile->IsOn("CMAKE_EXPORT_NO_PACKAGE_REGISTRY"))
-    {
+  if (this->Makefile->IsOn("CMAKE_EXPORT_NO_PACKAGE_REGISTRY")) {
     return true;
-    }
+  }
 
   // We store the current build directory in the registry as a value
   // named by a hash of its own content.  This is deterministic and is
@@ -311,24 +266,21 @@ bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
 }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-# include <windows.h>
-# undef GetCurrentDirectory
+#include <windows.h>
+#undef GetCurrentDirectory
 void cmExportCommand::ReportRegistryError(std::string const& msg,
-                                          std::string const& key,
-                                          long err)
+                                          std::string const& key, long err)
 {
   std::ostringstream e;
   e << msg << "\n"
     << "  HKEY_CURRENT_USER\\" << key << "\n";
   wchar_t winmsg[1024];
-  if(FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
-                   FORMAT_MESSAGE_IGNORE_INSERTS, 0, err,
-                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                   winmsg, 1024, 0) > 0)
-    {
+  if (FormatMessageW(
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), winmsg, 1024, 0) > 0) {
     e << "Windows reported:\n"
       << "  " << cmsys::Encoding::ToNarrow(winmsg);
-    }
+  }
   this->Makefile->IssueMessage(cmake::WARNING, e.str());
 }
 
@@ -339,29 +291,26 @@ void cmExportCommand::StorePackageRegistryWin(std::string const& package,
   std::string key = "Software\\Kitware\\CMake\\Packages\\";
   key += package;
   HKEY hKey;
-  LONG err = RegCreateKeyExW(HKEY_CURRENT_USER,
-                            cmsys::Encoding::ToWide(key).c_str(),
-                            0, 0, REG_OPTION_NON_VOLATILE,
-                            KEY_SET_VALUE, 0, &hKey, 0);
-  if(err != ERROR_SUCCESS)
-    {
-    this->ReportRegistryError(
-      "Cannot create/open registry key", key, err);
+  LONG err =
+    RegCreateKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(key).c_str(), 0,
+                    0, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, 0, &hKey, 0);
+  if (err != ERROR_SUCCESS) {
+    this->ReportRegistryError("Cannot create/open registry key", key, err);
     return;
-    }
+  }
 
   std::wstring wcontent = cmsys::Encoding::ToWide(content);
-  err = RegSetValueExW(hKey, cmsys::Encoding::ToWide(hash).c_str(),
-                       0, REG_SZ, (BYTE const*)wcontent.c_str(),
-                       static_cast<DWORD>(wcontent.size()+1)*sizeof(wchar_t));
+  err =
+    RegSetValueExW(hKey, cmsys::Encoding::ToWide(hash).c_str(), 0, REG_SZ,
+                   (BYTE const*)wcontent.c_str(),
+                   static_cast<DWORD>(wcontent.size() + 1) * sizeof(wchar_t));
   RegCloseKey(hKey);
-  if(err != ERROR_SUCCESS)
-    {
+  if (err != ERROR_SUCCESS) {
     std::ostringstream msg;
     msg << "Cannot set registry value \"" << hash << "\" under key";
     this->ReportRegistryError(msg.str(), key, err);
     return;
-    }
+  }
 }
 #else
 void cmExportCommand::StorePackageRegistryDir(std::string const& package,
@@ -371,19 +320,17 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
 #if defined(__HAIKU__)
   char dir[B_PATH_NAME_LENGTH];
   if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) !=
-      B_OK)
-    {
+      B_OK) {
     return;
-    }
+  }
   std::string fname = dir;
   fname += "/cmake/packages/";
   fname += package;
 #else
   const char* home = cmSystemTools::GetEnv("HOME");
-  if(!home)
-    {
+  if (!home) {
     return;
-    }
+  }
   std::string fname = home;
   cmSystemTools::ConvertToUnixSlashes(fname);
   fname += "/.cmake/packages/";
@@ -392,15 +339,11 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
   cmSystemTools::MakeDirectory(fname.c_str());
   fname += "/";
   fname += hash;
-  if(!cmSystemTools::FileExists(fname.c_str()))
-    {
+  if (!cmSystemTools::FileExists(fname.c_str())) {
     cmGeneratedFileStream entry(fname.c_str(), true);
-    if(entry)
-      {
+    if (entry) {
       entry << content << "\n";
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       /* clang-format off */
       e << "Cannot create package registry file:\n"
@@ -408,7 +351,7 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
         << cmSystemTools::GetLastSystemError() << "\n";
       /* clang-format on */
       this->Makefile->IssueMessage(cmake::WARNING, e.str());
-      }
     }
+  }
 }
 #endif
diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h
index f9506bb..a71393a 100644
--- a/Source/cmExportCommand.h
+++ b/Source/cmExportCommand.h
@@ -30,22 +30,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmExportCommand;
-    }
+  virtual cmCommand* Clone() { return new cmExportCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "export";}
+  virtual std::string GetName() const { return "export"; }
 
   cmTypeMacro(cmExportCommand, cmCommand);
 
@@ -58,19 +55,18 @@ private:
   cmCAString Filename;
   cmCAEnabler ExportOld;
 
-  cmExportSet *ExportSet;
+  cmExportSet* ExportSet;
 
   friend class cmExportBuildFileGenerator;
   std::string ErrorMessage;
 
   bool HandlePackage(std::vector<std::string> const& args);
-  void StorePackageRegistryWin(std::string const& package,
-                               const char* content, const char* hash);
-  void StorePackageRegistryDir(std::string const& package,
-                               const char* content, const char* hash);
+  void StorePackageRegistryWin(std::string const& package, const char* content,
+                               const char* hash);
+  void StorePackageRegistryDir(std::string const& package, const char* content,
+                               const char* hash);
   void ReportRegistryError(std::string const& msg, std::string const& key,
                            long err);
 };
 
-
 #endif
diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
index 5aa466d..2d645da 100644
--- a/Source/cmExportFileGenerator.cxx
+++ b/Source/cmExportFileGenerator.cxx
@@ -33,11 +33,9 @@ static std::string cmExportFileGeneratorEscape(std::string const& str)
   // Escape a property value for writing into a .cmake file.
   std::string result = cmOutputConverter::EscapeForCMake(str);
   // Un-escape variable references generated by our own export code.
-  cmSystemTools::ReplaceString(result,
-                               "\\${_IMPORT_PREFIX}",
+  cmSystemTools::ReplaceString(result, "\\${_IMPORT_PREFIX}",
                                "${_IMPORT_PREFIX}");
-  cmSystemTools::ReplaceString(result,
-                               "\\${CMAKE_IMPORT_LIBRARY_SUFFIX}",
+  cmSystemTools::ReplaceString(result, "\\${CMAKE_IMPORT_LIBRARY_SUFFIX}",
                                "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
   return result;
 }
@@ -56,8 +54,7 @@ void cmExportFileGenerator::AddConfiguration(const std::string& config)
 void cmExportFileGenerator::SetExportFile(const char* mainFile)
 {
   this->MainImportFile = mainFile;
-  this->FileDir =
-    cmSystemTools::GetFilenamePath(this->MainImportFile);
+  this->FileDir = cmSystemTools::GetFilenamePath(this->MainImportFile);
   this->FileBase =
     cmSystemTools::GetFilenameWithoutLastExtension(this->MainImportFile);
   this->FileExt =
@@ -73,30 +70,25 @@ bool cmExportFileGenerator::GenerateImportFile()
 {
   // Open the output file to generate it.
   cmsys::auto_ptr<cmsys::ofstream> foutPtr;
-  if(this->AppendMode)
-    {
+  if (this->AppendMode) {
     // Open for append.
-    cmsys::auto_ptr<cmsys::ofstream>
-      ap(new cmsys::ofstream(this->MainImportFile.c_str(), std::ios::app));
+    cmsys::auto_ptr<cmsys::ofstream> ap(
+      new cmsys::ofstream(this->MainImportFile.c_str(), std::ios::app));
     foutPtr = ap;
-    }
-  else
-    {
+  } else {
     // Generate atomically and with copy-if-different.
-    cmsys::auto_ptr<cmGeneratedFileStream>
-      ap(new cmGeneratedFileStream(this->MainImportFile.c_str(), true));
+    cmsys::auto_ptr<cmGeneratedFileStream> ap(
+      new cmGeneratedFileStream(this->MainImportFile.c_str(), true));
     ap->SetCopyIfDifferent(true);
     foutPtr = ap;
-    }
-  if(!foutPtr.get() || !*foutPtr)
-    {
+  }
+  if (!foutPtr.get() || !*foutPtr) {
     std::string se = cmSystemTools::GetLastSystemError();
     std::ostringstream e;
-    e << "cannot write to file \"" << this->MainImportFile
-      << "\": " << se;
+    e << "cannot write to file \"" << this->MainImportFile << "\": " << se;
     cmSystemTools::Error(e.str().c_str());
     return false;
-    }
+  }
   std::ostream& os = *foutPtr;
 
   // Protect that file against use with older CMake versions.
@@ -129,68 +121,58 @@ bool cmExportFileGenerator::GenerateImportFile()
   return result;
 }
 
-void cmExportFileGenerator::GenerateImportConfig(std::ostream& os,
-                                    const std::string& config,
-                                    std::vector<std::string> &missingTargets)
+void cmExportFileGenerator::GenerateImportConfig(
+  std::ostream& os, const std::string& config,
+  std::vector<std::string>& missingTargets)
 {
   // Construct the property configuration suffix.
   std::string suffix = "_";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     suffix += cmSystemTools::UpperCase(config);
-    }
-  else
-    {
+  } else {
     suffix += "NOCONFIG";
-    }
+  }
 
   // Generate the per-config target information.
   this->GenerateImportTargetsConfig(os, config, suffix, missingTargets);
 }
 
 void cmExportFileGenerator::PopulateInterfaceProperty(
-                                              const std::string& propName,
-                                              cmGeneratorTarget *target,
-                                              ImportPropertyMap &properties)
+  const std::string& propName, cmGeneratorTarget* target,
+  ImportPropertyMap& properties)
 {
-  const char *input = target->GetProperty(propName);
-  if (input)
-    {
+  const char* input = target->GetProperty(propName);
+  if (input) {
     properties[propName] = input;
-    }
+  }
 }
 
 void cmExportFileGenerator::PopulateInterfaceProperty(
-                      const std::string& propName,
-                      const std::string& outputName,
-                      cmGeneratorTarget *target,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets)
+  const std::string& propName, const std::string& outputName,
+  cmGeneratorTarget* target,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
 {
-  const char *input = target->GetProperty(propName);
-  if (input)
-    {
-    if (!*input)
-      {
+  const char* input = target->GetProperty(propName);
+  if (input) {
+    if (!*input) {
       // Set to empty
       properties[outputName] = "";
       return;
-      }
+    }
 
-    std::string prepro = cmGeneratorExpression::Preprocess(input,
-                                                           preprocessRule);
-    if (!prepro.empty())
-      {
+    std::string prepro =
+      cmGeneratorExpression::Preprocess(input, preprocessRule);
+    if (!prepro.empty()) {
       this->ResolveTargetsInGeneratorExpressions(prepro, target,
                                                  missingTargets);
       properties[outputName] = prepro;
-      }
     }
+  }
 }
 
-void cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream& os,
-                                                    const char *versionString)
+void cmExportFileGenerator::GenerateRequiredCMakeVersion(
+  std::ostream& os, const char* versionString)
 {
   /* clang-format off */
   os << "if(CMAKE_VERSION VERSION_LESS " << versionString << ")\n"
@@ -201,29 +183,24 @@ void cmExportFileGenerator::GenerateRequiredCMakeVersion(std::ostream& os,
 }
 
 bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
-                      cmGeneratorTarget *target,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets)
+  cmGeneratorTarget* target,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
 {
-  if(!target->IsLinkable())
-    {
+  if (!target->IsLinkable()) {
     return false;
-    }
-  const char *input = target->GetProperty("INTERFACE_LINK_LIBRARIES");
-  if (input)
-    {
-    std::string prepro = cmGeneratorExpression::Preprocess(input,
-                                                           preprocessRule);
-    if (!prepro.empty())
-      {
-      this->ResolveTargetsInGeneratorExpressions(prepro, target,
-                                                 missingTargets,
-                                                 ReplaceFreeTargets);
+  }
+  const char* input = target->GetProperty("INTERFACE_LINK_LIBRARIES");
+  if (input) {
+    std::string prepro =
+      cmGeneratorExpression::Preprocess(input, preprocessRule);
+    if (!prepro.empty()) {
+      this->ResolveTargetsInGeneratorExpressions(
+        prepro, target, missingTargets, ReplaceFreeTargets);
       properties["INTERFACE_LINK_LIBRARIES"] = prepro;
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -233,15 +210,14 @@ static bool isSubDirectory(const char* a, const char* b)
           cmSystemTools::IsSubDirectory(a, b));
 }
 
-static bool checkInterfaceDirs(const std::string &prepro,
-                      cmGeneratorTarget *target, const std::string& prop)
+static bool checkInterfaceDirs(const std::string& prepro,
+                               cmGeneratorTarget* target,
+                               const std::string& prop)
 {
   const char* installDir =
-            target->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
-  const char* topSourceDir =
-      target->GetLocalGenerator()->GetSourceDirectory();
-  const char* topBinaryDir =
-      target->GetLocalGenerator()->GetBinaryDirectory();
+    target->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
+  const char* topSourceDir = target->GetLocalGenerator()->GetSourceDirectory();
+  const char* topBinaryDir = target->GetLocalGenerator()->GetBinaryDirectory();
 
   std::vector<std::string> parts;
   cmGeneratorExpression::Split(prepro, parts);
@@ -250,22 +226,17 @@ static bool checkInterfaceDirs(const std::string &prepro,
 
   bool hadFatalError = false;
 
-  for(std::vector<std::string>::iterator li = parts.begin();
-      li != parts.end(); ++li)
-    {
+  for (std::vector<std::string>::iterator li = parts.begin();
+       li != parts.end(); ++li) {
     size_t genexPos = cmGeneratorExpression::Find(*li);
-    if (genexPos == 0)
-      {
+    if (genexPos == 0) {
       continue;
-      }
+    }
     cmake::MessageType messageType = cmake::FATAL_ERROR;
     std::ostringstream e;
-    if (genexPos != std::string::npos)
-      {
-      if (prop == "INTERFACE_INCLUDE_DIRECTORIES")
-        {
-        switch (target->GetPolicyStatusCMP0041())
-          {
+    if (genexPos != std::string::npos) {
+      if (prop == "INTERFACE_INCLUDE_DIRECTORIES") {
+        switch (target->GetPolicyStatusCMP0041()) {
           case cmPolicies::WARN:
             messageType = cmake::WARNING;
             e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0041) << "\n";
@@ -277,30 +248,25 @@ static bool checkInterfaceDirs(const std::string &prepro,
           case cmPolicies::NEW:
             hadFatalError = true;
             break; // Issue fatal message.
-          }
         }
-      else
-        {
+      } else {
         hadFatalError = true;
-        }
       }
-    if (cmHasLiteralPrefix(li->c_str(), "${_IMPORT_PREFIX}"))
-      {
+    }
+    if (cmHasLiteralPrefix(li->c_str(), "${_IMPORT_PREFIX}")) {
       continue;
-      }
-    if (!cmSystemTools::FileIsFullPath(li->c_str()))
-      {
+    }
+    if (!cmSystemTools::FileIsFullPath(li->c_str())) {
       /* clang-format off */
       e << "Target \"" << target->GetName() << "\" " << prop <<
            " property contains relative path:\n"
            "  \"" << *li << "\"";
       /* clang-format on */
       target->GetLocalGenerator()->IssueMessage(messageType, e.str());
-      }
+    }
     bool inBinary = isSubDirectory(li->c_str(), topBinaryDir);
     bool inSource = isSubDirectory(li->c_str(), topSourceDir);
-    if (isSubDirectory(li->c_str(), installDir))
-      {
+    if (isSubDirectory(li->c_str(), installDir)) {
       // The include directory is inside the install tree.  If the
       // install tree is not inside the source tree or build tree then
       // fall through to the checks below that the include directory is not
@@ -309,26 +275,25 @@ static bool checkInterfaceDirs(const std::string &prepro,
         (!inBinary || isSubDirectory(installDir, topBinaryDir)) &&
         (!inSource || isSubDirectory(installDir, topSourceDir));
 
-      if (prop == "INTERFACE_INCLUDE_DIRECTORIES")
-        {
-        if (!shouldContinue)
-          {
-          switch(target->GetPolicyStatusCMP0052())
-            {
-            case cmPolicies::WARN:
-              {
+      if (prop == "INTERFACE_INCLUDE_DIRECTORIES") {
+        if (!shouldContinue) {
+          switch (target->GetPolicyStatusCMP0052()) {
+            case cmPolicies::WARN: {
               std::ostringstream s;
               s << cmPolicies::GetPolicyWarning(cmPolicies::CMP0052) << "\n";
-              s << "Directory:\n    \"" << *li << "\"\nin "
-                "INTERFACE_INCLUDE_DIRECTORIES of target \""
+              s << "Directory:\n    \"" << *li
+                << "\"\nin "
+                   "INTERFACE_INCLUDE_DIRECTORIES of target \""
                 << target->GetName() << "\" is a subdirectory of the install "
-                "directory:\n    \"" << installDir << "\"\nhowever it is also "
-                "a subdirectory of the " << (inBinary ? "build" : "source")
-                << " tree:\n    \"" << (inBinary ? topBinaryDir : topSourceDir)
-                << "\"" << std::endl;
+                                        "directory:\n    \""
+                << installDir << "\"\nhowever it is also "
+                                 "a subdirectory of the "
+                << (inBinary ? "build" : "source") << " tree:\n    \""
+                << (inBinary ? topBinaryDir : topSourceDir) << "\""
+                << std::endl;
               target->GetLocalGenerator()->IssueMessage(cmake::AUTHOR_WARNING,
-                                                  s.str());
-              }
+                                                        s.str());
+            }
             case cmPolicies::OLD:
               shouldContinue = true;
               break;
@@ -336,242 +301,207 @@ static bool checkInterfaceDirs(const std::string &prepro,
             case cmPolicies::REQUIRED_IF_USED:
             case cmPolicies::NEW:
               break;
-            }
           }
         }
-      if (shouldContinue)
-        {
+      }
+      if (shouldContinue) {
         continue;
-        }
       }
-    if (inBinary)
-      {
+    }
+    if (inBinary) {
       /* clang-format off */
       e << "Target \"" << target->GetName() << "\" " << prop <<
            " property contains path:\n"
            "  \"" << *li << "\"\nwhich is prefixed in the build directory.";
       /* clang-format on */
       target->GetLocalGenerator()->IssueMessage(messageType, e.str());
-      }
-    if (!inSourceBuild)
-      {
-      if (inSource)
-        {
-        e << "Target \"" << target->GetName() << "\" " << prop <<
-            " property contains path:\n"
-            "  \"" << *li << "\"\nwhich is prefixed in the source directory.";
+    }
+    if (!inSourceBuild) {
+      if (inSource) {
+        e << "Target \"" << target->GetName() << "\" " << prop
+          << " property contains path:\n"
+             "  \""
+          << *li << "\"\nwhich is prefixed in the source directory.";
         target->GetLocalGenerator()->IssueMessage(messageType, e.str());
-        }
       }
     }
+  }
   return !hadFatalError;
 }
 
-static void prefixItems(std::string &exportDirs)
+static void prefixItems(std::string& exportDirs)
 {
   std::vector<std::string> entries;
   cmGeneratorExpression::Split(exportDirs, entries);
   exportDirs = "";
-  const char *sep = "";
-  for(std::vector<std::string>::const_iterator ei = entries.begin();
-      ei != entries.end(); ++ei)
-    {
+  const char* sep = "";
+  for (std::vector<std::string>::const_iterator ei = entries.begin();
+       ei != entries.end(); ++ei) {
     exportDirs += sep;
     sep = ";";
-    if (!cmSystemTools::FileIsFullPath(ei->c_str())
-        && ei->find("${_IMPORT_PREFIX}") == std::string::npos)
-      {
+    if (!cmSystemTools::FileIsFullPath(ei->c_str()) &&
+        ei->find("${_IMPORT_PREFIX}") == std::string::npos) {
       exportDirs += "${_IMPORT_PREFIX}/";
-      }
-    exportDirs += *ei;
     }
+    exportDirs += *ei;
+  }
 }
 
 void cmExportFileGenerator::PopulateSourcesInterface(
-                      cmTargetExport *tei,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets)
+  cmTargetExport* tei, cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
 {
   cmGeneratorTarget* gt = tei->Target;
   assert(preprocessRule == cmGeneratorExpression::InstallInterface);
 
-  const char *propName = "INTERFACE_SOURCES";
-  const char *input = gt->GetProperty(propName);
+  const char* propName = "INTERFACE_SOURCES";
+  const char* input = gt->GetProperty(propName);
 
-  if (!input)
-    {
+  if (!input) {
     return;
-    }
+  }
 
-  if (!*input)
-    {
+  if (!*input) {
     properties[propName] = "";
     return;
-    }
+  }
 
-  std::string prepro = cmGeneratorExpression::Preprocess(input,
-                                                         preprocessRule,
-                                                         true);
-  if (!prepro.empty())
-    {
-    this->ResolveTargetsInGeneratorExpressions(prepro, gt,
-                                                missingTargets);
+  std::string prepro =
+    cmGeneratorExpression::Preprocess(input, preprocessRule, true);
+  if (!prepro.empty()) {
+    this->ResolveTargetsInGeneratorExpressions(prepro, gt, missingTargets);
 
-    if (!checkInterfaceDirs(prepro, gt, propName))
-      {
+    if (!checkInterfaceDirs(prepro, gt, propName)) {
       return;
-      }
-    properties[propName] = prepro;
     }
+    properties[propName] = prepro;
+  }
 }
 
 void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
-                      cmTargetExport *tei,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets)
+  cmTargetExport* tei, cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
 {
-  cmGeneratorTarget *target = tei->Target;
+  cmGeneratorTarget* target = tei->Target;
   assert(preprocessRule == cmGeneratorExpression::InstallInterface);
 
-  const char *propName = "INTERFACE_INCLUDE_DIRECTORIES";
-  const char *input = target->GetProperty(propName);
+  const char* propName = "INTERFACE_INCLUDE_DIRECTORIES";
+  const char* input = target->GetProperty(propName);
 
   cmGeneratorExpression ge;
 
   std::string dirs = cmGeneratorExpression::Preprocess(
-                                            tei->InterfaceIncludeDirectories,
-                                            preprocessRule,
-                                            true);
+    tei->InterfaceIncludeDirectories, preprocessRule, true);
   this->ReplaceInstallPrefix(dirs);
   cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
-  std::string exportDirs = cge->Evaluate(target->GetLocalGenerator(), "",
-                                         false, target);
+  std::string exportDirs =
+    cge->Evaluate(target->GetLocalGenerator(), "", false, target);
 
-  if (cge->GetHadContextSensitiveCondition())
-    {
+  if (cge->GetHadContextSensitiveCondition()) {
     cmLocalGenerator* lg = target->GetLocalGenerator();
     std::ostringstream e;
-    e << "Target \"" << target->GetName() << "\" is installed with "
-    "INCLUDES DESTINATION set to a context sensitive path.  Paths which "
-    "depend on the configuration, policy values or the link interface are "
-    "not supported.  Consider using target_include_directories instead.";
+    e << "Target \"" << target->GetName()
+      << "\" is installed with "
+         "INCLUDES DESTINATION set to a context sensitive path.  Paths which "
+         "depend on the configuration, policy values or the link interface "
+         "are "
+         "not supported.  Consider using target_include_directories instead.";
     lg->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
+  }
 
-  if (!input && exportDirs.empty())
-    {
+  if (!input && exportDirs.empty()) {
     return;
-    }
-  if ((input && !*input) && exportDirs.empty())
-    {
+  }
+  if ((input && !*input) && exportDirs.empty()) {
     // Set to empty
     properties[propName] = "";
     return;
-    }
+  }
 
   prefixItems(exportDirs);
 
-  std::string includes = (input?input:"");
+  std::string includes = (input ? input : "");
   const char* sep = input ? ";" : "";
   includes += sep + exportDirs;
-  std::string prepro = cmGeneratorExpression::Preprocess(includes,
-                                                         preprocessRule,
-                                                         true);
-  if (!prepro.empty())
-    {
-    this->ResolveTargetsInGeneratorExpressions(prepro, target,
-                                                missingTargets);
+  std::string prepro =
+    cmGeneratorExpression::Preprocess(includes, preprocessRule, true);
+  if (!prepro.empty()) {
+    this->ResolveTargetsInGeneratorExpressions(prepro, target, missingTargets);
 
-    if (!checkInterfaceDirs(prepro, target, propName))
-      {
+    if (!checkInterfaceDirs(prepro, target, propName)) {
       return;
-      }
-    properties[propName] = prepro;
     }
+    properties[propName] = prepro;
+  }
 }
 
 void cmExportFileGenerator::PopulateInterfaceProperty(
-                      const std::string& propName,
-                      cmGeneratorTarget* target,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets)
+  const std::string& propName, cmGeneratorTarget* target,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
 {
   this->PopulateInterfaceProperty(propName, propName, target, preprocessRule,
-                            properties, missingTargets);
+                                  properties, missingTargets);
 }
 
-
-void getPropertyContents(cmGeneratorTarget const* tgt,
-                         const std::string& prop,
-                         std::set<std::string> &ifaceProperties)
+void getPropertyContents(cmGeneratorTarget const* tgt, const std::string& prop,
+                         std::set<std::string>& ifaceProperties)
 {
-  const char *p = tgt->GetProperty(prop);
-  if (!p)
-    {
+  const char* p = tgt->GetProperty(prop);
+  if (!p) {
     return;
-    }
+  }
   std::vector<std::string> content;
   cmSystemTools::ExpandListArgument(p, content);
   ifaceProperties.insert(content.begin(), content.end());
 }
 
-void getCompatibleInterfaceProperties(cmGeneratorTarget *target,
-                                      std::set<std::string> &ifaceProperties,
+void getCompatibleInterfaceProperties(cmGeneratorTarget* target,
+                                      std::set<std::string>& ifaceProperties,
                                       const std::string& config)
 {
-  cmComputeLinkInformation *info = target->GetLinkInformation(config);
+  cmComputeLinkInformation* info = target->GetLinkInformation(config);
 
-  if (!info)
-    {
+  if (!info) {
     cmLocalGenerator* lg = target->GetLocalGenerator();
     std::ostringstream e;
-    e << "Exporting the target \"" << target->GetName() << "\" is not "
-        "allowed since its linker language cannot be determined";
+    e << "Exporting the target \"" << target->GetName()
+      << "\" is not "
+         "allowed since its linker language cannot be determined";
     lg->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
+  }
 
-  const cmComputeLinkInformation::ItemVector &deps = info->GetItems();
+  const cmComputeLinkInformation::ItemVector& deps = info->GetItems();
 
-  for(cmComputeLinkInformation::ItemVector::const_iterator li =
-      deps.begin();
-      li != deps.end(); ++li)
-    {
-    if (!li->Target)
-      {
+  for (cmComputeLinkInformation::ItemVector::const_iterator li = deps.begin();
+       li != deps.end(); ++li) {
+    if (!li->Target) {
       continue;
-      }
-    getPropertyContents(li->Target,
-                        "COMPATIBLE_INTERFACE_BOOL",
+    }
+    getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_BOOL",
                         ifaceProperties);
-    getPropertyContents(li->Target,
-                        "COMPATIBLE_INTERFACE_STRING",
+    getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_STRING",
                         ifaceProperties);
-    getPropertyContents(li->Target,
-                        "COMPATIBLE_INTERFACE_NUMBER_MIN",
+    getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_NUMBER_MIN",
                         ifaceProperties);
-    getPropertyContents(li->Target,
-                        "COMPATIBLE_INTERFACE_NUMBER_MAX",
+    getPropertyContents(li->Target, "COMPATIBLE_INTERFACE_NUMBER_MAX",
                         ifaceProperties);
-    }
+  }
 }
 
 void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
-                                cmGeneratorTarget *gtarget,
-                                ImportPropertyMap &properties)
+  cmGeneratorTarget* gtarget, ImportPropertyMap& properties)
 {
-  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL",
-                                gtarget, properties);
-  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING",
-                                gtarget, properties);
-  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MIN",
-                                gtarget, properties);
-  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MAX",
-                                gtarget, properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_BOOL", gtarget,
+                                  properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_STRING", gtarget,
+                                  properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MIN", gtarget,
+                                  properties);
+  this->PopulateInterfaceProperty("COMPATIBLE_INTERFACE_NUMBER_MAX", gtarget,
+                                  properties);
 
   std::set<std::string> ifaceProperties;
 
@@ -582,335 +512,272 @@ void cmExportFileGenerator::PopulateCompatibleInterfaceProperties(
   getPropertyContents(gtarget, "COMPATIBLE_INTERFACE_NUMBER_MAX",
                       ifaceProperties);
 
-  if (gtarget->GetType() != cmState::INTERFACE_LIBRARY)
-    {
+  if (gtarget->GetType() != cmState::INTERFACE_LIBRARY) {
     getCompatibleInterfaceProperties(gtarget, ifaceProperties, "");
 
     std::vector<std::string> configNames;
     gtarget->Target->GetMakefile()->GetConfigurations(configNames);
 
     for (std::vector<std::string>::const_iterator ci = configNames.begin();
-      ci != configNames.end(); ++ci)
-      {
+         ci != configNames.end(); ++ci) {
       getCompatibleInterfaceProperties(gtarget, ifaceProperties, *ci);
-      }
     }
+  }
 
   for (std::set<std::string>::const_iterator it = ifaceProperties.begin();
-    it != ifaceProperties.end(); ++it)
-    {
-    this->PopulateInterfaceProperty("INTERFACE_" + *it,
-                                    gtarget, properties);
-    }
+       it != ifaceProperties.end(); ++it) {
+    this->PopulateInterfaceProperty("INTERFACE_" + *it, gtarget, properties);
+  }
 }
 
 void cmExportFileGenerator::GenerateInterfaceProperties(
-                                        const cmGeneratorTarget* target,
-                                        std::ostream& os,
-                                        const ImportPropertyMap &properties)
+  const cmGeneratorTarget* target, std::ostream& os,
+  const ImportPropertyMap& properties)
 {
-  if (!properties.empty())
-    {
+  if (!properties.empty()) {
     std::string targetName = this->Namespace;
     targetName += target->GetExportName();
     os << "set_target_properties(" << targetName << " PROPERTIES\n";
-    for(ImportPropertyMap::const_iterator pi = properties.begin();
-        pi != properties.end(); ++pi)
-      {
-      os << "  " << pi->first << " "
-         << cmExportFileGeneratorEscape(pi->second) << "\n";
-      }
-    os << ")\n\n";
+    for (ImportPropertyMap::const_iterator pi = properties.begin();
+         pi != properties.end(); ++pi) {
+      os << "  " << pi->first << " " << cmExportFileGeneratorEscape(pi->second)
+         << "\n";
     }
+    os << ")\n\n";
+  }
 }
 
-bool
-cmExportFileGenerator::AddTargetNamespace(std::string &input,
-                                    cmGeneratorTarget* target,
-                                    std::vector<std::string> &missingTargets)
+bool cmExportFileGenerator::AddTargetNamespace(
+  std::string& input, cmGeneratorTarget* target,
+  std::vector<std::string>& missingTargets)
 {
-  cmLocalGenerator *lg = target->GetLocalGenerator();
+  cmLocalGenerator* lg = target->GetLocalGenerator();
 
-  cmGeneratorTarget *tgt = lg->FindGeneratorTargetToUse(input);
-  if (!tgt)
-    {
+  cmGeneratorTarget* tgt = lg->FindGeneratorTargetToUse(input);
+  if (!tgt) {
     return false;
-    }
+  }
 
-  if(tgt->IsImported())
-    {
+  if (tgt->IsImported()) {
     return true;
-    }
-  if(this->ExportedTargets.find(tgt) != this->ExportedTargets.end())
-    {
+  }
+  if (this->ExportedTargets.find(tgt) != this->ExportedTargets.end()) {
     input = this->Namespace + tgt->GetExportName();
-    }
-  else
-    {
+  } else {
     std::string namespacedTarget;
-    this->HandleMissingTarget(namespacedTarget, missingTargets,
-                              target, tgt);
-    if (!namespacedTarget.empty())
-      {
+    this->HandleMissingTarget(namespacedTarget, missingTargets, target, tgt);
+    if (!namespacedTarget.empty()) {
       input = namespacedTarget;
-      }
     }
+  }
   return true;
 }
 
-void
-cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
-                                    std::string &input,
-                                    cmGeneratorTarget* target,
-                                    std::vector<std::string> &missingTargets,
-                                    FreeTargetsReplace replace)
+void cmExportFileGenerator::ResolveTargetsInGeneratorExpressions(
+  std::string& input, cmGeneratorTarget* target,
+  std::vector<std::string>& missingTargets, FreeTargetsReplace replace)
 {
-  if (replace == NoReplaceFreeTargets)
-    {
+  if (replace == NoReplaceFreeTargets) {
     this->ResolveTargetsInGeneratorExpression(input, target, missingTargets);
     return;
-    }
+  }
   std::vector<std::string> parts;
   cmGeneratorExpression::Split(input, parts);
 
   std::string sep;
   input = "";
-  for(std::vector<std::string>::iterator li = parts.begin();
-      li != parts.end(); ++li)
-    {
-    if (cmGeneratorExpression::Find(*li) == std::string::npos)
-      {
+  for (std::vector<std::string>::iterator li = parts.begin();
+       li != parts.end(); ++li) {
+    if (cmGeneratorExpression::Find(*li) == std::string::npos) {
       this->AddTargetNamespace(*li, target, missingTargets);
-      }
-    else
-      {
-      this->ResolveTargetsInGeneratorExpression(
-                                    *li,
-                                    target,
-                                    missingTargets);
-      }
+    } else {
+      this->ResolveTargetsInGeneratorExpression(*li, target, missingTargets);
+    }
     input += sep + *li;
     sep = ";";
-    }
+  }
 }
 
-void
-cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
-                                    std::string &input,
-                                    cmGeneratorTarget* target,
-                                    std::vector<std::string> &missingTargets)
+void cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
+  std::string& input, cmGeneratorTarget* target,
+  std::vector<std::string>& missingTargets)
 {
   std::string::size_type pos = 0;
   std::string::size_type lastPos = pos;
 
-  while((pos = input.find("$<TARGET_PROPERTY:", lastPos)) != input.npos)
-    {
-    std::string::size_type nameStartPos = pos +
-                                            sizeof("$<TARGET_PROPERTY:") - 1;
+  while ((pos = input.find("$<TARGET_PROPERTY:", lastPos)) != input.npos) {
+    std::string::size_type nameStartPos =
+      pos + sizeof("$<TARGET_PROPERTY:") - 1;
     std::string::size_type closePos = input.find(">", nameStartPos);
     std::string::size_type commaPos = input.find(",", nameStartPos);
     std::string::size_type nextOpenPos = input.find("$<", nameStartPos);
-    if (commaPos == input.npos // Implied 'this' target
-        || closePos == input.npos // Imcomplete expression.
-        || closePos < commaPos // Implied 'this' target
+    if (commaPos == input.npos     // Implied 'this' target
+        || closePos == input.npos  // Imcomplete expression.
+        || closePos < commaPos     // Implied 'this' target
         || nextOpenPos < commaPos) // Non-literal
-      {
+    {
       lastPos = nameStartPos;
       continue;
-      }
+    }
 
-    std::string targetName = input.substr(nameStartPos,
-                                                commaPos - nameStartPos);
+    std::string targetName =
+      input.substr(nameStartPos, commaPos - nameStartPos);
 
-    if (this->AddTargetNamespace(targetName, target, missingTargets))
-      {
+    if (this->AddTargetNamespace(targetName, target, missingTargets)) {
       input.replace(nameStartPos, commaPos - nameStartPos, targetName);
-      }
-    lastPos = nameStartPos + targetName.size() + 1;
     }
+    lastPos = nameStartPos + targetName.size() + 1;
+  }
 
   std::string errorString;
   pos = 0;
   lastPos = pos;
-  while((pos = input.find("$<TARGET_NAME:", lastPos)) != input.npos)
-    {
+  while ((pos = input.find("$<TARGET_NAME:", lastPos)) != input.npos) {
     std::string::size_type nameStartPos = pos + sizeof("$<TARGET_NAME:") - 1;
     std::string::size_type endPos = input.find(">", nameStartPos);
-    if (endPos == input.npos)
-      {
+    if (endPos == input.npos) {
       errorString = "$<TARGET_NAME:...> expression incomplete";
       break;
-      }
-    std::string targetName = input.substr(nameStartPos,
-                                                endPos - nameStartPos);
-    if(targetName.find("$<") != input.npos)
-      {
+    }
+    std::string targetName = input.substr(nameStartPos, endPos - nameStartPos);
+    if (targetName.find("$<") != input.npos) {
       errorString = "$<TARGET_NAME:...> requires its parameter to be a "
                     "literal.";
       break;
-      }
-    if (!this->AddTargetNamespace(targetName, target, missingTargets))
-      {
+    }
+    if (!this->AddTargetNamespace(targetName, target, missingTargets)) {
       errorString = "$<TARGET_NAME:...> requires its parameter to be a "
                     "reachable target.";
       break;
-      }
+    }
     input.replace(pos, endPos - pos + 1, targetName);
     lastPos = endPos;
-    }
+  }
 
   pos = 0;
   lastPos = pos;
   while (errorString.empty() &&
-         (pos = input.find("$<LINK_ONLY:", lastPos)) != input.npos)
-    {
+         (pos = input.find("$<LINK_ONLY:", lastPos)) != input.npos) {
     std::string::size_type nameStartPos = pos + sizeof("$<LINK_ONLY:") - 1;
     std::string::size_type endPos = input.find(">", nameStartPos);
-    if (endPos == input.npos)
-      {
+    if (endPos == input.npos) {
       errorString = "$<LINK_ONLY:...> expression incomplete";
       break;
-      }
+    }
     std::string libName = input.substr(nameStartPos, endPos - nameStartPos);
     if (cmGeneratorExpression::IsValidTargetName(libName) &&
-        this->AddTargetNamespace(libName, target, missingTargets))
-      {
+        this->AddTargetNamespace(libName, target, missingTargets)) {
       input.replace(nameStartPos, endPos - nameStartPos, libName);
-      }
-    lastPos = nameStartPos + libName.size() + 1;
     }
+    lastPos = nameStartPos + libName.size() + 1;
+  }
 
   this->ReplaceInstallPrefix(input);
 
-  if (!errorString.empty())
-    {
+  if (!errorString.empty()) {
     target->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, errorString);
-    }
+  }
 }
 
-void
-cmExportFileGenerator::ReplaceInstallPrefix(std::string &)
+void cmExportFileGenerator::ReplaceInstallPrefix(std::string&)
 {
   // Do nothing
 }
 
-void
-cmExportFileGenerator
-::SetImportLinkInterface(const std::string& config, std::string const& suffix,
-                    cmGeneratorExpression::PreprocessContext preprocessRule,
-                    cmGeneratorTarget* target, ImportPropertyMap& properties,
-                    std::vector<std::string>& missingTargets)
+void cmExportFileGenerator::SetImportLinkInterface(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorExpression::PreprocessContext preprocessRule,
+  cmGeneratorTarget* target, ImportPropertyMap& properties,
+  std::vector<std::string>& missingTargets)
 {
   // Add the transitive link dependencies for this configuration.
-  cmLinkInterface const* iface = target->GetLinkInterface(config,
-                                                          target);
-  if (!iface)
-    {
+  cmLinkInterface const* iface = target->GetLinkInterface(config, target);
+  if (!iface) {
     return;
-    }
+  }
 
-  if (iface->ImplementationIsInterface)
-    {
+  if (iface->ImplementationIsInterface) {
     // Policy CMP0022 must not be NEW.
     this->SetImportLinkProperty(suffix, target,
                                 "IMPORTED_LINK_INTERFACE_LIBRARIES",
                                 iface->Libraries, properties, missingTargets);
     return;
-    }
+  }
 
-  const char *propContent;
+  const char* propContent;
 
-  if (const char *prop_suffixed = target->GetProperty(
-                    "LINK_INTERFACE_LIBRARIES" + suffix))
-    {
+  if (const char* prop_suffixed =
+        target->GetProperty("LINK_INTERFACE_LIBRARIES" + suffix)) {
     propContent = prop_suffixed;
-    }
-  else if (const char *prop = target->GetProperty(
-                    "LINK_INTERFACE_LIBRARIES"))
-    {
+  } else if (const char* prop =
+               target->GetProperty("LINK_INTERFACE_LIBRARIES")) {
     propContent = prop;
-    }
-  else
-    {
+  } else {
     return;
-    }
+  }
 
   const bool newCMP0022Behavior =
-                        target->GetPolicyStatusCMP0022() != cmPolicies::WARN
-                     && target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+    target->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+    target->GetPolicyStatusCMP0022() != cmPolicies::OLD;
 
-  if(newCMP0022Behavior && !this->ExportOld)
-    {
-    cmLocalGenerator *lg = target->GetLocalGenerator();
+  if (newCMP0022Behavior && !this->ExportOld) {
+    cmLocalGenerator* lg = target->GetLocalGenerator();
     std::ostringstream e;
-    e << "Target \"" << target->GetName() << "\" has policy CMP0022 enabled, "
+    e << "Target \"" << target->GetName()
+      << "\" has policy CMP0022 enabled, "
          "but also has old-style LINK_INTERFACE_LIBRARIES properties "
          "populated, but it was exported without the "
          "EXPORT_LINK_INTERFACE_LIBRARIES to export the old-style properties";
     lg->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
+  }
 
-  if (!*propContent)
-    {
+  if (!*propContent) {
     properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix] = "";
     return;
-    }
+  }
 
-  std::string prepro = cmGeneratorExpression::Preprocess(propContent,
-                                                         preprocessRule);
-  if (!prepro.empty())
-    {
-    this->ResolveTargetsInGeneratorExpressions(prepro, target,
-                                               missingTargets,
+  std::string prepro =
+    cmGeneratorExpression::Preprocess(propContent, preprocessRule);
+  if (!prepro.empty()) {
+    this->ResolveTargetsInGeneratorExpressions(prepro, target, missingTargets,
                                                ReplaceFreeTargets);
     properties["IMPORTED_LINK_INTERFACE_LIBRARIES" + suffix] = prepro;
-    }
+  }
 }
 
-void
-cmExportFileGenerator
-::SetImportDetailProperties(const std::string& config,
-                            std::string const& suffix,
-                            cmGeneratorTarget* target,
-                            ImportPropertyMap& properties,
-                            std::vector<std::string>& missingTargets
-                           )
+void cmExportFileGenerator::SetImportDetailProperties(
+  const std::string& config, std::string const& suffix,
+  cmGeneratorTarget* target, ImportPropertyMap& properties,
+  std::vector<std::string>& missingTargets)
 {
   // Get the makefile in which to lookup target information.
   cmMakefile* mf = target->Makefile;
 
   // Add the soname for unix shared libraries.
-  if(target->GetType() == cmState::SHARED_LIBRARY ||
-     target->GetType() == cmState::MODULE_LIBRARY)
-    {
-    if(!target->IsDLLPlatform())
-      {
+  if (target->GetType() == cmState::SHARED_LIBRARY ||
+      target->GetType() == cmState::MODULE_LIBRARY) {
+    if (!target->IsDLLPlatform()) {
       std::string prop;
       std::string value;
-      if(target->HasSOName(config))
-        {
-        if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-          {
+      if (target->HasSOName(config)) {
+        if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
           value = this->InstallNameDir(target, config);
-          }
+        }
         prop = "IMPORTED_SONAME";
         value += target->GetSOName(config);
-        }
-      else
-        {
+      } else {
         prop = "IMPORTED_NO_SONAME";
         value = "TRUE";
-        }
+      }
       prop += suffix;
       properties[prop] = value;
-      }
     }
+  }
 
   // Add the transitive link dependencies for this configuration.
-  if(cmLinkInterface const* iface =
-                            target->GetLinkInterface(config, target))
-    {
+  if (cmLinkInterface const* iface =
+        target->GetLinkInterface(config, target)) {
     this->SetImportLinkProperty(suffix, target,
                                 "IMPORTED_LINK_INTERFACE_LANGUAGES",
                                 iface->Languages, properties, missingTargets);
@@ -919,40 +786,32 @@ cmExportFileGenerator
     this->SetImportLinkProperty(suffix, target,
                                 "IMPORTED_LINK_DEPENDENT_LIBRARIES",
                                 iface->SharedDeps, properties, dummy);
-    if(iface->Multiplicity > 0)
-      {
+    if (iface->Multiplicity > 0) {
       std::string prop = "IMPORTED_LINK_INTERFACE_MULTIPLICITY";
       prop += suffix;
       std::ostringstream m;
       m << iface->Multiplicity;
       properties[prop] = m.str();
-      }
     }
+  }
 }
 
 template <typename T>
-void
-cmExportFileGenerator
-::SetImportLinkProperty(std::string const& suffix,
-                        cmGeneratorTarget* target,
-                        const std::string& propName,
-                        std::vector<T> const& entries,
-                        ImportPropertyMap& properties,
-                        std::vector<std::string>& missingTargets
-  )
+void cmExportFileGenerator::SetImportLinkProperty(
+  std::string const& suffix, cmGeneratorTarget* target,
+  const std::string& propName, std::vector<T> const& entries,
+  ImportPropertyMap& properties, std::vector<std::string>& missingTargets)
 {
   // Skip the property if there are no entries.
-  if(entries.empty())
-    {
+  if (entries.empty()) {
     return;
-    }
+  }
 
   // Construct the property value.
   std::string link_entries;
   const char* sep = "";
-  for(typename std::vector<T>::const_iterator li = entries.begin();
-      li != entries.end(); ++li)
-    {
+  for (typename std::vector<T>::const_iterator li = entries.begin();
+       li != entries.end(); ++li) {
     // Separate this from the previous entry.
     link_entries += sep;
     sep = ";";
@@ -960,7 +819,7 @@ cmExportFileGenerator
     std::string temp = *li;
     this->AddTargetNamespace(temp, target, missingTargets);
     link_entries += temp;
-    }
+  }
 
   // Store the property.
   std::string prop = propName;
@@ -969,18 +828,15 @@ cmExportFileGenerator
 }
 
 void cmExportFileGenerator::GenerateImportHeaderCode(std::ostream& os,
-                                                    const std::string& config)
+                                                     const std::string& config)
 {
   os << "#----------------------------------------------------------------\n"
      << "# Generated CMake target import file";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     os << " for configuration \"" << config << "\".\n";
-    }
-  else
-    {
+  } else {
     os << ".\n";
-    }
+  }
   os << "#----------------------------------------------------------------\n"
      << "\n";
   this->GenerateImportVersionCode(os);
@@ -1003,8 +859,8 @@ void cmExportFileGenerator::GenerateImportVersionCode(std::ostream& os)
   /* clang-format on */
 }
 
-void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os,
-                                            const std::string &expectedTargets)
+void cmExportFileGenerator::GenerateExpectedTargetsCode(
+  std::ostream& os, const std::string& expectedTargets)
 {
   /* clang-format off */
   os << "# Protect against multiple inclusion, which would fail when already "
@@ -1040,9 +896,8 @@ void cmExportFileGenerator::GenerateExpectedTargetsCode(std::ostream& os,
         "\n\n";
   /* clang-format on */
 }
-void
-cmExportFileGenerator
-::GenerateImportTargetCode(std::ostream& os, const cmGeneratorTarget* target)
+void cmExportFileGenerator::GenerateImportTargetCode(
+  std::ostream& os, const cmGeneratorTarget* target)
 {
   // Construct the imported target name.
   std::string targetName = this->Namespace;
@@ -1051,8 +906,7 @@ cmExportFileGenerator
 
   // Create the imported target.
   os << "# Create imported target " << targetName << "\n";
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::EXECUTABLE:
       os << "add_executable(" << targetName << " IMPORTED)\n";
       break;
@@ -1071,44 +925,36 @@ cmExportFileGenerator
     case cmState::INTERFACE_LIBRARY:
       os << "add_library(" << targetName << " INTERFACE IMPORTED)\n";
       break;
-    default:  // should never happen
+    default: // should never happen
       break;
-    }
+  }
 
   // Mark the imported executable if it has exports.
-  if(target->IsExecutableWithExports())
-    {
+  if (target->IsExecutableWithExports()) {
     os << "set_property(TARGET " << targetName
        << " PROPERTY ENABLE_EXPORTS 1)\n";
-    }
+  }
 
   // Mark the imported library if it is a framework.
-  if(target->IsFrameworkOnApple())
-    {
-    os << "set_property(TARGET " << targetName
-       << " PROPERTY FRAMEWORK 1)\n";
-    }
+  if (target->IsFrameworkOnApple()) {
+    os << "set_property(TARGET " << targetName << " PROPERTY FRAMEWORK 1)\n";
+  }
 
   // Mark the imported executable if it is an application bundle.
-  if(target->IsAppBundleOnApple())
-    {
+  if (target->IsAppBundleOnApple()) {
     os << "set_property(TARGET " << targetName
        << " PROPERTY MACOSX_BUNDLE 1)\n";
-    }
+  }
 
-  if (target->IsCFBundleOnApple())
-    {
-    os << "set_property(TARGET " << targetName
-       << " PROPERTY BUNDLE 1)\n";
-    }
+  if (target->IsCFBundleOnApple()) {
+    os << "set_property(TARGET " << targetName << " PROPERTY BUNDLE 1)\n";
+  }
   os << "\n";
 }
 
-void
-cmExportFileGenerator
-::GenerateImportPropertyCode(std::ostream& os, const std::string& config,
-                             cmGeneratorTarget const* target,
-                             ImportPropertyMap const& properties)
+void cmExportFileGenerator::GenerateImportPropertyCode(
+  std::ostream& os, const std::string& config, cmGeneratorTarget const* target,
+  ImportPropertyMap const& properties)
 {
   // Construct the imported target name.
   std::string targetName = this->Namespace;
@@ -1120,39 +966,33 @@ cmExportFileGenerator
      << config << "\"\n";
   os << "set_property(TARGET " << targetName
      << " APPEND PROPERTY IMPORTED_CONFIGURATIONS ";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     os << cmSystemTools::UpperCase(config);
-    }
-  else
-    {
+  } else {
     os << "NOCONFIG";
-    }
+  }
   os << ")\n";
   os << "set_target_properties(" << targetName << " PROPERTIES\n";
-  for(ImportPropertyMap::const_iterator pi = properties.begin();
-      pi != properties.end(); ++pi)
-    {
-    os << "  " << pi->first << " "
-       << cmExportFileGeneratorEscape(pi->second) << "\n";
-    }
+  for (ImportPropertyMap::const_iterator pi = properties.begin();
+       pi != properties.end(); ++pi) {
+    os << "  " << pi->first << " " << cmExportFileGeneratorEscape(pi->second)
+       << "\n";
+  }
   os << "  )\n"
      << "\n";
 }
 
-
-void cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream& os,
-                                const std::vector<std::string>& missingTargets)
+void cmExportFileGenerator::GenerateMissingTargetsCheckCode(
+  std::ostream& os, const std::vector<std::string>& missingTargets)
 {
-  if (missingTargets.empty())
-    {
+  if (missingTargets.empty()) {
     /* clang-format off */
     os << "# This file does not depend on other imported targets which have\n"
           "# been exported from the same project but in a separate "
             "export set.\n\n";
     /* clang-format on */
     return;
-    }
+  }
   /* clang-format off */
   os << "# Make sure the targets which have been exported in some other \n"
         "# export set exist.\n"
@@ -1160,13 +1000,11 @@ void cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream& os,
         "foreach(_target ";
   /* clang-format on */
   std::set<std::string> emitted;
-  for(unsigned int i=0; i<missingTargets.size(); ++i)
-    {
-    if (emitted.insert(missingTargets[i]).second)
-      {
-      os << "\"" << missingTargets[i] <<  "\" ";
-      }
+  for (unsigned int i = 0; i < missingTargets.size(); ++i) {
+    if (emitted.insert(missingTargets[i]).second) {
+      os << "\"" << missingTargets[i] << "\" ";
     }
+  }
   /* clang-format off */
   os << ")\n"
         "  if(NOT TARGET \"${_target}\" )\n"
@@ -1194,9 +1032,7 @@ void cmExportFileGenerator::GenerateMissingTargetsCheckCode(std::ostream& os,
   /* clang-format on */
 }
 
-
-void
-cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
+void cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
 {
   // Add code which verifies at cmake time that the file which is being
   // imported actually exists on disk. This should in theory always be theory
@@ -1229,30 +1065,27 @@ cmExportFileGenerator::GenerateImportedFileCheckLoop(std::ostream& os)
   /* clang-format on */
 }
 
-
-void
-cmExportFileGenerator
-::GenerateImportedFileChecksCode(std::ostream& os, cmGeneratorTarget* target,
-                                 ImportPropertyMap const& properties,
-                                const std::set<std::string>& importedLocations)
+void cmExportFileGenerator::GenerateImportedFileChecksCode(
+  std::ostream& os, cmGeneratorTarget* target,
+  ImportPropertyMap const& properties,
+  const std::set<std::string>& importedLocations)
 {
   // Construct the imported target name.
   std::string targetName = this->Namespace;
   targetName += target->GetExportName();
 
-  os << "list(APPEND _IMPORT_CHECK_TARGETS " << targetName << " )\n"
-        "list(APPEND _IMPORT_CHECK_FILES_FOR_" << targetName << " ";
+  os << "list(APPEND _IMPORT_CHECK_TARGETS " << targetName
+     << " )\n"
+        "list(APPEND _IMPORT_CHECK_FILES_FOR_"
+     << targetName << " ";
 
-  for(std::set<std::string>::const_iterator li = importedLocations.begin();
-      li != importedLocations.end();
-      ++li)
-    {
+  for (std::set<std::string>::const_iterator li = importedLocations.begin();
+       li != importedLocations.end(); ++li) {
     ImportPropertyMap::const_iterator pi = properties.find(*li);
-    if (pi != properties.end())
-      {
+    if (pi != properties.end()) {
       os << cmExportFileGeneratorEscape(pi->second) << " ";
-      }
     }
+  }
 
   os << ")\n\n";
 }
diff --git a/Source/cmExportFileGenerator.h b/Source/cmExportFileGenerator.h
index 9fc02a4..9c96015 100644
--- a/Source/cmExportFileGenerator.h
+++ b/Source/cmExportFileGenerator.h
@@ -21,13 +21,12 @@
 #define STRINGIFY_HELPER(X) #X
 #define STRINGIFY(X) STRINGIFY_HELPER(X)
 
-#define DEVEL_CMAKE_VERSION(major, minor) ( \
-  CMake_VERSION_ENCODE(major, minor, 0) > \
-  CMake_VERSION_ENCODE(CMake_VERSION_MAJOR, CMake_VERSION_MINOR, 0) ?  \
-    STRINGIFY(CMake_VERSION_MAJOR) "." STRINGIFY(CMake_VERSION_MINOR) "." \
-    STRINGIFY(CMake_VERSION_PATCH) \
-  : #major "." #minor ".0" \
-  )
+#define DEVEL_CMAKE_VERSION(major, minor)                                     \
+  (CMake_VERSION_ENCODE(major, minor, 0) >                                    \
+       CMake_VERSION_ENCODE(CMake_VERSION_MAJOR, CMake_VERSION_MINOR, 0)      \
+     ? STRINGIFY(CMake_VERSION_MAJOR) "." STRINGIFY(                          \
+         CMake_VERSION_MINOR) "." STRINGIFY(CMake_VERSION_PATCH)              \
+     : #major "." #minor ".0")
 
 class cmTargetExport;
 
@@ -47,7 +46,7 @@ public:
 
   /** Set the full path to the export file to generate.  */
   void SetExportFile(const char* mainFile);
-  const char *GetMainExportFileName() const;
+  const char* GetMainExportFileName() const;
 
   /** Set the namespace in which to place exported target names.  */
   void SetNamespace(const std::string& ns) { this->Namespace = ns; }
@@ -61,14 +60,14 @@ public:
   /** Actually generate the export file.  Returns whether there was an
       error.  */
   bool GenerateImportFile();
-protected:
 
+protected:
   typedef std::map<std::string, std::string> ImportPropertyMap;
 
   // Generate per-configuration target information to the given output
   // stream.
   void GenerateImportConfig(std::ostream& os, const std::string& config,
-                            std::vector<std::string> &missingTargets);
+                            std::vector<std::string>& missingTargets);
 
   // Methods to implement export file code generation.
   void GenerateImportHeaderCode(std::ostream& os,
@@ -80,16 +79,16 @@ protected:
   void GenerateImportPropertyCode(std::ostream& os, const std::string& config,
                                   cmGeneratorTarget const* target,
                                   ImportPropertyMap const& properties);
-  void GenerateImportedFileChecksCode(std::ostream& os,
-                                      cmGeneratorTarget* target,
-                                      ImportPropertyMap const& properties,
-                               const std::set<std::string>& importedLocations);
+  void GenerateImportedFileChecksCode(
+    std::ostream& os, cmGeneratorTarget* target,
+    ImportPropertyMap const& properties,
+    const std::set<std::string>& importedLocations);
   void GenerateImportedFileCheckLoop(std::ostream& os);
-  void GenerateMissingTargetsCheckCode(std::ostream& os,
-                               const std::vector<std::string>& missingTargets);
+  void GenerateMissingTargetsCheckCode(
+    std::ostream& os, const std::vector<std::string>& missingTargets);
 
   void GenerateExpectedTargetsCode(std::ostream& os,
-                                          const std::string &expectedTargets);
+                                   const std::string& expectedTargets);
 
   // Collect properties with detailed information about targets beyond
   // their location on disk.
@@ -111,10 +110,9 @@ protected:
   virtual bool GenerateMainFile(std::ostream& os) = 0;
 
   /** Each subclass knows where the target files are located.  */
-  virtual void GenerateImportTargetsConfig(std::ostream& os,
-                                           const std::string& config,
-                                           std::string const& suffix,
-                            std::vector<std::string> &missingTargets) = 0;
+  virtual void GenerateImportTargetsConfig(
+    std::ostream& os, const std::string& config, std::string const& suffix,
+    std::vector<std::string>& missingTargets) = 0;
 
   /** Each subclass knows how to deal with a target that is  missing from an
    *  export set.  */
@@ -122,52 +120,49 @@ protected:
                                    std::vector<std::string>& missingTargets,
                                    cmGeneratorTarget* depender,
                                    cmGeneratorTarget* dependee) = 0;
-  void PopulateInterfaceProperty(const std::string&,
-                                 cmGeneratorTarget *target,
+  void PopulateInterfaceProperty(const std::string&, cmGeneratorTarget* target,
                                  cmGeneratorExpression::PreprocessContext,
-                                 ImportPropertyMap &properties,
-                                 std::vector<std::string> &missingTargets);
-  bool PopulateInterfaceLinkLibrariesProperty(cmGeneratorTarget* target,
-                                 cmGeneratorExpression::PreprocessContext,
-                                 ImportPropertyMap &properties,
-                                 std::vector<std::string> &missingTargets);
+                                 ImportPropertyMap& properties,
+                                 std::vector<std::string>& missingTargets);
+  bool PopulateInterfaceLinkLibrariesProperty(
+    cmGeneratorTarget* target, cmGeneratorExpression::PreprocessContext,
+    ImportPropertyMap& properties, std::vector<std::string>& missingTargets);
   void PopulateInterfaceProperty(const std::string& propName,
                                  cmGeneratorTarget* target,
-                                 ImportPropertyMap &properties);
-  void PopulateCompatibleInterfaceProperties(cmGeneratorTarget *target,
-                                 ImportPropertyMap &properties);
+                                 ImportPropertyMap& properties);
+  void PopulateCompatibleInterfaceProperties(cmGeneratorTarget* target,
+                                             ImportPropertyMap& properties);
   void GenerateInterfaceProperties(cmGeneratorTarget const* target,
                                    std::ostream& os,
-                                   const ImportPropertyMap &properties);
+                                   const ImportPropertyMap& properties);
   void PopulateIncludeDirectoriesInterface(
-                      cmTargetExport *target,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets);
+    cmTargetExport* target,
+    cmGeneratorExpression::PreprocessContext preprocessRule,
+    ImportPropertyMap& properties, std::vector<std::string>& missingTargets);
   void PopulateSourcesInterface(
-                      cmTargetExport *target,
-                      cmGeneratorExpression::PreprocessContext preprocessRule,
-                      ImportPropertyMap &properties,
-                      std::vector<std::string> &missingTargets);
-
-  void SetImportLinkInterface(const std::string& config,
-                    std::string const& suffix,
-                    cmGeneratorExpression::PreprocessContext preprocessRule,
-                    cmGeneratorTarget* target, ImportPropertyMap& properties,
-                    std::vector<std::string>& missingTargets);
-
-  enum FreeTargetsReplace {
+    cmTargetExport* target,
+    cmGeneratorExpression::PreprocessContext preprocessRule,
+    ImportPropertyMap& properties, std::vector<std::string>& missingTargets);
+
+  void SetImportLinkInterface(
+    const std::string& config, std::string const& suffix,
+    cmGeneratorExpression::PreprocessContext preprocessRule,
+    cmGeneratorTarget* target, ImportPropertyMap& properties,
+    std::vector<std::string>& missingTargets);
+
+  enum FreeTargetsReplace
+  {
     ReplaceFreeTargets,
     NoReplaceFreeTargets
   };
 
-  void ResolveTargetsInGeneratorExpressions(std::string &input,
-                          cmGeneratorTarget* target,
-                          std::vector<std::string> &missingTargets,
-                          FreeTargetsReplace replace = NoReplaceFreeTargets);
+  void ResolveTargetsInGeneratorExpressions(
+    std::string& input, cmGeneratorTarget* target,
+    std::vector<std::string>& missingTargets,
+    FreeTargetsReplace replace = NoReplaceFreeTargets);
 
   void GenerateRequiredCMakeVersion(std::ostream& os,
-                                    const char *versionString);
+                                    const char* versionString);
 
   // The namespace in which the exports are placed in the generated file.
   std::string Namespace;
@@ -191,17 +186,17 @@ private:
   void PopulateInterfaceProperty(const std::string&, const std::string&,
                                  cmGeneratorTarget* target,
                                  cmGeneratorExpression::PreprocessContext,
-                                 ImportPropertyMap &properties,
-                                 std::vector<std::string> &missingTargets);
+                                 ImportPropertyMap& properties,
+                                 std::vector<std::string>& missingTargets);
 
-  bool AddTargetNamespace(std::string &input, cmGeneratorTarget* target,
-                          std::vector<std::string> &missingTargets);
+  bool AddTargetNamespace(std::string& input, cmGeneratorTarget* target,
+                          std::vector<std::string>& missingTargets);
 
-  void ResolveTargetsInGeneratorExpression(std::string &input,
-                                    cmGeneratorTarget* target,
-                                    std::vector<std::string> &missingTargets);
+  void ResolveTargetsInGeneratorExpression(
+    std::string& input, cmGeneratorTarget* target,
+    std::vector<std::string>& missingTargets);
 
-  virtual void ReplaceInstallPrefix(std::string &input);
+  virtual void ReplaceInstallPrefix(std::string& input);
 
   virtual std::string InstallNameDir(cmGeneratorTarget* target,
                                      const std::string& config) = 0;
diff --git a/Source/cmExportInstallFileGenerator.cxx b/Source/cmExportInstallFileGenerator.cxx
index 2d454b9..38b08f0 100644
--- a/Source/cmExportInstallFileGenerator.cxx
+++ b/Source/cmExportInstallFileGenerator.cxx
@@ -21,9 +21,9 @@
 #include "cmLocalGenerator.h"
 #include "cmTargetExport.h"
 
-cmExportInstallFileGenerator
-::cmExportInstallFileGenerator(cmInstallExportGenerator* iegen):
-  IEGen(iegen)
+cmExportInstallFileGenerator::cmExportInstallFileGenerator(
+  cmInstallExportGenerator* iegen)
+  : IEGen(iegen)
 {
 }
 
@@ -39,42 +39,39 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
 {
   std::vector<cmTargetExport*> allTargets;
   {
-  std::string expectedTargets;
-  std::string sep;
-  for(std::vector<cmTargetExport*>::const_iterator
-        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
-      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
-    {
-    expectedTargets +=
+    std::string expectedTargets;
+    std::string sep;
+    for (std::vector<cmTargetExport*>::const_iterator tei =
+           this->IEGen->GetExportSet()->GetTargetExports()->begin();
+         tei != this->IEGen->GetExportSet()->GetTargetExports()->end();
+         ++tei) {
+      expectedTargets +=
         sep + this->Namespace + (*tei)->Target->GetExportName();
-    sep = " ";
-    cmTargetExport * te = *tei;
-    if(this->ExportedTargets.insert(te->Target).second)
-      {
-      allTargets.push_back(te);
-      }
-    else
-      {
-      std::ostringstream e;
-      e << "install(EXPORT \""
-        << this->IEGen->GetExportSet()->GetName()
-        << "\" ...) " << "includes target \"" << te->Target->GetName()
-        << "\" more than once in the export set.";
-      cmSystemTools::Error(e.str().c_str());
-      return false;
+      sep = " ";
+      cmTargetExport* te = *tei;
+      if (this->ExportedTargets.insert(te->Target).second) {
+        allTargets.push_back(te);
+      } else {
+        std::ostringstream e;
+        e << "install(EXPORT \"" << this->IEGen->GetExportSet()->GetName()
+          << "\" ...) "
+          << "includes target \"" << te->Target->GetName()
+          << "\" more than once in the export set.";
+        cmSystemTools::Error(e.str().c_str());
+        return false;
       }
     }
 
-  this->GenerateExpectedTargetsCode(os, expectedTargets);
+    this->GenerateExpectedTargetsCode(os, expectedTargets);
   }
 
   // Set an _IMPORT_PREFIX variable for import location properties
   // to reference if they are relative to the install prefix.
-  std::string installPrefix = this->IEGen->GetLocalGenerator()
-      ->GetMakefile()->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
+  std::string installPrefix =
+    this->IEGen->GetLocalGenerator()->GetMakefile()->GetSafeDefinition(
+      "CMAKE_INSTALL_PREFIX");
   std::string const& expDest = this->IEGen->GetDestination();
-  if(cmSystemTools::FileIsFullPath(expDest))
-    {
+  if (cmSystemTools::FileIsFullPath(expDest)) {
     // The export file is being installed to an absolute path so the
     // package is not relocatable.  Use the configured install prefix.
     /* clang-format off */
@@ -83,9 +80,7 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
       "set(_IMPORT_PREFIX \"" << installPrefix << "\")\n"
       "\n";
     /* clang-format on */
-    }
-  else
-    {
+  } else {
     // Add code to compute the installation prefix relative to the
     // import file location.
     std::string absDest = installPrefix + "/" + expDest;
@@ -93,11 +88,10 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
     os << "# Compute the installation prefix relative to this file.\n"
        << "get_filename_component(_IMPORT_PREFIX"
        << " \"${CMAKE_CURRENT_LIST_FILE}\" PATH)\n";
-    if(cmHasLiteralPrefix(absDestS.c_str(), "/lib/") ||
-       cmHasLiteralPrefix(absDestS.c_str(), "/lib64/") ||
-       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib/") ||
-       cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib64/"))
-      {
+    if (cmHasLiteralPrefix(absDestS.c_str(), "/lib/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/lib64/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib/") ||
+        cmHasLiteralPrefix(absDestS.c_str(), "/usr/lib64/")) {
       // Handle "/usr move" symlinks created by some Linux distros.
       /* clang-format off */
       os <<
@@ -111,16 +105,15 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
         "unset(_realOrig)\n"
         "unset(_realCurr)\n";
       /* clang-format on */
-      }
+    }
     std::string dest = expDest;
-    while(!dest.empty())
-      {
-      os <<
-        "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" PATH)\n";
+    while (!dest.empty()) {
+      os << "get_filename_component(_IMPORT_PREFIX \"${_IMPORT_PREFIX}\" "
+            "PATH)\n";
       dest = cmSystemTools::GetFilenamePath(dest);
-      }
-    os << "\n";
     }
+    os << "\n";
+  }
 
   std::vector<std::string> missingTargets;
 
@@ -129,90 +122,74 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
   bool require3_1_0 = false;
   bool requiresConfigFiles = false;
   // Create all the imported targets.
-  for(std::vector<cmTargetExport*>::const_iterator
-        tei = allTargets.begin();
-      tei != allTargets.end(); ++tei)
-    {
+  for (std::vector<cmTargetExport*>::const_iterator tei = allTargets.begin();
+       tei != allTargets.end(); ++tei) {
     cmGeneratorTarget* gt = (*tei)->Target;
 
-    requiresConfigFiles = requiresConfigFiles
-                              || gt->GetType() != cmState::INTERFACE_LIBRARY;
+    requiresConfigFiles =
+      requiresConfigFiles || gt->GetType() != cmState::INTERFACE_LIBRARY;
 
     this->GenerateImportTargetCode(os, gt);
 
     ImportPropertyMap properties;
 
-    this->PopulateIncludeDirectoriesInterface(*tei,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
+    this->PopulateIncludeDirectoriesInterface(
+      *tei, cmGeneratorExpression::InstallInterface, properties,
+      missingTargets);
     this->PopulateSourcesInterface(*tei,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
-                                  gt,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS",
-                                  gt,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS",
-                                  gt,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS",
-                                  gt,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
-    this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES",
-                                  gt,
-                                  cmGeneratorExpression::InstallInterface,
-                                  properties, missingTargets);
+                                   cmGeneratorExpression::InstallInterface,
+                                   properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_OPTIONS", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_AUTOUIC_OPTIONS", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_COMPILE_FEATURES", gt,
+                                    cmGeneratorExpression::InstallInterface,
+                                    properties, missingTargets);
 
     const bool newCMP0022Behavior =
-        gt->GetPolicyStatusCMP0022() != cmPolicies::WARN
-        && gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
-    if (newCMP0022Behavior)
-      {
-      if (this->PopulateInterfaceLinkLibrariesProperty(gt,
-                                    cmGeneratorExpression::InstallInterface,
-                                    properties, missingTargets)
-          && !this->ExportOld)
-        {
+      gt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+      gt->GetPolicyStatusCMP0022() != cmPolicies::OLD;
+    if (newCMP0022Behavior) {
+      if (this->PopulateInterfaceLinkLibrariesProperty(
+            gt, cmGeneratorExpression::InstallInterface, properties,
+            missingTargets) &&
+          !this->ExportOld) {
         require2_8_12 = true;
-        }
       }
-    if (gt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    }
+    if (gt->GetType() == cmState::INTERFACE_LIBRARY) {
       require3_0_0 = true;
-      }
-    if(gt->GetProperty("INTERFACE_SOURCES"))
-      {
+    }
+    if (gt->GetProperty("INTERFACE_SOURCES")) {
       // We can only generate INTERFACE_SOURCES in CMake 3.3, but CMake 3.1
       // can consume them.
       require3_1_0 = true;
-      }
+    }
 
-    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE",
-                                  gt, properties);
+    this->PopulateInterfaceProperty("INTERFACE_POSITION_INDEPENDENT_CODE", gt,
+                                    properties);
 
     this->PopulateCompatibleInterfaceProperties(gt, properties);
 
     this->GenerateInterfaceProperties(gt, os, properties);
-    }
+  }
 
-  if (require3_1_0)
-    {
+  if (require3_1_0) {
     this->GenerateRequiredCMakeVersion(os, "3.1.0");
-    }
-  else if (require3_0_0)
-    {
+  } else if (require3_0_0) {
     this->GenerateRequiredCMakeVersion(os, "3.0.0");
-    }
-  else if (require2_8_12)
-    {
+  } else if (require2_8_12) {
     this->GenerateRequiredCMakeVersion(os, "2.8.12");
-    }
+  }
 
   // Now load per-configuration properties for them.
   /* clang-format off */
@@ -237,75 +214,62 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
   bool result = true;
   // Generate an import file for each configuration.
   // Don't do this if we only export INTERFACE_LIBRARY targets.
-  if (requiresConfigFiles)
-    {
-    for(std::vector<std::string>::const_iterator
-          ci = this->Configurations.begin();
-        ci != this->Configurations.end(); ++ci)
-      {
-      if(!this->GenerateImportFileConfig(*ci, missingTargets))
-        {
+  if (requiresConfigFiles) {
+    for (std::vector<std::string>::const_iterator ci =
+           this->Configurations.begin();
+         ci != this->Configurations.end(); ++ci) {
+      if (!this->GenerateImportFileConfig(*ci, missingTargets)) {
         result = false;
-        }
       }
     }
+  }
 
   this->GenerateMissingTargetsCheckCode(os, missingTargets);
 
   return result;
 }
 
-void
-cmExportInstallFileGenerator::ReplaceInstallPrefix(std::string &input)
+void cmExportInstallFileGenerator::ReplaceInstallPrefix(std::string& input)
 {
   std::string::size_type pos = 0;
   std::string::size_type lastPos = pos;
 
-  while((pos = input.find("$<INSTALL_PREFIX>", lastPos)) != input.npos)
-    {
+  while ((pos = input.find("$<INSTALL_PREFIX>", lastPos)) != input.npos) {
     std::string::size_type endPos = pos + sizeof("$<INSTALL_PREFIX>") - 1;
     input.replace(pos, endPos - pos, "${_IMPORT_PREFIX}");
     lastPos = endPos;
-    }
+  }
 }
 
-bool
-cmExportInstallFileGenerator::GenerateImportFileConfig(
-                                    const std::string& config,
-                                    std::vector<std::string> &missingTargets)
+bool cmExportInstallFileGenerator::GenerateImportFileConfig(
+  const std::string& config, std::vector<std::string>& missingTargets)
 {
   // Skip configurations not enabled for this export.
-  if(!this->IEGen->InstallsForConfig(config))
-    {
+  if (!this->IEGen->InstallsForConfig(config)) {
     return true;
-    }
+  }
 
   // Construct the name of the file to generate.
   std::string fileName = this->FileDir;
   fileName += "/";
   fileName += this->FileBase;
   fileName += "-";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     fileName += cmSystemTools::LowerCase(config);
-    }
-  else
-    {
+  } else {
     fileName += "noconfig";
-    }
+  }
   fileName += this->FileExt;
 
   // Open the output file to generate it.
   cmGeneratedFileStream exportFileStream(fileName.c_str(), true);
-  if(!exportFileStream)
-    {
+  if (!exportFileStream) {
     std::string se = cmSystemTools::GetLastSystemError();
     std::ostringstream e;
-    e << "cannot write to file \"" << fileName
-      << "\": " << se;
+    e << "cannot write to file \"" << fileName << "\": " << se;
     cmSystemTools::Error(e.str().c_str());
     return false;
-    }
+  }
   std::ostream& os = exportFileStream;
 
   // Start with the import file header.
@@ -323,24 +287,19 @@ cmExportInstallFileGenerator::GenerateImportFileConfig(
   return true;
 }
 
-void
-cmExportInstallFileGenerator
-::GenerateImportTargetsConfig(std::ostream& os,
-                              const std::string& config,
-                              std::string const& suffix,
-                              std::vector<std::string> &missingTargets)
+void cmExportInstallFileGenerator::GenerateImportTargetsConfig(
+  std::ostream& os, const std::string& config, std::string const& suffix,
+  std::vector<std::string>& missingTargets)
 {
   // Add each target in the set to the export.
-  for(std::vector<cmTargetExport*>::const_iterator
-        tei = this->IEGen->GetExportSet()->GetTargetExports()->begin();
-      tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei)
-    {
+  for (std::vector<cmTargetExport*>::const_iterator tei =
+         this->IEGen->GetExportSet()->GetTargetExports()->begin();
+       tei != this->IEGen->GetExportSet()->GetTargetExports()->end(); ++tei) {
     // Collect import properties for this target.
     cmTargetExport const* te = *tei;
-    if (te->Target->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (te->Target->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
 
     ImportPropertyMap properties;
     std::set<std::string> importedLocations;
@@ -349,9 +308,8 @@ cmExportInstallFileGenerator
                                     properties, importedLocations);
     this->SetImportLocationProperty(config, suffix, te->LibraryGenerator,
                                     properties, importedLocations);
-    this->SetImportLocationProperty(config, suffix,
-                                    te->RuntimeGenerator, properties,
-                                    importedLocations);
+    this->SetImportLocationProperty(config, suffix, te->RuntimeGenerator,
+                                    properties, importedLocations);
     this->SetImportLocationProperty(config, suffix, te->FrameworkGenerator,
                                     properties, importedLocations);
     this->SetImportLocationProperty(config, suffix, te->BundleGenerator,
@@ -359,12 +317,11 @@ cmExportInstallFileGenerator
 
     // If any file location was set for the target add it to the
     // import file.
-    if(!properties.empty())
-      {
+    if (!properties.empty()) {
       // Get the rest of the target details.
-      cmGeneratorTarget *gtgt = te->Target;
-      this->SetImportDetailProperties(config, suffix,
-                                      gtgt, properties, missingTargets);
+      cmGeneratorTarget* gtgt = te->Target;
+      this->SetImportDetailProperties(config, suffix, gtgt, properties,
+                                      missingTargets);
 
       this->SetImportLinkInterface(config, suffix,
                                    cmGeneratorExpression::InstallInterface,
@@ -380,24 +337,19 @@ cmExportInstallFileGenerator
       this->GenerateImportPropertyCode(os, config, gtgt, properties);
       this->GenerateImportedFileChecksCode(os, gtgt, properties,
                                            importedLocations);
-      }
     }
+  }
 }
 
-void
-cmExportInstallFileGenerator
-::SetImportLocationProperty(const std::string& config,
-                            std::string const& suffix,
-                            cmInstallTargetGenerator* itgen,
-                            ImportPropertyMap& properties,
-                            std::set<std::string>& importedLocations
-                           )
+void cmExportInstallFileGenerator::SetImportLocationProperty(
+  const std::string& config, std::string const& suffix,
+  cmInstallTargetGenerator* itgen, ImportPropertyMap& properties,
+  std::set<std::string>& importedLocations)
 {
   // Skip rules that do not match this configuration.
-  if(!(itgen && itgen->InstallsForConfig(config)))
-    {
+  if (!(itgen && itgen->InstallsForConfig(config))) {
     return;
-    }
+  }
 
   // Get the target to be installed.
   cmGeneratorTarget* target = itgen->GetTarget();
@@ -405,16 +357,14 @@ cmExportInstallFileGenerator
   // Construct the installed location of the target.
   std::string dest = itgen->GetDestination(config);
   std::string value;
-  if(!cmSystemTools::FileIsFullPath(dest.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(dest.c_str())) {
     // The target is installed relative to the installation prefix.
     value = "${_IMPORT_PREFIX}/";
-    }
+  }
   value += dest;
   value += "/";
 
-  if(itgen->IsImportLibrary())
-    {
+  if (itgen->IsImportLibrary()) {
     // Construct the property name.
     std::string prop = "IMPORTED_IMPLIB";
     prop += suffix;
@@ -426,132 +376,106 @@ cmExportInstallFileGenerator
     // Store the property.
     properties[prop] = value;
     importedLocations.insert(prop);
-    }
-  else
-    {
+  } else {
     // Construct the property name.
     std::string prop = "IMPORTED_LOCATION";
     prop += suffix;
 
     // Append the installed file name.
-    if(target->IsAppBundleOnApple())
-      {
+    if (target->IsAppBundleOnApple()) {
       value += itgen->GetInstallFilename(target, config);
       value += ".app/Contents/MacOS/";
       value += itgen->GetInstallFilename(target, config);
-      }
-    else
-      {
+    } else {
       value += itgen->GetInstallFilename(target, config,
                                          cmInstallTargetGenerator::NameReal);
-      }
+    }
 
     // Store the property.
     properties[prop] = value;
     importedLocations.insert(prop);
-    }
+  }
 }
 
-void
-cmExportInstallFileGenerator::HandleMissingTarget(std::string& link_libs,
-  std::vector<std::string>& missingTargets,
+void cmExportInstallFileGenerator::HandleMissingTarget(
+  std::string& link_libs, std::vector<std::string>& missingTargets,
   cmGeneratorTarget* depender, cmGeneratorTarget* dependee)
 {
   const std::string name = dependee->GetName();
   cmGlobalGenerator* gg = dependee->GetLocalGenerator()->GetGlobalGenerator();
   std::vector<std::string> namespaces = this->FindNamespaces(gg, name);
   int targetOccurrences = (int)namespaces.size();
-  if (targetOccurrences == 1)
-    {
+  if (targetOccurrences == 1) {
     std::string missingTarget = namespaces[0];
 
     missingTarget += dependee->GetExportName();
     link_libs += missingTarget;
     missingTargets.push_back(missingTarget);
-    }
-  else
-    {
+  } else {
     // All exported targets should be known here and should be unique.
     // This is probably user-error.
     this->ComplainAboutMissingTarget(depender, dependee, targetOccurrences);
-    }
+  }
 }
 
-std::vector<std::string>
-cmExportInstallFileGenerator
-::FindNamespaces(cmGlobalGenerator* gg, const std::string& name)
+std::vector<std::string> cmExportInstallFileGenerator::FindNamespaces(
+  cmGlobalGenerator* gg, const std::string& name)
 {
   std::vector<std::string> namespaces;
   const cmExportSetMap& exportSets = gg->GetExportSets();
 
-  for(cmExportSetMap::const_iterator expIt = exportSets.begin();
-      expIt != exportSets.end();
-      ++expIt)
-    {
+  for (cmExportSetMap::const_iterator expIt = exportSets.begin();
+       expIt != exportSets.end(); ++expIt) {
     const cmExportSet* exportSet = expIt->second;
     std::vector<cmTargetExport*> const* targets =
-                                                 exportSet->GetTargetExports();
+      exportSet->GetTargetExports();
 
     bool containsTarget = false;
-    for(unsigned int i=0; i<targets->size(); i++)
-      {
-      if (name == (*targets)[i]->TargetName)
-        {
+    for (unsigned int i = 0; i < targets->size(); i++) {
+      if (name == (*targets)[i]->TargetName) {
         containsTarget = true;
         break;
-        }
       }
+    }
 
-    if (containsTarget)
-      {
+    if (containsTarget) {
       std::vector<cmInstallExportGenerator const*> const* installs =
-                                                 exportSet->GetInstallations();
-      for(unsigned int i=0; i<installs->size(); i++)
-        {
+        exportSet->GetInstallations();
+      for (unsigned int i = 0; i < installs->size(); i++) {
         namespaces.push_back((*installs)[i]->GetNamespace());
-        }
       }
     }
+  }
 
   return namespaces;
 }
 
-void
-cmExportInstallFileGenerator
-::ComplainAboutMissingTarget(cmGeneratorTarget* depender,
-                             cmGeneratorTarget* dependee,
-                             int occurrences)
+void cmExportInstallFileGenerator::ComplainAboutMissingTarget(
+  cmGeneratorTarget* depender, cmGeneratorTarget* dependee, int occurrences)
 {
   std::ostringstream e;
-  e << "install(EXPORT \""
-    << this->IEGen->GetExportSet()->GetName()
+  e << "install(EXPORT \"" << this->IEGen->GetExportSet()->GetName()
     << "\" ...) "
     << "includes target \"" << depender->GetName()
     << "\" which requires target \"" << dependee->GetName() << "\" ";
-  if (occurrences == 0)
-    {
+  if (occurrences == 0) {
     e << "that is not in the export set.";
-    }
-  else
-    {
+  } else {
     e << "that is not in this export set, but " << occurrences
-    << " times in others.";
-    }
+      << " times in others.";
+  }
   cmSystemTools::Error(e.str().c_str());
 }
 
-std::string
-cmExportInstallFileGenerator::InstallNameDir(cmGeneratorTarget* target,
-                                             const std::string&)
+std::string cmExportInstallFileGenerator::InstallNameDir(
+  cmGeneratorTarget* target, const std::string&)
 {
   std::string install_name_dir;
 
   cmMakefile* mf = target->Target->GetMakefile();
-  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
-    install_name_dir =
-      target->GetInstallNameDirForInstallTree();
-    }
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    install_name_dir = target->GetInstallNameDirForInstallTree();
+  }
 
   return install_name_dir;
 }
diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h
index 13dae89..723b6e5 100644
--- a/Source/cmExportInstallFileGenerator.h
+++ b/Source/cmExportInstallFileGenerator.h
@@ -31,7 +31,7 @@ class cmInstallTargetGenerator;
  *
  * This is used to implement the INSTALL(EXPORT) command.
  */
-class cmExportInstallFileGenerator: public cmExportFileGenerator
+class cmExportInstallFileGenerator : public cmExportFileGenerator
 {
 public:
   /** Construct with the export installer that will install the
@@ -42,25 +42,26 @@ public:
       maps from the configuration name to the file temporary location
       for installation.  */
   std::map<std::string, std::string> const& GetConfigImportFiles()
-    { return this->ConfigImportFiles; }
+  {
+    return this->ConfigImportFiles;
+  }
 
   /** Compute the globbing expression used to load per-config import
       files from the main file.  */
   std::string GetConfigImportFileGlob();
-protected:
 
+protected:
   // Implement virtual methods from the superclass.
   virtual bool GenerateMainFile(std::ostream& os);
-  virtual void GenerateImportTargetsConfig(std::ostream& os,
-                                           const std::string& config,
-                                           std::string const& suffix,
-                            std::vector<std::string> &missingTargets);
+  virtual void GenerateImportTargetsConfig(
+    std::ostream& os, const std::string& config, std::string const& suffix,
+    std::vector<std::string>& missingTargets);
   virtual void HandleMissingTarget(std::string& link_libs,
                                    std::vector<std::string>& missingTargets,
                                    cmGeneratorTarget* depender,
                                    cmGeneratorTarget* dependee);
 
-  virtual void ReplaceInstallPrefix(std::string &input);
+  virtual void ReplaceInstallPrefix(std::string& input);
 
   void ComplainAboutMissingTarget(cmGeneratorTarget* depender,
                                   cmGeneratorTarget* dependee,
@@ -69,18 +70,16 @@ protected:
   std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg,
                                           const std::string& name);
 
-
   /** Generate a per-configuration file for the targets.  */
   bool GenerateImportFileConfig(const std::string& config,
-                            std::vector<std::string> &missingTargets);
+                                std::vector<std::string>& missingTargets);
 
   /** Fill in properties indicating installed file locations.  */
   void SetImportLocationProperty(const std::string& config,
                                  std::string const& suffix,
                                  cmInstallTargetGenerator* itgen,
                                  ImportPropertyMap& properties,
-                                 std::set<std::string>& importedLocations
-                                );
+                                 std::set<std::string>& importedLocations);
 
   std::string InstallNameDir(cmGeneratorTarget* target,
                              const std::string& config);
diff --git a/Source/cmExportLibraryDependenciesCommand.cxx b/Source/cmExportLibraryDependenciesCommand.cxx
index a715070..ab43aa8 100644
--- a/Source/cmExportLibraryDependenciesCommand.cxx
+++ b/Source/cmExportLibraryDependenciesCommand.cxx
@@ -18,33 +18,31 @@
 
 #include <cmsys/auto_ptr.hxx>
 
-bool cmExportLibraryDependenciesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmExportLibraryDependenciesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0033,
-      "The export_library_dependencies command should not be called; "
-      "see CMP0033."))
-    { return true; }
-  if(args.size() < 1 )
-    {
+  if (this->Disallowed(
+        cmPolicies::CMP0033,
+        "The export_library_dependencies command should not be called; "
+        "see CMP0033.")) {
+    return true;
+  }
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // store the arguments for the final pass
   this->Filename = args[0];
   this->Append = false;
-  if(args.size() > 1)
-    {
-    if(args[1] == "APPEND")
-      {
+  if (args.size() > 1) {
+    if (args[1] == "APPEND") {
       this->Append = true;
-      }
     }
+  }
   return true;
 }
 
-
 void cmExportLibraryDependenciesCommand::FinalPass()
 {
   // export_library_dependencies() shouldn't modify anything
@@ -56,27 +54,23 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
 {
   // Use copy-if-different if not appending.
   cmsys::auto_ptr<cmsys::ofstream> foutPtr;
-  if(this->Append)
-    {
+  if (this->Append) {
     cmsys::auto_ptr<cmsys::ofstream> ap(
       new cmsys::ofstream(this->Filename.c_str(), std::ios::app));
     foutPtr = ap;
-    }
-  else
-    {
+  } else {
     cmsys::auto_ptr<cmGeneratedFileStream> ap(
       new cmGeneratedFileStream(this->Filename.c_str(), true));
     ap->SetCopyIfDifferent(true);
     foutPtr = ap;
-    }
+  }
   std::ostream& fout = *foutPtr.get();
 
-  if (!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("Error Writing ", this->Filename.c_str());
     cmSystemTools::ReportLastSystemError("");
     return;
-    }
+  }
 
   // Collect dependency information about all library targets built in
   // the project.
@@ -86,22 +80,18 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
   std::map<std::string, std::string> libDepsOld;
   std::map<std::string, std::string> libDepsNew;
   std::map<std::string, std::string> libTypes;
-  for(std::vector<cmMakefile*>::const_iterator i = locals.begin();
-      i != locals.end(); ++i)
-    {
-    const cmTargets &tgts = (*i)->GetTargets();
-    for(cmTargets::const_iterator l = tgts.begin();
-        l != tgts.end(); ++l)
-      {
+  for (std::vector<cmMakefile*>::const_iterator i = locals.begin();
+       i != locals.end(); ++i) {
+    const cmTargets& tgts = (*i)->GetTargets();
+    for (cmTargets::const_iterator l = tgts.begin(); l != tgts.end(); ++l) {
       // Get the current target.
       cmTarget const& target = l->second;
 
       // Skip non-library targets.
-      if(target.GetType() < cmState::STATIC_LIBRARY
-         || target.GetType() > cmState::MODULE_LIBRARY)
-        {
+      if (target.GetType() < cmState::STATIC_LIBRARY ||
+          target.GetType() > cmState::MODULE_LIBRARY) {
         continue;
-        }
+      }
 
       // Construct the dependency variable name.
       std::string targetEntry = target.GetName();
@@ -113,14 +103,12 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
       std::string valueNew;
       cmTarget::LinkLibraryVectorType const& libs =
         target.GetOriginalLinkLibraries();
-      for(cmTarget::LinkLibraryVectorType::const_iterator li = libs.begin();
-          li != libs.end(); ++li)
-        {
+      for (cmTarget::LinkLibraryVectorType::const_iterator li = libs.begin();
+           li != libs.end(); ++li) {
         std::string ltVar = li->first;
         ltVar += "_LINK_TYPE";
         std::string ltValue;
-        switch(li->second)
-          {
+        switch (li->second) {
           case GENERAL_LibraryType:
             valueNew += "general;";
             ltValue = "general";
@@ -133,73 +121,62 @@ void cmExportLibraryDependenciesCommand::ConstFinalPass() const
             valueNew += "optimized;";
             ltValue = "optimized";
             break;
-          }
+        }
         std::string lib = li->first;
-        if(cmTarget* libtgt = global->FindTarget(lib))
-          {
+        if (cmTarget* libtgt = global->FindTarget(lib)) {
           // Handle simple output name changes.  This command is
           // deprecated so we do not support full target name
           // translation (which requires per-configuration info).
-          if(const char* outname = libtgt->GetProperty("OUTPUT_NAME"))
-            {
+          if (const char* outname = libtgt->GetProperty("OUTPUT_NAME")) {
             lib = outname;
-            }
           }
+        }
         valueOld += lib;
         valueOld += ";";
         valueNew += lib;
         valueNew += ";";
 
         std::string& ltEntry = libTypes[ltVar];
-        if(ltEntry.empty())
-          {
+        if (ltEntry.empty()) {
           ltEntry = ltValue;
-          }
-        else if(ltEntry != ltValue)
-          {
+        } else if (ltEntry != ltValue) {
           ltEntry = "general";
-          }
         }
+      }
       libDepsNew[targetEntry] = valueNew;
       libDepsOld[targetEntry] = valueOld;
-      }
     }
+  }
 
   // Generate dependency information for both old and new style CMake
   // versions.
   const char* vertest =
     "\"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}\" GREATER 2.4";
-  fout << "# Generated by CMake " <<  cmVersion::GetCMakeVersion() << "\n\n";
+  fout << "# Generated by CMake " << cmVersion::GetCMakeVersion() << "\n\n";
   fout << "if(" << vertest << ")\n";
   fout << "  # Information for CMake 2.6 and above.\n";
-  for(std::map<std::string, std::string>::const_iterator
-        i = libDepsNew.begin();
-      i != libDepsNew.end(); ++i)
-    {
-    if(!i->second.empty())
-      {
+  for (std::map<std::string, std::string>::const_iterator i =
+         libDepsNew.begin();
+       i != libDepsNew.end(); ++i) {
+    if (!i->second.empty()) {
       fout << "  set(\"" << i->first << "\" \"" << i->second << "\")\n";
-      }
     }
+  }
   fout << "else()\n";
   fout << "  # Information for CMake 2.4 and lower.\n";
-  for(std::map<std::string, std::string>::const_iterator
-        i = libDepsOld.begin();
-      i != libDepsOld.end(); ++i)
-    {
-    if(!i->second.empty())
-      {
+  for (std::map<std::string, std::string>::const_iterator i =
+         libDepsOld.begin();
+       i != libDepsOld.end(); ++i) {
+    if (!i->second.empty()) {
       fout << "  set(\"" << i->first << "\" \"" << i->second << "\")\n";
-      }
     }
-  for(std::map<std::string, std::string>::const_iterator i = libTypes.begin();
-      i != libTypes.end(); ++i)
-    {
-    if(i->second != "general")
-      {
+  }
+  for (std::map<std::string, std::string>::const_iterator i = libTypes.begin();
+       i != libTypes.end(); ++i) {
+    if (i->second != "general") {
       fout << "  set(\"" << i->first << "\" \"" << i->second << "\")\n";
-      }
     }
+  }
   fout << "endif()\n";
   return;
 }
diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h
index 81aa21a..3fb3565 100644
--- a/Source/cmExportLibraryDependenciesCommand.h
+++ b/Source/cmExportLibraryDependenciesCommand.h
@@ -20,8 +20,8 @@ public:
   cmTypeMacro(cmExportLibraryDependenciesCommand, cmCommand);
   virtual cmCommand* Clone() { return new cmExportLibraryDependenciesCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const { return "export_library_dependencies";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "export_library_dependencies"; }
 
   virtual void FinalPass();
   virtual bool HasFinalPass() const { return true; }
@@ -32,5 +32,4 @@ private:
   void ConstFinalPass() const;
 };
 
-
 #endif
diff --git a/Source/cmExportSet.cxx b/Source/cmExportSet.cxx
index 83c4fdc..c468e3e 100644
--- a/Source/cmExportSet.cxx
+++ b/Source/cmExportSet.cxx
@@ -24,10 +24,9 @@ cmExportSet::~cmExportSet()
 void cmExportSet::Compute(cmLocalGenerator* lg)
 {
   for (std::vector<cmTargetExport*>::iterator it = this->TargetExports.begin();
-       it != this->TargetExports.end(); ++it)
-    {
+       it != this->TargetExports.end(); ++it) {
     (*it)->Target = lg->FindGeneratorTargetToUse((*it)->TargetName);
-    }
+  }
 }
 
 void cmExportSet::AddTargetExport(cmTargetExport* te)
diff --git a/Source/cmExportSet.h b/Source/cmExportSet.h
index a3359ac..49f2cac 100644
--- a/Source/cmExportSet.h
+++ b/Source/cmExportSet.h
@@ -23,7 +23,10 @@ class cmExportSet
 {
 public:
   /// Construct an empty export set named \a name
-  cmExportSet(const std::string &name) : Name(name) {}
+  cmExportSet(const std::string& name)
+    : Name(name)
+  {
+  }
   /// Destructor
   ~cmExportSet();
 
@@ -36,10 +39,14 @@ public:
   std::string const& GetName() const { return this->Name; }
 
   std::vector<cmTargetExport*> const* GetTargetExports() const
-     { return &this->TargetExports; }
+  {
+    return &this->TargetExports;
+  }
 
   std::vector<cmInstallExportGenerator const*> const* GetInstallations() const
-     { return &this->Installations; }
+  {
+    return &this->Installations;
+  }
 
 private:
   std::vector<cmTargetExport*> TargetExports;
diff --git a/Source/cmExportSetMap.cxx b/Source/cmExportSetMap.cxx
index d267cd3..ac1c66e 100644
--- a/Source/cmExportSetMap.cxx
+++ b/Source/cmExportSetMap.cxx
@@ -15,13 +15,13 @@
 #include "cmAlgorithms.h"
 #include "cmExportSet.h"
 
-cmExportSet* cmExportSetMap::operator[](const std::string &name)
+cmExportSet* cmExportSetMap::operator[](const std::string& name)
 {
   std::map<std::string, cmExportSet*>::iterator it = this->find(name);
   if (it == this->end()) // Export set not found
-    {
+  {
     it = this->insert(std::make_pair(name, new cmExportSet(name))).first;
-    }
+  }
   return it->second;
 }
 
diff --git a/Source/cmExportSetMap.h b/Source/cmExportSetMap.h
index 87f2060..d2954e3 100644
--- a/Source/cmExportSetMap.h
+++ b/Source/cmExportSetMap.h
@@ -20,13 +20,14 @@ class cmExportSet;
 class cmExportSetMap : public std::map<std::string, cmExportSet*>
 {
   typedef std::map<std::string, cmExportSet*> derived;
+
 public:
   /** \brief Overloaded operator[].
    *
    * The operator is overloaded because cmExportSet has no default constructor:
    * we do not want unnamed export sets.
    */
-  cmExportSet* operator[](const std::string &name);
+  cmExportSet* operator[](const std::string& name);
 
   void clear();
 
diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx
index 891af84..5a826f2 100644
--- a/Source/cmExportTryCompileFileGenerator.cxx
+++ b/Source/cmExportTryCompileFileGenerator.cxx
@@ -18,9 +18,8 @@
 #include "cmLocalGenerator.h"
 
 cmExportTryCompileFileGenerator::cmExportTryCompileFileGenerator(
-    cmGlobalGenerator* gg,
-    const std::vector<std::string>& targets,
-    cmMakefile* mf)
+  cmGlobalGenerator* gg, const std::vector<std::string>& targets,
+  cmMakefile* mf)
 {
   gg->CreateImportedGenerationObjects(mf, targets, this->Exports);
 }
@@ -29,19 +28,17 @@ bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os)
 {
   std::set<cmGeneratorTarget const*> emitted;
   std::set<cmGeneratorTarget const*> emittedDeps;
-  while(!this->Exports.empty())
-    {
+  while (!this->Exports.empty()) {
     cmGeneratorTarget const* te = this->Exports.back();
     this->Exports.pop_back();
-    if (emitted.insert(te).second)
-      {
+    if (emitted.insert(te).second) {
       emittedDeps.insert(te);
       this->GenerateImportTargetCode(os, te);
 
       ImportPropertyMap properties;
 
-#define FIND_TARGETS(PROPERTY) \
-      this->FindTargets("INTERFACE_" #PROPERTY, te, emittedDeps);
+#define FIND_TARGETS(PROPERTY)                                                \
+  this->FindTargets("INTERFACE_" #PROPERTY, te, emittedDeps);
 
       CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(FIND_TARGETS)
 
@@ -50,27 +47,23 @@ bool cmExportTryCompileFileGenerator::GenerateMainFile(std::ostream& os)
       this->PopulateProperties(te, properties, emittedDeps);
 
       this->GenerateInterfaceProperties(te, os, properties);
-      }
     }
+  }
   return true;
 }
 
 std::string cmExportTryCompileFileGenerator::FindTargets(
-                                  const std::string& propName,
-                                  cmGeneratorTarget const* tgt,
-                                  std::set<cmGeneratorTarget const*> &emitted)
+  const std::string& propName, cmGeneratorTarget const* tgt,
+  std::set<cmGeneratorTarget const*>& emitted)
 {
-  const char *prop = tgt->GetProperty(propName);
-  if(!prop)
-    {
+  const char* prop = tgt->GetProperty(propName);
+  if (!prop) {
     return std::string();
-    }
+  }
 
   cmGeneratorExpression ge;
 
-  cmGeneratorExpressionDAGChecker dagChecker(
-                                      tgt->GetName(),
-                                      propName, 0, 0);
+  cmGeneratorExpressionDAGChecker dagChecker(tgt->GetName(), propName, 0, 0);
 
   cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
 
@@ -81,70 +74,58 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
   cmGeneratorTarget gDummyHead(&dummyHead, tgt->GetLocalGenerator());
 
   std::string result = cge->Evaluate(tgt->GetLocalGenerator(), this->Config,
-                                     false, &gDummyHead,
-                                     tgt, &dagChecker);
-
-  const std::set<cmGeneratorTarget const*> &allTargets =
-      cge->GetAllTargetsSeen();
-  for(std::set<cmGeneratorTarget const*>::const_iterator li =
-      allTargets.begin(); li != allTargets.end(); ++li)
-    {
-    if(emitted.insert(*li).second)
-      {
+                                     false, &gDummyHead, tgt, &dagChecker);
+
+  const std::set<cmGeneratorTarget const*>& allTargets =
+    cge->GetAllTargetsSeen();
+  for (std::set<cmGeneratorTarget const*>::const_iterator li =
+         allTargets.begin();
+       li != allTargets.end(); ++li) {
+    if (emitted.insert(*li).second) {
       this->Exports.push_back(*li);
-      }
     }
+  }
   return result;
 }
 
-void
-cmExportTryCompileFileGenerator::PopulateProperties(
-                                 const cmGeneratorTarget* target,
-                                 ImportPropertyMap& properties,
-                                 std::set<cmGeneratorTarget const*> &emitted)
+void cmExportTryCompileFileGenerator::PopulateProperties(
+  const cmGeneratorTarget* target, ImportPropertyMap& properties,
+  std::set<cmGeneratorTarget const*>& emitted)
 {
   std::vector<std::string> props = target->GetPropertyKeys();
-  for(std::vector<std::string>::const_iterator i = props.begin();
-      i != props.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = props.begin();
+       i != props.end(); ++i) {
 
     properties[*i] = target->GetProperty(*i);
 
-    if(i->find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0
-        || i->find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0
-        || i->find("INTERFACE_LINK_LIBRARIES") == 0)
-      {
-      std::string evalResult = this->FindTargets(*i,
-                                                 target, emitted);
+    if (i->find("IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 ||
+        i->find("IMPORTED_LINK_DEPENDENT_LIBRARIES") == 0 ||
+        i->find("INTERFACE_LINK_LIBRARIES") == 0) {
+      std::string evalResult = this->FindTargets(*i, target, emitted);
 
       std::vector<std::string> depends;
       cmSystemTools::ExpandListArgument(evalResult, depends);
-      for(std::vector<std::string>::const_iterator li = depends.begin();
-          li != depends.end(); ++li)
-        {
-        cmGeneratorTarget *tgt =
-            target->GetLocalGenerator()->FindGeneratorTargetToUse(*li);
-        if(tgt && emitted.insert(tgt).second)
-          {
+      for (std::vector<std::string>::const_iterator li = depends.begin();
+           li != depends.end(); ++li) {
+        cmGeneratorTarget* tgt =
+          target->GetLocalGenerator()->FindGeneratorTargetToUse(*li);
+        if (tgt && emitted.insert(tgt).second) {
           this->Exports.push_back(tgt);
-          }
         }
       }
     }
+  }
 }
 
-std::string
-cmExportTryCompileFileGenerator::InstallNameDir(cmGeneratorTarget* target,
-                                                const std::string& config)
+std::string cmExportTryCompileFileGenerator::InstallNameDir(
+  cmGeneratorTarget* target, const std::string& config)
 {
   std::string install_name_dir;
 
   cmMakefile* mf = target->Target->GetMakefile();
-  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
-    install_name_dir =
-      target->GetInstallNameDirForBuildTree(config);
-    }
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
+    install_name_dir = target->GetInstallNameDirForBuildTree(config);
+  }
 
   return install_name_dir;
 }
diff --git a/Source/cmExportTryCompileFileGenerator.h b/Source/cmExportTryCompileFileGenerator.h
index fc135a4..26f4db1 100644
--- a/Source/cmExportTryCompileFileGenerator.h
+++ b/Source/cmExportTryCompileFileGenerator.h
@@ -17,7 +17,7 @@
 class cmInstallExportGenerator;
 class cmInstallTargetGenerator;
 
-class cmExportTryCompileFileGenerator: public cmExportFileGenerator
+class cmExportTryCompileFileGenerator : public cmExportFileGenerator
 {
 public:
   cmExportTryCompileFileGenerator(cmGlobalGenerator* gg,
@@ -27,18 +27,18 @@ public:
   /** Set the list of targets to export.  */
   void SetConfig(const std::string& config) { this->Config = config; }
 protected:
-
   // Implement virtual methods from the superclass.
   virtual bool GenerateMainFile(std::ostream& os);
 
-  virtual void GenerateImportTargetsConfig(std::ostream&,
-                                           const std::string&,
+  virtual void GenerateImportTargetsConfig(std::ostream&, const std::string&,
                                            std::string const&,
-                            std::vector<std::string>&) {}
-  virtual void HandleMissingTarget(std::string&,
-                                   std::vector<std::string>&,
-                                   cmGeneratorTarget*,
-                                   cmGeneratorTarget*) {}
+                                           std::vector<std::string>&)
+  {
+  }
+  virtual void HandleMissingTarget(std::string&, std::vector<std::string>&,
+                                   cmGeneratorTarget*, cmGeneratorTarget*)
+  {
+  }
 
   void PopulateProperties(cmGeneratorTarget const* target,
                           ImportPropertyMap& properties,
@@ -46,12 +46,12 @@ protected:
 
   std::string InstallNameDir(cmGeneratorTarget* target,
                              const std::string& config);
+
 private:
   std::string FindTargets(const std::string& prop,
                           const cmGeneratorTarget* tgt,
                           std::set<const cmGeneratorTarget*>& emitted);
 
-
   std::vector<cmGeneratorTarget const*> Exports;
   std::string Config;
 };
diff --git a/Source/cmExprParserHelper.cxx b/Source/cmExprParserHelper.cxx
index c5ecde4..2ba9b8d 100644
--- a/Source/cmExprParserHelper.cxx
+++ b/Source/cmExprParserHelper.cxx
@@ -16,7 +16,7 @@
 
 #include "cmExprLexer.h"
 
-int cmExpr_yyparse( yyscan_t yyscanner );
+int cmExpr_yyparse(yyscan_t yyscanner);
 //
 cmExprParserHelper::cmExprParserHelper()
 {
@@ -24,7 +24,6 @@ cmExprParserHelper::cmExprParserHelper()
   this->FileName = 0;
 }
 
-
 cmExprParserHelper::~cmExprParserHelper()
 {
   this->CleanupParser();
@@ -32,11 +31,10 @@ cmExprParserHelper::~cmExprParserHelper()
 
 int cmExprParserHelper::ParseString(const char* str, int verb)
 {
-  if ( !str)
-    {
+  if (!str) {
     return 0;
-    }
-  //printf("Do some parsing: %s\n", str);
+  }
+  // printf("Do some parsing: %s\n", str);
 
   this->Verbose = verb;
   this->InputBuffer = str;
@@ -50,20 +48,18 @@ int cmExprParserHelper::ParseString(const char* str, int verb)
   cmExpr_yyset_extra(this, yyscanner);
   int res = cmExpr_yyparse(yyscanner);
   cmExpr_yylex_destroy(yyscanner);
-  if ( res != 0 )
-    {
-    //str << "CAL_Parser returned: " << res << std::endl;
-    //std::cerr << "When parsing: [" << str << "]" << std::endl;
+  if (res != 0) {
+    // str << "CAL_Parser returned: " << res << std::endl;
+    // std::cerr << "When parsing: [" << str << "]" << std::endl;
     return 0;
-    }
+  }
 
   this->CleanupParser();
 
-  if ( Verbose )
-    {
-    std::cerr << "Expanding [" << str << "] produced: ["
-              << this->Result << "]" << std::endl;
-    }
+  if (Verbose) {
+    std::cerr << "Expanding [" << str << "] produced: [" << this->Result << "]"
+              << std::endl;
+  }
   return 1;
 }
 
@@ -73,27 +69,22 @@ void cmExprParserHelper::CleanupParser()
 
 int cmExprParserHelper::LexInput(char* buf, int maxlen)
 {
-  //std::cout << "JPLexInput ";
-  //std::cout.write(buf, maxlen);
-  //std::cout << std::endl;
-  if ( maxlen < 1 )
-    {
+  // std::cout << "JPLexInput ";
+  // std::cout.write(buf, maxlen);
+  // std::cout << std::endl;
+  if (maxlen < 1) {
     return 0;
+  }
+  if (this->InputBufferPos < this->InputBuffer.size()) {
+    buf[0] = this->InputBuffer[this->InputBufferPos++];
+    if (buf[0] == '\n') {
+      this->CurrentLine++;
     }
-  if ( this->InputBufferPos < this->InputBuffer.size() )
-    {
-    buf[0] = this->InputBuffer[ this->InputBufferPos++ ];
-    if ( buf[0] == '\n' )
-      {
-      this->CurrentLine ++;
-      }
-    return(1);
-    }
-  else
-    {
+    return (1);
+  } else {
     buf[0] = '\n';
-    return( 0 );
-    }
+    return (0);
+  }
 }
 
 void cmExprParserHelper::Error(const char* str)
@@ -108,5 +99,3 @@ void cmExprParserHelper::SetResult(int value)
 {
   this->Result = value;
 }
-
-
diff --git a/Source/cmExprParserHelper.h b/Source/cmExprParserHelper.h
index 8d6b2cd..af0b916 100644
--- a/Source/cmExprParserHelper.h
+++ b/Source/cmExprParserHelper.h
@@ -30,7 +30,8 @@ class cmMakefile;
 class cmExprParserHelper
 {
 public:
-  typedef struct {
+  typedef struct
+  {
     int Number;
   } ParserType;
 
@@ -66,6 +67,3 @@ private:
 };
 
 #endif
-
-
-
diff --git a/Source/cmExternalMakefileProjectGenerator.cxx b/Source/cmExternalMakefileProjectGenerator.cxx
index cdf0292..e3c8fa4 100644
--- a/Source/cmExternalMakefileProjectGenerator.cxx
+++ b/Source/cmExternalMakefileProjectGenerator.cxx
@@ -14,58 +14,48 @@
 
 #include <assert.h>
 
-void cmExternalMakefileProjectGenerator
-::EnableLanguage(std::vector<std::string> const&,
-                 cmMakefile *, bool)
+void cmExternalMakefileProjectGenerator::EnableLanguage(
+  std::vector<std::string> const&, cmMakefile*, bool)
 {
 }
 
 std::string cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
-                                            const std::string& globalGenerator,
-                                            const std::string& extraGenerator)
+  const std::string& globalGenerator, const std::string& extraGenerator)
 {
   std::string fullName;
-  if (!globalGenerator.empty())
-    {
-    if (!extraGenerator.empty())
-      {
+  if (!globalGenerator.empty()) {
+    if (!extraGenerator.empty()) {
       fullName = extraGenerator;
       fullName += " - ";
-      }
-    fullName += globalGenerator;
     }
+    fullName += globalGenerator;
+  }
   return fullName;
 }
 
 std::string cmExternalMakefileProjectGenerator::GetGlobalGeneratorName(
-                                                  const std::string& fullName)
+  const std::string& fullName)
 {
   // at least one global generator must be supported
   assert(!this->SupportedGlobalGenerators.empty());
 
-  if (fullName.empty())
-    {
+  if (fullName.empty()) {
     return "";
-    }
+  }
 
   std::string currentName = fullName;
   // if we get only the short name, take the first global generator as default
-  if (currentName == this->GetName())
-    {
+  if (currentName == this->GetName()) {
     return this->SupportedGlobalGenerators[0];
-    }
+  }
 
   // otherwise search for the matching global generator
-  for (std::vector<std::string>::const_iterator
-       it = this->SupportedGlobalGenerators.begin();
-       it != this->SupportedGlobalGenerators.end();
-       ++it)
-    {
-      if (this->CreateFullGeneratorName(*it, this->GetName())
-                                                                == currentName)
-      {
-        return *it;
-      }
+  for (std::vector<std::string>::const_iterator it =
+         this->SupportedGlobalGenerators.begin();
+       it != this->SupportedGlobalGenerators.end(); ++it) {
+    if (this->CreateFullGeneratorName(*it, this->GetName()) == currentName) {
+      return *it;
     }
+  }
   return "";
 }
diff --git a/Source/cmExternalMakefileProjectGenerator.h b/Source/cmExternalMakefileProjectGenerator.h
index cba1c76..5d4d54d 100644
--- a/Source/cmExternalMakefileProjectGenerator.h
+++ b/Source/cmExternalMakefileProjectGenerator.h
@@ -33,7 +33,6 @@ class cmGlobalGenerator;
 class cmExternalMakefileProjectGenerator
 {
 public:
-
   virtual ~cmExternalMakefileProjectGenerator() {}
 
   ///! Get the name for this generator.
@@ -42,15 +41,19 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const std::string& fullName) const = 0;
   virtual void EnableLanguage(std::vector<std::string> const& languages,
-                              cmMakefile *, bool optional);
+                              cmMakefile*, bool optional);
 
   ///! set the global generator which will generate the makefiles
   virtual void SetGlobalGenerator(cmGlobalGenerator* generator)
-                                           {this->GlobalGenerator = generator;}
+  {
+    this->GlobalGenerator = generator;
+  }
 
   ///! Return the list of global generators supported by this extra generator
   const std::vector<std::string>& GetSupportedGlobalGenerators() const
-                                      {return this->SupportedGlobalGenerators;}
+  {
+    return this->SupportedGlobalGenerators;
+  }
 
   ///! Get the name of the global generator for the given full name
   std::string GetGlobalGeneratorName(const std::string& fullName);
@@ -58,11 +61,11 @@ public:
    * extra generator name
    */
   static std::string CreateFullGeneratorName(
-                                            const std::string& globalGenerator,
-                                            const std::string& extraGenerator);
+    const std::string& globalGenerator, const std::string& extraGenerator);
 
   ///! Generate the project files, the Makefiles have already been generated
   virtual void Generate() = 0;
+
 protected:
   ///! Contains the names of the global generators support by this generator.
   std::vector<std::string> SupportedGlobalGenerators;
diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx
index 53a9fdc..2070b1f 100644
--- a/Source/cmExtraCodeBlocksGenerator.cxx
+++ b/Source/cmExtraCodeBlocksGenerator.cxx
@@ -36,15 +36,15 @@ Discussion:
 http://forums.codeblocks.org/index.php/topic,6789.0.html
 */
 
-void cmExtraCodeBlocksGenerator
-::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
+void cmExtraCodeBlocksGenerator::GetDocumentation(cmDocumentationEntry& entry,
+                                                  const std::string&) const
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates CodeBlocks project files.";
 }
 
 cmExtraCodeBlocksGenerator::cmExtraCodeBlocksGenerator()
-:cmExternalMakefileProjectGenerator()
+  : cmExternalMakefileProjectGenerator()
 {
 #if defined(_WIN32)
   this->SupportedGlobalGenerators.push_back("MinGW Makefiles");
@@ -56,37 +56,32 @@ cmExtraCodeBlocksGenerator::cmExtraCodeBlocksGenerator()
   this->SupportedGlobalGenerators.push_back("Unix Makefiles");
 }
 
-
 void cmExtraCodeBlocksGenerator::Generate()
 {
   // for each sub project in the project create a codeblocks project
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = this->GlobalGenerator->GetProjectMap().begin();
-      it!= this->GlobalGenerator->GetProjectMap().end();
-      ++it)
-    {
+         it = this->GlobalGenerator->GetProjectMap().begin();
+       it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     // create a project file
     this->CreateProjectFile(it->second);
-    }
+  }
 }
 
-
 /* create the project file */
 void cmExtraCodeBlocksGenerator::CreateProjectFile(
-                                     const std::vector<cmLocalGenerator*>& lgs)
+  const std::vector<cmLocalGenerator*>& lgs)
 {
-  std::string outputDir=lgs[0]->GetCurrentBinaryDirectory();
-  std::string projectName=lgs[0]->GetProjectName();
+  std::string outputDir = lgs[0]->GetCurrentBinaryDirectory();
+  std::string projectName = lgs[0]->GetProjectName();
 
-  std::string filename=outputDir+"/";
-  filename+=projectName+".cbp";
-  std::string sessionFilename=outputDir+"/";
-  sessionFilename+=projectName+".layout";
+  std::string filename = outputDir + "/";
+  filename += projectName + ".cbp";
+  std::string sessionFilename = outputDir + "/";
+  sessionFilename += projectName + ".layout";
 
   this->CreateNewProjectFile(lgs, filename);
 }
 
-
 /* Tree is used to create a "Virtual Folder" in CodeBlocks, in which all
  CMake files this project depends on will be put. This means additionally
  to the "Sources" and "Headers" virtual folders of CodeBlocks, there will
@@ -95,7 +90,7 @@ void cmExtraCodeBlocksGenerator::CreateProjectFile(
  files in QtCreator).*/
 struct Tree
 {
-  std::string path; //only one component of the path
+  std::string path; // only one component of the path
   std::vector<Tree> folders;
   std::vector<std::string> files;
   void InsertPath(const std::vector<std::string>& splitted,
@@ -105,94 +100,72 @@ struct Tree
   void BuildVirtualFolderImpl(std::string& virtualFolders,
                               const std::string& prefix) const;
   void BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const;
-  void BuildUnitImpl(cmXMLWriter& xml,
-                     const std::string& virtualFolderPath,
+  void BuildUnitImpl(cmXMLWriter& xml, const std::string& virtualFolderPath,
                      const std::string& fsPath) const;
 };
 
-
 void Tree::InsertPath(const std::vector<std::string>& splitted,
                       std::vector<std::string>::size_type start,
                       const std::string& fileName)
 {
-  if (start == splitted.size())
-    {
+  if (start == splitted.size()) {
     files.push_back(fileName);
     return;
-    }
-  for (std::vector<Tree>::iterator
-       it = folders.begin();
-       it != folders.end();
-       ++it)
-    {
-    if ((*it).path == splitted[start])
-      {
-      if (start + 1 <  splitted.size())
-        {
+  }
+  for (std::vector<Tree>::iterator it = folders.begin(); it != folders.end();
+       ++it) {
+    if ((*it).path == splitted[start]) {
+      if (start + 1 < splitted.size()) {
         it->InsertPath(splitted, start + 1, fileName);
         return;
-        }
-      else
-        {
+      } else {
         // last part of splitted
         it->files.push_back(fileName);
         return;
-        }
       }
     }
+  }
   // Not found in folders, thus insert
   Tree newFolder;
   newFolder.path = splitted[start];
-  if (start + 1 <  splitted.size())
-    {
+  if (start + 1 < splitted.size()) {
     newFolder.InsertPath(splitted, start + 1, fileName);
     folders.push_back(newFolder);
     return;
-    }
-  else
-    {
+  } else {
     // last part of splitted
     newFolder.files.push_back(fileName);
     folders.push_back(newFolder);
     return;
-    }
+  }
 }
 
-
 void Tree::BuildVirtualFolder(cmXMLWriter& xml) const
 {
   xml.StartElement("Option");
   std::string virtualFolders = "CMake Files\\;";
   for (std::vector<Tree>::const_iterator it = folders.begin();
-     it != folders.end();
-     ++it)
-    {
+       it != folders.end(); ++it) {
     it->BuildVirtualFolderImpl(virtualFolders, "");
-    }
+  }
   xml.Attribute("virtualFolders", virtualFolders);
   xml.EndElement();
 }
 
-
 void Tree::BuildVirtualFolderImpl(std::string& virtualFolders,
                                   const std::string& prefix) const
 {
-  virtualFolders += "CMake Files\\" + prefix +  path + "\\;";
+  virtualFolders += "CMake Files\\" + prefix + path + "\\;";
   for (std::vector<Tree>::const_iterator it = folders.begin();
-       it != folders.end();
-     ++it)
-    {
+       it != folders.end(); ++it) {
     it->BuildVirtualFolderImpl(virtualFolders, prefix + path + "\\");
-    }
+  }
 }
 
-
 void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
 {
   for (std::vector<std::string>::const_iterator it = files.begin();
-       it != files.end();
-       ++it)
-    {
+       it != files.end(); ++it) {
     xml.StartElement("Unit");
     xml.Attribute("filename", fsPath + *it);
 
@@ -201,111 +174,92 @@ void Tree::BuildUnit(cmXMLWriter& xml, const std::string& fsPath) const
     xml.EndElement();
 
     xml.EndElement();
-    }
+  }
   for (std::vector<Tree>::const_iterator it = folders.begin();
-     it != folders.end();
-     ++it)
-    {
+       it != folders.end(); ++it) {
     it->BuildUnitImpl(xml, "", fsPath);
-    }
+  }
 }
 
-
 void Tree::BuildUnitImpl(cmXMLWriter& xml,
                          const std::string& virtualFolderPath,
                          const std::string& fsPath) const
 {
   for (std::vector<std::string>::const_iterator it = files.begin();
-       it != files.end();
-       ++it)
-    {
+       it != files.end(); ++it) {
     xml.StartElement("Unit");
     xml.Attribute("filename", fsPath + path + "/" + *it);
 
     xml.StartElement("Option");
     xml.Attribute("virtualFolder",
-        "CMake Files\\" + virtualFolderPath + path + "\\");
+                  "CMake Files\\" + virtualFolderPath + path + "\\");
     xml.EndElement();
 
     xml.EndElement();
-    }
+  }
   for (std::vector<Tree>::const_iterator it = folders.begin();
-     it != folders.end();
-     ++it)
-    {
-    it->BuildUnitImpl(xml,
-                      virtualFolderPath + path + "\\", fsPath + path + "/");
-    }
+       it != folders.end(); ++it) {
+    it->BuildUnitImpl(xml, virtualFolderPath + path + "\\",
+                      fsPath + path + "/");
+  }
 }
 
-
-void cmExtraCodeBlocksGenerator
-  ::CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
-                         const std::string& filename)
+void cmExtraCodeBlocksGenerator::CreateNewProjectFile(
+  const std::vector<cmLocalGenerator*>& lgs, const std::string& filename)
 {
-  const cmMakefile* mf=lgs[0]->GetMakefile();
+  const cmMakefile* mf = lgs[0]->GetMakefile();
   cmGeneratedFileStream fout(filename.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
   Tree tree;
 
   // build tree of virtual folders
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-          it = this->GlobalGenerator->GetProjectMap().begin();
-         it != this->GlobalGenerator->GetProjectMap().end();
-         ++it)
-    {
+         it = this->GlobalGenerator->GetProjectMap().begin();
+       it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     // Collect all files
     std::vector<std::string> listFiles;
-    for (std::vector<cmLocalGenerator *>::const_iterator
-         jt = it->second.begin();
-         jt != it->second.end();
-         ++jt)
-      {
-      const std::vector<std::string> & files =
-                                          (*jt)->GetMakefile()->GetListFiles();
+    for (std::vector<cmLocalGenerator*>::const_iterator jt =
+           it->second.begin();
+         jt != it->second.end(); ++jt) {
+      const std::vector<std::string>& files =
+        (*jt)->GetMakefile()->GetListFiles();
       listFiles.insert(listFiles.end(), files.begin(), files.end());
-      }
+    }
 
     // Convert
     for (std::vector<std::string>::const_iterator jt = listFiles.begin();
-         jt != listFiles.end();
-         ++jt)
-      {
+         jt != listFiles.end(); ++jt) {
       // don't put cmake's own files into the project (#12110):
-      if (jt->find(cmSystemTools::GetCMakeRoot()) == 0)
-        {
+      if (jt->find(cmSystemTools::GetCMakeRoot()) == 0) {
         continue;
-        }
+      }
 
-      const std::string &relative = cmSystemTools::RelativePath(
-                         it->second[0]->GetSourceDirectory(),
-                         jt->c_str());
+      const std::string& relative = cmSystemTools::RelativePath(
+        it->second[0]->GetSourceDirectory(), jt->c_str());
       std::vector<std::string> splitted;
       cmSystemTools::SplitPath(relative, splitted, false);
       // Split filename from path
-      std::string fileName = *(splitted.end()-1);
+      std::string fileName = *(splitted.end() - 1);
       splitted.erase(splitted.end() - 1, splitted.end());
 
       // We don't want paths with CMakeFiles in them
       // or do we?
       // In speedcrunch those where purely internal
-      if (splitted.size() >= 1
-          && relative.find("CMakeFiles") == std::string::npos)
-        {
+      if (splitted.size() >= 1 &&
+          relative.find("CMakeFiles") == std::string::npos) {
         tree.InsertPath(splitted, 1, fileName);
-        }
       }
     }
+  }
 
   // figure out the compiler
   std::string compiler = this->GetCBCompilerId(mf);
   std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
-  const std::string makeArgs = mf->GetSafeDefinition(
-                                            "CMAKE_CODEBLOCKS_MAKE_ARGUMENTS");
+  const std::string makeArgs =
+    mf->GetSafeDefinition("CMAKE_CODEBLOCKS_MAKE_ARGUMENTS");
 
   cmXMLWriter xml(fout);
   xml.StartDocument();
@@ -340,64 +294,55 @@ void cmExtraCodeBlocksGenerator
 
   // add all executable and library targets and some of the GLOBAL
   // and UTILITY targets
-  for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
-       lg!=lgs.end(); lg++)
-    {
-    std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
+  for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
+       lg != lgs.end(); lg++) {
+    std::vector<cmGeneratorTarget*> targets = (*lg)->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-         ti != targets.end(); ti++)
-      {
+         ti != targets.end(); ti++) {
       std::string targetName = (*ti)->GetName();
-      switch((*ti)->GetType())
-        {
-        case cmState::GLOBAL_TARGET:
-          {
+      switch ((*ti)->GetType()) {
+        case cmState::GLOBAL_TARGET: {
           // Only add the global targets from CMAKE_BINARY_DIR,
           // not from the subdirs
           if (strcmp((*lg)->GetCurrentBinaryDirectory(),
-                     (*lg)->GetBinaryDirectory())==0)
-            {
-            this->AppendTarget(xml, targetName, 0,
-                               make.c_str(), *lg, compiler.c_str(),
-                               makeArgs);
-            }
+                     (*lg)->GetBinaryDirectory()) == 0) {
+            this->AppendTarget(xml, targetName, 0, make.c_str(), *lg,
+                               compiler.c_str(), makeArgs);
           }
-          break;
+        } break;
         case cmState::UTILITY:
           // Add all utility targets, except the Nightly/Continuous/
           // Experimental-"sub"targets as e.g. NightlyStart
-          if (((targetName.find("Nightly")==0)   &&(targetName!="Nightly"))
-             || ((targetName.find("Continuous")==0)
-                 &&(targetName!="Continuous"))
-             || ((targetName.find("Experimental")==0)
-                                             && (targetName!="Experimental")))
-            {
+          if (((targetName.find("Nightly") == 0) &&
+               (targetName != "Nightly")) ||
+              ((targetName.find("Continuous") == 0) &&
+               (targetName != "Continuous")) ||
+              ((targetName.find("Experimental") == 0) &&
+               (targetName != "Experimental"))) {
             break;
-            }
+          }
 
-          this->AppendTarget(xml, targetName, 0,
-                                 make.c_str(), *lg, compiler.c_str(),makeArgs);
+          this->AppendTarget(xml, targetName, 0, make.c_str(), *lg,
+                             compiler.c_str(), makeArgs);
           break;
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
         case cmState::SHARED_LIBRARY:
         case cmState::MODULE_LIBRARY:
-        case cmState::OBJECT_LIBRARY:
-          {
+        case cmState::OBJECT_LIBRARY: {
           cmGeneratorTarget* gt = *ti;
-          this->AppendTarget(xml, targetName, gt,
-                             make.c_str(), *lg, compiler.c_str(), makeArgs);
+          this->AppendTarget(xml, targetName, gt, make.c_str(), *lg,
+                             compiler.c_str(), makeArgs);
           std::string fastTarget = targetName;
           fastTarget += "/fast";
-          this->AppendTarget(xml, fastTarget, gt,
-                             make.c_str(), *lg, compiler.c_str(), makeArgs);
-          }
-          break;
+          this->AppendTarget(xml, fastTarget, gt, make.c_str(), *lg,
+                             compiler.c_str(), makeArgs);
+        } break;
         default:
           break;
-        }
       }
     }
+  }
 
   xml.EndElement(); // Build
 
@@ -409,74 +354,66 @@ void cmExtraCodeBlocksGenerator
   std::vector<std::string> cFiles;
 
   std::vector<std::string> srcExts =
-      this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
+    this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
 
-  for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
-       lg!=lgs.end(); lg++)
-    {
-    cmMakefile* makefile=(*lg)->GetMakefile();
-    std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
+  for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
+       lg != lgs.end(); lg++) {
+    cmMakefile* makefile = (*lg)->GetMakefile();
+    std::vector<cmGeneratorTarget*> targets = (*lg)->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-         ti != targets.end(); ti++)
-      {
-      switch((*ti)->GetType())
-        {
+         ti != targets.end(); ti++) {
+      switch ((*ti)->GetType()) {
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
         case cmState::SHARED_LIBRARY:
         case cmState::MODULE_LIBRARY:
         case cmState::OBJECT_LIBRARY:
         case cmState::UTILITY: // can have sources since 2.6.3
-          {
+        {
           std::vector<cmSourceFile*> sources;
           cmGeneratorTarget* gt = *ti;
           gt->GetSourceFiles(sources,
-                            makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-          for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
-               si!=sources.end(); si++)
-            {
+                             makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+          for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
+               si != sources.end(); si++) {
             // don't add source files which have the GENERATED property set:
-            if ((*si)->GetPropertyAsBool("GENERATED"))
-              {
+            if ((*si)->GetPropertyAsBool("GENERATED")) {
               continue;
-              }
+            }
 
             // check whether it is a C/C++ implementation file
             bool isCFile = false;
             std::string lang = (*si)->GetLanguage();
-            if (lang == "C" || lang == "CXX")
-              {
+            if (lang == "C" || lang == "CXX") {
               std::string srcext = (*si)->GetExtension();
-              for(std::vector<std::string>::const_iterator
-                  ext = srcExts.begin(); ext != srcExts.end(); ++ext)
-                {
-                if (srcext == *ext)
-                  {
+              for (std::vector<std::string>::const_iterator ext =
+                     srcExts.begin();
+                   ext != srcExts.end(); ++ext) {
+                if (srcext == *ext) {
                   isCFile = true;
                   break;
-                  }
                 }
               }
+            }
 
             std::string fullPath = (*si)->GetFullPath();
 
-            if(isCFile)
-              {
+            if (isCFile) {
               cFiles.push_back(fullPath);
-              }
+            }
 
-            CbpUnit &cbpUnit = allFiles[fullPath];
+            CbpUnit& cbpUnit = allFiles[fullPath];
             cbpUnit.Targets.push_back(*ti);
-            }
           }
-        default:  // intended fallthrough
-          break;
         }
+        default: // intended fallthrough
+          break;
       }
     }
+  }
 
   std::vector<std::string> headerExts =
-      this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
+    this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
 
   // The following loop tries to add header files matching to implementation
   // files to the project. It does that by iterating over all
@@ -485,62 +422,50 @@ void cmExtraCodeBlocksGenerator
   // file exists. If it does, it is inserted into the map of files.
   // A very similar version of that code exists also in the kdevelop
   // project generator.
-  for (std::vector<std::string>::const_iterator
-       sit=cFiles.begin();
-       sit!=cFiles.end();
-       ++sit)
-    {
+  for (std::vector<std::string>::const_iterator sit = cFiles.begin();
+       sit != cFiles.end(); ++sit) {
     std::string const& fileName = *sit;
-    std::string headerBasename=cmSystemTools::GetFilenamePath(fileName);
-    headerBasename+="/";
-    headerBasename+=cmSystemTools::GetFilenameWithoutExtension(fileName);
+    std::string headerBasename = cmSystemTools::GetFilenamePath(fileName);
+    headerBasename += "/";
+    headerBasename += cmSystemTools::GetFilenameWithoutExtension(fileName);
 
     // check if there's a matching header around
-    for(std::vector<std::string>::const_iterator
-        ext = headerExts.begin();
-        ext != headerExts.end();
-        ++ext)
-      {
-      std::string hname=headerBasename;
+    for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+         ext != headerExts.end(); ++ext) {
+      std::string hname = headerBasename;
       hname += ".";
       hname += *ext;
       // if it's already in the set, don't check if it exists on disk
-      if (allFiles.find(hname) != allFiles.end())
-        {
+      if (allFiles.find(hname) != allFiles.end()) {
         break;
-        }
+      }
 
-      if(cmSystemTools::FileExists(hname.c_str()))
-        {
+      if (cmSystemTools::FileExists(hname.c_str())) {
         allFiles[hname].Targets = allFiles[fileName].Targets;
         break;
-        }
       }
     }
+  }
 
   // insert all source files in the CodeBlocks project
-  for (all_files_map_t::const_iterator
-       sit=allFiles.begin();
-       sit!=allFiles.end();
-       ++sit)
-    {
+  for (all_files_map_t::const_iterator sit = allFiles.begin();
+       sit != allFiles.end(); ++sit) {
     std::string const& unitFilename = sit->first;
     CbpUnit const& unit = sit->second;
 
     xml.StartElement("Unit");
     xml.Attribute("filename", unitFilename);
 
-    for(std::vector<const cmGeneratorTarget*>::const_iterator ti =
-        unit.Targets.begin();
-        ti != unit.Targets.end(); ++ti)
-      {
+    for (std::vector<const cmGeneratorTarget*>::const_iterator ti =
+           unit.Targets.begin();
+         ti != unit.Targets.end(); ++ti) {
       xml.StartElement("Option");
       xml.Attribute("target", (*ti)->GetName());
       xml.EndElement();
-      }
+    }
 
     xml.EndElement();
-    }
+  }
 
   // Add CMakeLists.txt
   tree.BuildUnit(xml, std::string(mf->GetHomeDirectory()) + "/");
@@ -550,11 +475,9 @@ void cmExtraCodeBlocksGenerator
   xml.EndDocument();
 }
 
-
 // Write a dummy file for OBJECT libraries, so C::B can reference some file
 std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile(
-                                        cmLocalGenerator* lg,
-                                        cmGeneratorTarget* target) const
+  cmLocalGenerator* lg, cmGeneratorTarget* target) const
 {
   // this file doesn't seem to be used by C::B in custom makefile mode,
   // but we generate a unique file for each OBJECT library so in case
@@ -566,27 +489,22 @@ std::string cmExtraCodeBlocksGenerator::CreateDummyTargetFile(
   filename += target->GetName();
   filename += ".objlib";
   cmGeneratedFileStream fout(filename.c_str());
-  if(fout)
-    {
+  if (fout) {
     /* clang-format off */
     fout << "# This is a dummy file for the OBJECT library "
          << target->GetName()
          << " for the CMake CodeBlocks project generator.\n"
          << "# Don't edit, this file will be overwritten.\n";
     /* clang-format on */
-    }
+  }
   return filename;
 }
 
-
 // Generate the xml code for one target.
-void cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter& xml,
-                                              const std::string& targetName,
-                                              cmGeneratorTarget* target,
-                                              const char* make,
-                                              const cmLocalGenerator* lg,
-                                              const char* compiler,
-                                              const std::string& makeFlags)
+void cmExtraCodeBlocksGenerator::AppendTarget(
+  cmXMLWriter& xml, const std::string& targetName, cmGeneratorTarget* target,
+  const char* make, const cmLocalGenerator* lg, const char* compiler,
+  const std::string& makeFlags)
 {
   cmMakefile const* makefile = lg->GetMakefile();
   std::string makefileName = lg->GetCurrentBinaryDirectory();
@@ -595,42 +513,33 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter& xml,
   xml.StartElement("Target");
   xml.Attribute("title", targetName);
 
-  if (target!=0)
-    {
+  if (target != 0) {
     int cbTargetType = this->GetCBTargetType(target);
     std::string workingDir = lg->GetCurrentBinaryDirectory();
-    if ( target->GetType()==cmState::EXECUTABLE)
-      {
+    if (target->GetType() == cmState::EXECUTABLE) {
       // Determine the directory where the executable target is created, and
       // set the working directory to this dir.
-      const char* runtimeOutputDir = makefile->GetDefinition(
-                                             "CMAKE_RUNTIME_OUTPUT_DIRECTORY");
-      if (runtimeOutputDir != 0)
-        {
+      const char* runtimeOutputDir =
+        makefile->GetDefinition("CMAKE_RUNTIME_OUTPUT_DIRECTORY");
+      if (runtimeOutputDir != 0) {
         workingDir = runtimeOutputDir;
-        }
-      else
-        {
-        const char* executableOutputDir = makefile->GetDefinition(
-                                                     "EXECUTABLE_OUTPUT_PATH");
-        if (executableOutputDir != 0)
-          {
+      } else {
+        const char* executableOutputDir =
+          makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
+        if (executableOutputDir != 0) {
           workingDir = executableOutputDir;
-          }
         }
       }
+    }
 
     std::string buildType = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
     std::string location;
-    if ( target->GetType()==cmState::OBJECT_LIBRARY)
-      {
-      location = this->CreateDummyTargetFile(const_cast<cmLocalGenerator*>(lg),
-                                             target);
-      }
-    else
-      {
+    if (target->GetType() == cmState::OBJECT_LIBRARY) {
+      location =
+        this->CreateDummyTargetFile(const_cast<cmLocalGenerator*>(lg), target);
+    } else {
       location = target->GetLocation(buildType);
-      }
+    }
 
     xml.StartElement("Option");
     xml.Attribute("output", location);
@@ -661,13 +570,12 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter& xml,
     target->GetCompileDefinitions(cdefs, buildType, "C");
 
     // Expand the list.
-    for(std::vector<std::string>::const_iterator di = cdefs.begin();
-        di != cdefs.end(); ++di)
-      {
+    for (std::vector<std::string>::const_iterator di = cdefs.begin();
+         di != cdefs.end(); ++di) {
       xml.StartElement("Add");
       xml.Attribute("option", "-D" + *di);
       xml.EndElement();
-      }
+    }
 
     // the include directories for this target
     std::set<std::string> uniqIncludeDirs;
@@ -678,36 +586,31 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter& xml,
     uniqIncludeDirs.insert(includes.begin(), includes.end());
 
     std::string systemIncludeDirs = makefile->GetSafeDefinition(
-                              "CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS");
-    if (!systemIncludeDirs.empty())
-      {
+      "CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS");
+    if (!systemIncludeDirs.empty()) {
       std::vector<std::string> dirs;
       cmSystemTools::ExpandListArgument(systemIncludeDirs, dirs);
       uniqIncludeDirs.insert(dirs.begin(), dirs.end());
-      }
+    }
 
     systemIncludeDirs = makefile->GetSafeDefinition(
-                            "CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS");
-    if (!systemIncludeDirs.empty())
-      {
+      "CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS");
+    if (!systemIncludeDirs.empty()) {
       std::vector<std::string> dirs;
       cmSystemTools::ExpandListArgument(systemIncludeDirs, dirs);
       uniqIncludeDirs.insert(dirs.begin(), dirs.end());
-      }
+    }
 
-    for(std::set<std::string>::const_iterator dirIt=uniqIncludeDirs.begin();
-        dirIt != uniqIncludeDirs.end();
-        ++dirIt)
-      {
+    for (std::set<std::string>::const_iterator dirIt = uniqIncludeDirs.begin();
+         dirIt != uniqIncludeDirs.end(); ++dirIt) {
       xml.StartElement("Add");
       xml.Attribute("directory", *dirIt);
       xml.EndElement();
-      }
+    }
 
     xml.EndElement(); // Compiler
-    }
-  else // e.g. all and the GLOBAL and UTILITY targets
-    {
+  } else              // e.g. all and the GLOBAL and UTILITY targets
+  {
     xml.StartElement("Option");
     xml.Attribute("working_dir", lg->GetCurrentBinaryDirectory());
     xml.EndElement();
@@ -715,35 +618,34 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmXMLWriter& xml,
     xml.StartElement("Option");
     xml.Attribute("type", 4);
     xml.EndElement();
-    }
+  }
 
   xml.StartElement("MakeCommands");
 
   xml.StartElement("Build");
-  xml.Attribute("command",
-    this->BuildMakeCommand(make, makefileName.c_str(), targetName, makeFlags));
+  xml.Attribute("command", this->BuildMakeCommand(make, makefileName.c_str(),
+                                                  targetName, makeFlags));
   xml.EndElement();
 
   xml.StartElement("CompileFile");
-  xml.Attribute("command",
-    this->BuildMakeCommand(make, makefileName.c_str(),"\"$file\"", makeFlags));
+  xml.Attribute("command", this->BuildMakeCommand(make, makefileName.c_str(),
+                                                  "\"$file\"", makeFlags));
   xml.EndElement();
 
   xml.StartElement("Clean");
-  xml.Attribute("command",
-    this->BuildMakeCommand(make, makefileName.c_str(), "clean", makeFlags));
+  xml.Attribute("command", this->BuildMakeCommand(make, makefileName.c_str(),
+                                                  "clean", makeFlags));
   xml.EndElement();
 
   xml.StartElement("DistClean");
-  xml.Attribute("command",
-    this->BuildMakeCommand(make, makefileName.c_str(), "clean", makeFlags));
+  xml.Attribute("command", this->BuildMakeCommand(make, makefileName.c_str(),
+                                                  "clean", makeFlags));
   xml.EndElement();
 
-  xml.EndElement(); //MakeCommands
-  xml.EndElement(); //Target
+  xml.EndElement(); // MakeCommands
+  xml.EndElement(); // Target
 }
 
-
 // Translate the cmake compiler id into the CodeBlocks compiler id
 std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf)
 {
@@ -753,131 +655,87 @@ std::string cmExtraCodeBlocksGenerator::GetCBCompilerId(const cmMakefile* mf)
   // projects with C/C++ and Fortran are handled as C/C++ projects
   bool pureFortran = false;
   std::string compilerIdVar;
-  if (this->GlobalGenerator->GetLanguageEnabled("CXX") == true)
-    {
+  if (this->GlobalGenerator->GetLanguageEnabled("CXX") == true) {
     compilerIdVar = "CMAKE_CXX_COMPILER_ID";
-    }
-  else if (this->GlobalGenerator->GetLanguageEnabled("C") == true)
-    {
+  } else if (this->GlobalGenerator->GetLanguageEnabled("C") == true) {
     compilerIdVar = "CMAKE_C_COMPILER_ID";
-    }
-  else if (this->GlobalGenerator->GetLanguageEnabled("Fortran") == true)
-    {
+  } else if (this->GlobalGenerator->GetLanguageEnabled("Fortran") == true) {
     compilerIdVar = "CMAKE_Fortran_COMPILER_ID";
     pureFortran = true;
-    }
-
+  }
 
   std::string compilerId = mf->GetSafeDefinition(compilerIdVar);
-  std::string compiler = "gcc";  // default to gcc
-  if (compilerId == "MSVC")
-    {
-    if( mf->IsDefinitionSet("MSVC10") == true )
-      {
+  std::string compiler = "gcc"; // default to gcc
+  if (compilerId == "MSVC") {
+    if (mf->IsDefinitionSet("MSVC10") == true) {
       compiler = "msvc10";
-      }
-    else
-      {
+    } else {
       compiler = "msvc8";
-      }
     }
-  else if (compilerId == "Borland")
-    {
+  } else if (compilerId == "Borland") {
     compiler = "bcc";
-    }
-  else if (compilerId == "SDCC")
-    {
+  } else if (compilerId == "SDCC") {
     compiler = "sdcc";
-    }
-  else if (compilerId == "Intel")
-    {
-    if (pureFortran && mf->IsDefinitionSet("WIN32"))
-      {
+  } else if (compilerId == "Intel") {
+    if (pureFortran && mf->IsDefinitionSet("WIN32")) {
       compiler = "ifcwin"; // Intel Fortran for Windows (known by cbFortran)
-      }
-    else
-      {
+    } else {
       compiler = "icc";
-      }
     }
-  else if (compilerId == "Watcom" || compilerId == "OpenWatcom")
-    {
+  } else if (compilerId == "Watcom" || compilerId == "OpenWatcom") {
     compiler = "ow";
-    }
-  else if (compilerId == "Clang")
-    {
+  } else if (compilerId == "Clang") {
     compiler = "clang";
-    }
-  else if (compilerId == "PGI")
-    {
-    if (pureFortran)
-      {
+  } else if (compilerId == "PGI") {
+    if (pureFortran) {
       compiler = "pgifortran";
-      }
-    else
-      {
+    } else {
       compiler = "pgi"; // does not exist as default in CodeBlocks 16.01
-      }
     }
-  else if (compilerId == "GNU")
-    {
-    if (pureFortran)
-      {
+  } else if (compilerId == "GNU") {
+    if (pureFortran) {
       compiler = "gfortran";
-      }
-    else
-      {
+    } else {
       compiler = "gcc";
-      }
     }
+  }
   return compiler;
 }
 
-
 // Translate the cmake target type into the CodeBlocks target type id
 int cmExtraCodeBlocksGenerator::GetCBTargetType(cmGeneratorTarget* target)
 {
-  if ( target->GetType()==cmState::EXECUTABLE)
-    {
-    if ((target->GetPropertyAsBool("WIN32_EXECUTABLE"))
-        || (target->GetPropertyAsBool("MACOSX_BUNDLE")))
-      {
+  if (target->GetType() == cmState::EXECUTABLE) {
+    if ((target->GetPropertyAsBool("WIN32_EXECUTABLE")) ||
+        (target->GetPropertyAsBool("MACOSX_BUNDLE"))) {
       return 0;
-      }
-    else
-      {
+    } else {
       return 1;
-      }
     }
-  else if (( target->GetType()==cmState::STATIC_LIBRARY)
-        || (target->GetType()==cmState::OBJECT_LIBRARY))
-    {
+  } else if ((target->GetType() == cmState::STATIC_LIBRARY) ||
+             (target->GetType() == cmState::OBJECT_LIBRARY)) {
     return 2;
-    }
-  else if ((target->GetType()==cmState::SHARED_LIBRARY)
-           || (target->GetType()==cmState::MODULE_LIBRARY))
-    {
+  } else if ((target->GetType() == cmState::SHARED_LIBRARY) ||
+             (target->GetType() == cmState::MODULE_LIBRARY)) {
     return 3;
-    }
+  }
   return 4;
 }
 
 // Create the command line for building the given target using the selected
 // make
 std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
-             const std::string& make, const char* makefile,
-             const std::string& target, const std::string& makeFlags)
+  const std::string& make, const char* makefile, const std::string& target,
+  const std::string& makeFlags)
 {
   std::string command = make;
-  if (makeFlags.size() > 0)
-    {
+  if (makeFlags.size() > 0) {
     command += " ";
     command += makeFlags;
-    }
+  }
 
   std::string generator = this->GlobalGenerator->GetName();
-  if (generator == "NMake Makefiles")
-    {
+  if (generator == "NMake Makefiles") {
     // For Windows ConvertToOutputPath already adds quotes when required.
     // These need to be escaped, see
     // http://public.kitware.com/Bug/view.php?id=13952
@@ -886,9 +744,7 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
     command += makefileName;
     command += " VERBOSE=1 ";
     command += target;
-    }
-  else if (generator == "MinGW Makefiles")
-    {
+  } else if (generator == "MinGW Makefiles") {
     // no escaping of spaces in this case, see
     // http://public.kitware.com/Bug/view.php?id=10014
     std::string makefileName = makefile;
@@ -897,20 +753,16 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
     command += "\" ";
     command += " VERBOSE=1 ";
     command += target;
-    }
-  else if (generator == "Ninja")
-    {
+  } else if (generator == "Ninja") {
     command += " -v ";
     command += target;
-    }
-  else
-    {
+  } else {
     std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
     command += " -f \"";
     command += makefileName;
     command += "\" ";
     command += " VERBOSE=1 ";
     command += target;
-    }
+  }
   return command;
 }
diff --git a/Source/cmExtraCodeBlocksGenerator.h b/Source/cmExtraCodeBlocksGenerator.h
index e2f09de..fe4f513 100644
--- a/Source/cmExtraCodeBlocksGenerator.h
+++ b/Source/cmExtraCodeBlocksGenerator.h
@@ -29,15 +29,20 @@ public:
   cmExtraCodeBlocksGenerator();
 
   virtual std::string GetName() const
-                         { return cmExtraCodeBlocksGenerator::GetActualName();}
-  static std::string GetActualName()                    { return "CodeBlocks";}
+  {
+    return cmExtraCodeBlocksGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "CodeBlocks"; }
   static cmExternalMakefileProjectGenerator* New()
-                                     { return new cmExtraCodeBlocksGenerator; }
+  {
+    return new cmExtraCodeBlocksGenerator;
+  }
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const std::string& fullName) const;
 
   virtual void Generate();
+
 private:
   struct CbpUnit
   {
@@ -47,7 +52,7 @@ private:
   void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
 
   void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
-                                const std::string& filename);
+                            const std::string& filename);
   std::string CreateDummyTargetFile(cmLocalGenerator* lg,
                                     cmGeneratorTarget* target) const;
 
@@ -56,15 +61,10 @@ private:
   std::string BuildMakeCommand(const std::string& make, const char* makefile,
                                const std::string& target,
                                const std::string& makeFlags);
-  void AppendTarget(cmXMLWriter& xml,
-                    const std::string& targetName,
-                    cmGeneratorTarget* target,
-                    const char* make,
-                    const cmLocalGenerator* lg,
-                    const char* compiler,
-                    const std::string& makeFlags
-                   );
-
+  void AppendTarget(cmXMLWriter& xml, const std::string& targetName,
+                    cmGeneratorTarget* target, const char* make,
+                    const cmLocalGenerator* lg, const char* compiler,
+                    const std::string& makeFlags);
 };
 
 #endif
diff --git a/Source/cmExtraCodeLiteGenerator.cxx b/Source/cmExtraCodeLiteGenerator.cxx
index 6ef2290..ba58767 100644
--- a/Source/cmExtraCodeLiteGenerator.cxx
+++ b/Source/cmExtraCodeLiteGenerator.cxx
@@ -56,28 +56,28 @@ void cmExtraCodeLiteGenerator::Generate()
   std::string workspaceSourcePath;
 
   const std::map<std::string, std::vector<cmLocalGenerator*> >& projectMap =
-      this->GlobalGenerator->GetProjectMap();
+    this->GlobalGenerator->GetProjectMap();
 
   // loop projects and locate the root project.
   // and extract the information for creating the worspace
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = projectMap.begin(); it!= projectMap.end(); ++it)
-    {
-    const cmMakefile* mf =it->second[0]->GetMakefile();
-    this->ConfigName = GetConfigurationName( mf );
+         it = projectMap.begin();
+       it != projectMap.end(); ++it) {
+    const cmMakefile* mf = it->second[0]->GetMakefile();
+    this->ConfigName = GetConfigurationName(mf);
 
     if (strcmp(it->second[0]->GetCurrentBinaryDirectory(),
-               it->second[0]->GetBinaryDirectory()) == 0)
-      {
-      workspaceOutputDir   = it->second[0]->GetCurrentBinaryDirectory();
+               it->second[0]->GetBinaryDirectory()) == 0) {
+      workspaceOutputDir = it->second[0]->GetCurrentBinaryDirectory();
       workspaceProjectName = it->second[0]->GetProjectName();
-      workspaceSourcePath  = it->second[0]->GetSourceDirectory();
-      workspaceFileName    = workspaceOutputDir+"/";
-      workspaceFileName   += workspaceProjectName + ".workspace";
-      this->WorkspacePath = it->second[0]->GetCurrentBinaryDirectory();;
+      workspaceSourcePath = it->second[0]->GetSourceDirectory();
+      workspaceFileName = workspaceOutputDir + "/";
+      workspaceFileName += workspaceProjectName + ".workspace";
+      this->WorkspacePath = it->second[0]->GetCurrentBinaryDirectory();
+      ;
       break;
-      }
     }
+  }
 
   cmGeneratedFileStream fout(workspaceFileName.c_str());
   cmXMLWriter xml(fout);
@@ -88,16 +88,16 @@ void cmExtraCodeLiteGenerator::Generate()
 
   // for each sub project in the workspace create a codelite project
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = projectMap.begin(); it!= projectMap.end(); ++it)
-    {
+         it = projectMap.begin();
+       it != projectMap.end(); ++it) {
     // retrive project information
-    std::string outputDir   = it->second[0]->GetCurrentBinaryDirectory();
+    std::string outputDir = it->second[0]->GetCurrentBinaryDirectory();
     std::string projectName = it->second[0]->GetProjectName();
-    std::string filename    = outputDir + "/" + projectName + ".project";
+    std::string filename = outputDir + "/" + projectName + ".project";
 
     // Make the project file relative to the workspace
     filename = cmSystemTools::RelativePath(this->WorkspacePath.c_str(),
-                                          filename.c_str());
+                                           filename.c_str());
 
     // create a project file
     this->CreateProjectFile(it->second);
@@ -106,7 +106,7 @@ void cmExtraCodeLiteGenerator::Generate()
     xml.Attribute("Path", filename);
     xml.Attribute("Active", "No");
     xml.EndElement();
-    }
+  }
 
   xml.StartElement("BuildMatrix");
   xml.StartElement("WorkspaceConfiguration");
@@ -114,8 +114,8 @@ void cmExtraCodeLiteGenerator::Generate()
   xml.Attribute("Selected", "yes");
 
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = projectMap.begin(); it!= projectMap.end(); ++it)
-    {
+         it = projectMap.begin();
+       it != projectMap.end(); ++it) {
     // retrive project information
     std::string projectName = it->second[0]->GetProjectName();
 
@@ -123,7 +123,7 @@ void cmExtraCodeLiteGenerator::Generate()
     xml.Attribute("Name", projectName);
     xml.Attribute("ConfigName", this->ConfigName);
     xml.EndElement();
-    }
+  }
 
   xml.EndElement(); // WorkspaceConfiguration
   xml.EndElement(); // BuildMatrix
@@ -134,24 +134,22 @@ void cmExtraCodeLiteGenerator::Generate()
 void cmExtraCodeLiteGenerator::CreateProjectFile(
   const std::vector<cmLocalGenerator*>& lgs)
 {
-  std::string outputDir   = lgs[0]->GetCurrentBinaryDirectory();
+  std::string outputDir = lgs[0]->GetCurrentBinaryDirectory();
   std::string projectName = lgs[0]->GetProjectName();
-  std::string filename    = outputDir + "/";
+  std::string filename = outputDir + "/";
 
   filename += projectName + ".project";
   this->CreateNewProjectFile(lgs, filename);
 }
 
-void cmExtraCodeLiteGenerator
-::CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
-                       const std::string& filename)
+void cmExtraCodeLiteGenerator::CreateNewProjectFile(
+  const std::vector<cmLocalGenerator*>& lgs, const std::string& filename)
 {
-  const cmMakefile* mf=lgs[0]->GetMakefile();
+  const cmMakefile* mf = lgs[0]->GetMakefile();
   cmGeneratedFileStream fout(filename.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
   cmXMLWriter xml(fout);
 
   ////////////////////////////////////
@@ -166,94 +164,75 @@ void cmExtraCodeLiteGenerator
   std::string projectType;
 
   std::vector<std::string> srcExts =
-      this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
+    this->GlobalGenerator->GetCMakeInstance()->GetSourceExtensions();
   std::vector<std::string> headerExts =
-      this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
+    this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
 
   std::map<std::string, cmSourceFile*> cFiles;
   std::set<std::string> otherFiles;
-  for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
-       lg!=lgs.end(); lg++)
-    {
-    cmMakefile* makefile=(*lg)->GetMakefile();
-    std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
+  for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
+       lg != lgs.end(); lg++) {
+    cmMakefile* makefile = (*lg)->GetMakefile();
+    std::vector<cmGeneratorTarget*> targets = (*lg)->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-         ti != targets.end(); ti++)
-      {
+         ti != targets.end(); ti++) {
 
-      switch((*ti)->GetType())
-        {
-        case cmState::EXECUTABLE:
-          {
+      switch ((*ti)->GetType()) {
+        case cmState::EXECUTABLE: {
           projectType = "Executable";
-          }
-        break;
-        case cmState::STATIC_LIBRARY:
-          {
+        } break;
+        case cmState::STATIC_LIBRARY: {
           projectType = "Static Library";
-          }
-        break;
-        case cmState::SHARED_LIBRARY:
-          {
+        } break;
+        case cmState::SHARED_LIBRARY: {
           projectType = "Dynamic Library";
-          }
-        break;
-        case cmState::MODULE_LIBRARY:
-          {
+        } break;
+        case cmState::MODULE_LIBRARY: {
           projectType = "Dynamic Library";
-          }
-        break;
-        default:  // intended fallthrough
+        } break;
+        default: // intended fallthrough
           break;
-        }
+      }
 
-      switch((*ti)->GetType())
-        {
+      switch ((*ti)->GetType()) {
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
         case cmState::SHARED_LIBRARY:
-        case cmState::MODULE_LIBRARY:
-          {
+        case cmState::MODULE_LIBRARY: {
           std::vector<cmSourceFile*> sources;
           cmGeneratorTarget* gt = *ti;
           gt->GetSourceFiles(sources,
-                            makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-          for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
-               si!=sources.end(); si++)
-            {
+                             makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+          for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
+               si != sources.end(); si++) {
             // check whether it is a C/C++ implementation file
             bool isCFile = false;
             std::string lang = (*si)->GetLanguage();
-            if (lang == "C" || lang == "CXX")
-              {
+            if (lang == "C" || lang == "CXX") {
               std::string srcext = (*si)->GetExtension();
-              for(std::vector<std::string>::const_iterator
-                  ext = srcExts.begin(); ext != srcExts.end(); ++ext)
-                {
-                if (srcext == *ext)
-                  {
+              for (std::vector<std::string>::const_iterator ext =
+                     srcExts.begin();
+                   ext != srcExts.end(); ++ext) {
+                if (srcext == *ext) {
                   isCFile = true;
                   break;
-                  }
                 }
               }
+            }
 
             // then put it accordingly into one of the two containers
-            if (isCFile)
-              {
-              cFiles[(*si)->GetFullPath()] = *si ;
-              }
-            else
-              {
+            if (isCFile) {
+              cFiles[(*si)->GetFullPath()] = *si;
+            } else {
               otherFiles.insert((*si)->GetFullPath());
-              }
             }
           }
-        default:  // intended fallthrough
-          break;
         }
+        default: // intended fallthrough
+          break;
       }
     }
+  }
 
   // The following loop tries to add header files matching to implementation
   // files to the project. It does that by iterating over all source files,
@@ -261,38 +240,31 @@ void cmExtraCodeLiteGenerator
   // file exists. If it does, it is inserted into the map of files.
   // A very similar version of that code exists also in the kdevelop
   // project generator.
-  for (std::map<std::string, cmSourceFile*>::const_iterator
-       sit=cFiles.begin();
-       sit!=cFiles.end();
-       ++sit)
-    {
-    std::string headerBasename=cmSystemTools::GetFilenamePath(sit->first);
-    headerBasename+="/";
-    headerBasename+=cmSystemTools::GetFilenameWithoutExtension(sit->first);
+  for (std::map<std::string, cmSourceFile*>::const_iterator sit =
+         cFiles.begin();
+       sit != cFiles.end(); ++sit) {
+    std::string headerBasename = cmSystemTools::GetFilenamePath(sit->first);
+    headerBasename += "/";
+    headerBasename += cmSystemTools::GetFilenameWithoutExtension(sit->first);
 
     // check if there's a matching header around
-    for(std::vector<std::string>::const_iterator
-        ext = headerExts.begin();
-        ext != headerExts.end();
-        ++ext)
-      {
-      std::string hname=headerBasename;
+    for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+         ext != headerExts.end(); ++ext) {
+      std::string hname = headerBasename;
       hname += ".";
       hname += *ext;
       // if it's already in the set, don't check if it exists on disk
-      std::set<std::string>::const_iterator headerIt=otherFiles.find(hname);
-      if (headerIt != otherFiles.end())
-        {
+      std::set<std::string>::const_iterator headerIt = otherFiles.find(hname);
+      if (headerIt != otherFiles.end()) {
         break;
-        }
+      }
 
-      if(cmSystemTools::FileExists(hname.c_str()))
-        {
+      if (cmSystemTools::FileExists(hname.c_str())) {
         otherFiles.insert(hname);
         break;
-        }
       }
     }
+  }
 
   // Get the project path ( we need it later to convert files to
   // their relative path)
@@ -306,29 +278,24 @@ void cmExtraCodeLiteGenerator
 
   // insert all source files in the codelite project
   // first the C/C++ implementation files, then all others
-  for (std::map<std::string, cmSourceFile*>::const_iterator
-       sit=cFiles.begin();
-       sit!=cFiles.end();
-       ++sit)
-    {
+  for (std::map<std::string, cmSourceFile*>::const_iterator sit =
+         cFiles.begin();
+       sit != cFiles.end(); ++sit) {
     xml.StartElement("File");
-    xml.Attribute("Name",
-      cmSystemTools::RelativePath(projectPath.c_str(), sit->first.c_str()));
+    xml.Attribute("Name", cmSystemTools::RelativePath(projectPath.c_str(),
+                                                      sit->first.c_str()));
     xml.EndElement();
-    }
+  }
   xml.EndElement(); // VirtualDirectory
   xml.StartElement("VirtualDirectory");
   xml.Attribute("Name", "include");
-  for (std::set<std::string>::const_iterator
-       sit=otherFiles.begin();
-       sit!=otherFiles.end();
-       ++sit)
-    {
+  for (std::set<std::string>::const_iterator sit = otherFiles.begin();
+       sit != otherFiles.end(); ++sit) {
     xml.StartElement("File");
-    xml.Attribute("Name",
-      cmSystemTools::RelativePath(projectPath.c_str(), sit->c_str()));
+    xml.Attribute(
+      "Name", cmSystemTools::RelativePath(projectPath.c_str(), sit->c_str()));
     xml.EndElement();
-    }
+  }
   xml.EndElement(); // VirtualDirectory
 
   // Get the number of CPUs. We use this information for the make -jN
@@ -336,8 +303,8 @@ void cmExtraCodeLiteGenerator
   cmsys::SystemInformation info;
   info.RunCPUCheck();
 
-  this->CpuCount = info.GetNumberOfLogicalCPU() *
-                   info.GetNumberOfPhysicalCPU();
+  this->CpuCount =
+    info.GetNumberOfLogicalCPU() * info.GetNumberOfPhysicalCPU();
 
   std::string codeliteCompilerName = this->GetCodeLiteCompilerName(mf);
 
@@ -434,16 +401,15 @@ void cmExtraCodeLiteGenerator
   xml.EndElement(); // CodeLite_Project
 }
 
-std::string
-cmExtraCodeLiteGenerator::GetCodeLiteCompilerName(const cmMakefile* mf) const
+std::string cmExtraCodeLiteGenerator::GetCodeLiteCompilerName(
+  const cmMakefile* mf) const
 {
   // figure out which language to use
   // for now care only for C and C++
   std::string compilerIdVar = "CMAKE_CXX_COMPILER_ID";
-  if (this->GlobalGenerator->GetLanguageEnabled("CXX") == false)
-    {
+  if (this->GlobalGenerator->GetLanguageEnabled("CXX") == false) {
     compilerIdVar = "CMAKE_C_COMPILER_ID";
-    }
+  }
 
   std::string compilerId = mf->GetSafeDefinition(compilerIdVar);
   std::string compiler = "gnu g++"; // default to g++
@@ -451,80 +417,67 @@ cmExtraCodeLiteGenerator::GetCodeLiteCompilerName(const cmMakefile* mf) const
   // Since we need the compiler for parsing purposes only
   // it does not matter if we use clang or clang++, same as
   // "gnu gcc" vs "gnu g++"
-  if (compilerId == "MSVC")
-    {
+  if (compilerId == "MSVC") {
     compiler = "VC++";
-    }
-  else if (compilerId == "Clang")
-    {
+  } else if (compilerId == "Clang") {
     compiler = "clang++";
-    }
-  else if (compilerId == "GNU")
-    {
+  } else if (compilerId == "GNU") {
     compiler = "gnu g++";
-    }
+  }
   return compiler;
 }
 
-std::string
-cmExtraCodeLiteGenerator::GetConfigurationName(const cmMakefile* mf) const
+std::string cmExtraCodeLiteGenerator::GetConfigurationName(
+  const cmMakefile* mf) const
 {
   std::string confName = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
   // Trim the configuration name from whitespaces (left and right)
   confName.erase(0, confName.find_first_not_of(" \t\r\v\n"));
-  confName.erase(confName.find_last_not_of(" \t\r\v\n")+1);
-  if ( confName.empty() )
-    {
+  confName.erase(confName.find_last_not_of(" \t\r\v\n") + 1);
+  if (confName.empty()) {
     confName = "NoConfig";
-    }
+  }
   return confName;
 }
 
-std::string
-cmExtraCodeLiteGenerator::GetBuildCommand(const cmMakefile* mf) const
+std::string cmExtraCodeLiteGenerator::GetBuildCommand(
+  const cmMakefile* mf) const
 {
   std::string generator = mf->GetSafeDefinition("CMAKE_GENERATOR");
   std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   std::string buildCommand = make; // Default
-  if ( generator == "NMake Makefiles" ||
-       generator == "Ninja" )
-    {
+  if (generator == "NMake Makefiles" || generator == "Ninja") {
     buildCommand = make;
-    }
-  else if ( generator == "MinGW Makefiles" ||
-            generator == "Unix Makefiles" )
-    {
+  } else if (generator == "MinGW Makefiles" || generator == "Unix Makefiles") {
     std::ostringstream ss;
     ss << make << " -j " << this->CpuCount;
     buildCommand = ss.str();
-    }
+  }
   return buildCommand;
 }
 
-std::string
-cmExtraCodeLiteGenerator::GetCleanCommand(const cmMakefile* mf) const
+std::string cmExtraCodeLiteGenerator::GetCleanCommand(
+  const cmMakefile* mf) const
 {
   return GetBuildCommand(mf) + " clean";
 }
 
-std::string
-cmExtraCodeLiteGenerator::GetRebuildCommand(const cmMakefile* mf) const
+std::string cmExtraCodeLiteGenerator::GetRebuildCommand(
+  const cmMakefile* mf) const
 {
   return GetCleanCommand(mf) + " && " + GetBuildCommand(mf);
 }
 
-std::string
-cmExtraCodeLiteGenerator::GetSingleFileBuildCommand
-(const cmMakefile* mf) const
+std::string cmExtraCodeLiteGenerator::GetSingleFileBuildCommand(
+  const cmMakefile* mf) const
 {
   std::string buildCommand;
   std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   std::string generator = mf->GetSafeDefinition("CMAKE_GENERATOR");
-  if ( generator == "Unix Makefiles" || generator == "MinGW Makefiles" )
-    {
+  if (generator == "Unix Makefiles" || generator == "MinGW Makefiles") {
     std::ostringstream ss;
     ss << make << " -f$(ProjectPath)/Makefile $(CurrentFileName).cpp.o";
     buildCommand = ss.str();
-    }
+  }
   return buildCommand;
 }
diff --git a/Source/cmExtraCodeLiteGenerator.h b/Source/cmExtraCodeLiteGenerator.h
index 6b4965d..01ff31f 100644
--- a/Source/cmExtraCodeLiteGenerator.h
+++ b/Source/cmExtraCodeLiteGenerator.h
@@ -27,19 +27,24 @@ protected:
 
 protected:
   std::string GetCodeLiteCompilerName(const cmMakefile* mf) const;
-  std::string GetConfigurationName( const cmMakefile* mf ) const;
+  std::string GetConfigurationName(const cmMakefile* mf) const;
   std::string GetBuildCommand(const cmMakefile* mf) const;
   std::string GetCleanCommand(const cmMakefile* mf) const;
   std::string GetRebuildCommand(const cmMakefile* mf) const;
   std::string GetSingleFileBuildCommand(const cmMakefile* mf) const;
+
 public:
   cmExtraCodeLiteGenerator();
 
   virtual std::string GetName() const
-                          { return cmExtraCodeLiteGenerator::GetActualName();}
-  static std::string GetActualName()                     { return "CodeLite";}
+  {
+    return cmExtraCodeLiteGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "CodeLite"; }
   static cmExternalMakefileProjectGenerator* New()
-                                      { return new cmExtraCodeLiteGenerator; }
+  {
+    return new cmExtraCodeLiteGenerator;
+  }
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const std::string& fullName) const;
@@ -48,7 +53,7 @@ public:
   void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
 
   void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
-                                const std::string& filename);
+                            const std::string& filename);
 };
 
 #endif
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 2b20e95..a8f2e3f 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -34,7 +34,7 @@ static void AppendAttribute(cmXMLWriter& xml, const char* keyval)
   xml.EndElement();
 }
 
-template<typename T>
+template <typename T>
 void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
 {
   xml.StartElement("dictionary");
@@ -43,8 +43,8 @@ void AppendDictionary(cmXMLWriter& xml, const char* key, T const& value)
   xml.EndElement();
 }
 
-cmExtraEclipseCDT4Generator
-::cmExtraEclipseCDT4Generator() : cmExternalMakefileProjectGenerator()
+cmExtraEclipseCDT4Generator::cmExtraEclipseCDT4Generator()
+  : cmExternalMakefileProjectGenerator()
 {
 // TODO: Verify if __CYGWIN__ should be checked.
 //#if defined(_WIN32) && !defined(__CYGWIN__)
@@ -64,36 +64,29 @@ cmExtraEclipseCDT4Generator
   this->CXXEnabled = false;
 }
 
-void cmExtraEclipseCDT4Generator
-::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
+void cmExtraEclipseCDT4Generator::GetDocumentation(cmDocumentationEntry& entry,
+                                                   const std::string&) const
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates Eclipse CDT 4.0 project files.";
 }
 
-void cmExtraEclipseCDT4Generator
-::EnableLanguage(std::vector<std::string> const& languages,
-                 cmMakefile *, bool)
+void cmExtraEclipseCDT4Generator::EnableLanguage(
+  std::vector<std::string> const& languages, cmMakefile*, bool)
 {
   for (std::vector<std::string>::const_iterator lit = languages.begin();
-       lit != languages.end(); ++lit)
-    {
-    if (*lit == "CXX")
-      {
+       lit != languages.end(); ++lit) {
+    if (*lit == "CXX") {
       this->Natures.insert("org.eclipse.cdt.core.ccnature");
       this->Natures.insert("org.eclipse.cdt.core.cnature");
       this->CXXEnabled = true;
-      }
-    else if (*lit == "C")
-      {
+    } else if (*lit == "C") {
       this->Natures.insert("org.eclipse.cdt.core.cnature");
       this->CEnabled = true;
-      }
-    else if (*lit == "Java")
-      {
+    } else if (*lit == "Java") {
       this->Natures.insert("org.eclipse.jdt.core.javanature");
-      }
     }
+  }
 }
 
 void cmExtraEclipseCDT4Generator::Generate()
@@ -103,66 +96,65 @@ void cmExtraEclipseCDT4Generator::Generate()
 
   std::string eclipseVersion = mf->GetSafeDefinition("CMAKE_ECLIPSE_VERSION");
   cmsys::RegularExpression regex(".*([0-9]+\\.[0-9]+).*");
-  if (regex.find(eclipseVersion.c_str()))
-    {
+  if (regex.find(eclipseVersion.c_str())) {
     unsigned int majorVersion = 0;
     unsigned int minorVersion = 0;
-    int res=sscanf(regex.match(1).c_str(), "%u.%u", &majorVersion,
-                                                    &minorVersion);
-    if (res == 2)
-      {
+    int res =
+      sscanf(regex.match(1).c_str(), "%u.%u", &majorVersion, &minorVersion);
+    if (res == 2) {
       int version = majorVersion * 1000 + minorVersion;
       if (version < 3006) // 3.6 is Helios
-        {
+      {
         this->SupportsVirtualFolders = false;
         this->SupportsMachO64Parser = false;
-        }
+      }
       if (version < 3007) // 3.7 is Indigo
-        {
+      {
         this->SupportsGmakeErrorParser = false;
-        }
       }
     }
+  }
 
   // TODO: Decide if these are local or member variables
-  this->HomeDirectory       = lg->GetSourceDirectory();
+  this->HomeDirectory = lg->GetSourceDirectory();
   this->HomeOutputDirectory = lg->GetBinaryDirectory();
 
-  this->GenerateLinkedResources = mf->IsOn(
-                                    "CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES");
+  this->GenerateLinkedResources =
+    mf->IsOn("CMAKE_ECLIPSE_GENERATE_LINKED_RESOURCES");
 
-  this->IsOutOfSourceBuild = (this->HomeDirectory!=this->HomeOutputDirectory);
+  this->IsOutOfSourceBuild =
+    (this->HomeDirectory != this->HomeOutputDirectory);
 
-  this->GenerateSourceProject = (this->IsOutOfSourceBuild &&
-                            mf->IsOn("CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT"));
+  this->GenerateSourceProject =
+    (this->IsOutOfSourceBuild &&
+     mf->IsOn("CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT"));
 
-  if ((this->GenerateSourceProject == false)
-    && (mf->IsOn("ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT")))
-    {
-    mf->IssueMessage(cmake::WARNING,
-              "ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT is set to TRUE, "
-              "but this variable is not supported anymore since CMake 2.8.7.\n"
-              "Enable CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT instead.");
-    }
+  if ((this->GenerateSourceProject == false) &&
+      (mf->IsOn("ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT"))) {
+    mf->IssueMessage(
+      cmake::WARNING,
+      "ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT is set to TRUE, "
+      "but this variable is not supported anymore since CMake 2.8.7.\n"
+      "Enable CMAKE_ECLIPSE_GENERATE_SOURCE_PROJECT instead.");
+  }
 
   if (cmSystemTools::IsSubDirectory(this->HomeOutputDirectory,
-                                    this->HomeDirectory))
-    {
-    mf->IssueMessage(cmake::WARNING, "The build directory is a subdirectory "
+                                    this->HomeDirectory)) {
+    mf->IssueMessage(cmake::WARNING,
+                     "The build directory is a subdirectory "
                      "of the source directory.\n"
                      "This is not supported well by Eclipse. It is strongly "
                      "recommended to use a build directory which is a "
                      "sibling of the source directory.");
-    }
+  }
 
   // NOTE: This is not good, since it pollutes the source tree. However,
   //       Eclipse doesn't allow CVS/SVN to work when the .project is not in
   //       the cvs/svn root directory. Hence, this is provided as an option.
-  if (this->GenerateSourceProject)
-    {
+  if (this->GenerateSourceProject) {
     // create .project file in the source tree
     this->CreateSourceProjectFile();
-    }
+  }
 
   // create a .project file
   this->CreateProjectFile();
@@ -177,15 +169,15 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile()
 
   // set up the project name: <project>-Source@<baseSourcePathName>
   cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0];
-  std::string name = this->GenerateProjectName(lg->GetProjectName(), "Source",
-                                   this->GetPathBasename(this->HomeDirectory));
+  std::string name =
+    this->GenerateProjectName(lg->GetProjectName(), "Source",
+                              this->GetPathBasename(this->HomeDirectory));
 
   const std::string filename = this->HomeDirectory + "/.project";
   cmGeneratedFileStream fout(filename.c_str());
-  if (!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
   cmXMLWriter xml(fout);
   xml.StartDocument("UTF-8");
@@ -197,18 +189,16 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile()
   xml.Element("natures", "");
   xml.StartElement("linkedResources");
 
-  if (this->SupportsVirtualFolders)
-    {
+  if (this->SupportsVirtualFolders) {
     this->CreateLinksToSubprojects(xml, this->HomeDirectory);
     this->SrcLinkedResources.clear();
-    }
+  }
 
   xml.EndElement(); // linkedResources
   xml.EndElement(); // projectDescription
   xml.EndDocument();
 }
 
-
 void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
                                             const char* envVar,
                                             cmLocalGenerator* lg)
@@ -222,56 +212,44 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
 
   std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_";
   cacheEntryName += envVar;
-  const char* cacheValue = lg->GetState()->GetInitializedCacheValue(
-                                                       cacheEntryName);
+  const char* cacheValue =
+    lg->GetState()->GetInitializedCacheValue(cacheEntryName);
 
   // now we have both, decide which one to use
   std::string valueToUse;
-  if (envVarValue==0 && cacheValue==0)
-    {
+  if (envVarValue == 0 && cacheValue == 0) {
     // nothing known, do nothing
     valueToUse = "";
-    }
-  else if (envVarValue!=0 && cacheValue==0)
-    {
+  } else if (envVarValue != 0 && cacheValue == 0) {
     // The variable is in the env, but not in the cache. Use it and put it
     // in the cache
     valueToUse = envVarValue;
     mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
-                           cacheEntryName.c_str(), cmState::STRING,
-                           true);
+                           cacheEntryName.c_str(), cmState::STRING, true);
     mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory());
-    }
-  else if (envVarValue==0 && cacheValue!=0)
-    {
+  } else if (envVarValue == 0 && cacheValue != 0) {
     // It is already in the cache, but not in the env, so use it from the cache
     valueToUse = cacheValue;
-    }
-  else
-    {
+  } else {
     // It is both in the cache and in the env.
     // Use the version from the env. except if the value from the env is
     // completely contained in the value from the cache (for the case that we
     // now have a PATH without MSVC dirs in the env. but had the full PATH with
     // all MSVC dirs during the cmake run which stored the var in the cache:
     valueToUse = cacheValue;
-    if (valueToUse.find(envVarValue) == std::string::npos)
-      {
+    if (valueToUse.find(envVarValue) == std::string::npos) {
       valueToUse = envVarValue;
       mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
-                             cacheEntryName.c_str(), cmState::STRING,
-                             true);
+                             cacheEntryName.c_str(), cmState::STRING, true);
       mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory());
-      }
     }
+  }
 
-  if (!valueToUse.empty())
-    {
+  if (!valueToUse.empty()) {
     out << envVar << "=" << valueToUse << "|";
-    }
+  }
 }
 
-
 void cmExtraEclipseCDT4Generator::CreateProjectFile()
 {
   cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0];
@@ -280,25 +258,25 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   const std::string filename = this->HomeOutputDirectory + "/.project";
 
   cmGeneratedFileStream fout(filename.c_str());
-  if (!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
   std::string compilerId = mf->GetSafeDefinition("CMAKE_C_COMPILER_ID");
-  if (compilerId.empty())  // no C compiler, try the C++ compiler:
-    {
+  if (compilerId.empty()) // no C compiler, try the C++ compiler:
+  {
     compilerId = mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID");
-    }
+  }
 
   cmXMLWriter xml(fout);
 
   xml.StartDocument("UTF-8");
   xml.StartElement("projectDescription");
 
-  xml.Element("name", this->GenerateProjectName(lg->GetProjectName(),
-      mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
-      this->GetPathBasename(this->HomeOutputDirectory)));
+  xml.Element("name", this->GenerateProjectName(
+                        lg->GetProjectName(),
+                        mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
+                        this->GetPathBasename(this->HomeOutputDirectory)));
 
   xml.Element("comment", "");
   xml.Element("projects", "");
@@ -312,43 +290,42 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   // use clean target
   AppendDictionary(xml, "org.eclipse.cdt.make.core.cleanBuildTarget", "clean");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.enableCleanBuild", "true");
-  AppendDictionary(xml, "org.eclipse.cdt.make.core.append_environment","true");
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.append_environment",
+                   "true");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.stopOnError", "true");
 
   // set the make command
   AppendDictionary(xml, "org.eclipse.cdt.make.core.enabledIncrementalBuild",
-      "true");
-  AppendDictionary(xml, "org.eclipse.cdt.make.core.build.command",
-      this->GetEclipsePath(mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM")));
+                   "true");
+  AppendDictionary(
+    xml, "org.eclipse.cdt.make.core.build.command",
+    this->GetEclipsePath(mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM")));
   AppendDictionary(xml, "org.eclipse.cdt.make.core.contents",
-      "org.eclipse.cdt.make.core.activeConfigSettings");
+                   "org.eclipse.cdt.make.core.activeConfigSettings");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.build.target.inc", "all");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.build.arguments",
-      mf->GetSafeDefinition("CMAKE_ECLIPSE_MAKE_ARGUMENTS"));
+                   mf->GetSafeDefinition("CMAKE_ECLIPSE_MAKE_ARGUMENTS"));
   AppendDictionary(xml, "org.eclipse.cdt.make.core.buildLocation",
-      this->GetEclipsePath(this->HomeOutputDirectory));
-  AppendDictionary(xml,
-      "org.eclipse.cdt.make.core.useDefaultBuildCmd", "false");
+                   this->GetEclipsePath(this->HomeOutputDirectory));
+  AppendDictionary(xml, "org.eclipse.cdt.make.core.useDefaultBuildCmd",
+                   "false");
 
   // set project specific environment
   std::stringstream environment;
-  environment << "VERBOSE=1|CMAKE_NO_VERBOSE=1|"; //verbose Makefile output
+  environment << "VERBOSE=1|CMAKE_NO_VERBOSE=1|"; // verbose Makefile output
   // set vsvars32.bat environment available at CMake time,
   //   but not necessarily when eclipse is open
-  if (compilerId == "MSVC")
-    {
+  if (compilerId == "MSVC") {
     AddEnvVar(environment, "PATH", lg);
     AddEnvVar(environment, "INCLUDE", lg);
     AddEnvVar(environment, "LIB", lg);
     AddEnvVar(environment, "LIBPATH", lg);
-    }
-  else if (compilerId == "Intel")
-    {
+  } else if (compilerId == "Intel") {
     // if the env.var is set, use this one and put it in the cache
     // if the env.var is not set, but the value is in the cache,
     // use it from the cache:
     AddEnvVar(environment, "INTEL_LICENSE_FILE", lg);
-    }
+  }
   AppendDictionary(xml, "org.eclipse.cdt.make.core.environment",
                    environment.str());
 
@@ -356,41 +333,33 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   AppendDictionary(xml, "org.eclipse.cdt.make.core.build.target.auto", "all");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.enableAutoBuild", "false");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.build.target.clean",
-      "clean");
+                   "clean");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.fullBuildTarget", "all");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.buildArguments", "");
   AppendDictionary(xml, "org.eclipse.cdt.make.core.build.location",
-      this->GetEclipsePath(this->HomeOutputDirectory));
+                   this->GetEclipsePath(this->HomeOutputDirectory));
   AppendDictionary(xml, "org.eclipse.cdt.make.core.autoBuildTarget", "all");
 
   // set error parsers
   std::stringstream errorOutputParser;
 
-  if (compilerId == "MSVC")
-    {
+  if (compilerId == "MSVC") {
     errorOutputParser << "org.eclipse.cdt.core.VCErrorParser;";
-    }
-  else if (compilerId == "Intel")
-    {
+  } else if (compilerId == "Intel") {
     errorOutputParser << "org.eclipse.cdt.core.ICCErrorParser;";
-    }
+  }
 
-  if (this->SupportsGmakeErrorParser)
-    {
+  if (this->SupportsGmakeErrorParser) {
     errorOutputParser << "org.eclipse.cdt.core.GmakeErrorParser;";
-    }
-  else
-    {
+  } else {
     errorOutputParser << "org.eclipse.cdt.core.MakeErrorParser;";
-    }
+  }
 
-  errorOutputParser <<
-    "org.eclipse.cdt.core.GCCErrorParser;"
-    "org.eclipse.cdt.core.GASErrorParser;"
-    "org.eclipse.cdt.core.GLDErrorParser;"
-    ;
+  errorOutputParser << "org.eclipse.cdt.core.GCCErrorParser;"
+                       "org.eclipse.cdt.core.GASErrorParser;"
+                       "org.eclipse.cdt.core.GLDErrorParser;";
   AppendDictionary(xml, "org.eclipse.cdt.core.errorOutputParser",
-      errorOutputParser.str());
+                   errorOutputParser.str());
 
   xml.EndElement(); // arguments
   xml.EndElement(); // buildCommand
@@ -404,32 +373,29 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   // set natures for c/c++ projects
   xml.StartElement("natures");
   xml.Element("nature", "org.eclipse.cdt.make.core.makeNature");
-  xml.Element("nature", "org.eclipse.cdt.make.core.ScannerConfigNature");;
+  xml.Element("nature", "org.eclipse.cdt.make.core.ScannerConfigNature");
+  ;
 
-  for (std::set<std::string>::const_iterator nit=this->Natures.begin();
-       nit != this->Natures.end(); ++nit)
-    {
+  for (std::set<std::string>::const_iterator nit = this->Natures.begin();
+       nit != this->Natures.end(); ++nit) {
     xml.Element("nature", *nit);
-    }
+  }
 
-  if (const char *extraNaturesProp = mf->GetState()
-        ->GetGlobalProperty("ECLIPSE_EXTRA_NATURES"))
-    {
+  if (const char* extraNaturesProp =
+        mf->GetState()->GetGlobalProperty("ECLIPSE_EXTRA_NATURES")) {
     std::vector<std::string> extraNatures;
     cmSystemTools::ExpandListArgument(extraNaturesProp, extraNatures);
     for (std::vector<std::string>::const_iterator nit = extraNatures.begin();
-         nit != extraNatures.end(); ++nit)
-      {
+         nit != extraNatures.end(); ++nit) {
       xml.Element("nature", *nit);
-      }
     }
+  }
 
   xml.EndElement(); // natures
 
   xml.StartElement("linkedResources");
   // create linked resources
-  if (this->IsOutOfSourceBuild)
-    {
+  if (this->IsOutOfSourceBuild) {
     // create a linked resource to CMAKE_SOURCE_DIR
     // (this is not done anymore for each project because of
     // http://public.kitware.com/Bug/view.php?id=9978 and because I found it
@@ -437,73 +403,65 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     // projects, Alex
 
     std::string sourceLinkedResourceName = "[Source directory]";
-    std::string linkSourceDirectory = this->GetEclipsePath(
-                                             lg->GetCurrentSourceDirectory());
+    std::string linkSourceDirectory =
+      this->GetEclipsePath(lg->GetCurrentSourceDirectory());
     // .project dir can't be subdir of a linked resource dir
     if (!cmSystemTools::IsSubDirectory(this->HomeOutputDirectory,
-                                         linkSourceDirectory))
-      {
+                                       linkSourceDirectory)) {
       this->AppendLinkedResource(xml, sourceLinkedResourceName,
                                  this->GetEclipsePath(linkSourceDirectory),
                                  LinkToFolder);
       this->SrcLinkedResources.push_back(sourceLinkedResourceName);
-      }
-
     }
+  }
 
-  if (this->SupportsVirtualFolders)
-    {
+  if (this->SupportsVirtualFolders) {
     this->CreateLinksToSubprojects(xml, this->HomeOutputDirectory);
 
     this->CreateLinksForTargets(xml);
-    }
+  }
 
   xml.EndElement(); // linkedResources
   xml.EndElement(); // projectDescription
 }
 
 void cmExtraEclipseCDT4Generator::WriteGroups(
-  std::vector<cmSourceGroup> const& sourceGroups,
-  std::string& linkName, cmXMLWriter& xml)
+  std::vector<cmSourceGroup> const& sourceGroups, std::string& linkName,
+  cmXMLWriter& xml)
 {
-  for(std::vector<cmSourceGroup>::const_iterator sgIt = sourceGroups.begin();
-      sgIt != sourceGroups.end(); ++sgIt)
-    {
+  for (std::vector<cmSourceGroup>::const_iterator sgIt = sourceGroups.begin();
+       sgIt != sourceGroups.end(); ++sgIt) {
     std::string linkName3 = linkName;
     linkName3 += "/";
     linkName3 += sgIt->GetFullName();
 
     size_t pos = 0;
-    while ((pos = linkName3.find("\\", pos)) != std::string::npos)
-      {
+    while ((pos = linkName3.find("\\", pos)) != std::string::npos) {
       linkName3.replace(pos, 1, "/");
       pos++;
-      }
+    }
 
     this->AppendLinkedResource(xml, linkName3, "virtual:/virtual",
                                VirtualFolder);
     std::vector<cmSourceGroup> const& children = sgIt->GetGroupChildren();
-    if (!children.empty())
-      {
+    if (!children.empty()) {
       this->WriteGroups(children, linkName, xml);
-      }
+    }
     std::vector<const cmSourceFile*> sFiles = sgIt->GetSourceFiles();
-    for(std::vector<const cmSourceFile*>::const_iterator
-        fileIt = sFiles.begin(); fileIt != sFiles.end(); ++fileIt)
-      {
+    for (std::vector<const cmSourceFile*>::const_iterator fileIt =
+           sFiles.begin();
+         fileIt != sFiles.end(); ++fileIt) {
       std::string fullPath = (*fileIt)->GetFullPath();
 
-      if (!cmSystemTools::FileIsDirectory(fullPath))
-        {
+      if (!cmSystemTools::FileIsDirectory(fullPath)) {
         std::string linkName4 = linkName3;
         linkName4 += "/";
         linkName4 += cmSystemTools::GetFilenameName(fullPath);
         this->AppendLinkedResource(xml, linkName4,
-                                   this->GetEclipsePath(fullPath),
-                                   LinkToFile);
-        }
+                                   this->GetEclipsePath(fullPath), LinkToFile);
       }
     }
+  }
 }
 
 void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
@@ -511,141 +469,119 @@ void cmExtraEclipseCDT4Generator::CreateLinksForTargets(cmXMLWriter& xml)
   std::string linkName = "[Targets]";
   this->AppendLinkedResource(xml, linkName, "virtual:/virtual", VirtualFolder);
 
-  for (std::vector<cmLocalGenerator*>::const_iterator
-       lgIt = this->GlobalGenerator->GetLocalGenerators().begin();
-       lgIt != this->GlobalGenerator->GetLocalGenerators().end();
-       ++lgIt)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator lgIt =
+         this->GlobalGenerator->GetLocalGenerators().begin();
+       lgIt != this->GlobalGenerator->GetLocalGenerators().end(); ++lgIt) {
     cmMakefile* makefile = (*lgIt)->GetMakefile();
     const std::vector<cmGeneratorTarget*> targets =
-        (*lgIt)->GetGeneratorTargets();
+      (*lgIt)->GetGeneratorTargets();
 
-    for(std::vector<cmGeneratorTarget*>::const_iterator ti=targets.begin();
-        ti!=targets.end();++ti)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
+         ti != targets.end(); ++ti) {
       std::string linkName2 = linkName;
       linkName2 += "/";
-      switch((*ti)->GetType())
-        {
+      switch ((*ti)->GetType()) {
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
         case cmState::SHARED_LIBRARY:
         case cmState::MODULE_LIBRARY:
-        case cmState::OBJECT_LIBRARY:
-          {
-          const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ?
-                                                          "[exe] " : "[lib] ");
+        case cmState::OBJECT_LIBRARY: {
+          const char* prefix =
+            ((*ti)->GetType() == cmState::EXECUTABLE ? "[exe] " : "[lib] ");
           linkName2 += prefix;
           linkName2 += (*ti)->GetName();
           this->AppendLinkedResource(xml, linkName2, "virtual:/virtual",
                                      VirtualFolder);
-          if (!this->GenerateLinkedResources)
-            {
+          if (!this->GenerateLinkedResources) {
             break; // skip generating the linked resources to the source files
-            }
-          std::vector<cmSourceGroup> sourceGroups=makefile->GetSourceGroups();
+          }
+          std::vector<cmSourceGroup> sourceGroups =
+            makefile->GetSourceGroups();
           // get the files from the source lists then add them to the groups
           cmGeneratorTarget* gt = const_cast<cmGeneratorTarget*>(*ti);
           std::vector<cmSourceFile*> files;
           gt->GetSourceFiles(files,
-                            makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-          for(std::vector<cmSourceFile*>::const_iterator sfIt = files.begin();
-              sfIt != files.end();
-              sfIt++)
-            {
+                             makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+          for (std::vector<cmSourceFile*>::const_iterator sfIt = files.begin();
+               sfIt != files.end(); sfIt++) {
             // Add the file to the list of sources.
             std::string source = (*sfIt)->GetFullPath();
             cmSourceGroup* sourceGroup =
-                       makefile->FindSourceGroup(source.c_str(), sourceGroups);
+              makefile->FindSourceGroup(source.c_str(), sourceGroups);
             sourceGroup->AssignSource(*sfIt);
-            }
+          }
 
           this->WriteGroups(sourceGroups, linkName2, xml);
-          }
-          break;
+        } break;
         // ignore all others:
         default:
           break;
-        }
       }
     }
+  }
 }
 
-
 void cmExtraEclipseCDT4Generator::CreateLinksToSubprojects(
-                       cmXMLWriter& xml, const std::string& baseDir)
+  cmXMLWriter& xml, const std::string& baseDir)
 {
-  if (!this->GenerateLinkedResources)
-    {
+  if (!this->GenerateLinkedResources) {
     return;
-    }
+  }
 
   // for each sub project create a linked resource to the source dir
   // - only if it is an out-of-source build
-  this->AppendLinkedResource(xml, "[Subprojects]",
-                             "virtual:/virtual", VirtualFolder);
+  this->AppendLinkedResource(xml, "[Subprojects]", "virtual:/virtual",
+                             VirtualFolder);
 
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = this->GlobalGenerator->GetProjectMap().begin();
-       it != this->GlobalGenerator->GetProjectMap().end();
-       ++it)
-    {
-    std::string linkSourceDirectory = this->GetEclipsePath(
-                   it->second[0]->GetCurrentSourceDirectory());
+         it = this->GlobalGenerator->GetProjectMap().begin();
+       it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
+    std::string linkSourceDirectory =
+      this->GetEclipsePath(it->second[0]->GetCurrentSourceDirectory());
     // a linked resource must not point to a parent directory of .project or
     // .project itself
     if ((baseDir != linkSourceDirectory) &&
-        !cmSystemTools::IsSubDirectory(baseDir,
-                                       linkSourceDirectory))
-      {
+        !cmSystemTools::IsSubDirectory(baseDir, linkSourceDirectory)) {
       std::string linkName = "[Subprojects]/";
       linkName += it->first;
       this->AppendLinkedResource(xml, linkName,
                                  this->GetEclipsePath(linkSourceDirectory),
-                                 LinkToFolder
-                                );
+                                 LinkToFolder);
       // Don't add it to the srcLinkedResources, because listing multiple
       // directories confuses the Eclipse indexer (#13596).
-      }
     }
+  }
 }
 
-
 void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
-                            cmXMLWriter& xml,
-                            const std::vector<std::string>& includeDirs,
-                            std::set<std::string>& emittedDirs)
+  cmXMLWriter& xml, const std::vector<std::string>& includeDirs,
+  std::set<std::string>& emittedDirs)
 {
-  for(std::vector<std::string>::const_iterator inc = includeDirs.begin();
-      inc != includeDirs.end();
-      ++inc)
-    {
-    if (!inc->empty())
-      {
+  for (std::vector<std::string>::const_iterator inc = includeDirs.begin();
+       inc != includeDirs.end(); ++inc) {
+    if (!inc->empty()) {
       std::string dir = cmSystemTools::CollapseFullPath(*inc);
 
       // handle framework include dirs on OSX, the remainder after the
       // Frameworks/ part has to be stripped
       //   /System/Library/Frameworks/GLUT.framework/Headers
       cmsys::RegularExpression frameworkRx("(.+/Frameworks)/.+\\.framework/");
-      if(frameworkRx.find(dir.c_str()))
-        {
+      if (frameworkRx.find(dir.c_str())) {
         dir = frameworkRx.match(1);
-        }
+      }
 
-      if(emittedDirs.find(dir) == emittedDirs.end())
-        {
+      if (emittedDirs.find(dir) == emittedDirs.end()) {
         emittedDirs.insert(dir);
         xml.StartElement("pathentry");
         xml.Attribute("include",
-            cmExtraEclipseCDT4Generator::GetEclipsePath(dir));
+                      cmExtraEclipseCDT4Generator::GetEclipsePath(dir));
         xml.Attribute("kind", "inc");
         xml.Attribute("path", "");
         xml.Attribute("system", "true");
         xml.EndElement();
-        }
       }
     }
+  }
 }
 
 void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
@@ -658,10 +594,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   const std::string filename = this->HomeOutputDirectory + "/.cproject";
 
   cmGeneratedFileStream fout(filename.c_str());
-  if (!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
   cmXMLWriter xml(fout);
 
@@ -678,7 +613,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   // Configuration settings...
   xml.StartElement("storageModule");
   xml.Attribute("buildSystemId",
-      "org.eclipse.cdt.core.defaultConfigDataProvider");
+                "org.eclipse.cdt.core.defaultConfigDataProvider");
   xml.Attribute("id", "org.eclipse.cdt.core.default.config.1");
   xml.Attribute("moduleId", "org.eclipse.cdt.core.settings");
   xml.Attribute("name", "Configuration");
@@ -686,10 +621,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   xml.StartElement("extensions");
 
   // TODO: refactor this out...
-  std::string executableFormat = mf->GetSafeDefinition(
-                                                    "CMAKE_EXECUTABLE_FORMAT");
-  if (executableFormat == "ELF")
-    {
+  std::string executableFormat =
+    mf->GetSafeDefinition("CMAKE_EXECUTABLE_FORMAT");
+  if (executableFormat == "ELF") {
     xml.StartElement("extension");
     xml.Attribute("id", "org.eclipse.cdt.core.ELF");
     xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
@@ -701,12 +635,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     AppendAttribute(xml, "addr2line");
     AppendAttribute(xml, "c++filt");
     xml.EndElement(); // extension
-    }
-  else
-    {
+  } else {
     std::string systemName = mf->GetSafeDefinition("CMAKE_SYSTEM_NAME");
-    if (systemName == "CYGWIN")
-      {
+    if (systemName == "CYGWIN") {
       xml.StartElement("extension");
       xml.Attribute("id", "org.eclipse.cdt.core.Cygwin_PE");
       xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
@@ -715,29 +646,24 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
       AppendAttribute(xml, "cygpath");
       AppendAttribute(xml, "nm");
       xml.EndElement(); // extension
-      }
-    else if (systemName == "Windows")
-      {
+    } else if (systemName == "Windows") {
       xml.StartElement("extension");
       xml.Attribute("id", "org.eclipse.cdt.core.PE");
       xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
       xml.EndElement(); // extension
-      }
-    else if (systemName == "Darwin")
-      {
+    } else if (systemName == "Darwin") {
       xml.StartElement("extension");
-      xml.Attribute("id",  this->SupportsMachO64Parser ?
-              "org.eclipse.cdt.core.MachO64" : "org.eclipse.cdt.core.MachO");
+      xml.Attribute("id", this->SupportsMachO64Parser
+                      ? "org.eclipse.cdt.core.MachO64"
+                      : "org.eclipse.cdt.core.MachO");
       xml.Attribute("point", "org.eclipse.cdt.core.BinaryParser");
       AppendAttribute(xml, "c++filt");
       xml.EndElement(); // extension
-      }
-    else
-      {
+    } else {
       // *** Should never get here ***
       xml.Element("error_toolchain_type");
-      }
     }
+  }
 
   xml.EndElement(); // extensions
   xml.EndElement(); // storageModule
@@ -761,24 +687,23 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   // - make it type 'src'
   // - and exclude it from type 'out'
   std::string excludeFromOut;
-/* I don't know what the pathentry kind="src" are good for, e.g. autocompletion
- * works also without them. Done wrong, the indexer complains, see #12417
- * and #12213.
- * According to #13596, this entry at least limits the directories the
- * indexer is searching for files. So now the "src" entry contains only
- * the linked resource to CMAKE_SOURCE_DIR.
- * The CDT documentation is very terse on that:
- * "CDT_SOURCE: Entry kind constant describing a path entry identifying a
- * folder containing source code to be compiled."
- * Also on the cdt-dev list didn't bring any information:
- * http://web.archiveorange.com/archive/v/B4NlJDNIpYoOS1SbxFNy
- * Alex */
-
-  for (std::vector<std::string>::const_iterator
-       it = this->SrcLinkedResources.begin();
-       it != this->SrcLinkedResources.end();
-       ++it)
-    {
+  /* I don't know what the pathentry kind="src" are good for, e.g.
+   * autocompletion
+   * works also without them. Done wrong, the indexer complains, see #12417
+   * and #12213.
+   * According to #13596, this entry at least limits the directories the
+   * indexer is searching for files. So now the "src" entry contains only
+   * the linked resource to CMAKE_SOURCE_DIR.
+   * The CDT documentation is very terse on that:
+   * "CDT_SOURCE: Entry kind constant describing a path entry identifying a
+   * folder containing source code to be compiled."
+   * Also on the cdt-dev list didn't bring any information:
+   * http://web.archiveorange.com/archive/v/B4NlJDNIpYoOS1SbxFNy
+   * Alex */
+
+  for (std::vector<std::string>::const_iterator it =
+         this->SrcLinkedResources.begin();
+       it != this->SrcLinkedResources.end(); ++it) {
     xml.StartElement("pathentry");
     xml.Attribute("kind", "src");
     xml.Attribute("path", *it);
@@ -787,11 +712,10 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     // exlude source directory from output search path
     // - only if not named the same as an output directory
     if (!cmSystemTools::FileIsDirectory(
-           std::string(this->HomeOutputDirectory + "/" + *it)))
-      {
+          std::string(this->HomeOutputDirectory + "/" + *it))) {
       excludeFromOut += *it + "/|";
-      }
     }
+  }
 
   excludeFromOut += "**/CMakeFiles/";
 
@@ -803,47 +727,38 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
 
   // add pre-processor definitions to allow eclipse to gray out sections
   emmited.clear();
-  for (std::vector<cmLocalGenerator*>::const_iterator
-        it = this->GlobalGenerator->GetLocalGenerators().begin();
-       it != this->GlobalGenerator->GetLocalGenerators().end();
-       ++it)
-    {
-
-    if(const char* cdefs = (*it)->GetMakefile()->GetProperty(
-                                                        "COMPILE_DEFINITIONS"))
-      {
+  for (std::vector<cmLocalGenerator*>::const_iterator it =
+         this->GlobalGenerator->GetLocalGenerators().begin();
+       it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
+
+    if (const char* cdefs =
+          (*it)->GetMakefile()->GetProperty("COMPILE_DEFINITIONS")) {
       // Expand the list.
       std::vector<std::string> defs;
       cmGeneratorExpression::Split(cdefs, defs);
 
-      for(std::vector<std::string>::const_iterator di = defs.begin();
-          di != defs.end(); ++di)
-        {
-        if (cmGeneratorExpression::Find(*di) != std::string::npos)
-          {
+      for (std::vector<std::string>::const_iterator di = defs.begin();
+           di != defs.end(); ++di) {
+        if (cmGeneratorExpression::Find(*di) != std::string::npos) {
           continue;
-          }
+        }
 
         std::string::size_type equals = di->find('=', 0);
         std::string::size_type enddef = di->length();
 
         std::string def;
         std::string val;
-        if (equals != std::string::npos && equals < enddef)
-          {
+        if (equals != std::string::npos && equals < enddef) {
           // we have -DFOO=BAR
           def = di->substr(0, equals);
           val = di->substr(equals + 1, enddef - equals + 1);
-          }
-        else
-          {
+        } else {
           // we have -DFOO
           def = *di;
-          }
+        }
 
         // insert the definition if not already added.
-        if(emmited.find(def) == emmited.end())
-          {
+        if (emmited.find(def) == emmited.end()) {
           emmited.insert(def);
           xml.StartElement("pathentry");
           xml.Attribute("kind", "mac");
@@ -851,37 +766,32 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           xml.Attribute("path", "");
           xml.Attribute("value", val);
           xml.EndElement();
-          }
         }
       }
     }
+  }
   // add system defined c macros
-  const char* cDefs=mf->GetDefinition(
-                              "CMAKE_EXTRA_GENERATOR_C_SYSTEM_DEFINED_MACROS");
-  if(this->CEnabled && cDefs)
-    {
+  const char* cDefs =
+    mf->GetDefinition("CMAKE_EXTRA_GENERATOR_C_SYSTEM_DEFINED_MACROS");
+  if (this->CEnabled && cDefs) {
     // Expand the list.
     std::vector<std::string> defs;
     cmSystemTools::ExpandListArgument(cDefs, defs, true);
 
     // the list must contain only definition-value pairs:
-    if ((defs.size() % 2) == 0)
-      {
+    if ((defs.size() % 2) == 0) {
       std::vector<std::string>::const_iterator di = defs.begin();
-      while (di != defs.end())
-        {
+      while (di != defs.end()) {
         std::string def = *di;
         ++di;
         std::string val;
-        if (di != defs.end())
-          {
+        if (di != defs.end()) {
           val = *di;
           ++di;
-          }
+        }
 
         // insert the definition if not already added.
-        if(emmited.find(def) == emmited.end())
-          {
+        if (emmited.find(def) == emmited.end()) {
           emmited.insert(def);
           xml.StartElement("pathentry");
           xml.Attribute("kind", "mac");
@@ -889,37 +799,32 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           xml.Attribute("path", "");
           xml.Attribute("value", val);
           xml.EndElement();
-          }
         }
       }
     }
+  }
   // add system defined c++ macros
-  const char* cxxDefs = mf->GetDefinition(
-                            "CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS");
-  if(this->CXXEnabled && cxxDefs)
-    {
+  const char* cxxDefs =
+    mf->GetDefinition("CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS");
+  if (this->CXXEnabled && cxxDefs) {
     // Expand the list.
     std::vector<std::string> defs;
     cmSystemTools::ExpandListArgument(cxxDefs, defs, true);
 
     // the list must contain only definition-value pairs:
-    if ((defs.size() % 2) == 0)
-      {
+    if ((defs.size() % 2) == 0) {
       std::vector<std::string>::const_iterator di = defs.begin();
-      while (di != defs.end())
-        {
+      while (di != defs.end()) {
         std::string def = *di;
         ++di;
         std::string val;
-        if (di != defs.end())
-          {
+        if (di != defs.end()) {
           val = *di;
           ++di;
-          }
+        }
 
         // insert the definition if not already added.
-        if(emmited.find(def) == emmited.end())
-          {
+        if (emmited.find(def) == emmited.end()) {
           emmited.insert(def);
           xml.StartElement("pathentry");
           xml.Attribute("kind", "mac");
@@ -927,49 +832,44 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           xml.Attribute("path", "");
           xml.Attribute("value", val);
           xml.EndElement();
-          }
         }
       }
     }
+  }
 
   // include dirs
   emmited.clear();
-  for (std::vector<cmLocalGenerator*>::const_iterator
-        it = this->GlobalGenerator->GetLocalGenerators().begin();
-       it != this->GlobalGenerator->GetLocalGenerators().end();
-       ++it)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator it =
+         this->GlobalGenerator->GetLocalGenerators().begin();
+       it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
     std::vector<cmGeneratorTarget*> targets = (*it)->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator l = targets.begin();
-         l != targets.end(); ++l)
-      {
+         l != targets.end(); ++l) {
       std::vector<std::string> includeDirs;
       std::string config = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
       (*it)->GetIncludeDirectories(includeDirs, *l, "C", config);
       this->AppendIncludeDirectories(xml, includeDirs, emmited);
-      }
     }
+  }
   // now also the system include directories, in case we found them in
   // CMakeSystemSpecificInformation.cmake. This makes Eclipse find the
   // standard headers.
   std::string compiler = mf->GetSafeDefinition("CMAKE_C_COMPILER");
-  if (this->CEnabled && !compiler.empty())
-    {
-    std::string systemIncludeDirs = mf->GetSafeDefinition(
-                                "CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS");
+  if (this->CEnabled && !compiler.empty()) {
+    std::string systemIncludeDirs =
+      mf->GetSafeDefinition("CMAKE_EXTRA_GENERATOR_C_SYSTEM_INCLUDE_DIRS");
     std::vector<std::string> dirs;
     cmSystemTools::ExpandListArgument(systemIncludeDirs, dirs);
     this->AppendIncludeDirectories(xml, dirs, emmited);
-    }
+  }
   compiler = mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
-  if (this->CXXEnabled && !compiler.empty())
-    {
-    std::string systemIncludeDirs = mf->GetSafeDefinition(
-                              "CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS");
+  if (this->CXXEnabled && !compiler.empty()) {
+    std::string systemIncludeDirs =
+      mf->GetSafeDefinition("CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_INCLUDE_DIRS");
     std::vector<std::string> dirs;
     cmSystemTools::ExpandListArgument(systemIncludeDirs, dirs);
     this->AppendIncludeDirectories(xml, dirs, emmited);
-    }
+  }
 
   xml.EndElement(); // storageModule
 
@@ -979,141 +879,124 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   xml.StartElement("buildTargets");
   emmited.clear();
   const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
-  const std::string makeArgs = mf->GetSafeDefinition(
-                                               "CMAKE_ECLIPSE_MAKE_ARGUMENTS");
+  const std::string makeArgs =
+    mf->GetSafeDefinition("CMAKE_ECLIPSE_MAKE_ARGUMENTS");
 
-  cmGlobalGenerator* generator
-    = const_cast<cmGlobalGenerator*>(this->GlobalGenerator);
+  cmGlobalGenerator* generator =
+    const_cast<cmGlobalGenerator*>(this->GlobalGenerator);
 
   std::string allTarget;
   std::string cleanTarget;
-  if (generator->GetAllTargetName())
-    {
+  if (generator->GetAllTargetName()) {
     allTarget = generator->GetAllTargetName();
-    }
-  if (generator->GetCleanTargetName())
-    {
+  }
+  if (generator->GetCleanTargetName()) {
     cleanTarget = generator->GetCleanTargetName();
-    }
+  }
 
   // add all executable and library targets and some of the GLOBAL
   // and UTILITY targets
-  for (std::vector<cmLocalGenerator*>::const_iterator
-        it = this->GlobalGenerator->GetLocalGenerators().begin();
-       it != this->GlobalGenerator->GetLocalGenerators().end();
-       ++it)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator it =
+         this->GlobalGenerator->GetLocalGenerators().begin();
+       it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
     const std::vector<cmGeneratorTarget*> targets =
-        (*it)->GetGeneratorTargets();
+      (*it)->GetGeneratorTargets();
     std::string subdir = (*it)->Convert((*it)->GetCurrentBinaryDirectory(),
-                           cmLocalGenerator::HOME_OUTPUT);
-    if (subdir == ".")
-      {
+                                        cmLocalGenerator::HOME_OUTPUT);
+    if (subdir == ".") {
       subdir = "";
-      }
+    }
 
-    for(std::vector<cmGeneratorTarget*>::const_iterator ti =
-        targets.begin(); ti!=targets.end(); ++ti)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
+         ti != targets.end(); ++ti) {
       std::string targetName = (*ti)->GetName();
-      switch((*ti)->GetType())
-        {
-        case cmState::GLOBAL_TARGET:
-          {
+      switch ((*ti)->GetType()) {
+        case cmState::GLOBAL_TARGET: {
           // Only add the global targets from CMAKE_BINARY_DIR,
           // not from the subdirs
-          if (subdir.empty())
-           {
-           this->AppendTarget(xml, targetName, make, makeArgs, subdir, ": ");
-           }
-         }
-         break;
-       case cmState::UTILITY:
-         // Add all utility targets, except the Nightly/Continuous/
-         // Experimental-"sub"targets as e.g. NightlyStart
-         if (((targetName.find("Nightly")==0)   &&(targetName!="Nightly"))
-          || ((targetName.find("Continuous")==0)&&(targetName!="Continuous"))
-          || ((targetName.find("Experimental")==0)
-                                            && (targetName!="Experimental")))
-           {
-           break;
-           }
-
-         this->AppendTarget(xml, targetName, make, makeArgs, subdir, ": ");
-         break;
-       case cmState::EXECUTABLE:
-       case cmState::STATIC_LIBRARY:
-       case cmState::SHARED_LIBRARY:
-       case cmState::MODULE_LIBRARY:
-       case cmState::OBJECT_LIBRARY:
-         {
-         const char* prefix = ((*ti)->GetType()==cmState::EXECUTABLE ?
-                                                          "[exe] " : "[lib] ");
-         this->AppendTarget(xml, targetName, make, makeArgs, subdir, prefix);
-         std::string fastTarget = targetName;
-         fastTarget += "/fast";
-         this->AppendTarget(xml, fastTarget, make, makeArgs, subdir, prefix);
-
-         // Add Build and Clean targets in the virtual folder of targets:
-         if (this->SupportsVirtualFolders)
-          {
-          std::string virtDir = "[Targets]/";
-          virtDir += prefix;
-          virtDir += targetName;
-          std::string buildArgs = "-C \"";
-          buildArgs += (*it)->GetBinaryDirectory();
-          buildArgs += "\" ";
-          buildArgs += makeArgs;
-          this->AppendTarget(xml, "Build", make, buildArgs, virtDir, "",
-                             targetName.c_str());
-
-          std::string cleanArgs = "-E chdir \"";
-          cleanArgs += (*it)->GetCurrentBinaryDirectory();
-          cleanArgs += "\" \"";
-          cleanArgs += cmSystemTools::GetCMakeCommand();
-          cleanArgs += "\" -P \"";
-          cmGeneratorTarget* gt = *ti;
-          cleanArgs += (*it)->GetTargetDirectory(gt);
-          cleanArgs += "/cmake_clean.cmake\"";
-          this->AppendTarget(xml, "Clean", cmSystemTools::GetCMakeCommand(),
-                             cleanArgs, virtDir, "", "");
+          if (subdir.empty()) {
+            this->AppendTarget(xml, targetName, make, makeArgs, subdir, ": ");
           }
-         }
-         break;
+        } break;
+        case cmState::UTILITY:
+          // Add all utility targets, except the Nightly/Continuous/
+          // Experimental-"sub"targets as e.g. NightlyStart
+          if (((targetName.find("Nightly") == 0) &&
+               (targetName != "Nightly")) ||
+              ((targetName.find("Continuous") == 0) &&
+               (targetName != "Continuous")) ||
+              ((targetName.find("Experimental") == 0) &&
+               (targetName != "Experimental"))) {
+            break;
+          }
+
+          this->AppendTarget(xml, targetName, make, makeArgs, subdir, ": ");
+          break;
+        case cmState::EXECUTABLE:
+        case cmState::STATIC_LIBRARY:
+        case cmState::SHARED_LIBRARY:
+        case cmState::MODULE_LIBRARY:
+        case cmState::OBJECT_LIBRARY: {
+          const char* prefix =
+            ((*ti)->GetType() == cmState::EXECUTABLE ? "[exe] " : "[lib] ");
+          this->AppendTarget(xml, targetName, make, makeArgs, subdir, prefix);
+          std::string fastTarget = targetName;
+          fastTarget += "/fast";
+          this->AppendTarget(xml, fastTarget, make, makeArgs, subdir, prefix);
+
+          // Add Build and Clean targets in the virtual folder of targets:
+          if (this->SupportsVirtualFolders) {
+            std::string virtDir = "[Targets]/";
+            virtDir += prefix;
+            virtDir += targetName;
+            std::string buildArgs = "-C \"";
+            buildArgs += (*it)->GetBinaryDirectory();
+            buildArgs += "\" ";
+            buildArgs += makeArgs;
+            this->AppendTarget(xml, "Build", make, buildArgs, virtDir, "",
+                               targetName.c_str());
+
+            std::string cleanArgs = "-E chdir \"";
+            cleanArgs += (*it)->GetCurrentBinaryDirectory();
+            cleanArgs += "\" \"";
+            cleanArgs += cmSystemTools::GetCMakeCommand();
+            cleanArgs += "\" -P \"";
+            cmGeneratorTarget* gt = *ti;
+            cleanArgs += (*it)->GetTargetDirectory(gt);
+            cleanArgs += "/cmake_clean.cmake\"";
+            this->AppendTarget(xml, "Clean", cmSystemTools::GetCMakeCommand(),
+                               cleanArgs, virtDir, "", "");
+          }
+        } break;
         default:
           break;
-        }
       }
+    }
 
     // insert the all and clean targets in every subdir
-    if (!allTarget.empty())
-      {
+    if (!allTarget.empty()) {
       this->AppendTarget(xml, allTarget, make, makeArgs, subdir, ": ");
-      }
-    if (!cleanTarget.empty())
-      {
+    }
+    if (!cleanTarget.empty()) {
       this->AppendTarget(xml, cleanTarget, make, makeArgs, subdir, ": ");
-      }
+    }
 
-    //insert rules for compiling, preprocessing and assembling individual files
+    // insert rules for compiling, preprocessing and assembling individual
+    // files
     std::vector<std::string> objectFileTargets;
     (*it)->GetIndividualFileTargets(objectFileTargets);
-    for(std::vector<std::string>::const_iterator fit=objectFileTargets.begin();
-        fit != objectFileTargets.end();
-        ++fit)
-      {
+    for (std::vector<std::string>::const_iterator fit =
+           objectFileTargets.begin();
+         fit != objectFileTargets.end(); ++fit) {
       const char* prefix = "[obj] ";
-      if ((*fit)[fit->length()-1] == 's')
-        {
+      if ((*fit)[fit->length() - 1] == 's') {
         prefix = "[to asm] ";
-        }
-      else if ((*fit)[fit->length()-1] == 'i')
-        {
+      } else if ((*fit)[fit->length() - 1] == 'i') {
         prefix = "[pre] ";
-        }
-      this->AppendTarget(xml, *fit, make, makeArgs, subdir, prefix);
       }
+      this->AppendTarget(xml, *fit, make, makeArgs, subdir, prefix);
     }
+  }
 
   xml.EndElement(); // buildTargets
   xml.EndElement(); // storageModule
@@ -1136,80 +1019,70 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   xml.EndElement(); // cproject
 }
 
-std::string
-cmExtraEclipseCDT4Generator::GetEclipsePath(const std::string& path)
+std::string cmExtraEclipseCDT4Generator::GetEclipsePath(
+  const std::string& path)
 {
 #if defined(__CYGWIN__)
   std::string cmd = "cygpath -m " + path;
   std::string out;
-  if (!cmSystemTools::RunSingleCommand(cmd.c_str(), &out, &out))
-    {
+  if (!cmSystemTools::RunSingleCommand(cmd.c_str(), &out, &out)) {
     return path;
-    }
-  else
-    {
+  } else {
     out.erase(out.find_last_of('\n'));
     return out;
-    }
+  }
 #else
   return path;
 #endif
 }
 
-std::string
-cmExtraEclipseCDT4Generator::GetPathBasename(const std::string& path)
+std::string cmExtraEclipseCDT4Generator::GetPathBasename(
+  const std::string& path)
 {
   std::string outputBasename = path;
   while (!outputBasename.empty() &&
          (outputBasename[outputBasename.size() - 1] == '/' ||
-          outputBasename[outputBasename.size() - 1] == '\\'))
-    {
+          outputBasename[outputBasename.size() - 1] == '\\')) {
     outputBasename.resize(outputBasename.size() - 1);
-    }
+  }
   std::string::size_type loc = outputBasename.find_last_of("/\\");
-  if (loc != std::string::npos)
-    {
+  if (loc != std::string::npos) {
     outputBasename = outputBasename.substr(loc + 1);
-    }
+  }
 
   return outputBasename;
 }
 
-std::string
-cmExtraEclipseCDT4Generator::GenerateProjectName(const std::string& name,
-                                                 const std::string& type,
-                                                 const std::string& path)
+std::string cmExtraEclipseCDT4Generator::GenerateProjectName(
+  const std::string& name, const std::string& type, const std::string& path)
 {
   return name + (type.empty() ? "" : "-") + type + "@" + path;
 }
 
 // Helper functions
-void cmExtraEclipseCDT4Generator
-::AppendStorageScanners(cmXMLWriter& xml,
-                        const cmMakefile& makefile)
+void cmExtraEclipseCDT4Generator::AppendStorageScanners(
+  cmXMLWriter& xml, const cmMakefile& makefile)
 {
   // we need the "make" and the C (or C++) compiler which are used, Alex
   std::string make = makefile.GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   std::string compiler = makefile.GetSafeDefinition("CMAKE_C_COMPILER");
   std::string arg1 = makefile.GetSafeDefinition("CMAKE_C_COMPILER_ARG1");
-  if (compiler.empty())
-    {
+  if (compiler.empty()) {
     compiler = makefile.GetSafeDefinition("CMAKE_CXX_COMPILER");
     arg1 = makefile.GetSafeDefinition("CMAKE_CXX_COMPILER_ARG1");
-    }
-  if (compiler.empty())  //Hmm, what to do now ?
-    {
+  }
+  if (compiler.empty()) // Hmm, what to do now ?
+  {
     compiler = "gcc";
-    }
+  }
 
   // the following right now hardcodes gcc behaviour :-/
   std::string compilerArgs =
-                         "-E -P -v -dD ${plugin_state_location}/${specs_file}";
-  if (!arg1.empty())
-    {
+    "-E -P -v -dD ${plugin_state_location}/${specs_file}";
+  if (!arg1.empty()) {
     arg1 += " ";
     compilerArgs = arg1 + compilerArgs;
-    }
+  }
 
   xml.StartElement("storageModule");
   xml.Attribute("moduleId", "scannerConfiguration");
@@ -1218,19 +1091,15 @@ void cmExtraEclipseCDT4Generator
   xml.Attribute("enabled", "true");
   xml.Attribute("problemReportingEnabled", "true");
   xml.Attribute("selectedProfileId",
-      "org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile");
+                "org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile");
   xml.EndElement(); // autodiscovery
 
-  cmExtraEclipseCDT4Generator::AppendScannerProfile(xml,
-    "org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile",
-    true, "", true, "specsFile",
-    compilerArgs,
-    compiler, true, true);
-  cmExtraEclipseCDT4Generator::AppendScannerProfile(xml,
-    "org.eclipse.cdt.make.core.GCCStandardMakePerFileProfile",
-    true, "", true, "makefileGenerator",
-    "-f ${project_name}_scd.mk",
-    make, true, true);
+  cmExtraEclipseCDT4Generator::AppendScannerProfile(
+    xml, "org.eclipse.cdt.make.core.GCCStandardMakePerProjectProfile", true,
+    "", true, "specsFile", compilerArgs, compiler, true, true);
+  cmExtraEclipseCDT4Generator::AppendScannerProfile(
+    xml, "org.eclipse.cdt.make.core.GCCStandardMakePerFileProfile", true, "",
+    true, "makefileGenerator", "-f ${project_name}_scd.mk", make, true, true);
 
   xml.EndElement(); // storageModule
 }
@@ -1243,21 +1112,17 @@ void cmExtraEclipseCDT4Generator
 // finally the assembly files "[to asm] ". Note the "to" in "to asm",
 // without it, "asm" would be the first targets in the list, with the "to"
 // they are the last targets, which makes more sense.
-void cmExtraEclipseCDT4Generator::AppendTarget(cmXMLWriter& xml,
-                                               const std::string&     target,
-                                               const std::string&     make,
-                                               const std::string&     makeArgs,
-                                               const std::string&     path,
-                                               const char* prefix,
-                                               const char* makeTarget
-                                              )
+void cmExtraEclipseCDT4Generator::AppendTarget(
+  cmXMLWriter& xml, const std::string& target, const std::string& make,
+  const std::string& makeArgs, const std::string& path, const char* prefix,
+  const char* makeTarget)
 {
   xml.StartElement("target");
   xml.Attribute("name", prefix + target);
   xml.Attribute("path", path);
   xml.Attribute("targetID", "org.eclipse.cdt.make.MakeTargetBuilder");
   xml.Element("buildCommand",
-      cmExtraEclipseCDT4Generator::GetEclipsePath(make));
+              cmExtraEclipseCDT4Generator::GetEclipsePath(make));
   xml.Element("buildArguments", makeArgs);
   xml.Element("buildTarget", makeTarget ? makeTarget : target.c_str());
   xml.Element("stopOnError", "true");
@@ -1265,17 +1130,12 @@ void cmExtraEclipseCDT4Generator::AppendTarget(cmXMLWriter& xml,
   xml.EndElement();
 }
 
-void cmExtraEclipseCDT4Generator
-::AppendScannerProfile(cmXMLWriter& xml,
-                       const std::string&     profileID,
-                       bool                   openActionEnabled,
-                       const std::string&     openActionFilePath,
-                       bool                   pParserEnabled,
-                       const std::string&     scannerInfoProviderID,
-                       const std::string&     runActionArguments,
-                       const std::string&     runActionCommand,
-                       bool                   runActionUseDefault,
-                       bool                   sipParserEnabled)
+void cmExtraEclipseCDT4Generator::AppendScannerProfile(
+  cmXMLWriter& xml, const std::string& profileID, bool openActionEnabled,
+  const std::string& openActionFilePath, bool pParserEnabled,
+  const std::string& scannerInfoProviderID,
+  const std::string& runActionArguments, const std::string& runActionCommand,
+  bool runActionUseDefault, bool sipParserEnabled)
 {
   xml.StartElement("profile");
   xml.Attribute("id", profileID);
@@ -1305,22 +1165,20 @@ void cmExtraEclipseCDT4Generator
   xml.EndElement(); // profile
 }
 
-void cmExtraEclipseCDT4Generator
-::AppendLinkedResource (cmXMLWriter& xml,
-                        const std::string&     name,
-                        const std::string&     path,
-                        LinkType linkType)
+void cmExtraEclipseCDT4Generator::AppendLinkedResource(cmXMLWriter& xml,
+                                                       const std::string& name,
+                                                       const std::string& path,
+                                                       LinkType linkType)
 {
   const char* locationTag = "location";
   int typeTag = 2;
   if (linkType == VirtualFolder) // ... and not a linked folder
-    {
+  {
     locationTag = "locationURI";
-    }
-  if (linkType == LinkToFile)
-    {
+  }
+  if (linkType == LinkToFile) {
     typeTag = 1;
-    }
+  }
 
   xml.StartElement("link");
   xml.Element("name", name);
diff --git a/Source/cmExtraEclipseCDT4Generator.h b/Source/cmExtraEclipseCDT4Generator.h
index 26955ef..0cef071 100644
--- a/Source/cmExtraEclipseCDT4Generator.h
+++ b/Source/cmExtraEclipseCDT4Generator.h
@@ -26,24 +26,31 @@ class cmSourceGroup;
 class cmExtraEclipseCDT4Generator : public cmExternalMakefileProjectGenerator
 {
 public:
-  enum LinkType {VirtualFolder, LinkToFolder, LinkToFile };
+  enum LinkType
+  {
+    VirtualFolder,
+    LinkToFolder,
+    LinkToFile
+  };
 
   cmExtraEclipseCDT4Generator();
 
-  static cmExternalMakefileProjectGenerator* New() {
+  static cmExternalMakefileProjectGenerator* New()
+  {
     return new cmExtraEclipseCDT4Generator;
   }
 
-  virtual std::string GetName() const {
+  virtual std::string GetName() const
+  {
     return cmExtraEclipseCDT4Generator::GetActualName();
   }
 
   static std::string GetActualName() { return "Eclipse CDT4"; }
 
   virtual void GetDocumentation(cmDocumentationEntry& entry,
-                                const std::string&    fullName) const;
+                                const std::string& fullName) const;
   virtual void EnableLanguage(std::vector<std::string> const& languages,
-                              cmMakefile *, bool optional);
+                              cmMakefile*, bool optional);
 
   virtual void Generate();
 
@@ -71,32 +78,24 @@ private:
   // Helper functions
   static void AppendStorageScanners(cmXMLWriter& xml,
                                     const cmMakefile& makefile);
-  static void AppendTarget         (cmXMLWriter& xml,
-                                    const std::string&     target,
-                                    const std::string&     make,
-                                    const std::string&     makeArguments,
-                                    const std::string&     path,
-                                    const char* prefix = "",
-                                    const char* makeTarget = NULL);
-  static void AppendScannerProfile (cmXMLWriter& xml,
-                                    const std::string&   profileID,
-                                    bool                 openActionEnabled,
-                                    const std::string&   openActionFilePath,
-                                    bool                 pParserEnabled,
-                                    const std::string&   scannerInfoProviderID,
-                                    const std::string&   runActionArguments,
-                                    const std::string&   runActionCommand,
-                                    bool                 runActionUseDefault,
-                                    bool                 sipParserEnabled);
-
-  static void AppendLinkedResource (cmXMLWriter& xml,
-                                    const std::string&     name,
-                                    const std::string&     path,
-                                    LinkType linkType);
-
-  static void AppendIncludeDirectories(cmXMLWriter& xml,
-                                   const std::vector<std::string>& includeDirs,
-                                   std::set<std::string>& emittedDirs);
+  static void AppendTarget(cmXMLWriter& xml, const std::string& target,
+                           const std::string& make,
+                           const std::string& makeArguments,
+                           const std::string& path, const char* prefix = "",
+                           const char* makeTarget = NULL);
+  static void AppendScannerProfile(
+    cmXMLWriter& xml, const std::string& profileID, bool openActionEnabled,
+    const std::string& openActionFilePath, bool pParserEnabled,
+    const std::string& scannerInfoProviderID,
+    const std::string& runActionArguments, const std::string& runActionCommand,
+    bool runActionUseDefault, bool sipParserEnabled);
+
+  static void AppendLinkedResource(cmXMLWriter& xml, const std::string& name,
+                                   const std::string& path, LinkType linkType);
+
+  static void AppendIncludeDirectories(
+    cmXMLWriter& xml, const std::vector<std::string>& includeDirs,
+    std::set<std::string>& emittedDirs);
 
   static void AddEnvVar(std::ostream& out, const char* envVar,
                         cmLocalGenerator* lg);
@@ -118,7 +117,6 @@ private:
   bool SupportsMachO64Parser;
   bool CEnabled;
   bool CXXEnabled;
-
 };
 
 #endif
diff --git a/Source/cmExtraKateGenerator.cxx b/Source/cmExtraKateGenerator.cxx
index f221604..02159dd 100644
--- a/Source/cmExtraKateGenerator.cxx
+++ b/Source/cmExtraKateGenerator.cxx
@@ -22,15 +22,15 @@
 
 #include <cmsys/SystemTools.hxx>
 
-void cmExtraKateGenerator
-::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
+void cmExtraKateGenerator::GetDocumentation(cmDocumentationEntry& entry,
+                                            const std::string&) const
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates Kate project files.";
 }
 
 cmExtraKateGenerator::cmExtraKateGenerator()
-:cmExternalMakefileProjectGenerator()
+  : cmExternalMakefileProjectGenerator()
 {
 #if defined(_WIN32)
   this->SupportedGlobalGenerators.push_back("MinGW Makefiles");
@@ -42,31 +42,28 @@ cmExtraKateGenerator::cmExtraKateGenerator()
   this->SupportedGlobalGenerators.push_back("Unix Makefiles");
 }
 
-
 void cmExtraKateGenerator::Generate()
 {
   cmLocalGenerator* lg = this->GlobalGenerator->GetLocalGenerators()[0];
   const cmMakefile* mf = lg->GetMakefile();
-  this->ProjectName = this->GenerateProjectName(lg->GetProjectName(),
-                          mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
-                          this->GetPathBasename(lg->GetBinaryDirectory()));
+  this->ProjectName = this->GenerateProjectName(
+    lg->GetProjectName(), mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
+    this->GetPathBasename(lg->GetBinaryDirectory()));
   this->UseNinja = (this->GlobalGenerator->GetName() == "Ninja");
 
   this->CreateKateProjectFile(lg);
   this->CreateDummyKateProjectFile(lg);
 }
 
-
 void cmExtraKateGenerator::CreateKateProjectFile(
-    const cmLocalGenerator* lg) const
+  const cmLocalGenerator* lg) const
 {
   std::string filename = lg->GetBinaryDirectory();
   filename += "/.kateproject";
   cmGeneratedFileStream fout(filename.c_str());
-  if (!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
   /* clang-format off */
   fout <<
@@ -79,15 +76,13 @@ void cmExtraKateGenerator::CreateKateProjectFile(
   fout << "}\n";
 }
 
-
-void
-cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
-                                   cmGeneratedFileStream& fout) const
+void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
+                                        cmGeneratedFileStream& fout) const
 {
   cmMakefile const* mf = lg->GetMakefile();
   const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
-  const std::string makeArgs = mf->GetSafeDefinition(
-    "CMAKE_KATE_MAKE_ARGUMENTS");
+  const std::string makeArgs =
+    mf->GetSafeDefinition("CMAKE_KATE_MAKE_ARGUMENTS");
   const char* homeOutputDir = lg->GetBinaryDirectory();
 
   /* clang-format off */
@@ -99,178 +94,154 @@ cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg,
   /* clang-format on */
 
   // build, clean and quick are for the build plugin kate <= 4.12:
-  fout << "\t\t\"build\": \"" << make << " -C \\\"" << homeOutputDir
-       << "\\\" " << makeArgs << " " << "all\",\n";
-  fout << "\t\t\"clean\": \"" << make << " -C \\\"" << homeOutputDir
-       << "\\\" " << makeArgs << " " << "clean\",\n";
-  fout << "\t\t\"quick\": \"" << make << " -C \\\"" << homeOutputDir
-       << "\\\" " << makeArgs << " " << "install\",\n";
+  fout << "\t\t\"build\": \"" << make << " -C \\\"" << homeOutputDir << "\\\" "
+       << makeArgs << " "
+       << "all\",\n";
+  fout << "\t\t\"clean\": \"" << make << " -C \\\"" << homeOutputDir << "\\\" "
+       << makeArgs << " "
+       << "clean\",\n";
+  fout << "\t\t\"quick\": \"" << make << " -C \\\"" << homeOutputDir << "\\\" "
+       << makeArgs << " "
+       << "install\",\n";
 
   // this is for kate >= 4.13:
-  fout <<
-  "\t\t\"targets\":[\n";
+  fout << "\t\t\"targets\":[\n";
 
-  this->AppendTarget(fout, "all", make, makeArgs,
-                     homeOutputDir, homeOutputDir);
-  this->AppendTarget(fout, "clean", make, makeArgs,
-                     homeOutputDir, homeOutputDir);
+  this->AppendTarget(fout, "all", make, makeArgs, homeOutputDir,
+                     homeOutputDir);
+  this->AppendTarget(fout, "clean", make, makeArgs, homeOutputDir,
+                     homeOutputDir);
 
   // add all executable and library targets and some of the GLOBAL
   // and UTILITY targets
-  for (std::vector<cmLocalGenerator*>::const_iterator
-       it = this->GlobalGenerator->GetLocalGenerators().begin();
-       it != this->GlobalGenerator->GetLocalGenerators().end();
-       ++it)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator it =
+         this->GlobalGenerator->GetLocalGenerators().begin();
+       it != this->GlobalGenerator->GetLocalGenerators().end(); ++it) {
     const std::vector<cmGeneratorTarget*> targets =
-        (*it)->GetGeneratorTargets();
+      (*it)->GetGeneratorTargets();
     std::string currentDir = (*it)->GetCurrentBinaryDirectory();
     bool topLevel = (currentDir == (*it)->GetBinaryDirectory());
 
-    for(std::vector<cmGeneratorTarget*>::const_iterator ti =
-        targets.begin(); ti!=targets.end(); ++ti)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti = targets.begin();
+         ti != targets.end(); ++ti) {
       std::string targetName = (*ti)->GetName();
-      switch((*ti)->GetType())
-        {
-        case cmState::GLOBAL_TARGET:
-          {
+      switch ((*ti)->GetType()) {
+        case cmState::GLOBAL_TARGET: {
           bool insertTarget = false;
           // Only add the global targets from CMAKE_BINARY_DIR,
           // not from the subdirs
-          if (topLevel)
-            {
+          if (topLevel) {
             insertTarget = true;
             // only add the "edit_cache" target if it's not ccmake, because
             // this will not work within the IDE
-            if (targetName == "edit_cache")
-              {
-              const char* editCommand = (*it)->GetMakefile()->GetDefinition
-              ("CMAKE_EDIT_COMMAND");
-              if (editCommand == 0)
-                {
+            if (targetName == "edit_cache") {
+              const char* editCommand =
+                (*it)->GetMakefile()->GetDefinition("CMAKE_EDIT_COMMAND");
+              if (editCommand == 0) {
                 insertTarget = false;
-                }
-              else if (strstr(editCommand, "ccmake")!=NULL)
-                {
+              } else if (strstr(editCommand, "ccmake") != NULL) {
                 insertTarget = false;
-                }
               }
             }
-          if (insertTarget)
-            {
-            this->AppendTarget(fout, targetName, make, makeArgs,
-                               currentDir, homeOutputDir);
-            }
-        }
-        break;
+          }
+          if (insertTarget) {
+            this->AppendTarget(fout, targetName, make, makeArgs, currentDir,
+                               homeOutputDir);
+          }
+        } break;
         case cmState::UTILITY:
           // Add all utility targets, except the Nightly/Continuous/
           // Experimental-"sub"targets as e.g. NightlyStart
-          if (((targetName.find("Nightly")==0)   &&(targetName!="Nightly"))
-            || ((targetName.find("Continuous")==0)
-                &&(targetName!="Continuous"))
-            || ((targetName.find("Experimental")==0)
-            && (targetName!="Experimental")))
-            {
-              break;
-            }
-
-            this->AppendTarget(fout, targetName, make, makeArgs,
-                               currentDir, homeOutputDir);
+          if (((targetName.find("Nightly") == 0) &&
+               (targetName != "Nightly")) ||
+              ((targetName.find("Continuous") == 0) &&
+               (targetName != "Continuous")) ||
+              ((targetName.find("Experimental") == 0) &&
+               (targetName != "Experimental"))) {
+            break;
+          }
+
+          this->AppendTarget(fout, targetName, make, makeArgs, currentDir,
+                             homeOutputDir);
           break;
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
         case cmState::SHARED_LIBRARY:
         case cmState::MODULE_LIBRARY:
-        case cmState::OBJECT_LIBRARY:
-        {
-          this->AppendTarget(fout, targetName, make, makeArgs,
-                             currentDir, homeOutputDir);
+        case cmState::OBJECT_LIBRARY: {
+          this->AppendTarget(fout, targetName, make, makeArgs, currentDir,
+                             homeOutputDir);
           std::string fastTarget = targetName;
           fastTarget += "/fast";
-          this->AppendTarget(fout, fastTarget, make, makeArgs,
-                             currentDir, homeOutputDir);
+          this->AppendTarget(fout, fastTarget, make, makeArgs, currentDir,
+                             homeOutputDir);
 
-        }
-        break;
+        } break;
         default:
           break;
       }
     }
 
-    //insert rules for compiling, preprocessing and assembling individual files
+    // insert rules for compiling, preprocessing and assembling individual
+    // files
     std::vector<std::string> objectFileTargets;
     (*it)->GetIndividualFileTargets(objectFileTargets);
-    for(std::vector<std::string>::const_iterator fit=objectFileTargets.begin();
-        fit != objectFileTargets.end();
-        ++fit)
-      {
-      this->AppendTarget(fout, *fit, make, makeArgs, currentDir,homeOutputDir);
-      }
+    for (std::vector<std::string>::const_iterator fit =
+           objectFileTargets.begin();
+         fit != objectFileTargets.end(); ++fit) {
+      this->AppendTarget(fout, *fit, make, makeArgs, currentDir,
+                         homeOutputDir);
+    }
   }
 
-  fout <<
-  "\t] }\n";
+  fout << "\t] }\n";
 }
 
-
-void
-cmExtraKateGenerator::AppendTarget(cmGeneratedFileStream& fout,
-                                   const std::string&     target,
-                                   const std::string&     make,
-                                   const std::string&     makeArgs,
-                                   const std::string&     path,
-                                   const char*            homeOutputDir
-                                  ) const
+void cmExtraKateGenerator::AppendTarget(cmGeneratedFileStream& fout,
+                                        const std::string& target,
+                                        const std::string& make,
+                                        const std::string& makeArgs,
+                                        const std::string& path,
+                                        const char* homeOutputDir) const
 {
   static char JsonSep = ' ';
 
-  fout <<
-    "\t\t\t" << JsonSep << "{\"name\":\"" << target << "\", "
-    "\"build_cmd\":\"" << make
-               << " -C \\\"" << (this->UseNinja ? homeOutputDir : path.c_str())
-               << "\\\" " << makeArgs << " "
-               << target << "\"}\n";
+  fout << "\t\t\t" << JsonSep << "{\"name\":\"" << target << "\", "
+                                                             "\"build_cmd\":\""
+       << make << " -C \\\"" << (this->UseNinja ? homeOutputDir : path.c_str())
+       << "\\\" " << makeArgs << " " << target << "\"}\n";
 
   JsonSep = ',';
 }
 
-
-
-void
-cmExtraKateGenerator::CreateDummyKateProjectFile(
-    const cmLocalGenerator* lg) const
+void cmExtraKateGenerator::CreateDummyKateProjectFile(
+  const cmLocalGenerator* lg) const
 {
   std::string filename = lg->GetBinaryDirectory();
   filename += "/";
   filename += this->ProjectName;
   filename += ".kateproject";
   cmGeneratedFileStream fout(filename.c_str());
-  if (!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
   fout << "#Generated by " << cmSystemTools::GetCMakeCommand()
        << ", do not edit.\n";
 }
 
-
-std::string
-cmExtraKateGenerator::GenerateFilesString(const cmLocalGenerator* lg) const
+std::string cmExtraKateGenerator::GenerateFilesString(
+  const cmLocalGenerator* lg) const
 {
   std::string s = lg->GetSourceDirectory();
   s += "/.git";
-  if(cmSystemTools::FileExists(s.c_str()))
-  {
+  if (cmSystemTools::FileExists(s.c_str())) {
     return std::string("\"git\": 1 ");
   }
 
   s = lg->GetSourceDirectory();
   s += "/.svn";
-  if(cmSystemTools::FileExists(s.c_str()))
-  {
+  if (cmSystemTools::FileExists(s.c_str())) {
     return std::string("\"svn\": 1 ");
   }
 
@@ -279,77 +250,69 @@ cmExtraKateGenerator::GenerateFilesString(const cmLocalGenerator* lg) const
 
   std::set<std::string> files;
   std::string tmp;
-  const std::vector<cmLocalGenerator *>& lgs =
-                                   this->GlobalGenerator->GetLocalGenerators();
-
-  for (std::vector<cmLocalGenerator*>::const_iterator it=lgs.begin();
-       it!=lgs.end(); it++)
-    {
-    cmMakefile* makefile=(*it)->GetMakefile();
-    const std::vector<std::string>& listFiles=makefile->GetListFiles();
-    for (std::vector<std::string>::const_iterator lt=listFiles.begin();
-         lt!=listFiles.end(); lt++)
+  const std::vector<cmLocalGenerator*>& lgs =
+    this->GlobalGenerator->GetLocalGenerators();
+
+  for (std::vector<cmLocalGenerator*>::const_iterator it = lgs.begin();
+       it != lgs.end(); it++) {
+    cmMakefile* makefile = (*it)->GetMakefile();
+    const std::vector<std::string>& listFiles = makefile->GetListFiles();
+    for (std::vector<std::string>::const_iterator lt = listFiles.begin();
+         lt != listFiles.end(); lt++) {
+      tmp = *lt;
       {
-      tmp=*lt;
-        {
         files.insert(tmp);
-        }
       }
+    }
 
     const std::vector<cmSourceFile*>& sources = makefile->GetSourceFiles();
     for (std::vector<cmSourceFile*>::const_iterator sfIt = sources.begin();
-         sfIt != sources.end(); sfIt++)
-      {
+         sfIt != sources.end(); sfIt++) {
       cmSourceFile* sf = *sfIt;
-      if (sf->GetPropertyAsBool("GENERATED"))
-        {
+      if (sf->GetPropertyAsBool("GENERATED")) {
         continue;
-        }
+      }
 
       tmp = sf->GetFullPath();
       files.insert(tmp);
-      }
     }
+  }
 
   const char* sep = "";
   tmp = "\"list\": [";
-  for(std::set<std::string>::const_iterator it = files.begin();
-      it != files.end(); ++it)
-    {
+  for (std::set<std::string>::const_iterator it = files.begin();
+       it != files.end(); ++it) {
     tmp += sep;
     tmp += " \"";
     tmp += *it;
     tmp += "\"";
     sep = ",";
-    }
+  }
   tmp += "] ";
 
   return tmp;
 }
 
-
-std::string cmExtraKateGenerator::GenerateProjectName(const std::string& name,
-                                                 const std::string& type,
-                                                 const std::string& path) const
+std::string cmExtraKateGenerator::GenerateProjectName(
+  const std::string& name, const std::string& type,
+  const std::string& path) const
 {
   return name + (type.empty() ? "" : "-") + type + "@" + path;
 }
 
-
-std::string cmExtraKateGenerator::GetPathBasename(const std::string& path)const
+std::string cmExtraKateGenerator::GetPathBasename(
+  const std::string& path) const
 {
   std::string outputBasename = path;
   while (!outputBasename.empty() &&
          (outputBasename[outputBasename.size() - 1] == '/' ||
-          outputBasename[outputBasename.size() - 1] == '\\'))
-    {
+          outputBasename[outputBasename.size() - 1] == '\\')) {
     outputBasename.resize(outputBasename.size() - 1);
-    }
+  }
   std::string::size_type loc = outputBasename.find_last_of("/\\");
-  if (loc != std::string::npos)
-    {
+  if (loc != std::string::npos) {
     outputBasename = outputBasename.substr(loc + 1);
-    }
+  }
 
   return outputBasename;
 }
diff --git a/Source/cmExtraKateGenerator.h b/Source/cmExtraKateGenerator.h
index 281c1ef..71e88a9 100644
--- a/Source/cmExtraKateGenerator.h
+++ b/Source/cmExtraKateGenerator.h
@@ -27,26 +27,28 @@ public:
   cmExtraKateGenerator();
 
   virtual std::string GetName() const
-                         { return cmExtraKateGenerator::GetActualName();}
-  static std::string GetActualName()                    { return "Kate";}
+  {
+    return cmExtraKateGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "Kate"; }
   static cmExternalMakefileProjectGenerator* New()
-                                     { return new cmExtraKateGenerator; }
+  {
+    return new cmExtraKateGenerator;
+  }
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const std::string& fullName) const;
 
   virtual void Generate();
+
 private:
   void CreateKateProjectFile(const cmLocalGenerator* lg) const;
   void CreateDummyKateProjectFile(const cmLocalGenerator* lg) const;
   void WriteTargets(const cmLocalGenerator* lg,
                     cmGeneratedFileStream& fout) const;
-  void AppendTarget(cmGeneratedFileStream& fout,
-                    const std::string&     target,
-                    const std::string&     make,
-                    const std::string&     makeArgs,
-                    const std::string&     path,
-                    const char*            homeOutputDir) const;
+  void AppendTarget(cmGeneratedFileStream& fout, const std::string& target,
+                    const std::string& make, const std::string& makeArgs,
+                    const std::string& path, const char* homeOutputDir) const;
 
   std::string GenerateFilesString(const cmLocalGenerator* lg) const;
   std::string GetPathBasename(const std::string& path) const;
diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx
index 0f64eda..9b3ea0b 100644
--- a/Source/cmExtraSublimeTextGenerator.cxx
+++ b/Source/cmExtraSublimeTextGenerator.cxx
@@ -38,15 +38,15 @@ http://www.sublimetext.com/docs/2/projects.html
 http://sublimetext.info/docs/en/reference/build_systems.html
 */
 
-void cmExtraSublimeTextGenerator
-::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
+void cmExtraSublimeTextGenerator::GetDocumentation(cmDocumentationEntry& entry,
+                                                   const std::string&) const
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates Sublime Text 2 project files.";
 }
 
 cmExtraSublimeTextGenerator::cmExtraSublimeTextGenerator()
-:cmExternalMakefileProjectGenerator()
+  : cmExternalMakefileProjectGenerator()
 {
 #if defined(_WIN32)
   this->SupportedGlobalGenerators.push_back("MinGW Makefiles");
@@ -58,68 +58,57 @@ cmExtraSublimeTextGenerator::cmExtraSublimeTextGenerator()
   this->SupportedGlobalGenerators.push_back("Unix Makefiles");
 }
 
-
 void cmExtraSublimeTextGenerator::Generate()
 {
   // for each sub project in the project create a sublime text 2 project
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = this->GlobalGenerator->GetProjectMap().begin();
-      it!= this->GlobalGenerator->GetProjectMap().end();
-      ++it)
-    {
+         it = this->GlobalGenerator->GetProjectMap().begin();
+       it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
     // create a project file
     this->CreateProjectFile(it->second);
-    }
+  }
 }
 
-
 void cmExtraSublimeTextGenerator::CreateProjectFile(
-                                     const std::vector<cmLocalGenerator*>& lgs)
+  const std::vector<cmLocalGenerator*>& lgs)
 {
-  std::string outputDir=lgs[0]->GetCurrentBinaryDirectory();
-  std::string projectName=lgs[0]->GetProjectName();
+  std::string outputDir = lgs[0]->GetCurrentBinaryDirectory();
+  std::string projectName = lgs[0]->GetProjectName();
 
   const std::string filename =
-                     outputDir + "/" + projectName + ".sublime-project";
+    outputDir + "/" + projectName + ".sublime-project";
 
   this->CreateNewProjectFile(lgs, filename);
 }
 
-void cmExtraSublimeTextGenerator
-  ::CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
-                         const std::string& filename)
+void cmExtraSublimeTextGenerator::CreateNewProjectFile(
+  const std::vector<cmLocalGenerator*>& lgs, const std::string& filename)
 {
-  const cmMakefile* mf=lgs[0]->GetMakefile();
+  const cmMakefile* mf = lgs[0]->GetMakefile();
   cmGeneratedFileStream fout(filename.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
-  const std::string &sourceRootRelativeToOutput = cmSystemTools::RelativePath(
-                     lgs[0]->GetBinaryDirectory(),
-                     lgs[0]->GetSourceDirectory());
+  const std::string& sourceRootRelativeToOutput = cmSystemTools::RelativePath(
+    lgs[0]->GetBinaryDirectory(), lgs[0]->GetSourceDirectory());
   // Write the folder entries to the project file
   fout << "{\n";
   fout << "\t\"folders\":\n\t[\n\t";
-  if (!sourceRootRelativeToOutput.empty())
-    {
-      fout << "\t{\n\t\t\t\"path\": \"" << sourceRootRelativeToOutput << "\"";
-      const std::string &outputRelativeToSourceRoot =
-        cmSystemTools::RelativePath(lgs[0]->GetSourceDirectory(),
-                                    lgs[0]->GetBinaryDirectory());
-      if ((!outputRelativeToSourceRoot.empty()) &&
+  if (!sourceRootRelativeToOutput.empty()) {
+    fout << "\t{\n\t\t\t\"path\": \"" << sourceRootRelativeToOutput << "\"";
+    const std::string& outputRelativeToSourceRoot =
+      cmSystemTools::RelativePath(lgs[0]->GetSourceDirectory(),
+                                  lgs[0]->GetBinaryDirectory());
+    if ((!outputRelativeToSourceRoot.empty()) &&
         ((outputRelativeToSourceRoot.length() < 3) ||
-          (outputRelativeToSourceRoot.substr(0, 3) != "../")))
-        {
-        fout << ",\n\t\t\t\"folder_exclude_patterns\": [\"" <<
-                outputRelativeToSourceRoot << "\"]";
-        }
-    }
-  else
-    {
-      fout << "\t{\n\t\t\t\"path\": \"./\"";
+         (outputRelativeToSourceRoot.substr(0, 3) != "../"))) {
+      fout << ",\n\t\t\t\"folder_exclude_patterns\": [\""
+           << outputRelativeToSourceRoot << "\"]";
     }
+  } else {
+    fout << "\t{\n\t\t\t\"path\": \"./\"";
+  }
   fout << "\n\t\t}";
   // End of the folders section
   fout << "\n\t]";
@@ -138,173 +127,143 @@ void cmExtraSublimeTextGenerator
   fout << "\n\t}";
 }
 
-
-void cmExtraSublimeTextGenerator::
-  AppendAllTargets(const std::vector<cmLocalGenerator*>& lgs,
-                   const cmMakefile* mf,
-                   cmGeneratedFileStream& fout,
-                   MapSourceFileFlags& sourceFileFlags)
+void cmExtraSublimeTextGenerator::AppendAllTargets(
+  const std::vector<cmLocalGenerator*>& lgs, const cmMakefile* mf,
+  cmGeneratedFileStream& fout, MapSourceFileFlags& sourceFileFlags)
 {
   std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
   std::string compiler = "";
-  if (!lgs.empty())
-    {
-      this->AppendTarget(fout, "all", lgs[0], 0, make.c_str(), mf,
-                         compiler.c_str(), sourceFileFlags, true);
-      this->AppendTarget(fout, "clean", lgs[0], 0, make.c_str(), mf,
-                         compiler.c_str(), sourceFileFlags, false);
-    }
+  if (!lgs.empty()) {
+    this->AppendTarget(fout, "all", lgs[0], 0, make.c_str(), mf,
+                       compiler.c_str(), sourceFileFlags, true);
+    this->AppendTarget(fout, "clean", lgs[0], 0, make.c_str(), mf,
+                       compiler.c_str(), sourceFileFlags, false);
+  }
 
   // add all executable and library targets and some of the GLOBAL
   // and UTILITY targets
-  for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
-       lg!=lgs.end(); lg++)
-    {
-    cmMakefile* makefile=(*lg)->GetMakefile();
-    std::vector<cmGeneratorTarget*> targets=(*lg)->GetGeneratorTargets();
+  for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
+       lg != lgs.end(); lg++) {
+    cmMakefile* makefile = (*lg)->GetMakefile();
+    std::vector<cmGeneratorTarget*> targets = (*lg)->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-         ti != targets.end(); ti++)
-      {
+         ti != targets.end(); ti++) {
       std::string targetName = (*ti)->GetName();
-      switch((*ti)->GetType())
-        {
-        case cmState::GLOBAL_TARGET:
-          {
+      switch ((*ti)->GetType()) {
+        case cmState::GLOBAL_TARGET: {
           // Only add the global targets from CMAKE_BINARY_DIR,
           // not from the subdirs
           if (strcmp((*lg)->GetCurrentBinaryDirectory(),
-                     (*lg)->GetBinaryDirectory())==0)
-            {
-            this->AppendTarget(fout, targetName, *lg, 0,
-                               make.c_str(), makefile, compiler.c_str(),
-                               sourceFileFlags, false);
-            }
+                     (*lg)->GetBinaryDirectory()) == 0) {
+            this->AppendTarget(fout, targetName, *lg, 0, make.c_str(),
+                               makefile, compiler.c_str(), sourceFileFlags,
+                               false);
           }
-          break;
+        } break;
         case cmState::UTILITY:
           // Add all utility targets, except the Nightly/Continuous/
           // Experimental-"sub"targets as e.g. NightlyStart
-          if (((targetName.find("Nightly")==0)   &&(targetName!="Nightly"))
-             || ((targetName.find("Continuous")==0)
-                 &&(targetName!="Continuous"))
-             || ((targetName.find("Experimental")==0)
-                 && (targetName!="Experimental")))
-            {
+          if (((targetName.find("Nightly") == 0) &&
+               (targetName != "Nightly")) ||
+              ((targetName.find("Continuous") == 0) &&
+               (targetName != "Continuous")) ||
+              ((targetName.find("Experimental") == 0) &&
+               (targetName != "Experimental"))) {
             break;
-            }
+          }
 
-          this->AppendTarget(fout, targetName, *lg, 0,
-                             make.c_str(), makefile, compiler.c_str(),
-                             sourceFileFlags, false);
+          this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), makefile,
+                             compiler.c_str(), sourceFileFlags, false);
           break;
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
         case cmState::SHARED_LIBRARY:
         case cmState::MODULE_LIBRARY:
-        case cmState::OBJECT_LIBRARY:
-          {
-          this->AppendTarget(fout, targetName, *lg, *ti,
-                             make.c_str(), makefile, compiler.c_str(),
-                             sourceFileFlags, false);
+        case cmState::OBJECT_LIBRARY: {
+          this->AppendTarget(fout, targetName, *lg, *ti, make.c_str(),
+                             makefile, compiler.c_str(), sourceFileFlags,
+                             false);
           std::string fastTarget = targetName;
           fastTarget += "/fast";
-          this->AppendTarget(fout, fastTarget, *lg, *ti,
-                             make.c_str(), makefile, compiler.c_str(),
-                             sourceFileFlags, false);
-          }
-          break;
+          this->AppendTarget(fout, fastTarget, *lg, *ti, make.c_str(),
+                             makefile, compiler.c_str(), sourceFileFlags,
+                             false);
+        } break;
         default:
           break;
-        }
       }
     }
+  }
 }
 
-void cmExtraSublimeTextGenerator::
-  AppendTarget(cmGeneratedFileStream& fout,
-               const std::string& targetName,
-               cmLocalGenerator* lg,
-               cmGeneratorTarget* target,
-               const char* make,
-               const cmMakefile* makefile,
-               const char*, //compiler
-               MapSourceFileFlags& sourceFileFlags,
-               bool firstTarget)
+void cmExtraSublimeTextGenerator::AppendTarget(
+  cmGeneratedFileStream& fout, const std::string& targetName,
+  cmLocalGenerator* lg, cmGeneratorTarget* target, const char* make,
+  const cmMakefile* makefile,
+  const char*, // compiler
+  MapSourceFileFlags& sourceFileFlags, bool firstTarget)
 {
 
-  if (target != 0)
-    {
-      std::vector<cmSourceFile*> sourceFiles;
-      target->GetSourceFiles(sourceFiles,
-                             makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-      std::vector<cmSourceFile*>::const_iterator sourceFilesEnd =
-        sourceFiles.end();
-      for (std::vector<cmSourceFile*>::const_iterator iter =
-        sourceFiles.begin(); iter != sourceFilesEnd; ++iter)
-        {
-          cmSourceFile* sourceFile = *iter;
-          MapSourceFileFlags::iterator sourceFileFlagsIter =
-            sourceFileFlags.find(sourceFile->GetFullPath());
-          if (sourceFileFlagsIter == sourceFileFlags.end())
-            {
-            sourceFileFlagsIter =
-              sourceFileFlags.insert(MapSourceFileFlags::value_type(
-                sourceFile->GetFullPath(), std::vector<std::string>())).first;
-            }
-          std::vector<std::string>& flags = sourceFileFlagsIter->second;
-          std::string flagsString =
-            this->ComputeFlagsForObject(*iter, lg, target);
-          std::string definesString =
-            this->ComputeDefines(*iter, lg, target);
-          flags.clear();
-          cmsys::RegularExpression flagRegex;
-          // Regular expression to extract compiler flags from a string
-          // https://gist.github.com/3944250
-          const char* regexString =
-            "(^|[ ])-[DIOUWfgs][^= ]+(=\\\"[^\"]+\\\"|=[^\"][^ ]+)?";
-          flagRegex.compile(regexString);
-          std::string workString = flagsString + " " + definesString;
-          while (flagRegex.find(workString))
-            {
-              std::string::size_type start = flagRegex.start();
-              if (workString[start] == ' ')
-                {
-                  start++;
-                }
-              flags.push_back(workString.substr(start,
-                flagRegex.end() - start));
-              if (flagRegex.end() < workString.size())
-                {
-                workString = workString.substr(flagRegex.end());
-                }
-                else
-                {
-                workString = "";
-                }
-            }
+  if (target != 0) {
+    std::vector<cmSourceFile*> sourceFiles;
+    target->GetSourceFiles(sourceFiles,
+                           makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+    std::vector<cmSourceFile*>::const_iterator sourceFilesEnd =
+      sourceFiles.end();
+    for (std::vector<cmSourceFile*>::const_iterator iter = sourceFiles.begin();
+         iter != sourceFilesEnd; ++iter) {
+      cmSourceFile* sourceFile = *iter;
+      MapSourceFileFlags::iterator sourceFileFlagsIter =
+        sourceFileFlags.find(sourceFile->GetFullPath());
+      if (sourceFileFlagsIter == sourceFileFlags.end()) {
+        sourceFileFlagsIter =
+          sourceFileFlags
+            .insert(MapSourceFileFlags::value_type(sourceFile->GetFullPath(),
+                                                   std::vector<std::string>()))
+            .first;
+      }
+      std::vector<std::string>& flags = sourceFileFlagsIter->second;
+      std::string flagsString = this->ComputeFlagsForObject(*iter, lg, target);
+      std::string definesString = this->ComputeDefines(*iter, lg, target);
+      flags.clear();
+      cmsys::RegularExpression flagRegex;
+      // Regular expression to extract compiler flags from a string
+      // https://gist.github.com/3944250
+      const char* regexString =
+        "(^|[ ])-[DIOUWfgs][^= ]+(=\\\"[^\"]+\\\"|=[^\"][^ ]+)?";
+      flagRegex.compile(regexString);
+      std::string workString = flagsString + " " + definesString;
+      while (flagRegex.find(workString)) {
+        std::string::size_type start = flagRegex.start();
+        if (workString[start] == ' ') {
+          start++;
         }
+        flags.push_back(workString.substr(start, flagRegex.end() - start));
+        if (flagRegex.end() < workString.size()) {
+          workString = workString.substr(flagRegex.end());
+        } else {
+          workString = "";
+        }
+      }
     }
+  }
 
   // Ninja uses ninja.build files (look for a way to get the output file name
   // from cmMakefile or something)
   std::string makefileName;
-  if (this->GlobalGenerator->GetName() == "Ninja")
-    {
-      makefileName = "build.ninja";
-    }
-    else
-    {
-      makefileName = "Makefile";
-    }
-  if (!firstTarget)
-    {
+  if (this->GlobalGenerator->GetName() == "Ninja") {
+    makefileName = "build.ninja";
+  } else {
+    makefileName = "Makefile";
+  }
+  if (!firstTarget) {
     fout << ",\n\t";
-    }
-  fout << "\t{\n\t\t\t\"name\": \"" << lg->GetProjectName() << " - " <<
-          targetName << "\",\n";
-  fout << "\t\t\t\"cmd\": [" <<
-          this->BuildMakeCommand(make, makefileName.c_str(), targetName) <<
-          "],\n";
+  }
+  fout << "\t{\n\t\t\t\"name\": \"" << lg->GetProjectName() << " - "
+       << targetName << "\",\n";
+  fout << "\t\t\t\"cmd\": ["
+       << this->BuildMakeCommand(make, makefileName.c_str(), targetName)
+       << "],\n";
   fout << "\t\t\t\"working_dir\": \"${project_path}\",\n";
   fout << "\t\t\t\"file_regex\": \"^(..[^:]*):([0-9]+):?([0-9]+)?:? (.*)$\"\n";
   fout << "\t\t}";
@@ -313,66 +272,54 @@ void cmExtraSublimeTextGenerator::
 // Create the command line for building the given target using the selected
 // make
 std::string cmExtraSublimeTextGenerator::BuildMakeCommand(
-             const std::string& make, const char* makefile,
-             const std::string& target)
+  const std::string& make, const char* makefile, const std::string& target)
 {
   std::string command = "\"";
   command += make + "\"";
   std::string generator = this->GlobalGenerator->GetName();
-  if (generator == "NMake Makefiles")
-    {
+  if (generator == "NMake Makefiles") {
     std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
     command += ", \"/NOLOGO\", \"/f\", \"";
     command += makefileName + "\"";
     command += ", \"VERBOSE=1\", \"";
     command += target;
     command += "\"";
-    }
-  else if (generator == "Ninja")
-    {
+  } else if (generator == "Ninja") {
     std::string makefileName = cmSystemTools::ConvertToOutputPath(makefile);
     command += ", \"-f\", \"";
     command += makefileName + "\"";
     command += ", \"-v\", \"";
     command += target;
     command += "\"";
-    }
-  else
-    {
+  } else {
     std::string makefileName;
-    if (generator == "MinGW Makefiles")
-      {
-        // no escaping of spaces in this case, see
-        // http://public.kitware.com/Bug/view.php?id=10014
-        makefileName = makefile;
-      }
-      else
-      {
-        makefileName = cmSystemTools::ConvertToOutputPath(makefile);
-      }
+    if (generator == "MinGW Makefiles") {
+      // no escaping of spaces in this case, see
+      // http://public.kitware.com/Bug/view.php?id=10014
+      makefileName = makefile;
+    } else {
+      makefileName = cmSystemTools::ConvertToOutputPath(makefile);
+    }
     command += ", \"-f\", \"";
     command += makefileName + "\"";
     command += ", \"VERBOSE=1\", \"";
     command += target;
     command += "\"";
-    }
+  }
   return command;
 }
 
 // TODO: Most of the code is picked up from the Ninja generator, refactor it.
-std::string
-cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
-                                                   cmLocalGenerator* lg,
-                                                   cmGeneratorTarget* gtgt)
+std::string cmExtraSublimeTextGenerator::ComputeFlagsForObject(
+  cmSourceFile* source, cmLocalGenerator* lg, cmGeneratorTarget* gtgt)
 {
   std::string flags;
 
-  cmMakefile *makefile = lg->GetMakefile();
+  cmMakefile* makefile = lg->GetMakefile();
   std::string language = source->GetLanguage();
-  if (language.empty())
-   {
-   language = "C";
-   }
+  if (language.empty()) {
+    language = "C";
+  }
   const std::string& config = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
   // Add language-specific flags.
   lg->AddLanguageFlags(flags, language, config);
@@ -391,11 +338,11 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
 
   // Add include directory flags.
   {
-  std::vector<std::string> includes;
-  lg->GetIncludeDirectories(includes, gtgt, language, config);
-  std::string includeFlags =
-    lg->GetIncludeFlags(includes, gtgt, language, true); // full include paths
-  lg->AppendFlags(flags, includeFlags);
+    std::vector<std::string> includes;
+    lg->GetIncludeDirectories(includes, gtgt, language, config);
+    std::string includeFlags = lg->GetIncludeFlags(includes, gtgt, language,
+                                                   true); // full include paths
+    lg->AppendFlags(flags, includeFlags);
   }
 
   // Append old-style preprocessor definition flags.
@@ -414,30 +361,27 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
 
 // TODO: Refactor with
 // void cmMakefileTargetGenerator::WriteTargetLanguageFlags().
-std::string
-cmExtraSublimeTextGenerator::
-ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg,
-               cmGeneratorTarget* target)
+std::string cmExtraSublimeTextGenerator::ComputeDefines(
+  cmSourceFile* source, cmLocalGenerator* lg, cmGeneratorTarget* target)
 
 {
   std::set<std::string> defines;
-  cmMakefile *makefile = lg->GetMakefile();
+  cmMakefile* makefile = lg->GetMakefile();
   const std::string& language = source->GetLanguage();
   const std::string& config = makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
 
   // Add the export symbol definition for shared library objects.
-  if(const char* exportMacro = target->GetExportMacro())
-    {
+  if (const char* exportMacro = target->GetExportMacro()) {
     lg->AppendDefines(defines, exportMacro);
-    }
+  }
 
   // Add preprocessor definitions for this target and configuration.
   lg->AddCompileDefinitions(defines, target, config, language);
   lg->AppendDefines(defines, source->GetProperty("COMPILE_DEFINITIONS"));
   {
-  std::string defPropName = "COMPILE_DEFINITIONS_";
-  defPropName += cmSystemTools::UpperCase(config);
-  lg->AppendDefines(defines, source->GetProperty(defPropName));
+    std::string defPropName = "COMPILE_DEFINITIONS_";
+    defPropName += cmSystemTools::UpperCase(config);
+    lg->AppendDefines(defines, source->GetProperty(defPropName));
   }
 
   std::string definesString;
diff --git a/Source/cmExtraSublimeTextGenerator.h b/Source/cmExtraSublimeTextGenerator.h
index cf31ee0..6efec7a 100644
--- a/Source/cmExtraSublimeTextGenerator.h
+++ b/Source/cmExtraSublimeTextGenerator.h
@@ -31,29 +31,31 @@ public:
   cmExtraSublimeTextGenerator();
 
   virtual std::string GetName() const
-                        { return cmExtraSublimeTextGenerator::GetActualName();}
-  static std::string GetActualName()
-                        { return "Sublime Text 2";}
+  {
+    return cmExtraSublimeTextGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "Sublime Text 2"; }
   static cmExternalMakefileProjectGenerator* New()
-                                    { return new cmExtraSublimeTextGenerator; }
+  {
+    return new cmExtraSublimeTextGenerator;
+  }
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const std::string& fullName) const;
 
   virtual void Generate();
-private:
 
+private:
   void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs);
 
   void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs,
-                                const std::string& filename);
+                            const std::string& filename);
 
   /** Appends all targets as build systems to the project file and get all
    * include directories and compiler definitions used.
    */
   void AppendAllTargets(const std::vector<cmLocalGenerator*>& lgs,
-                        const cmMakefile* mf,
-                        cmGeneratedFileStream& fout,
+                        const cmMakefile* mf, cmGeneratedFileStream& fout,
                         MapSourceFileFlags& sourceFileFlags);
   /** Returns the build command that needs to be executed to build the
    *  specified target.
@@ -63,24 +65,20 @@ private:
   /** Appends the specified target to the generated project file as a Sublime
    *  Text build system.
    */
-  void AppendTarget(cmGeneratedFileStream& fout,
-                    const std::string& targetName,
-                    cmLocalGenerator* lg,
-                    cmGeneratorTarget* target,
-                    const char* make,
-                    const cmMakefile* makefile,
-                    const char* compiler,
-                    MapSourceFileFlags& sourceFileFlags, bool firstTarget);
+  void AppendTarget(cmGeneratedFileStream& fout, const std::string& targetName,
+                    cmLocalGenerator* lg, cmGeneratorTarget* target,
+                    const char* make, const cmMakefile* makefile,
+                    const char* compiler, MapSourceFileFlags& sourceFileFlags,
+                    bool firstTarget);
   /**
    * Compute the flags for compilation of object files for a given @a language.
    * @note Generally it is the value of the variable whose name is computed
    *       by LanguageFlagsVarName().
    */
-  std::string ComputeFlagsForObject(cmSourceFile *source,
-                                    cmLocalGenerator* lg,
+  std::string ComputeFlagsForObject(cmSourceFile* source, cmLocalGenerator* lg,
                                     cmGeneratorTarget* gtgt);
 
-  std::string ComputeDefines(cmSourceFile *source, cmLocalGenerator* lg,
+  std::string ComputeDefines(cmSourceFile* source, cmLocalGenerator* lg,
                              cmGeneratorTarget* gtgt);
 };
 
diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx
index c64e813..ebd6223 100644
--- a/Source/cmFLTKWrapUICommand.cxx
+++ b/Source/cmFLTKWrapUICommand.cxx
@@ -14,14 +14,13 @@
 #include "cmSourceFile.h"
 
 // cmFLTKWrapUICommand
-bool cmFLTKWrapUICommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args,
+                                      cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // what is the current source dir
   std::string cdir = this->Makefile->GetCurrentSourceDirectory();
@@ -29,27 +28,25 @@ bool cmFLTKWrapUICommand
     this->Makefile->GetRequiredDefinition("FLTK_FLUID_EXECUTABLE");
 
   // get parameter for the command
-  this->Target = args[0];  // Target that will use the generated files
+  this->Target = args[0]; // Target that will use the generated files
 
   // get the list of GUI files from which .cxx and .h will be generated
   std::string outputDirectory = this->Makefile->GetCurrentBinaryDirectory();
 
   {
-  // Some of the generated files are *.h so the directory "GUI"
-  // where they are created have to be added to the include path
-  std::vector<std::string> outputDirectories;
-  outputDirectories.push_back(outputDirectory);
-  this->Makefile->AddIncludeDirectories( outputDirectories );
+    // Some of the generated files are *.h so the directory "GUI"
+    // where they are created have to be added to the include path
+    std::vector<std::string> outputDirectories;
+    outputDirectories.push_back(outputDirectory);
+    this->Makefile->AddIncludeDirectories(outputDirectories);
   }
 
-  for(std::vector<std::string>::const_iterator i = (args.begin() + 1);
-      i != args.end(); i++)
-    {
-    cmSourceFile *curr = this->Makefile->GetSource(*i);
+  for (std::vector<std::string>::const_iterator i = (args.begin() + 1);
+       i != args.end(); i++) {
+    cmSourceFile* curr = this->Makefile->GetSource(*i);
     // if we should use the source GUI
     // to generate .cxx and .h files
-    if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE"))
-      {
+    if (!curr || !curr->GetPropertyAsBool("WRAP_EXCLUDE")) {
       std::string outName = outputDirectory;
       outName += "/";
       outName += cmSystemTools::GetFilenameWithoutExtension(*i);
@@ -70,7 +67,7 @@ bool cmFLTKWrapUICommand
       commandLine.push_back(hname);
       commandLine.push_back("-o"); // optionally rename .cxx files
       commandLine.push_back(cxxres);
-      commandLine.push_back(origname);// name of the GUI fluid file
+      commandLine.push_back(origname); // name of the GUI fluid file
       cmCustomCommandLines commandLines;
       commandLines.push_back(commandLine);
 
@@ -78,33 +75,29 @@ bool cmFLTKWrapUICommand
       std::string no_main_dependency = "";
       const char* no_comment = 0;
       const char* no_working_dir = 0;
-      this->Makefile->AddCustomCommandToOutput(cxxres,
-                                           depends, no_main_dependency,
-                                           commandLines, no_comment,
-                                           no_working_dir);
-      this->Makefile->AddCustomCommandToOutput(hname,
-                                           depends, no_main_dependency,
-                                           commandLines, no_comment,
-                                           no_working_dir);
-
-      cmSourceFile *sf = this->Makefile->GetSource(cxxres);
+      this->Makefile->AddCustomCommandToOutput(
+        cxxres, depends, no_main_dependency, commandLines, no_comment,
+        no_working_dir);
+      this->Makefile->AddCustomCommandToOutput(
+        hname, depends, no_main_dependency, commandLines, no_comment,
+        no_working_dir);
+
+      cmSourceFile* sf = this->Makefile->GetSource(cxxres);
       sf->AddDepend(hname.c_str());
       sf->AddDepend(origname.c_str());
       this->GeneratedSourcesClasses.push_back(sf);
-      }
     }
+  }
 
   // create the variable with the list of sources in it
   size_t lastHeadersClass = this->GeneratedSourcesClasses.size();
   std::string sourceListValue;
-  for(size_t classNum = 0; classNum < lastHeadersClass; classNum++)
-    {
-    if (classNum)
-      {
+  for (size_t classNum = 0; classNum < lastHeadersClass; classNum++) {
+    if (classNum) {
       sourceListValue += ";";
-      }
-    sourceListValue += this->GeneratedSourcesClasses[classNum]->GetFullPath();
     }
+    sourceListValue += this->GeneratedSourcesClasses[classNum]->GetFullPath();
+  }
   std::string varName = this->Target;
   varName += "_FLTK_UI_SRCS";
   this->Makefile->AddDefinition(varName, sourceListValue.c_str());
@@ -118,18 +111,14 @@ void cmFLTKWrapUICommand::FinalPass()
   // didn't support that, so check and see if they added the files in and if
   // they didn;t then print a warning and add then anyhow
   cmTarget* target = this->Makefile->FindLocalNonAliasTarget(this->Target);
-  if(!target)
-    {
+  if (!target) {
     std::string msg =
       "FLTK_WRAP_UI was called with a target that was never created: ";
     msg += this->Target;
-    msg +=".  The problem was found while processing the source directory: ";
+    msg += ".  The problem was found while processing the source directory: ";
     msg += this->Makefile->GetCurrentSourceDirectory();
     msg += ".  This FLTK_WRAP_UI call will be ignored.";
-    cmSystemTools::Message(msg.c_str(),"Warning");
+    cmSystemTools::Message(msg.c_str(), "Warning");
     return;
-    }
+  }
 }
-
-
-
diff --git a/Source/cmFLTKWrapUICommand.h b/Source/cmFLTKWrapUICommand.h
index 617fcd9..2e60051 100644
--- a/Source/cmFLTKWrapUICommand.h
+++ b/Source/cmFLTKWrapUICommand.h
@@ -28,17 +28,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFLTKWrapUICommand;
-    }
+  virtual cmCommand* Clone() { return new cmFLTKWrapUICommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This is called at the end after all the information
@@ -52,13 +49,13 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "fltk_wrap_ui";}
+  virtual std::string GetName() const { return "fltk_wrap_ui"; }
 
 private:
   /**
    * List of produced files.
    */
-  std::vector<cmSourceFile *> GeneratedSourcesClasses;
+  std::vector<cmSourceFile*> GeneratedSourcesClasses;
 
   /**
    * List of Fluid files that provide the source
@@ -67,6 +64,4 @@ private:
   std::string Target;
 };
 
-
-
 #endif
diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index 6b6b913..5363a99 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -74,232 +74,169 @@ static mode_t mode_setgid = S_ISGID;
 static std::string fix_file_url_windows(const std::string& url)
 {
   std::string ret = url;
-  if(strncmp(url.c_str(), "file://", 7) == 0)
-    {
+  if (strncmp(url.c_str(), "file://", 7) == 0) {
     std::wstring wurl = cmsys::Encoding::ToWide(url);
-    if(!wurl.empty())
-      {
-      int mblen = WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1,
-                                   NULL, 0, NULL, NULL);
-      if(mblen > 0)
-        {
+    if (!wurl.empty()) {
+      int mblen =
+        WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1, NULL, 0, NULL, NULL);
+      if (mblen > 0) {
         std::vector<char> chars(mblen);
-        mblen = WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1,
-                                   &chars[0], mblen, NULL, NULL);
-        if(mblen > 0)
-          {
+        mblen = WideCharToMultiByte(CP_ACP, 0, wurl.c_str(), -1, &chars[0],
+                                    mblen, NULL, NULL);
+        if (mblen > 0) {
           ret = &chars[0];
-          }
         }
       }
     }
+  }
   return ret;
 }
 #endif
 
 // cmLibraryCommand
-bool cmFileCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmFileCommand::InitialPass(std::vector<std::string> const& args,
+                                cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("must be called with at least two arguments.");
     return false;
-    }
+  }
   std::string subCommand = args[0];
-  if ( subCommand == "WRITE" )
-    {
+  if (subCommand == "WRITE") {
     return this->HandleWriteCommand(args, false);
-    }
-  else if ( subCommand == "APPEND" )
-    {
+  } else if (subCommand == "APPEND") {
     return this->HandleWriteCommand(args, true);
-    }
-  else if ( subCommand == "DOWNLOAD" )
-    {
+  } else if (subCommand == "DOWNLOAD") {
     return this->HandleDownloadCommand(args);
-    }
-  else if ( subCommand == "UPLOAD" )
-    {
+  } else if (subCommand == "UPLOAD") {
     return this->HandleUploadCommand(args);
-    }
-  else if ( subCommand == "READ" )
-    {
+  } else if (subCommand == "READ") {
     return this->HandleReadCommand(args);
-    }
-  else if ( subCommand == "MD5" ||
-            subCommand == "SHA1" ||
-            subCommand == "SHA224" ||
-            subCommand == "SHA256" ||
-            subCommand == "SHA384" ||
-            subCommand == "SHA512" )
-    {
+  } else if (subCommand == "MD5" || subCommand == "SHA1" ||
+             subCommand == "SHA224" || subCommand == "SHA256" ||
+             subCommand == "SHA384" || subCommand == "SHA512") {
     return this->HandleHashCommand(args);
-    }
-  else if ( subCommand == "STRINGS" )
-    {
+  } else if (subCommand == "STRINGS") {
     return this->HandleStringsCommand(args);
-    }
-  else if ( subCommand == "GLOB" )
-    {
+  } else if (subCommand == "GLOB") {
     return this->HandleGlobCommand(args, false);
-    }
-  else if ( subCommand == "GLOB_RECURSE" )
-    {
+  } else if (subCommand == "GLOB_RECURSE") {
     return this->HandleGlobCommand(args, true);
-    }
-  else if ( subCommand == "MAKE_DIRECTORY" )
-    {
+  } else if (subCommand == "MAKE_DIRECTORY") {
     return this->HandleMakeDirectoryCommand(args);
-    }
-  else if ( subCommand == "RENAME" )
-    {
+  } else if (subCommand == "RENAME") {
     return this->HandleRename(args);
-    }
-  else if ( subCommand == "REMOVE" )
-    {
+  } else if (subCommand == "REMOVE") {
     return this->HandleRemove(args, false);
-    }
-  else if ( subCommand == "REMOVE_RECURSE" )
-    {
+  } else if (subCommand == "REMOVE_RECURSE") {
     return this->HandleRemove(args, true);
-    }
-  else if ( subCommand == "COPY" )
-    {
+  } else if (subCommand == "COPY") {
     return this->HandleCopyCommand(args);
-    }
-  else if ( subCommand == "INSTALL" )
-    {
+  } else if (subCommand == "INSTALL") {
     return this->HandleInstallCommand(args);
-    }
-  else if ( subCommand == "DIFFERENT" )
-    {
+  } else if (subCommand == "DIFFERENT") {
     return this->HandleDifferentCommand(args);
-    }
-  else if ( subCommand == "RPATH_CHANGE" || subCommand == "CHRPATH" )
-    {
+  } else if (subCommand == "RPATH_CHANGE" || subCommand == "CHRPATH") {
     return this->HandleRPathChangeCommand(args);
-    }
-  else if ( subCommand == "RPATH_CHECK" )
-    {
+  } else if (subCommand == "RPATH_CHECK") {
     return this->HandleRPathCheckCommand(args);
-    }
-  else if ( subCommand == "RPATH_REMOVE" )
-    {
+  } else if (subCommand == "RPATH_REMOVE") {
     return this->HandleRPathRemoveCommand(args);
-    }
-  else if ( subCommand == "RELATIVE_PATH" )
-    {
+  } else if (subCommand == "RELATIVE_PATH") {
     return this->HandleRelativePathCommand(args);
-    }
-  else if ( subCommand == "TO_CMAKE_PATH" )
-    {
+  } else if (subCommand == "TO_CMAKE_PATH") {
     return this->HandleCMakePathCommand(args, false);
-    }
-  else if ( subCommand == "TO_NATIVE_PATH" )
-    {
+  } else if (subCommand == "TO_NATIVE_PATH") {
     return this->HandleCMakePathCommand(args, true);
-    }
-  else if ( subCommand == "TIMESTAMP" )
-    {
+  } else if (subCommand == "TIMESTAMP") {
     return this->HandleTimestampCommand(args);
-    }
-  else if ( subCommand == "GENERATE" )
-    {
+  } else if (subCommand == "GENERATE") {
     return this->HandleGenerateCommand(args);
-    }
-  else if ( subCommand == "LOCK" )
-    {
+  } else if (subCommand == "LOCK") {
     return this->HandleLockCommand(args);
-    }
+  }
 
-  std::string e = "does not recognize sub-command "+subCommand;
+  std::string e = "does not recognize sub-command " + subCommand;
   this->SetError(e);
   return false;
 }
 
 bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
-  bool append)
+                                       bool append)
 {
   std::vector<std::string>::const_iterator i = args.begin();
 
   i++; // Get rid of subcommand
 
   std::string fileName = *i;
-  if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(i->c_str())) {
     fileName = this->Makefile->GetCurrentSourceDirectory();
     fileName += "/" + *i;
-    }
+  }
 
   i++;
 
-  if ( !this->Makefile->CanIWriteThisFile(fileName.c_str()) )
-    {
-    std::string e
-      = "attempted to write a file: " + fileName +
-      " into a source directory.";
+  if (!this->Makefile->CanIWriteThisFile(fileName.c_str())) {
+    std::string e =
+      "attempted to write a file: " + fileName + " into a source directory.";
     this->SetError(e);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
   std::string dir = cmSystemTools::GetFilenamePath(fileName);
   cmSystemTools::MakeDirectory(dir.c_str());
 
   mode_t mode = 0;
 
   // Set permissions to writable
-  if ( cmSystemTools::GetPermissions(fileName.c_str(), mode) )
-    {
+  if (cmSystemTools::GetPermissions(fileName.c_str(), mode)) {
     cmSystemTools::SetPermissions(fileName.c_str(),
-#if defined( _MSC_VER ) || defined( __MINGW32__ )
-      mode | S_IWRITE
+#if defined(_MSC_VER) || defined(__MINGW32__)
+                                  mode | S_IWRITE
 #else
-      mode | S_IWUSR | S_IWGRP
+                                  mode | S_IWUSR | S_IWGRP
 #endif
-    );
-    }
+                                  );
+  }
   // If GetPermissions fails, pretend like it is ok. File open will fail if
   // the file is not writable
-  cmsys::ofstream file(fileName.c_str(), append?std::ios::app: std::ios::out);
-  if ( !file )
-    {
+  cmsys::ofstream file(fileName.c_str(),
+                       append ? std::ios::app : std::ios::out);
+  if (!file) {
     std::string error = "failed to open for writing (";
     error += cmSystemTools::GetLastSystemError();
     error += "):\n  ";
     error += fileName;
     this->SetError(error);
     return false;
-    }
+  }
   std::string message = cmJoin(cmMakeRange(i, args.end()), std::string());
   file << message;
   file.close();
-  if(mode)
-    {
+  if (mode) {
     cmSystemTools::SetPermissions(fileName.c_str(), mode);
-    }
+  }
   return true;
 }
 
 bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
 {
-  if ( args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("READ must be called with at least two additional "
                    "arguments");
     return false;
-    }
+  }
 
   cmCommandArgumentsHelper argHelper;
   cmCommandArgumentGroup group;
 
-  cmCAString readArg    (&argHelper, "READ");
-  cmCAString fileNameArg    (&argHelper, 0);
-  cmCAString resultArg      (&argHelper, 0);
+  cmCAString readArg(&argHelper, "READ");
+  cmCAString fileNameArg(&argHelper, 0);
+  cmCAString resultArg(&argHelper, 0);
 
-  cmCAString offsetArg      (&argHelper, "OFFSET", &group);
-  cmCAString limitArg       (&argHelper, "LIMIT", &group);
-  cmCAEnabler hexOutputArg  (&argHelper, "HEX", &group);
+  cmCAString offsetArg(&argHelper, "OFFSET", &group);
+  cmCAString limitArg(&argHelper, "LIMIT", &group);
+  cmCAEnabler hexOutputArg(&argHelper, "HEX", &group);
   readArg.Follows(0);
   fileNameArg.Follows(&readArg);
   resultArg.Follows(&fileNameArg);
@@ -307,92 +244,78 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
   argHelper.Parse(&args, 0);
 
   std::string fileName = fileNameArg.GetString();
-  if ( !cmsys::SystemTools::FileIsFullPath(fileName.c_str()) )
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) {
     fileName = this->Makefile->GetCurrentSourceDirectory();
     fileName += "/" + fileNameArg.GetString();
-    }
+  }
 
   std::string variable = resultArg.GetString();
 
-  // Open the specified file.
+// Open the specified file.
 #if defined(_WIN32) || defined(__CYGWIN__)
-  cmsys::ifstream file(fileName.c_str(), std::ios::in |
-               (hexOutputArg.IsEnabled() ? std::ios::binary : std::ios::in));
+  cmsys::ifstream file(
+    fileName.c_str(), std::ios::in |
+      (hexOutputArg.IsEnabled() ? std::ios::binary : std::ios::in));
 #else
   cmsys::ifstream file(fileName.c_str(), std::ios::in);
 #endif
 
-  if ( !file )
-    {
+  if (!file) {
     std::string error = "failed to open for reading (";
     error += cmSystemTools::GetLastSystemError();
     error += "):\n  ";
     error += fileName;
     this->SetError(error);
     return false;
-    }
+  }
 
   // is there a limit?
   long sizeLimit = -1;
-  if (!limitArg.GetString().empty())
-    {
+  if (!limitArg.GetString().empty()) {
     sizeLimit = atoi(limitArg.GetCString());
-    }
+  }
 
   // is there an offset?
   long offset = 0;
-  if (!offsetArg.GetString().empty())
-    {
+  if (!offsetArg.GetString().empty()) {
     offset = atoi(offsetArg.GetCString());
-    }
+  }
 
   file.seekg(offset, std::ios::beg); // explicit ios::beg for IBM VisualAge 6
 
   std::string output;
 
-  if (hexOutputArg.IsEnabled())
-    {
+  if (hexOutputArg.IsEnabled()) {
     // Convert part of the file into hex code
     char c;
-    while((sizeLimit != 0) && (file.get(c)))
-      {
+    while ((sizeLimit != 0) && (file.get(c))) {
       char hex[4];
-      sprintf(hex, "%.2x", c&0xff);
+      sprintf(hex, "%.2x", c & 0xff);
       output += hex;
-      if (sizeLimit > 0)
-        {
+      if (sizeLimit > 0) {
         sizeLimit--;
-        }
       }
     }
-  else
-    {
+  } else {
     std::string line;
     bool has_newline = false;
-    while (sizeLimit != 0 &&
-          cmSystemTools::GetLineFromStream(file, line, &has_newline,
-                                            sizeLimit) )
-      {
-      if (sizeLimit > 0)
-        {
+    while (sizeLimit != 0 && cmSystemTools::GetLineFromStream(
+                               file, line, &has_newline, sizeLimit)) {
+      if (sizeLimit > 0) {
         sizeLimit = sizeLimit - static_cast<long>(line.size());
-        if (has_newline)
-          {
+        if (has_newline) {
           sizeLimit--;
-          }
-        if (sizeLimit < 0)
-          {
+        }
+        if (sizeLimit < 0) {
           sizeLimit = 0;
-          }
         }
+      }
       output += line;
-      if ( has_newline )
-        {
+      if (has_newline) {
         output += "\n";
-        }
       }
     }
+  }
   this->Makefile->AddDefinition(variable, output.c_str());
   return true;
 }
@@ -400,28 +323,25 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
 bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     std::ostringstream e;
     e << args[0] << " requires a file name and output variable";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
-  if(hash.get())
-    {
+  if (hash.get()) {
     std::string out = hash->HashFile(args[1]);
-    if(!out.empty())
-      {
+    if (!out.empty()) {
       this->Makefile->AddDefinition(args[2], out.c_str());
       return true;
-      }
+    }
     std::ostringstream e;
-    e << args[0] << " failed to read file \"" << args[1] << "\": "
-      << cmSystemTools::GetLastSystemError();
+    e << args[0] << " failed to read file \"" << args[1]
+      << "\": " << cmSystemTools::GetLastSystemError();
     this->SetError(e.str());
-    }
+  }
   return false;
 #else
   std::ostringstream e;
@@ -433,33 +353,34 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
 
 bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("STRINGS requires a file name and output variable");
     return false;
-    }
+  }
 
   // Get the file to read.
   std::string fileName = args[1];
-  if(!cmsys::SystemTools::FileIsFullPath(fileName.c_str()))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) {
     fileName = this->Makefile->GetCurrentSourceDirectory();
     fileName += "/" + args[1];
-    }
+  }
 
   // Get the variable in which to store the results.
   std::string outVar = args[2];
 
   // Parse the options.
-  enum { arg_none,
-         arg_limit_input,
-         arg_limit_output,
-         arg_limit_count,
-         arg_length_minimum,
-         arg_length_maximum,
-         arg__maximum,
-         arg_regex,
-         arg_encoding };
+  enum
+  {
+    arg_none,
+    arg_limit_input,
+    arg_limit_output,
+    arg_limit_count,
+    arg_length_minimum,
+    arg_length_maximum,
+    arg__maximum,
+    arg_regex,
+    arg_encoding
+  };
   unsigned int minlen = 0;
   unsigned int maxlen = 0;
   int limit_input = -1;
@@ -469,396 +390,302 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
   bool have_regex = false;
   bool newline_consume = false;
   bool hex_conversion_enabled = true;
-  enum { encoding_none = cmsys::FStream::BOM_None,
-         encoding_utf8 = cmsys::FStream::BOM_UTF8,
-         encoding_utf16le = cmsys::FStream::BOM_UTF16LE,
-         encoding_utf16be = cmsys::FStream::BOM_UTF16BE,
-         encoding_utf32le = cmsys::FStream::BOM_UTF32LE,
-         encoding_utf32be = cmsys::FStream::BOM_UTF32BE};
+  enum
+  {
+    encoding_none = cmsys::FStream::BOM_None,
+    encoding_utf8 = cmsys::FStream::BOM_UTF8,
+    encoding_utf16le = cmsys::FStream::BOM_UTF16LE,
+    encoding_utf16be = cmsys::FStream::BOM_UTF16BE,
+    encoding_utf32le = cmsys::FStream::BOM_UTF32LE,
+    encoding_utf32be = cmsys::FStream::BOM_UTF32BE
+  };
   int encoding = encoding_none;
   int arg_mode = arg_none;
-  for(unsigned int i=3; i < args.size(); ++i)
-    {
-    if(args[i] == "LIMIT_INPUT")
-      {
+  for (unsigned int i = 3; i < args.size(); ++i) {
+    if (args[i] == "LIMIT_INPUT") {
       arg_mode = arg_limit_input;
-      }
-    else if(args[i] == "LIMIT_OUTPUT")
-      {
+    } else if (args[i] == "LIMIT_OUTPUT") {
       arg_mode = arg_limit_output;
-      }
-    else if(args[i] == "LIMIT_COUNT")
-      {
+    } else if (args[i] == "LIMIT_COUNT") {
       arg_mode = arg_limit_count;
-      }
-    else if(args[i] == "LENGTH_MINIMUM")
-      {
+    } else if (args[i] == "LENGTH_MINIMUM") {
       arg_mode = arg_length_minimum;
-      }
-    else if(args[i] == "LENGTH_MAXIMUM")
-      {
+    } else if (args[i] == "LENGTH_MAXIMUM") {
       arg_mode = arg_length_maximum;
-      }
-    else if(args[i] == "REGEX")
-      {
+    } else if (args[i] == "REGEX") {
       arg_mode = arg_regex;
-      }
-    else if(args[i] == "NEWLINE_CONSUME")
-      {
+    } else if (args[i] == "NEWLINE_CONSUME") {
       newline_consume = true;
       arg_mode = arg_none;
-      }
-    else if(args[i] == "NO_HEX_CONVERSION")
-      {
+    } else if (args[i] == "NO_HEX_CONVERSION") {
       hex_conversion_enabled = false;
       arg_mode = arg_none;
-      }
-    else if(args[i] == "ENCODING")
-      {
+    } else if (args[i] == "ENCODING") {
       arg_mode = arg_encoding;
-      }
-    else if(arg_mode == arg_limit_input)
-      {
-      if(sscanf(args[i].c_str(), "%d", &limit_input) != 1 ||
-         limit_input < 0)
-        {
+    } else if (arg_mode == arg_limit_input) {
+      if (sscanf(args[i].c_str(), "%d", &limit_input) != 1 ||
+          limit_input < 0) {
         std::ostringstream e;
-        e << "STRINGS option LIMIT_INPUT value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LIMIT_INPUT value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
-      arg_mode = arg_none;
       }
-    else if(arg_mode == arg_limit_output)
-      {
-      if(sscanf(args[i].c_str(), "%d", &limit_output) != 1 ||
-         limit_output < 0)
-        {
+      arg_mode = arg_none;
+    } else if (arg_mode == arg_limit_output) {
+      if (sscanf(args[i].c_str(), "%d", &limit_output) != 1 ||
+          limit_output < 0) {
         std::ostringstream e;
-        e << "STRINGS option LIMIT_OUTPUT value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LIMIT_OUTPUT value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
-      arg_mode = arg_none;
       }
-    else if(arg_mode == arg_limit_count)
-      {
+      arg_mode = arg_none;
+    } else if (arg_mode == arg_limit_count) {
       int count;
-      if(sscanf(args[i].c_str(), "%d", &count) != 1 || count < 0)
-        {
+      if (sscanf(args[i].c_str(), "%d", &count) != 1 || count < 0) {
         std::ostringstream e;
-        e << "STRINGS option LIMIT_COUNT value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LIMIT_COUNT value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
+      }
       limit_count = count;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_length_minimum)
-      {
+    } else if (arg_mode == arg_length_minimum) {
       int len;
-      if(sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0)
-        {
+      if (sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0) {
         std::ostringstream e;
-        e << "STRINGS option LENGTH_MINIMUM value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LENGTH_MINIMUM value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
+      }
       minlen = len;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_length_maximum)
-      {
+    } else if (arg_mode == arg_length_maximum) {
       int len;
-      if(sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0)
-        {
+      if (sscanf(args[i].c_str(), "%d", &len) != 1 || len < 0) {
         std::ostringstream e;
-        e << "STRINGS option LENGTH_MAXIMUM value \""
-          << args[i] << "\" is not an unsigned integer.";
+        e << "STRINGS option LENGTH_MAXIMUM value \"" << args[i]
+          << "\" is not an unsigned integer.";
         this->SetError(e.str());
         return false;
-        }
+      }
       maxlen = len;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_regex)
-      {
-      if(!regex.compile(args[i].c_str()))
-        {
+    } else if (arg_mode == arg_regex) {
+      if (!regex.compile(args[i].c_str())) {
         std::ostringstream e;
-        e << "STRINGS option REGEX value \""
-          << args[i] << "\" could not be compiled.";
+        e << "STRINGS option REGEX value \"" << args[i]
+          << "\" could not be compiled.";
         this->SetError(e.str());
         return false;
-        }
+      }
       have_regex = true;
       arg_mode = arg_none;
-      }
-    else if(arg_mode == arg_encoding)
-      {
-      if(args[i] == "UTF-8")
-        {
+    } else if (arg_mode == arg_encoding) {
+      if (args[i] == "UTF-8") {
         encoding = encoding_utf8;
-        }
-      else if(args[i] == "UTF-16LE")
-        {
+      } else if (args[i] == "UTF-16LE") {
         encoding = encoding_utf16le;
-        }
-      else if(args[i] == "UTF-16BE")
-        {
+      } else if (args[i] == "UTF-16BE") {
         encoding = encoding_utf16be;
-        }
-      else if(args[i] == "UTF-32LE")
-        {
+      } else if (args[i] == "UTF-32LE") {
         encoding = encoding_utf32le;
-        }
-      else if(args[i] == "UTF-32BE")
-        {
+      } else if (args[i] == "UTF-32BE") {
         encoding = encoding_utf32be;
-        }
-      else
-        {
+      } else {
         std::ostringstream e;
-        e << "STRINGS option ENCODING \""
-          << args[i] << "\" not recognized.";
+        e << "STRINGS option ENCODING \"" << args[i] << "\" not recognized.";
         this->SetError(e.str());
         return false;
-        }
-      arg_mode = arg_none;
       }
-    else
-      {
+      arg_mode = arg_none;
+    } else {
       std::ostringstream e;
-      e << "STRINGS given unknown argument \""
-        << args[i] << "\"";
+      e << "STRINGS given unknown argument \"" << args[i] << "\"";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
-  if (hex_conversion_enabled)
-    {
+  if (hex_conversion_enabled) {
     // TODO: should work without temp file, but just on a memory buffer
     std::string binaryFileName = this->Makefile->GetCurrentBinaryDirectory();
     binaryFileName += cmake::GetCMakeFilesDirectory();
     binaryFileName += "/FileCommandStringsBinaryFile";
-    if(cmHexFileConverter::TryConvert(fileName.c_str(),binaryFileName.c_str()))
-      {
+    if (cmHexFileConverter::TryConvert(fileName.c_str(),
+                                       binaryFileName.c_str())) {
       fileName = binaryFileName;
-      }
     }
+  }
 
-  // Open the specified file.
+// Open the specified file.
 #if defined(_WIN32) || defined(__CYGWIN__)
   cmsys::ifstream fin(fileName.c_str(), std::ios::in | std::ios::binary);
 #else
   cmsys::ifstream fin(fileName.c_str(), std::ios::in);
 #endif
-  if(!fin)
-    {
+  if (!fin) {
     std::ostringstream e;
     e << "STRINGS file \"" << fileName << "\" cannot be read.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
-  //If BOM is found and encoding was not specified, use the BOM
+  // If BOM is found and encoding was not specified, use the BOM
   int bom_found = cmsys::FStream::ReadBOM(fin);
-  if(encoding == encoding_none && bom_found != cmsys::FStream::BOM_None)
-    {
+  if (encoding == encoding_none && bom_found != cmsys::FStream::BOM_None) {
     encoding = bom_found;
-    }
+  }
 
   unsigned int bytes_rem = 0;
-  if(encoding == encoding_utf16le || encoding == encoding_utf16be)
-    {
+  if (encoding == encoding_utf16le || encoding == encoding_utf16be) {
     bytes_rem = 1;
-    }
-  if(encoding == encoding_utf32le || encoding == encoding_utf32be)
-    {
+  }
+  if (encoding == encoding_utf32le || encoding == encoding_utf32be) {
     bytes_rem = 3;
-    }
+  }
 
   // Parse strings out of the file.
   int output_size = 0;
   std::vector<std::string> strings;
   std::string s;
-  while((!limit_count || strings.size() < limit_count) &&
-        (limit_input < 0 || static_cast<int>(fin.tellg()) < limit_input) &&
-        fin)
-    {
+  while ((!limit_count || strings.size() < limit_count) &&
+         (limit_input < 0 || static_cast<int>(fin.tellg()) < limit_input) &&
+         fin) {
     std::string current_str;
 
     int c = fin.get();
-    for(unsigned int i=0; i<bytes_rem; ++i)
-      {
+    for (unsigned int i = 0; i < bytes_rem; ++i) {
       int c1 = fin.get();
-      if(!fin)
-        {
+      if (!fin) {
         fin.putback(static_cast<char>(c1));
         break;
-        }
-      c = (c << 8) | c1;
       }
-    if(encoding == encoding_utf16le)
-      {
+      c = (c << 8) | c1;
+    }
+    if (encoding == encoding_utf16le) {
       c = ((c & 0xFF) << 8) | ((c & 0xFF00) >> 8);
-      }
-    else if(encoding == encoding_utf32le)
-      {
-       c = (((c & 0xFF) << 24) | ((c & 0xFF00) << 8) |
-          ((c & 0xFF0000) >> 8) | ((c & 0xFF000000) >> 24));
-      }
+    } else if (encoding == encoding_utf32le) {
+      c = (((c & 0xFF) << 24) | ((c & 0xFF00) << 8) | ((c & 0xFF0000) >> 8) |
+           ((c & 0xFF000000) >> 24));
+    }
 
-    if(c == '\r')
-      {
+    if (c == '\r') {
       // Ignore CR character to make output always have UNIX newlines.
       continue;
-      }
+    }
 
-    else if((c >= 0x20 && c < 0x7F) || c == '\t' ||
-            (c == '\n' && newline_consume))
-      {
+    else if ((c >= 0x20 && c < 0x7F) || c == '\t' ||
+             (c == '\n' && newline_consume)) {
       // This is an ASCII character that may be part of a string.
       // Cast added to avoid compiler warning. Cast is ok because
       // c is guaranteed to fit in char by the above if...
       current_str += static_cast<char>(c);
-      }
-    else if(encoding == encoding_utf8)
-      {
+    } else if (encoding == encoding_utf8) {
       // Check for UTF-8 encoded string (up to 4 octets)
-      static const unsigned char utf8_check_table[3][2] =
-        {
-          {0xE0, 0xC0},
-          {0xF0, 0xE0},
-          {0xF8, 0xF0},
-        };
+      static const unsigned char utf8_check_table[3][2] = {
+        { 0xE0, 0xC0 }, { 0xF0, 0xE0 }, { 0xF8, 0xF0 },
+      };
 
       // how many octets are there?
       unsigned int num_utf8_bytes = 0;
-      for(unsigned int j=0; num_utf8_bytes == 0 && j<3; j++)
-        {
-        if((c & utf8_check_table[j][0]) == utf8_check_table[j][1])
-          num_utf8_bytes = j+2;
-        }
+      for (unsigned int j = 0; num_utf8_bytes == 0 && j < 3; j++) {
+        if ((c & utf8_check_table[j][0]) == utf8_check_table[j][1])
+          num_utf8_bytes = j + 2;
+      }
 
       // get subsequent octets and check that they are valid
-      for(unsigned int j=0; j<num_utf8_bytes; j++)
-        {
-        if(j != 0)
-          {
+      for (unsigned int j = 0; j < num_utf8_bytes; j++) {
+        if (j != 0) {
           c = fin.get();
-          if(!fin || (c & 0xC0) != 0x80)
-            {
+          if (!fin || (c & 0xC0) != 0x80) {
             fin.putback(static_cast<char>(c));
             break;
-            }
           }
-        current_str += static_cast<char>(c);
         }
+        current_str += static_cast<char>(c);
+      }
 
       // if this was an invalid utf8 sequence, discard the data, and put
       // back subsequent characters
-      if((current_str.length() != num_utf8_bytes))
-        {
-        for(unsigned int j=0; j<current_str.size()-1; j++)
-          {
+      if ((current_str.length() != num_utf8_bytes)) {
+        for (unsigned int j = 0; j < current_str.size() - 1; j++) {
           c = current_str[current_str.size() - 1 - j];
           fin.putback(static_cast<char>(c));
-          }
-        current_str = "";
         }
+        current_str = "";
       }
+    }
 
-
-    if(c == '\n' && !newline_consume)
-      {
+    if (c == '\n' && !newline_consume) {
       // The current line has been terminated.  Check if the current
       // string matches the requirements.  The length may now be as
       // low as zero since blank lines are allowed.
-      if(s.length() >= minlen &&
-         (!have_regex || regex.find(s.c_str())))
-        {
+      if (s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) {
         output_size += static_cast<int>(s.size()) + 1;
-        if(limit_output >= 0 && output_size >= limit_output)
-          {
+        if (limit_output >= 0 && output_size >= limit_output) {
           s = "";
           break;
-          }
-        strings.push_back(s);
         }
+        strings.push_back(s);
+      }
 
       // Reset the string to empty.
       s = "";
-      }
-    else if(current_str.empty())
-      {
+    } else if (current_str.empty()) {
       // A non-string character has been found.  Check if the current
       // string matches the requirements.  We require that the length
       // be at least one no matter what the user specified.
-      if(s.length() >= minlen && !s.empty() &&
-      (!have_regex || regex.find(s.c_str())))
-        {
+      if (s.length() >= minlen && !s.empty() &&
+          (!have_regex || regex.find(s.c_str()))) {
         output_size += static_cast<int>(s.size()) + 1;
-        if(limit_output >= 0 && output_size >= limit_output)
-          {
+        if (limit_output >= 0 && output_size >= limit_output) {
           s = "";
           break;
-          }
-        strings.push_back(s);
         }
+        strings.push_back(s);
+      }
 
       // Reset the string to empty.
       s = "";
-      }
-    else
-      {
+    } else {
       s += current_str;
-      }
-
+    }
 
-    if(maxlen > 0 && s.size() == maxlen)
-      {
+    if (maxlen > 0 && s.size() == maxlen) {
       // Terminate a string if the maximum length is reached.
-      if(s.length() >= minlen &&
-         (!have_regex || regex.find(s.c_str())))
-        {
+      if (s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) {
         output_size += static_cast<int>(s.size()) + 1;
-        if(limit_output >= 0 && output_size >= limit_output)
-          {
+        if (limit_output >= 0 && output_size >= limit_output) {
           s = "";
           break;
-          }
-        strings.push_back(s);
         }
-      s = "";
+        strings.push_back(s);
       }
+      s = "";
     }
+  }
 
   // If there is a non-empty current string we have hit the end of the
   // input file or the input size limit.  Check if the current string
   // matches the requirements.
-  if((!limit_count || strings.size() < limit_count) &&
-     !s.empty() && s.length() >= minlen &&
-     (!have_regex || regex.find(s.c_str())))
-    {
+  if ((!limit_count || strings.size() < limit_count) && !s.empty() &&
+      s.length() >= minlen && (!have_regex || regex.find(s.c_str()))) {
     output_size += static_cast<int>(s.size()) + 1;
-    if(limit_output < 0 || output_size < limit_output)
-      {
+    if (limit_output < 0 || output_size < limit_output) {
       strings.push_back(s);
-      }
     }
+  }
 
   // Encode the result in a CMake list.
   const char* sep = "";
   std::string output;
-  for(std::vector<std::string>::const_iterator si = strings.begin();
-      si != strings.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si = strings.begin();
+       si != strings.end(); ++si) {
     // Separate the strings in the output to make it a list.
     output += sep;
     sep = ";";
@@ -866,15 +693,13 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
     // Store the string in the output, but escape semicolons to
     // make sure it is a list.
     std::string const& sr = *si;
-    for(unsigned int i=0; i < sr.size(); ++i)
-      {
-      if(sr[i] == ';')
-        {
+    for (unsigned int i = 0; i < sr.size(); ++i) {
+      if (sr[i] == ';') {
         output += '\\';
-        }
-      output += sr[i];
       }
+      output += sr[i];
     }
+  }
 
   // Save the output in a makefile variable.
   this->Makefile->AddDefinition(outVar, output.c_str());
@@ -882,7 +707,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
 }
 
 bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
-  bool recurse)
+                                      bool recurse)
 {
   // File commands has at least one argument
   assert(args.size() > 1);
@@ -899,10 +724,8 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
   bool explicitFollowSymlinks = false;
   cmPolicies::PolicyStatus status =
     this->Makefile->GetPolicyStatus(cmPolicies::CMP0009);
-  if(recurse)
-    {
-    switch(status)
-      {
+  if (recurse) {
+    switch (status) {
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
@@ -912,154 +735,124 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
       case cmPolicies::WARN:
         g.RecurseThroughSymlinksOn();
         break;
-      }
     }
+  }
 
   std::string output = "";
   bool first = true;
-  for ( ; i != args.end(); ++i )
-    {
-    if( *i == "LIST_DIRECTORIES" )
-      {
+  for (; i != args.end(); ++i) {
+    if (*i == "LIST_DIRECTORIES") {
       ++i;
-      if(i != args.end())
-        {
-        if(cmSystemTools::IsOn(i->c_str()))
-          {
+      if (i != args.end()) {
+        if (cmSystemTools::IsOn(i->c_str())) {
           g.SetListDirs(true);
           g.SetRecurseListDirs(true);
-          }
-        else if(cmSystemTools::IsOff(i->c_str()))
-          {
+        } else if (cmSystemTools::IsOff(i->c_str())) {
           g.SetListDirs(false);
           g.SetRecurseListDirs(false);
-          }
-        else
-          {
+        } else {
           this->SetError("LIST_DIRECTORIES missing bool value.");
           return false;
-          }
         }
-      else
-        {
+      } else {
         this->SetError("LIST_DIRECTORIES missing bool value.");
         return false;
-        }
-      ++i;
       }
+      ++i;
+    }
 
-    if ( recurse && (*i == "FOLLOW_SYMLINKS") )
-      {
+    if (recurse && (*i == "FOLLOW_SYMLINKS")) {
       explicitFollowSymlinks = true;
       g.RecurseThroughSymlinksOn();
       ++i;
-      if ( i == args.end() )
-        {
+      if (i == args.end()) {
         this->SetError(
           "GLOB_RECURSE requires a glob expression after FOLLOW_SYMLINKS");
         return false;
-        }
       }
+    }
 
-    if ( *i == "RELATIVE" )
-      {
+    if (*i == "RELATIVE") {
       ++i; // skip RELATIVE
-      if ( i == args.end() )
-        {
+      if (i == args.end()) {
         this->SetError("GLOB requires a directory after the RELATIVE tag");
         return false;
-        }
+      }
       g.SetRelative(i->c_str());
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("GLOB requires a glob expression after the directory");
         return false;
-        }
       }
+    }
 
     cmsys::Glob::GlobMessages globMessages;
-    if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
-      {
+    if (!cmsys::SystemTools::FileIsFullPath(i->c_str())) {
       std::string expr = this->Makefile->GetCurrentSourceDirectory();
       // Handle script mode
-      if (!expr.empty())
-        {
+      if (!expr.empty()) {
         expr += "/" + *i;
         g.FindFiles(expr, &globMessages);
-        }
-      else
-        {
+      } else {
         g.FindFiles(*i, &globMessages);
-        }
       }
-    else
-      {
+    } else {
       g.FindFiles(*i, &globMessages);
-      }
+    }
 
-    if(!globMessages.empty())
-      {
+    if (!globMessages.empty()) {
       bool shouldExit = false;
-      for(cmsys::Glob::GlobMessagesIterator it=globMessages.begin();
-        it != globMessages.end(); ++it)
-        {
-        if(it->type == cmsys::Glob::cyclicRecursion)
-          {
-          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
-            "Cyclic recursion detected while globbing for '"
-            + *i + "':\n" + it->content);
-          }
-        else
-          {
-          this->Makefile->IssueMessage(cmake::FATAL_ERROR,
-            "Error has occurred while globbing for '"
-            + *i + "' - " + it->content);
+      for (cmsys::Glob::GlobMessagesIterator it = globMessages.begin();
+           it != globMessages.end(); ++it) {
+        if (it->type == cmsys::Glob::cyclicRecursion) {
+          this->Makefile->IssueMessage(
+            cmake::AUTHOR_WARNING,
+            "Cyclic recursion detected while globbing for '" + *i + "':\n" +
+              it->content);
+        } else {
+          this->Makefile->IssueMessage(
+            cmake::FATAL_ERROR, "Error has occurred while globbing for '" +
+              *i + "' - " + it->content);
           shouldExit = true;
-          }
-        }
-      if(shouldExit)
-        {
-          return false;
         }
       }
+      if (shouldExit) {
+        return false;
+      }
+    }
 
     std::vector<std::string>::size_type cc;
     std::vector<std::string>& files = g.GetFiles();
-    for ( cc = 0; cc < files.size(); cc ++ )
-      {
-      if ( !first )
-        {
+    for (cc = 0; cc < files.size(); cc++) {
+      if (!first) {
         output += ";";
-        }
+      }
       output += files[cc];
       first = false;
-      }
     }
+  }
 
-  if(recurse && !explicitFollowSymlinks)
-    {
-    switch (status)
-      {
+  if (recurse && !explicitFollowSymlinks) {
+    switch (status) {
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::NEW:
         // Correct behavior, yay!
         break;
       case cmPolicies::OLD:
-        // Probably not really the expected behavior, but the author explicitly
-        // asked for the old behavior... no warning.
+      // Probably not really the expected behavior, but the author explicitly
+      // asked for the old behavior... no warning.
       case cmPolicies::WARN:
         // Possibly unexpected old behavior *and* we actually traversed
         // symlinks without being explicitly asked to: warn the author.
-        if(g.GetFollowedSymlinkCount() != 0)
-          {
-          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
+        if (g.GetFollowedSymlinkCount() != 0) {
+          this->Makefile->IssueMessage(
+            cmake::AUTHOR_WARNING,
             cmPolicies::GetPolicyWarning(cmPolicies::CMP0009));
-          }
+        }
         break;
-      }
     }
+  }
 
   this->Makefile->AddDefinition(variable, output.c_str());
   return true;
@@ -1076,35 +869,31 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
   i++; // Get rid of subcommand
 
   std::string expr;
-  for ( ; i != args.end(); ++i )
-    {
+  for (; i != args.end(); ++i) {
     const std::string* cdir = &(*i);
-    if ( !cmsys::SystemTools::FileIsFullPath(i->c_str()) )
-      {
+    if (!cmsys::SystemTools::FileIsFullPath(i->c_str())) {
       expr = this->Makefile->GetCurrentSourceDirectory();
       expr += "/" + *i;
       cdir = &expr;
-      }
-    if ( !this->Makefile->CanIWriteThisFile(cdir->c_str()) )
-      {
-      std::string e = "attempted to create a directory: " + *cdir
-        + " into a source directory.";
+    }
+    if (!this->Makefile->CanIWriteThisFile(cdir->c_str())) {
+      std::string e = "attempted to create a directory: " + *cdir +
+        " into a source directory.";
       this->SetError(e);
       cmSystemTools::SetFatalErrorOccured();
       return false;
-      }
-    if ( !cmSystemTools::MakeDirectory(cdir->c_str()) )
-      {
+    }
+    if (!cmSystemTools::MakeDirectory(cdir->c_str())) {
       std::string error = "problem creating directory: " + *cdir;
       this->SetError(error);
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool
-cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleDifferentCommand(
+  std::vector<std::string> const& args)
 {
   /*
     FILE(DIFFERENT <variable> FILES <lhs> <rhs>)
@@ -1114,51 +903,45 @@ cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
   const char* file_lhs = 0;
   const char* file_rhs = 0;
   const char* var = 0;
-  enum Doing { DoingNone, DoingVar, DoingFileLHS, DoingFileRHS };
+  enum Doing
+  {
+    DoingNone,
+    DoingVar,
+    DoingFileLHS,
+    DoingFileRHS
+  };
   Doing doing = DoingVar;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "FILES")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "FILES") {
       doing = DoingFileLHS;
-      }
-    else if(doing == DoingVar)
-      {
+    } else if (doing == DoingVar) {
       var = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingFileLHS)
-      {
+    } else if (doing == DoingFileLHS) {
       file_lhs = args[i].c_str();
       doing = DoingFileRHS;
-      }
-    else if(doing == DoingFileRHS)
-      {
+    } else if (doing == DoingFileRHS) {
       file_rhs = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "DIFFERENT given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!var)
-    {
+  }
+  if (!var) {
     this->SetError("DIFFERENT not given result variable name.");
     return false;
-    }
-  if(!file_lhs || !file_rhs)
-    {
+  }
+  if (!file_lhs || !file_rhs) {
     this->SetError("DIFFERENT not given FILES option with two file names.");
     return false;
-    }
+  }
 
   // Compare the files.
   const char* result =
-    cmSystemTools::FilesDiffer(file_lhs, file_rhs)? "1" : "0";
+    cmSystemTools::FilesDiffer(file_lhs, file_rhs) ? "1" : "0";
   this->Makefile->AddDefinition(var, result);
   return true;
 }
@@ -1166,26 +949,26 @@ cmFileCommand::HandleDifferentCommand(std::vector<std::string> const& args)
 // File installation helper class.
 struct cmFileCopier
 {
-  cmFileCopier(cmFileCommand* command, const char* name = "COPY"):
-    FileCommand(command),
-    Makefile(command->GetMakefile()),
-    Name(name),
-    Always(false),
-    MatchlessFiles(true),
-    FilePermissions(0),
-    DirPermissions(0),
-    CurrentMatchRule(0),
-    UseGivenPermissionsFile(false),
-    UseGivenPermissionsDir(false),
-    UseSourcePermissions(true),
-    Doing(DoingNone)
-    {
-    }
+  cmFileCopier(cmFileCommand* command, const char* name = "COPY")
+    : FileCommand(command)
+    , Makefile(command->GetMakefile())
+    , Name(name)
+    , Always(false)
+    , MatchlessFiles(true)
+    , FilePermissions(0)
+    , DirPermissions(0)
+    , CurrentMatchRule(0)
+    , UseGivenPermissionsFile(false)
+    , UseGivenPermissionsDir(false)
+    , UseSourcePermissions(true)
+    , Doing(DoingNone)
+  {
+  }
   virtual ~cmFileCopier() {}
 
   bool Run(std::vector<std::string> const& args);
-protected:
 
+protected:
   cmFileCommand* FileCommand;
   cmMakefile* Makefile;
   const char* Name;
@@ -1204,7 +987,11 @@ protected:
   {
     bool Exclude;
     mode_t Permissions;
-    MatchProperties(): Exclude(false), Permissions(0) {}
+    MatchProperties()
+      : Exclude(false)
+      , Permissions(0)
+    {
+    }
   };
   struct MatchRule;
   friend struct MatchRule;
@@ -1213,15 +1000,18 @@ protected:
     cmsys::RegularExpression Regex;
     MatchProperties Properties;
     std::string RegexString;
-    MatchRule(std::string const& regex):
-      Regex(regex.c_str()), RegexString(regex) {}
+    MatchRule(std::string const& regex)
+      : Regex(regex.c_str())
+      , RegexString(regex)
+    {
+    }
   };
   std::vector<MatchRule> MatchRules;
 
   // Get the properties from rules matching this input file.
   MatchProperties CollectMatchProperties(const char* file)
-    {
-    // Match rules are case-insensitive on some platforms.
+  {
+// Match rules are case-insensitive on some platforms.
 #if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
     std::string lower = cmSystemTools::LowerCase(file);
     const char* file_to_match = lower.c_str();
@@ -1232,58 +1022,64 @@ protected:
     // Collect properties from all matching rules.
     bool matched = false;
     MatchProperties result;
-    for(std::vector<MatchRule>::iterator mr = this->MatchRules.begin();
-        mr != this->MatchRules.end(); ++mr)
-      {
-      if(mr->Regex.find(file_to_match))
-        {
+    for (std::vector<MatchRule>::iterator mr = this->MatchRules.begin();
+         mr != this->MatchRules.end(); ++mr) {
+      if (mr->Regex.find(file_to_match)) {
         matched = true;
         result.Exclude |= mr->Properties.Exclude;
         result.Permissions |= mr->Properties.Permissions;
-        }
       }
-    if(!matched && !this->MatchlessFiles)
-      {
+    }
+    if (!matched && !this->MatchlessFiles) {
       result.Exclude = !cmSystemTools::FileIsDirectory(file);
-      }
-    return result;
     }
+    return result;
+  }
 
   bool SetPermissions(const char* toFile, mode_t permissions)
-    {
-    if(permissions && !cmSystemTools::SetPermissions(toFile, permissions))
-      {
+  {
+    if (permissions && !cmSystemTools::SetPermissions(toFile, permissions)) {
       std::ostringstream e;
       e << this->Name << " cannot set permissions on \"" << toFile << "\"";
       this->FileCommand->SetError(e.str());
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 
   // Translate an argument to a permissions bit.
   bool CheckPermissions(std::string const& arg, mode_t& permissions)
-    {
-    if(arg == "OWNER_READ")         { permissions |= mode_owner_read; }
-    else if(arg == "OWNER_WRITE")   { permissions |= mode_owner_write; }
-    else if(arg == "OWNER_EXECUTE") { permissions |= mode_owner_execute; }
-    else if(arg == "GROUP_READ")    { permissions |= mode_group_read; }
-    else if(arg == "GROUP_WRITE")   { permissions |= mode_group_write; }
-    else if(arg == "GROUP_EXECUTE") { permissions |= mode_group_execute; }
-    else if(arg == "WORLD_READ")    { permissions |= mode_world_read; }
-    else if(arg == "WORLD_WRITE")   { permissions |= mode_world_write; }
-    else if(arg == "WORLD_EXECUTE") { permissions |= mode_world_execute; }
-    else if(arg == "SETUID")        { permissions |= mode_setuid; }
-    else if(arg == "SETGID")        { permissions |= mode_setgid; }
-    else
-      {
+  {
+    if (arg == "OWNER_READ") {
+      permissions |= mode_owner_read;
+    } else if (arg == "OWNER_WRITE") {
+      permissions |= mode_owner_write;
+    } else if (arg == "OWNER_EXECUTE") {
+      permissions |= mode_owner_execute;
+    } else if (arg == "GROUP_READ") {
+      permissions |= mode_group_read;
+    } else if (arg == "GROUP_WRITE") {
+      permissions |= mode_group_write;
+    } else if (arg == "GROUP_EXECUTE") {
+      permissions |= mode_group_execute;
+    } else if (arg == "WORLD_READ") {
+      permissions |= mode_world_read;
+    } else if (arg == "WORLD_WRITE") {
+      permissions |= mode_world_write;
+    } else if (arg == "WORLD_EXECUTE") {
+      permissions |= mode_world_execute;
+    } else if (arg == "SETUID") {
+      permissions |= mode_setuid;
+    } else if (arg == "SETGID") {
+      permissions |= mode_setgid;
+    } else {
       std::ostringstream e;
       e << this->Name << " given invalid permission \"" << arg << "\".";
       this->FileCommand->SetError(e.str());
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 
   bool InstallSymlink(const char* fromFile, const char* toFile);
   bool InstallFile(const char* fromFile, const char* toFile,
@@ -1292,7 +1088,9 @@ protected:
                         MatchProperties const& match_properties);
   virtual bool Install(const char* fromFile, const char* toFile);
   virtual std::string const& ToName(std::string const& fromName)
-    { return fromName; }
+  {
+    return fromName;
+  }
 
   enum Type
   {
@@ -1302,13 +1100,13 @@ protected:
   };
   virtual void ReportCopy(const char*, Type, bool) {}
   virtual bool ReportMissing(const char* fromFile)
-    {
+  {
     // The input file does not exist and installation is not optional.
     std::ostringstream e;
     e << this->Name << " cannot find \"" << fromFile << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   MatchRule* CurrentMatchRule;
   bool UseGivenPermissionsFile;
@@ -1336,30 +1134,30 @@ protected:
   virtual bool CheckValue(std::string const& arg);
 
   void NotBeforeMatch(std::string const& arg)
-    {
+  {
     std::ostringstream e;
     e << "option " << arg << " may not appear before PATTERN or REGEX.";
     this->FileCommand->SetError(e.str());
     this->Doing = DoingError;
-    }
+  }
   void NotAfterMatch(std::string const& arg)
-    {
+  {
     std::ostringstream e;
     e << "option " << arg << " may not appear after PATTERN or REGEX.";
     this->FileCommand->SetError(e.str());
     this->Doing = DoingError;
-    }
+  }
   virtual void DefaultFilePermissions()
-    {
+  {
     // Use read/write permissions.
     this->FilePermissions = 0;
     this->FilePermissions |= mode_owner_read;
     this->FilePermissions |= mode_owner_write;
     this->FilePermissions |= mode_group_read;
     this->FilePermissions |= mode_world_read;
-    }
+  }
   virtual void DefaultDirectoryPermissions()
-    {
+  {
     // Use read/write/executable permissions.
     this->DirPermissions = 0;
     this->DirPermissions |= mode_owner_read;
@@ -1369,197 +1167,137 @@ protected:
     this->DirPermissions |= mode_group_execute;
     this->DirPermissions |= mode_world_read;
     this->DirPermissions |= mode_world_execute;
-    }
+  }
 };
 
 bool cmFileCopier::Parse(std::vector<std::string> const& args)
 {
   this->Doing = DoingFiles;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
+  for (unsigned int i = 1; i < args.size(); ++i) {
     // Check this argument.
-    if(!this->CheckKeyword(args[i]) &&
-       !this->CheckValue(args[i]))
-      {
+    if (!this->CheckKeyword(args[i]) && !this->CheckValue(args[i])) {
       std::ostringstream e;
       e << "called with unknown argument \"" << args[i] << "\".";
       this->FileCommand->SetError(e.str());
       return false;
-      }
+    }
 
     // Quit if an argument is invalid.
-    if(this->Doing == DoingError)
-      {
+    if (this->Doing == DoingError) {
       return false;
-      }
     }
+  }
 
   // Require a destination.
-  if(this->Destination.empty())
-    {
+  if (this->Destination.empty()) {
     std::ostringstream e;
     e << this->Name << " given no DESTINATION";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // If file permissions were not specified set default permissions.
-  if(!this->UseGivenPermissionsFile && !this->UseSourcePermissions)
-    {
+  if (!this->UseGivenPermissionsFile && !this->UseSourcePermissions) {
     this->DefaultFilePermissions();
-    }
+  }
 
   // If directory permissions were not specified set default permissions.
-  if(!this->UseGivenPermissionsDir && !this->UseSourcePermissions)
-    {
+  if (!this->UseGivenPermissionsDir && !this->UseSourcePermissions) {
     this->DefaultDirectoryPermissions();
-    }
+  }
 
   return true;
 }
 
 bool cmFileCopier::CheckKeyword(std::string const& arg)
 {
-  if(arg == "DESTINATION")
-    {
-    if(this->CurrentMatchRule)
-      {
+  if (arg == "DESTINATION") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingDestination;
-      }
     }
-  else if(arg == "PATTERN")
-    {
+  } else if (arg == "PATTERN") {
     this->Doing = DoingPattern;
-    }
-  else if(arg == "REGEX")
-    {
+  } else if (arg == "REGEX") {
     this->Doing = DoingRegex;
-    }
-  else if(arg == "EXCLUDE")
-    {
+  } else if (arg == "EXCLUDE") {
     // Add this property to the current match rule.
-    if(this->CurrentMatchRule)
-      {
+    if (this->CurrentMatchRule) {
       this->CurrentMatchRule->Properties.Exclude = true;
       this->Doing = DoingNone;
-      }
-    else
-      {
+    } else {
       this->NotBeforeMatch(arg);
-      }
     }
-  else if(arg == "PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->Doing = DoingPermissionsMatch;
-      }
-    else
-      {
+    } else {
       this->NotBeforeMatch(arg);
-      }
     }
-  else if(arg == "FILE_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "FILE_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingPermissionsFile;
       this->UseGivenPermissionsFile = true;
-      }
     }
-  else if(arg == "DIRECTORY_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "DIRECTORY_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingPermissionsDir;
       this->UseGivenPermissionsDir = true;
-      }
     }
-  else if(arg == "USE_SOURCE_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "USE_SOURCE_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->UseSourcePermissions = true;
-      }
     }
-  else if(arg == "NO_SOURCE_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "NO_SOURCE_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->UseSourcePermissions = false;
-      }
     }
-  else if(arg == "FILES_MATCHING")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "FILES_MATCHING") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MatchlessFiles = false;
-      }
     }
-  else
-    {
+  } else {
     return false;
-    }
+  }
   return true;
 }
 
 bool cmFileCopier::CheckValue(std::string const& arg)
 {
-  switch(this->Doing)
-    {
+  switch (this->Doing) {
     case DoingFiles:
-      if(arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str()))
-        {
+      if (arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str())) {
         this->Files.push_back(arg);
-        }
-      else
-        {
+      } else {
         std::string file = this->Makefile->GetCurrentSourceDirectory();
         file += "/" + arg;
         this->Files.push_back(file);
-        }
+      }
       break;
     case DoingDestination:
-      if(arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str()))
-        {
+      if (arg.empty() || cmSystemTools::FileIsFullPath(arg.c_str())) {
         this->Destination = arg;
-        }
-      else
-        {
+      } else {
         this->Destination = this->Makefile->GetCurrentBinaryDirectory();
         this->Destination += "/" + arg;
-        }
+      }
       this->Doing = DoingNone;
       break;
-    case DoingPattern:
-      {
+    case DoingPattern: {
       // Convert the pattern to a regular expression.  Require a
       // leading slash and trailing end-of-string in the matched
       // string to make sure the pattern matches only whole file
@@ -1568,138 +1306,114 @@ bool cmFileCopier::CheckValue(std::string const& arg)
       regex += cmsys::Glob::PatternToRegex(arg, false);
       regex += "$";
       this->MatchRules.push_back(MatchRule(regex));
-      this->CurrentMatchRule = &*(this->MatchRules.end()-1);
-      if(this->CurrentMatchRule->Regex.is_valid())
-        {
+      this->CurrentMatchRule = &*(this->MatchRules.end() - 1);
+      if (this->CurrentMatchRule->Regex.is_valid()) {
         this->Doing = DoingNone;
-        }
-      else
-        {
+      } else {
         std::ostringstream e;
         e << "could not compile PATTERN \"" << arg << "\".";
         this->FileCommand->SetError(e.str());
         this->Doing = DoingError;
-        }
       }
-      break;
+    } break;
     case DoingRegex:
       this->MatchRules.push_back(MatchRule(arg));
-      this->CurrentMatchRule = &*(this->MatchRules.end()-1);
-      if(this->CurrentMatchRule->Regex.is_valid())
-        {
+      this->CurrentMatchRule = &*(this->MatchRules.end() - 1);
+      if (this->CurrentMatchRule->Regex.is_valid()) {
         this->Doing = DoingNone;
-        }
-      else
-        {
+      } else {
         std::ostringstream e;
         e << "could not compile REGEX \"" << arg << "\".";
         this->FileCommand->SetError(e.str());
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingPermissionsFile:
-      if(!this->CheckPermissions(arg, this->FilePermissions))
-        {
+      if (!this->CheckPermissions(arg, this->FilePermissions)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingPermissionsDir:
-      if(!this->CheckPermissions(arg, this->DirPermissions))
-        {
+      if (!this->CheckPermissions(arg, this->DirPermissions)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingPermissionsMatch:
-      if(!this->CheckPermissions(
-           arg, this->CurrentMatchRule->Properties.Permissions))
-        {
+      if (!this->CheckPermissions(
+            arg, this->CurrentMatchRule->Properties.Permissions)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     default:
       return false;
-    }
+  }
   return true;
 }
 
 bool cmFileCopier::Run(std::vector<std::string> const& args)
 {
-  if(!this->Parse(args))
-    {
+  if (!this->Parse(args)) {
     return false;
-    }
+  }
 
   std::vector<std::string> const& files = this->Files;
-  for(std::vector<std::string>::size_type i = 0; i < files.size(); ++i)
-    {
+  for (std::vector<std::string>::size_type i = 0; i < files.size(); ++i) {
     // Split the input file into its directory and name components.
     std::vector<std::string> fromPathComponents;
     cmSystemTools::SplitPath(files[i], fromPathComponents);
-    std::string fromName = *(fromPathComponents.end()-1);
-    std::string fromDir = cmSystemTools::JoinPath(fromPathComponents.begin(),
-                                                  fromPathComponents.end()-1);
+    std::string fromName = *(fromPathComponents.end() - 1);
+    std::string fromDir = cmSystemTools::JoinPath(
+      fromPathComponents.begin(), fromPathComponents.end() - 1);
 
     // Compute the full path to the destination file.
     std::string toFile = this->Destination;
     std::string const& toName = this->ToName(fromName);
-    if(!toName.empty())
-      {
+    if (!toName.empty()) {
       toFile += "/";
       toFile += toName;
-      }
+    }
 
     // Construct the full path to the source file.  The file name may
     // have been changed above.
     std::string fromFile = fromDir;
-    if(!fromName.empty())
-      {
+    if (!fromName.empty()) {
       fromFile += "/";
       fromFile += fromName;
-      }
+    }
 
-    if(!this->Install(fromFile.c_str(), toFile.c_str()))
-      {
+    if (!this->Install(fromFile.c_str(), toFile.c_str())) {
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmFileCopier::Install(const char* fromFile, const char* toFile)
 {
-  if(!*fromFile)
-    {
+  if (!*fromFile) {
     std::ostringstream e;
     e << "INSTALL encountered an empty string input file name.";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Collect any properties matching this file name.
   MatchProperties match_properties = this->CollectMatchProperties(fromFile);
 
   // Skip the file if it is excluded.
-  if(match_properties.Exclude)
-    {
+  if (match_properties.Exclude) {
     return true;
-    }
+  }
 
-  if(cmSystemTools::SameFile(fromFile, toFile))
-    {
+  if (cmSystemTools::SameFile(fromFile, toFile)) {
     return true;
-    }
-  else if(cmSystemTools::FileIsSymlink(fromFile))
-    {
+  } else if (cmSystemTools::FileIsSymlink(fromFile)) {
     return this->InstallSymlink(fromFile, toFile);
-    }
-  else if(cmSystemTools::FileIsDirectory(fromFile))
-    {
+  } else if (cmSystemTools::FileIsDirectory(fromFile)) {
     return this->InstallDirectory(fromFile, toFile, match_properties);
-    }
-  else if(cmSystemTools::FileExists(fromFile))
-    {
+  } else if (cmSystemTools::FileExists(fromFile)) {
     return this->InstallFile(fromFile, toFile, match_properties);
-    }
+  }
   return this->ReportMissing(fromFile);
 }
 
@@ -1707,48 +1421,42 @@ bool cmFileCopier::InstallSymlink(const char* fromFile, const char* toFile)
 {
   // Read the original symlink.
   std::string symlinkTarget;
-  if(!cmSystemTools::ReadSymlink(fromFile, symlinkTarget))
-    {
+  if (!cmSystemTools::ReadSymlink(fromFile, symlinkTarget)) {
     std::ostringstream e;
     e << this->Name << " cannot read symlink \"" << fromFile
       << "\" to duplicate at \"" << toFile << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Compare the symlink value to that at the destination if not
   // always installing.
   bool copy = true;
-  if(!this->Always)
-    {
+  if (!this->Always) {
     std::string oldSymlinkTarget;
-    if(cmSystemTools::ReadSymlink(toFile, oldSymlinkTarget))
-      {
-      if(symlinkTarget == oldSymlinkTarget)
-        {
+    if (cmSystemTools::ReadSymlink(toFile, oldSymlinkTarget)) {
+      if (symlinkTarget == oldSymlinkTarget) {
         copy = false;
-        }
       }
     }
+  }
 
   // Inform the user about this file installation.
   this->ReportCopy(toFile, TypeLink, copy);
 
-  if(copy)
-    {
+  if (copy) {
     // Remove the destination file so we can always create the symlink.
     cmSystemTools::RemoveFile(toFile);
 
     // Create the symlink.
-    if(!cmSystemTools::CreateSymlink(symlinkTarget, toFile))
-      {
+    if (!cmSystemTools::CreateSymlink(symlinkTarget, toFile)) {
       std::ostringstream e;
-      e << this->Name <<  " cannot duplicate symlink \"" << fromFile
+      e << this->Name << " cannot duplicate symlink \"" << fromFile
         << "\" at \"" << toFile << "\".";
       this->FileCommand->SetError(e.str());
       return false;
-      }
     }
+  }
 
   return true;
 }
@@ -1758,57 +1466,51 @@ bool cmFileCopier::InstallFile(const char* fromFile, const char* toFile,
 {
   // Determine whether we will copy the file.
   bool copy = true;
-  if(!this->Always)
-    {
+  if (!this->Always) {
     // If both files exist with the same time do not copy.
-    if(!this->FileTimes.FileTimesDiffer(fromFile, toFile))
-      {
+    if (!this->FileTimes.FileTimesDiffer(fromFile, toFile)) {
       copy = false;
-      }
     }
+  }
 
   // Inform the user about this file installation.
   this->ReportCopy(toFile, TypeFile, copy);
 
   // Copy the file.
-  if(copy && !cmSystemTools::CopyAFile(fromFile, toFile, true))
-    {
+  if (copy && !cmSystemTools::CopyAFile(fromFile, toFile, true)) {
     std::ostringstream e;
-    e << this->Name << " cannot copy file \"" << fromFile
-      << "\" to \"" << toFile << "\".";
+    e << this->Name << " cannot copy file \"" << fromFile << "\" to \""
+      << toFile << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Set the file modification time of the destination file.
-  if(copy && !this->Always)
-    {
+  if (copy && !this->Always) {
     // Add write permission so we can set the file time.
     // Permissions are set unconditionally below anyway.
     mode_t perm = 0;
-    if(cmSystemTools::GetPermissions(toFile, perm))
-      {
+    if (cmSystemTools::GetPermissions(toFile, perm)) {
       cmSystemTools::SetPermissions(toFile, perm | mode_owner_write);
-      }
-    if (!cmSystemTools::CopyFileTime(fromFile, toFile))
-      {
+    }
+    if (!cmSystemTools::CopyFileTime(fromFile, toFile)) {
       std::ostringstream e;
-      e << this->Name << " cannot set modification time on \""
-        << toFile << "\"";
+      e << this->Name << " cannot set modification time on \"" << toFile
+        << "\"";
       this->FileCommand->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Set permissions of the destination file.
-  mode_t permissions = (match_properties.Permissions?
-                        match_properties.Permissions : this->FilePermissions);
-  if(!permissions)
-    {
+  mode_t permissions =
+    (match_properties.Permissions ? match_properties.Permissions
+                                  : this->FilePermissions);
+  if (!permissions) {
     // No permissions were explicitly provided but the user requested
     // that the source file permissions be used.
     cmSystemTools::GetPermissions(fromFile, permissions);
-    }
+  }
   return this->SetPermissions(toFile, permissions);
 }
 
@@ -1821,24 +1523,23 @@ bool cmFileCopier::InstallDirectory(const char* source,
                    !cmSystemTools::FileIsDirectory(destination));
 
   // Make sure the destination directory exists.
-  if(!cmSystemTools::MakeDirectory(destination))
-    {
+  if (!cmSystemTools::MakeDirectory(destination)) {
     std::ostringstream e;
-    e << this->Name << " cannot make directory \"" << destination << "\": "
-      << cmSystemTools::GetLastSystemError();
+    e << this->Name << " cannot make directory \"" << destination
+      << "\": " << cmSystemTools::GetLastSystemError();
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
 
   // Compute the requested permissions for the destination directory.
-  mode_t permissions = (match_properties.Permissions?
-                        match_properties.Permissions : this->DirPermissions);
-  if(!permissions)
-    {
+  mode_t permissions =
+    (match_properties.Permissions ? match_properties.Permissions
+                                  : this->DirPermissions);
+  if (!permissions) {
     // No permissions were explicitly provided but the user requested
     // that the source directory permissions be used.
     cmSystemTools::GetPermissions(source, permissions);
-    }
+  }
 
   // Compute the set of permissions required on this directory to
   // recursively install files and subdirectories safely.
@@ -1850,46 +1551,38 @@ bool cmFileCopier::InstallDirectory(const char* source,
   // permissions temporarily during file installation.
   mode_t permissions_before = 0;
   mode_t permissions_after = 0;
-  if((permissions & required_permissions) == required_permissions)
-    {
+  if ((permissions & required_permissions) == required_permissions) {
     permissions_before = permissions;
-    }
-  else
-    {
+  } else {
     permissions_before = permissions | required_permissions;
     permissions_after = permissions;
-    }
+  }
 
   // Set the required permissions of the destination directory.
-  if(!this->SetPermissions(destination, permissions_before))
-    {
+  if (!this->SetPermissions(destination, permissions_before)) {
     return false;
-    }
+  }
 
   // Load the directory contents to traverse it recursively.
   cmsys::Directory dir;
-  if(source && *source)
-    {
+  if (source && *source) {
     dir.Load(source);
-    }
+  }
   unsigned long numFiles = static_cast<unsigned long>(dir.GetNumberOfFiles());
-  for(unsigned long fileNum = 0; fileNum < numFiles; ++fileNum)
-    {
-    if(!(strcmp(dir.GetFile(fileNum), ".") == 0 ||
-         strcmp(dir.GetFile(fileNum), "..") == 0))
-      {
+  for (unsigned long fileNum = 0; fileNum < numFiles; ++fileNum) {
+    if (!(strcmp(dir.GetFile(fileNum), ".") == 0 ||
+          strcmp(dir.GetFile(fileNum), "..") == 0)) {
       std::string fromPath = source;
       fromPath += "/";
       fromPath += dir.GetFile(fileNum);
       std::string toPath = destination;
       toPath += "/";
       toPath += dir.GetFile(fileNum);
-      if(!this->Install(fromPath.c_str(), toPath.c_str()))
-        {
+      if (!this->Install(fromPath.c_str(), toPath.c_str())) {
         return false;
-        }
       }
     }
+  }
 
   // Set the requested permissions of the destination directory.
   return this->SetPermissions(destination, permissions_after);
@@ -1901,17 +1594,17 @@ bool cmFileCommand::HandleCopyCommand(std::vector<std::string> const& args)
   return copier.Run(args);
 }
 
-struct cmFileInstaller: public cmFileCopier
+struct cmFileInstaller : public cmFileCopier
 {
-  cmFileInstaller(cmFileCommand* command):
-    cmFileCopier(command, "INSTALL"),
-    InstallType(cmInstallType_FILES),
-    Optional(false),
-    MessageAlways(false),
-    MessageLazy(false),
-    MessageNever(false),
-    DestDirLength(0)
-    {
+  cmFileInstaller(cmFileCommand* command)
+    : cmFileCopier(command, "INSTALL")
+    , InstallType(cmInstallType_FILES)
+    , Optional(false)
+    , MessageAlways(false)
+    , MessageLazy(false)
+    , MessageNever(false)
+    , DestDirLength(0)
+  {
     // Installation does not use source permissions by default.
     this->UseSourcePermissions = false;
     // Check whether to copy files always or only if they have changed.
@@ -1920,13 +1613,13 @@ struct cmFileInstaller: public cmFileCopier
     // Get the current manifest.
     this->Manifest =
       this->Makefile->GetSafeDefinition("CMAKE_INSTALL_MANIFEST_FILES");
-    }
+  }
   ~cmFileInstaller()
-    {
+  {
     // Save the updated install manifest.
     this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
                                   this->Manifest.c_str());
-    }
+  }
 
 protected:
   cmInstallType InstallType;
@@ -1939,45 +1632,42 @@ protected:
 
   std::string Manifest;
   void ManifestAppend(std::string const& file)
-    {
-    if (!this->Manifest.empty())
-      {
+  {
+    if (!this->Manifest.empty()) {
       this->Manifest += ";";
-      }
-    this->Manifest += file.substr(this->DestDirLength);
     }
+    this->Manifest += file.substr(this->DestDirLength);
+  }
 
   virtual std::string const& ToName(std::string const& fromName)
-    { return this->Rename.empty()? fromName : this->Rename; }
+  {
+    return this->Rename.empty() ? fromName : this->Rename;
+  }
 
   virtual void ReportCopy(const char* toFile, Type type, bool copy)
-    {
-    if(!this->MessageNever && (copy || !this->MessageLazy))
-      {
-      std::string message = (copy? "Installing: " : "Up-to-date: ");
+  {
+    if (!this->MessageNever && (copy || !this->MessageLazy)) {
+      std::string message = (copy ? "Installing: " : "Up-to-date: ");
       message += toFile;
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    if(type != TypeDir)
-      {
+    }
+    if (type != TypeDir) {
       // Add the file to the manifest.
       this->ManifestAppend(toFile);
-      }
     }
+  }
   virtual bool ReportMissing(const char* fromFile)
-    {
-    return (this->Optional ||
-            this->cmFileCopier::ReportMissing(fromFile));
-    }
+  {
+    return (this->Optional || this->cmFileCopier::ReportMissing(fromFile));
+  }
   virtual bool Install(const char* fromFile, const char* toFile)
-    {
+  {
     // Support installing from empty source to make a directory.
-    if(this->InstallType == cmInstallType_DIRECTORY && !*fromFile)
-      {
+    if (this->InstallType == cmInstallType_DIRECTORY && !*fromFile) {
       return this->InstallDirectory(fromFile, toFile, MatchProperties());
-      }
-    return this->cmFileCopier::Install(fromFile, toFile);
     }
+    return this->cmFileCopier::Install(fromFile, toFile);
+  }
 
   virtual bool Parse(std::vector<std::string> const& args);
   enum
@@ -1989,255 +1679,181 @@ protected:
   virtual bool CheckKeyword(std::string const& arg);
   virtual bool CheckValue(std::string const& arg);
   virtual void DefaultFilePermissions()
-    {
+  {
     this->cmFileCopier::DefaultFilePermissions();
     // Add execute permissions based on the target type.
-    switch(this->InstallType)
-      {
+    switch (this->InstallType) {
       case cmInstallType_SHARED_LIBRARY:
       case cmInstallType_MODULE_LIBRARY:
-        if(this->Makefile->IsOn("CMAKE_INSTALL_SO_NO_EXE"))
-          {
+        if (this->Makefile->IsOn("CMAKE_INSTALL_SO_NO_EXE")) {
           break;
-          }
+        }
       case cmInstallType_EXECUTABLE:
       case cmInstallType_PROGRAMS:
         this->FilePermissions |= mode_owner_execute;
         this->FilePermissions |= mode_group_execute;
         this->FilePermissions |= mode_world_execute;
         break;
-      default: break;
-      }
+      default:
+        break;
     }
+  }
   bool GetTargetTypeFromString(const std::string& stype);
   bool HandleInstallDestination();
 };
 
 bool cmFileInstaller::Parse(std::vector<std::string> const& args)
 {
-  if(!this->cmFileCopier::Parse(args))
-    {
+  if (!this->cmFileCopier::Parse(args)) {
     return false;
-    }
+  }
 
-  if(!this->Rename.empty())
-    {
-    if(this->InstallType != cmInstallType_FILES &&
-       this->InstallType != cmInstallType_PROGRAMS)
-      {
+  if (!this->Rename.empty()) {
+    if (this->InstallType != cmInstallType_FILES &&
+        this->InstallType != cmInstallType_PROGRAMS) {
       this->FileCommand->SetError("INSTALL option RENAME may be used "
                                   "only with FILES or PROGRAMS.");
       return false;
-      }
-    if(this->Files.size() > 1)
-      {
+    }
+    if (this->Files.size() > 1) {
       this->FileCommand->SetError("INSTALL option RENAME may be used "
                                   "only with one file.");
       return false;
-      }
     }
+  }
 
-  if(!this->HandleInstallDestination())
-    {
+  if (!this->HandleInstallDestination()) {
     return false;
-    }
+  }
 
-  if(((this->MessageAlways?1:0) +
-      (this->MessageLazy?1:0) +
-      (this->MessageNever?1:0)) > 1)
-    {
+  if (((this->MessageAlways ? 1 : 0) + (this->MessageLazy ? 1 : 0) +
+       (this->MessageNever ? 1 : 0)) > 1) {
     this->FileCommand->SetError("INSTALL options MESSAGE_ALWAYS, "
                                 "MESSAGE_LAZY, and MESSAGE_NEVER "
                                 "are mutually exclusive.");
     return false;
-    }
+  }
 
   return true;
 }
 
 bool cmFileInstaller::CheckKeyword(std::string const& arg)
 {
-  if(arg == "TYPE")
-    {
-    if(this->CurrentMatchRule)
-      {
+  if (arg == "TYPE") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingType;
-      }
     }
-  else if(arg == "FILES")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "FILES") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingFiles;
-      }
     }
-  else if(arg == "RENAME")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "RENAME") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingRename;
-      }
     }
-  else if(arg == "OPTIONAL")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "OPTIONAL") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->Optional = true;
-      }
     }
-  else if(arg == "MESSAGE_ALWAYS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "MESSAGE_ALWAYS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MessageAlways = true;
-      }
     }
-  else if(arg == "MESSAGE_LAZY")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "MESSAGE_LAZY") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MessageLazy = true;
-      }
     }
-  else if(arg == "MESSAGE_NEVER")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "MESSAGE_NEVER") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       this->Doing = DoingNone;
       this->MessageNever = true;
-      }
     }
-  else if(arg == "PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->Doing = DoingPermissionsMatch;
-      }
-    else
-      {
+    } else {
       // file(INSTALL) aliases PERMISSIONS to FILE_PERMISSIONS
       this->Doing = DoingPermissionsFile;
       this->UseGivenPermissionsFile = true;
-      }
     }
-  else if(arg == "DIR_PERMISSIONS")
-    {
-    if(this->CurrentMatchRule)
-      {
+  } else if (arg == "DIR_PERMISSIONS") {
+    if (this->CurrentMatchRule) {
       this->NotAfterMatch(arg);
-      }
-    else
-      {
+    } else {
       // file(INSTALL) aliases DIR_PERMISSIONS to DIRECTORY_PERMISSIONS
       this->Doing = DoingPermissionsDir;
       this->UseGivenPermissionsDir = true;
-      }
     }
-  else if(arg == "COMPONENTS" || arg == "CONFIGURATIONS" ||
-          arg == "PROPERTIES")
-    {
+  } else if (arg == "COMPONENTS" || arg == "CONFIGURATIONS" ||
+             arg == "PROPERTIES") {
     std::ostringstream e;
     e << "INSTALL called with old-style " << arg << " argument.  "
       << "This script was generated with an older version of CMake.  "
       << "Re-run this cmake version on your build tree.";
     this->FileCommand->SetError(e.str());
     this->Doing = DoingError;
-    }
-  else
-    {
+  } else {
     return this->cmFileCopier::CheckKeyword(arg);
-    }
+  }
   return true;
 }
 
 bool cmFileInstaller::CheckValue(std::string const& arg)
 {
-  switch(this->Doing)
-    {
+  switch (this->Doing) {
     case DoingType:
-      if(!this->GetTargetTypeFromString(arg))
-        {
+      if (!this->GetTargetTypeFromString(arg)) {
         this->Doing = DoingError;
-        }
+      }
       break;
     case DoingRename:
       this->Rename = arg;
       break;
     default:
       return this->cmFileCopier::CheckValue(arg);
-    }
+  }
   return true;
 }
 
-bool cmFileInstaller
-::GetTargetTypeFromString(const std::string& stype)
+bool cmFileInstaller::GetTargetTypeFromString(const std::string& stype)
 {
-  if ( stype == "EXECUTABLE" )
-    {
+  if (stype == "EXECUTABLE") {
     this->InstallType = cmInstallType_EXECUTABLE;
-    }
-  else if ( stype == "FILE" )
-    {
+  } else if (stype == "FILE") {
     this->InstallType = cmInstallType_FILES;
-    }
-  else if ( stype == "PROGRAM" )
-    {
+  } else if (stype == "PROGRAM") {
     this->InstallType = cmInstallType_PROGRAMS;
-    }
-  else if ( stype == "STATIC_LIBRARY" )
-    {
+  } else if (stype == "STATIC_LIBRARY") {
     this->InstallType = cmInstallType_STATIC_LIBRARY;
-    }
-  else if ( stype == "SHARED_LIBRARY" )
-    {
+  } else if (stype == "SHARED_LIBRARY") {
     this->InstallType = cmInstallType_SHARED_LIBRARY;
-    }
-  else if ( stype == "MODULE" )
-    {
+  } else if (stype == "MODULE") {
     this->InstallType = cmInstallType_MODULE_LIBRARY;
-    }
-  else if ( stype == "DIRECTORY" )
-    {
+  } else if (stype == "DIRECTORY") {
     this->InstallType = cmInstallType_DIRECTORY;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "Option TYPE given unknown value \"" << stype << "\".";
     this->FileCommand->SetError(e.str());
     return false;
-    }
+  }
   return true;
 }
 
@@ -2246,46 +1862,37 @@ bool cmFileInstaller::HandleInstallDestination()
   std::string& destination = this->Destination;
 
   // allow for / to be a valid destination
-  if ( destination.size() < 2 && destination != "/" )
-    {
+  if (destination.size() < 2 && destination != "/") {
     this->FileCommand->SetError("called with inappropriate arguments. "
-        "No DESTINATION provided or .");
+                                "No DESTINATION provided or .");
     return false;
-    }
+  }
 
   const char* destdir = cmSystemTools::GetEnv("DESTDIR");
-  if ( destdir && *destdir )
-    {
+  if (destdir && *destdir) {
     std::string sdestdir = destdir;
     cmSystemTools::ConvertToUnixSlashes(sdestdir);
     char ch1 = destination[0];
     char ch2 = destination[1];
     char ch3 = 0;
-    if ( destination.size() > 2 )
-      {
+    if (destination.size() > 2) {
       ch3 = destination[2];
-      }
+    }
     int skip = 0;
-    if ( ch1 != '/' )
-      {
+    if (ch1 != '/') {
       int relative = 0;
       if (((ch1 >= 'a' && ch1 <= 'z') || (ch1 >= 'A' && ch1 <= 'Z')) &&
-             ch2 == ':' )
-        {
+          ch2 == ':') {
         // Assume windows
         // let's do some destdir magic:
         skip = 2;
-        if ( ch3 != '/' )
-          {
+        if (ch3 != '/') {
           relative = 1;
-          }
         }
-      else
-        {
+      } else {
         relative = 1;
-        }
-      if ( relative )
-        {
+      }
+      if (relative) {
         // This is relative path on unix or windows. Since we are doing
         // destdir, this case does not make sense.
         this->FileCommand->SetError(
@@ -2293,124 +1900,105 @@ bool cmFileInstaller::HandleInstallDestination()
           "does not make sense when using DESTDIR. Specify "
           "absolute path or remove DESTDIR environment variable.");
         return false;
-        }
       }
-    else
-      {
-      if ( ch2 == '/' )
-        {
+    } else {
+      if (ch2 == '/') {
         // looks like a network path.
-        std::string message = "called with network path DESTINATION. This "
+        std::string message =
+          "called with network path DESTINATION. This "
           "does not make sense when using DESTDIR. Specify local "
           "absolute path or remove DESTDIR environment variable."
           "\nDESTINATION=\n";
         message += destination;
         this->FileCommand->SetError(message);
         return false;
-        }
       }
+    }
     destination = sdestdir + (destination.c_str() + skip);
     this->DestDirLength = int(sdestdir.size());
-    }
+  }
 
-  if(this->InstallType != cmInstallType_DIRECTORY)
-    {
-    if ( !cmSystemTools::FileExists(destination.c_str()) )
-      {
-      if ( !cmSystemTools::MakeDirectory(destination.c_str()) )
-        {
+  if (this->InstallType != cmInstallType_DIRECTORY) {
+    if (!cmSystemTools::FileExists(destination.c_str())) {
+      if (!cmSystemTools::MakeDirectory(destination.c_str())) {
         std::string errstring = "cannot create directory: " + destination +
           ". Maybe need administrative privileges.";
         this->FileCommand->SetError(errstring);
         return false;
-        }
       }
-    if ( !cmSystemTools::FileIsDirectory(destination) )
-      {
-      std::string errstring = "INSTALL destination: " + destination +
-        " is not a directory.";
+    }
+    if (!cmSystemTools::FileIsDirectory(destination)) {
+      std::string errstring =
+        "INSTALL destination: " + destination + " is not a directory.";
       this->FileCommand->SetError(errstring);
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool
-cmFileCommand::HandleRPathChangeCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleRPathChangeCommand(
+  std::vector<std::string> const& args)
 {
   // Evaluate arguments.
   const char* file = 0;
   const char* oldRPath = 0;
   const char* newRPath = 0;
-  enum Doing { DoingNone, DoingFile, DoingOld, DoingNew };
+  enum Doing
+  {
+    DoingNone,
+    DoingFile,
+    DoingOld,
+    DoingNew
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "OLD_RPATH")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "OLD_RPATH") {
       doing = DoingOld;
-      }
-    else if(args[i] == "NEW_RPATH")
-      {
+    } else if (args[i] == "NEW_RPATH") {
       doing = DoingNew;
-      }
-    else if(args[i] == "FILE")
-      {
+    } else if (args[i] == "FILE") {
       doing = DoingFile;
-      }
-    else if(doing == DoingFile)
-      {
+    } else if (doing == DoingFile) {
       file = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingOld)
-      {
+    } else if (doing == DoingOld) {
       oldRPath = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingNew)
-      {
+    } else if (doing == DoingNew) {
       newRPath = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "RPATH_CHANGE given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!file)
-    {
+  }
+  if (!file) {
     this->SetError("RPATH_CHANGE not given FILE option.");
     return false;
-    }
-  if(!oldRPath)
-    {
+  }
+  if (!oldRPath) {
     this->SetError("RPATH_CHANGE not given OLD_RPATH option.");
     return false;
-    }
-  if(!newRPath)
-    {
+  }
+  if (!newRPath) {
     this->SetError("RPATH_CHANGE not given NEW_RPATH option.");
     return false;
-    }
-  if(!cmSystemTools::FileExists(file, true))
-    {
+  }
+  if (!cmSystemTools::FileExists(file, true)) {
     std::ostringstream e;
     e << "RPATH_CHANGE given FILE \"" << file << "\" that does not exist.";
     this->SetError(e.str());
     return false;
-    }
+  }
   bool success = true;
   cmSystemToolsFileTime* ft = cmSystemTools::FileTimeNew();
   bool have_ft = cmSystemTools::FileTimeGet(file, ft);
   std::string emsg;
   bool changed;
-  if(!cmSystemTools::ChangeRPath(file, oldRPath, newRPath, &emsg, &changed))
-    {
+  if (!cmSystemTools::ChangeRPath(file, oldRPath, newRPath, &emsg, &changed)) {
     std::ostringstream e;
     /* clang-format off */
     e << "RPATH_CHANGE could not write new RPATH:\n"
@@ -2421,72 +2009,64 @@ cmFileCommand::HandleRPathChangeCommand(std::vector<std::string> const& args)
     /* clang-format on */
     this->SetError(e.str());
     success = false;
-    }
-  if(success)
-    {
-    if(changed)
-      {
+  }
+  if (success) {
+    if (changed) {
       std::string message = "Set runtime path of \"";
       message += file;
       message += "\" to \"";
       message += newRPath;
       message += "\"";
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    if(have_ft)
-      {
+    }
+    if (have_ft) {
       cmSystemTools::FileTimeSet(file, ft);
-      }
     }
+  }
   cmSystemTools::FileTimeDelete(ft);
   return success;
 }
 
-bool
-cmFileCommand::HandleRPathRemoveCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleRPathRemoveCommand(
+  std::vector<std::string> const& args)
 {
   // Evaluate arguments.
   const char* file = 0;
-  enum Doing { DoingNone, DoingFile };
+  enum Doing
+  {
+    DoingNone,
+    DoingFile
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "FILE")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "FILE") {
       doing = DoingFile;
-      }
-    else if(doing == DoingFile)
-      {
+    } else if (doing == DoingFile) {
       file = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "RPATH_REMOVE given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!file)
-    {
+  }
+  if (!file) {
     this->SetError("RPATH_REMOVE not given FILE option.");
     return false;
-    }
-  if(!cmSystemTools::FileExists(file, true))
-    {
+  }
+  if (!cmSystemTools::FileExists(file, true)) {
     std::ostringstream e;
     e << "RPATH_REMOVE given FILE \"" << file << "\" that does not exist.";
     this->SetError(e.str());
     return false;
-    }
+  }
   bool success = true;
   cmSystemToolsFileTime* ft = cmSystemTools::FileTimeNew();
   bool have_ft = cmSystemTools::FileTimeGet(file, ft);
   std::string emsg;
   bool removed;
-  if(!cmSystemTools::RemoveRPath(file, &emsg, &removed))
-    {
+  if (!cmSystemTools::RemoveRPath(file, &emsg, &removed)) {
     std::ostringstream e;
     /* clang-format off */
     e << "RPATH_REMOVE could not remove RPATH from file:\n"
@@ -2495,80 +2075,69 @@ cmFileCommand::HandleRPathRemoveCommand(std::vector<std::string> const& args)
     /* clang-format on */
     this->SetError(e.str());
     success = false;
-    }
-  if(success)
-    {
-    if(removed)
-      {
+  }
+  if (success) {
+    if (removed) {
       std::string message = "Removed runtime path from \"";
       message += file;
       message += "\"";
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    if(have_ft)
-      {
+    }
+    if (have_ft) {
       cmSystemTools::FileTimeSet(file, ft);
-      }
     }
+  }
   cmSystemTools::FileTimeDelete(ft);
   return success;
 }
 
-bool
-cmFileCommand::HandleRPathCheckCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleRPathCheckCommand(
+  std::vector<std::string> const& args)
 {
   // Evaluate arguments.
   const char* file = 0;
   const char* rpath = 0;
-  enum Doing { DoingNone, DoingFile, DoingRPath };
+  enum Doing
+  {
+    DoingNone,
+    DoingFile,
+    DoingRPath
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "RPATH")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "RPATH") {
       doing = DoingRPath;
-      }
-    else if(args[i] == "FILE")
-      {
+    } else if (args[i] == "FILE") {
       doing = DoingFile;
-      }
-    else if(doing == DoingFile)
-      {
+    } else if (doing == DoingFile) {
       file = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingRPath)
-      {
+    } else if (doing == DoingRPath) {
       rpath = args[i].c_str();
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "RPATH_CHECK given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
-  if(!file)
-    {
+  }
+  if (!file) {
     this->SetError("RPATH_CHECK not given FILE option.");
     return false;
-    }
-  if(!rpath)
-    {
+  }
+  if (!rpath) {
     this->SetError("RPATH_CHECK not given RPATH option.");
     return false;
-    }
+  }
 
   // If the file exists but does not have the desired RPath then
   // delete it.  This is used during installation to re-install a file
   // if its RPath will change.
-  if(cmSystemTools::FileExists(file, true) &&
-     !cmSystemTools::CheckRPath(file, rpath))
-    {
+  if (cmSystemTools::FileExists(file, true) &&
+      !cmSystemTools::CheckRPath(file, rpath)) {
     cmSystemTools::RemoveFile(file);
-    }
+  }
 
   return true;
 }
@@ -2582,65 +2151,55 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
 bool cmFileCommand::HandleRelativePathCommand(
   std::vector<std::string> const& args)
 {
-  if(args.size() != 4 )
-    {
+  if (args.size() != 4) {
     this->SetError("RELATIVE_PATH called with incorrect number of arguments");
     return false;
-    }
+  }
 
   const std::string& outVar = args[1];
   const std::string& directoryName = args[2];
   const std::string& fileName = args[3];
 
-  if(!cmSystemTools::FileIsFullPath(directoryName.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(directoryName.c_str())) {
     std::string errstring =
-      "RELATIVE_PATH must be passed a full path to the directory: "
-      + directoryName;
+      "RELATIVE_PATH must be passed a full path to the directory: " +
+      directoryName;
     this->SetError(errstring);
     return false;
-    }
-  if(!cmSystemTools::FileIsFullPath(fileName.c_str()))
-    {
+  }
+  if (!cmSystemTools::FileIsFullPath(fileName.c_str())) {
     std::string errstring =
-      "RELATIVE_PATH must be passed a full path to the file: "
-      + fileName;
+      "RELATIVE_PATH must be passed a full path to the file: " + fileName;
     this->SetError(errstring);
     return false;
-    }
+  }
 
-  std::string res = cmSystemTools::RelativePath(directoryName.c_str(),
-                                                fileName.c_str());
-  this->Makefile->AddDefinition(outVar,
-    res.c_str());
+  std::string res =
+    cmSystemTools::RelativePath(directoryName.c_str(), fileName.c_str());
+  this->Makefile->AddDefinition(outVar, res.c_str());
   return true;
 }
 
-
 bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("RENAME given incorrect number of arguments.");
     return false;
-    }
+  }
 
   // Compute full path for old and new names.
   std::string oldname = args[1];
-  if(!cmsys::SystemTools::FileIsFullPath(oldname.c_str()))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(oldname.c_str())) {
     oldname = this->Makefile->GetCurrentSourceDirectory();
     oldname += "/" + args[1];
-    }
+  }
   std::string newname = args[2];
-  if(!cmsys::SystemTools::FileIsFullPath(newname.c_str()))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(newname.c_str())) {
     newname = this->Makefile->GetCurrentSourceDirectory();
     newname += "/" + args[2];
-    }
+  }
 
-  if(!cmSystemTools::RenameFile(oldname.c_str(), newname.c_str()))
-    {
+  if (!cmSystemTools::RenameFile(oldname.c_str(), newname.c_str())) {
     std::string err = cmSystemTools::GetLastSystemError();
     std::ostringstream e;
     /* clang-format off */
@@ -2652,11 +2211,10 @@ bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
     /* clang-format on */
     this->SetError(e.str());
     return false;
-    }
+  }
   return true;
 }
 
-
 bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
                                  bool recurse)
 {
@@ -2665,79 +2223,64 @@ bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
   std::vector<std::string>::const_iterator i = args.begin();
 
   i++; // Get rid of subcommand
-  for(;i != args.end(); ++i)
-    {
+  for (; i != args.end(); ++i) {
     std::string fileName = *i;
-    if(!cmsys::SystemTools::FileIsFullPath(fileName.c_str()))
-      {
+    if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) {
       fileName = this->Makefile->GetCurrentSourceDirectory();
       fileName += "/" + *i;
-      }
+    }
 
-    if(cmSystemTools::FileIsDirectory(fileName) &&
-       !cmSystemTools::FileIsSymlink(fileName) && recurse)
-      {
+    if (cmSystemTools::FileIsDirectory(fileName) &&
+        !cmSystemTools::FileIsSymlink(fileName) && recurse) {
       cmSystemTools::RemoveADirectory(fileName);
-      }
-    else
-      {
+    } else {
       cmSystemTools::RemoveFile(fileName);
-      }
     }
+  }
   return true;
 }
 
-bool cmFileCommand::HandleCMakePathCommand(std::vector<std::string>
-                                           const& args,
-                                           bool nativePath)
+bool cmFileCommand::HandleCMakePathCommand(
+  std::vector<std::string> const& args, bool nativePath)
 {
   std::vector<std::string>::const_iterator i = args.begin();
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("FILE([TO_CMAKE_PATH|TO_NATIVE_PATH] path result) must be "
-      "called with exactly three arguments.");
+                   "called with exactly three arguments.");
     return false;
-    }
+  }
   i++; // Get rid of subcommand
 #if defined(_WIN32) && !defined(__CYGWIN__)
   char pathSep = ';';
 #else
   char pathSep = ':';
 #endif
-  std::vector<cmsys::String> path = cmSystemTools::SplitString(*i,
-                                                             pathSep);
+  std::vector<cmsys::String> path = cmSystemTools::SplitString(*i, pathSep);
   i++;
-  const char* var =  i->c_str();
+  const char* var = i->c_str();
   std::string value;
-  for(std::vector<cmsys::String>::iterator j = path.begin();
-      j != path.end(); ++j)
-    {
-    if(j != path.begin())
-      {
+  for (std::vector<cmsys::String>::iterator j = path.begin(); j != path.end();
+       ++j) {
+    if (j != path.begin()) {
       value += ";";
-      }
-    if(!nativePath)
-      {
+    }
+    if (!nativePath) {
       cmSystemTools::ConvertToUnixSlashes(*j);
-      }
-    else
-      {
+    } else {
       *j = cmSystemTools::ConvertToOutputPath(j->c_str());
       // remove double quotes in the path
       cmsys::String& s = *j;
 
-      if(s.size() > 1 && s[0] == '\"' && s[s.size()-1] == '\"')
-        {
-        s = s.substr(1,s.size()-2);
-        }
+      if (s.size() > 1 && s[0] == '\"' && s[s.size() - 1] == '\"') {
+        s = s.substr(1, s.size() - 2);
       }
-    value += *j;
     }
+    value += *j;
+  }
   this->Makefile->AddDefinition(var, value.c_str());
   return true;
 }
 
-
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 
 // Stuff for curl download/upload
@@ -2745,212 +2288,181 @@ typedef std::vector<char> cmFileCommandVectorOfChar;
 
 namespace {
 
-  size_t
-  cmWriteToFileCallback(void *ptr, size_t size, size_t nmemb,
-                        void *data)
-    {
-    int realsize = (int)(size * nmemb);
-    cmsys::ofstream* fout = static_cast<cmsys::ofstream*>(data);
-    const char* chPtr = static_cast<char*>(ptr);
-    fout->write(chPtr, realsize);
-    return realsize;
-    }
-
-
-  size_t
-  cmWriteToMemoryCallback(void *ptr, size_t size, size_t nmemb,
-                          void *data)
-    {
-    int realsize = (int)(size * nmemb);
-    cmFileCommandVectorOfChar *vec
-      = static_cast<cmFileCommandVectorOfChar*>(data);
-    const char* chPtr = static_cast<char*>(ptr);
-    vec->insert(vec->end(), chPtr, chPtr + realsize);
-    return realsize;
-    }
-
+size_t cmWriteToFileCallback(void* ptr, size_t size, size_t nmemb, void* data)
+{
+  int realsize = (int)(size * nmemb);
+  cmsys::ofstream* fout = static_cast<cmsys::ofstream*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  fout->write(chPtr, realsize);
+  return realsize;
+}
 
-  static size_t
-  cmFileCommandCurlDebugCallback(CURL *, curl_infotype type, char *chPtr,
-                                 size_t size, void *data)
-    {
-    cmFileCommandVectorOfChar *vec
-      = static_cast<cmFileCommandVectorOfChar*>(data);
-    switch(type)
-      {
-      case CURLINFO_TEXT:
-      case CURLINFO_HEADER_IN:
-      case CURLINFO_HEADER_OUT:
-        vec->insert(vec->end(), chPtr, chPtr + size);
-        break;
-      case CURLINFO_DATA_IN:
-      case CURLINFO_DATA_OUT:
-      case CURLINFO_SSL_DATA_IN:
-      case CURLINFO_SSL_DATA_OUT:
-        {
-        char buf[128];
-        int n = sprintf(buf, "[%" KWIML_INT_PRIu64 " bytes data]\n",
-                        static_cast<KWIML_INT_uint64_t>(size));
-        if (n > 0)
-          {
-          vec->insert(vec->end(), buf, buf + n);
-          }
-        }
-        break;
-      default:
-        break;
-      }
-    return 0;
-    }
+size_t cmWriteToMemoryCallback(void* ptr, size_t size, size_t nmemb,
+                               void* data)
+{
+  int realsize = (int)(size * nmemb);
+  cmFileCommandVectorOfChar* vec =
+    static_cast<cmFileCommandVectorOfChar*>(data);
+  const char* chPtr = static_cast<char*>(ptr);
+  vec->insert(vec->end(), chPtr, chPtr + realsize);
+  return realsize;
+}
 
+static size_t cmFileCommandCurlDebugCallback(CURL*, curl_infotype type,
+                                             char* chPtr, size_t size,
+                                             void* data)
+{
+  cmFileCommandVectorOfChar* vec =
+    static_cast<cmFileCommandVectorOfChar*>(data);
+  switch (type) {
+    case CURLINFO_TEXT:
+    case CURLINFO_HEADER_IN:
+    case CURLINFO_HEADER_OUT:
+      vec->insert(vec->end(), chPtr, chPtr + size);
+      break;
+    case CURLINFO_DATA_IN:
+    case CURLINFO_DATA_OUT:
+    case CURLINFO_SSL_DATA_IN:
+    case CURLINFO_SSL_DATA_OUT: {
+      char buf[128];
+      int n = sprintf(buf, "[%" KWIML_INT_PRIu64 " bytes data]\n",
+                      static_cast<KWIML_INT_uint64_t>(size));
+      if (n > 0) {
+        vec->insert(vec->end(), buf, buf + n);
+      }
+    } break;
+    default:
+      break;
+  }
+  return 0;
+}
 
-  class cURLProgressHelper
+class cURLProgressHelper
+{
+public:
+  cURLProgressHelper(cmFileCommand* fc, const char* text)
   {
-  public:
-    cURLProgressHelper(cmFileCommand *fc, const char *text)
-      {
-      this->CurrentPercentage = -1;
-      this->FileCommand = fc;
-      this->Text = text;
-      }
-
-    bool UpdatePercentage(double value, double total, std::string &status)
-      {
-      int OldPercentage = this->CurrentPercentage;
-
-      if (total > 0.0)
-        {
-        this->CurrentPercentage = static_cast<int>(value/total*100.0 + 0.5);
-        if(this->CurrentPercentage > 100)
-          {
-          // Avoid extra progress reports for unexpected data beyond total.
-          this->CurrentPercentage = 100;
-          }
-        }
-
-      bool updated = (OldPercentage != this->CurrentPercentage);
+    this->CurrentPercentage = -1;
+    this->FileCommand = fc;
+    this->Text = text;
+  }
 
-      if (updated)
-        {
-        std::ostringstream oss;
-        oss << "[" << this->Text << " " << this->CurrentPercentage
-            << "% complete]";
-        status = oss.str();
-        }
+  bool UpdatePercentage(double value, double total, std::string& status)
+  {
+    int OldPercentage = this->CurrentPercentage;
 
-      return updated;
+    if (total > 0.0) {
+      this->CurrentPercentage = static_cast<int>(value / total * 100.0 + 0.5);
+      if (this->CurrentPercentage > 100) {
+        // Avoid extra progress reports for unexpected data beyond total.
+        this->CurrentPercentage = 100;
       }
+    }
 
-    cmFileCommand *GetFileCommand()
-      {
-      return this->FileCommand;
-      }
+    bool updated = (OldPercentage != this->CurrentPercentage);
 
-  private:
-    int CurrentPercentage;
-    cmFileCommand *FileCommand;
-    std::string Text;
-  };
+    if (updated) {
+      std::ostringstream oss;
+      oss << "[" << this->Text << " " << this->CurrentPercentage
+          << "% complete]";
+      status = oss.str();
+    }
 
+    return updated;
+  }
 
-  static int
-  cmFileDownloadProgressCallback(void *clientp,
-                                 double dltotal, double dlnow,
-                                 double ultotal, double ulnow)
-    {
-    cURLProgressHelper *helper =
-      reinterpret_cast<cURLProgressHelper *>(clientp);
+  cmFileCommand* GetFileCommand() { return this->FileCommand; }
 
-    static_cast<void>(ultotal);
-    static_cast<void>(ulnow);
+private:
+  int CurrentPercentage;
+  cmFileCommand* FileCommand;
+  std::string Text;
+};
 
-    std::string status;
-    if (helper->UpdatePercentage(dlnow, dltotal, status))
-      {
-      cmFileCommand *fc = helper->GetFileCommand();
-      cmMakefile *mf = fc->GetMakefile();
-      mf->DisplayStatus(status.c_str(), -1);
-      }
+static int cmFileDownloadProgressCallback(void* clientp, double dltotal,
+                                          double dlnow, double ultotal,
+                                          double ulnow)
+{
+  cURLProgressHelper* helper = reinterpret_cast<cURLProgressHelper*>(clientp);
 
-    return 0;
-    }
+  static_cast<void>(ultotal);
+  static_cast<void>(ulnow);
 
+  std::string status;
+  if (helper->UpdatePercentage(dlnow, dltotal, status)) {
+    cmFileCommand* fc = helper->GetFileCommand();
+    cmMakefile* mf = fc->GetMakefile();
+    mf->DisplayStatus(status.c_str(), -1);
+  }
 
-  static int
-  cmFileUploadProgressCallback(void *clientp,
-                               double dltotal, double dlnow,
-                               double ultotal, double ulnow)
-    {
-    cURLProgressHelper *helper =
-    reinterpret_cast<cURLProgressHelper *>(clientp);
+  return 0;
+}
+
+static int cmFileUploadProgressCallback(void* clientp, double dltotal,
+                                        double dlnow, double ultotal,
+                                        double ulnow)
+{
+  cURLProgressHelper* helper = reinterpret_cast<cURLProgressHelper*>(clientp);
 
-    static_cast<void>(dltotal);
-    static_cast<void>(dlnow);
+  static_cast<void>(dltotal);
+  static_cast<void>(dlnow);
 
-    std::string status;
-    if (helper->UpdatePercentage(ulnow, ultotal, status))
-      {
-      cmFileCommand *fc = helper->GetFileCommand();
-      cmMakefile *mf = fc->GetMakefile();
-      mf->DisplayStatus(status.c_str(), -1);
-      }
+  std::string status;
+  if (helper->UpdatePercentage(ulnow, ultotal, status)) {
+    cmFileCommand* fc = helper->GetFileCommand();
+    cmMakefile* mf = fc->GetMakefile();
+    mf->DisplayStatus(status.c_str(), -1);
+  }
 
-    return 0;
-    }
+  return 0;
+}
 }
-
 
 namespace {
 
-  class cURLEasyGuard
+class cURLEasyGuard
+{
+public:
+  cURLEasyGuard(CURL* easy)
+    : Easy(easy)
   {
-  public:
-    cURLEasyGuard(CURL * easy)
-      : Easy(easy)
-      {}
-
-    ~cURLEasyGuard(void)
-      {
-        if (this->Easy)
-          {
-          ::curl_easy_cleanup(this->Easy);
-          }
-      }
+  }
 
-    inline void release(void)
-      {
-        this->Easy = 0;
-        return;
-      }
+  ~cURLEasyGuard(void)
+  {
+    if (this->Easy) {
+      ::curl_easy_cleanup(this->Easy);
+    }
+  }
 
-  private:
-    ::CURL * Easy;
-  };
+  inline void release(void)
+  {
+    this->Easy = 0;
+    return;
+  }
 
+private:
+  ::CURL* Easy;
+};
 }
 #endif
 
+#define check_curl_result(result, errstr)                                     \
+  if (result != CURLE_OK) {                                                   \
+    std::string e(errstr);                                                    \
+    e += ::curl_easy_strerror(result);                                        \
+    this->SetError(e);                                                        \
+    return false;                                                             \
+  }
 
-#define check_curl_result(result, errstr) \
-  if (result != CURLE_OK)                 \
-    {                                     \
-    std::string e(errstr);                \
-    e += ::curl_easy_strerror(result);    \
-    this->SetError(e);            \
-    return false;                         \
-    }
-
-
-bool
-cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   std::vector<std::string>::const_iterator i = args.begin();
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("DOWNLOAD must be called with at least three arguments.");
     return false;
-    }
+  }
   ++i; // Get rid of subcommand
   std::string url = *i;
   ++i;
@@ -2968,183 +2480,140 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   cmsys::auto_ptr<cmCryptoHash> hash;
   bool showProgress = false;
 
-  while(i != args.end())
-    {
-    if(*i == "TIMEOUT")
-      {
+  while (i != args.end()) {
+    if (*i == "TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("DOWNLOAD missing time for TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "INACTIVITY_TIMEOUT")
-      {
+    } else if (*i == "INACTIVITY_TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         inactivity_timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("DOWNLOAD missing time for INACTIVITY_TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "LOG")
-      {
+    } else if (*i == "LOG") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing VAR for LOG.");
         return false;
-        }
-      logVar = *i;
       }
-    else if(*i == "STATUS")
-      {
+      logVar = *i;
+    } else if (*i == "STATUS") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing VAR for STATUS.");
         return false;
-        }
-      statusVar = *i;
       }
-    else if(*i == "TLS_VERIFY")
-      {
+      statusVar = *i;
+    } else if (*i == "TLS_VERIFY") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         tls_verify = cmSystemTools::IsOn(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("TLS_VERIFY missing bool value.");
         return false;
-        }
       }
-    else if(*i == "TLS_CAINFO")
-      {
+    } else if (*i == "TLS_CAINFO") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         cainfo = i->c_str();
-        }
-      else
-        {
+      } else {
         this->SetError("TLS_CAFILE missing file value.");
         return false;
-        }
       }
-    else if(*i == "EXPECTED_MD5")
-      {
+    } else if (*i == "EXPECTED_MD5") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing sum value for EXPECTED_MD5.");
         return false;
-        }
+      }
       hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New("MD5"));
       hashMatchMSG = "MD5 sum";
       expectedHash = cmSystemTools::LowerCase(*i);
-      }
-    else if(*i == "SHOW_PROGRESS")
-      {
+    } else if (*i == "SHOW_PROGRESS") {
       showProgress = true;
-      }
-    else if(*i == "EXPECTED_HASH")
-      {
+    } else if (*i == "EXPECTED_HASH") {
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("DOWNLOAD missing ALGO=value for EXPECTED_HASH.");
         return false;
-        }
+      }
       std::string::size_type pos = i->find("=");
-      if(pos == std::string::npos)
-        {
+      if (pos == std::string::npos) {
         std::string err =
           "DOWNLOAD EXPECTED_HASH expects ALGO=value but got: ";
         err += *i;
         this->SetError(err);
         return false;
-        }
+      }
       std::string algo = i->substr(0, pos);
-      expectedHash = cmSystemTools::LowerCase(i->substr(pos+1));
+      expectedHash = cmSystemTools::LowerCase(i->substr(pos + 1));
       hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New(algo.c_str()));
-      if(!hash.get())
-        {
+      if (!hash.get()) {
         std::string err = "DOWNLOAD EXPECTED_HASH given unknown ALGO: ";
         err += algo;
         this->SetError(err);
         return false;
-        }
-      hashMatchMSG = algo + " hash";
       }
-    ++i;
+      hashMatchMSG = algo + " hash";
     }
+    ++i;
+  }
   // If file exists already, and caller specified an expected md5 or sha,
   // and the existing file already has the expected hash, then simply
   // return.
   //
-  if(cmSystemTools::FileExists(file.c_str()) && hash.get())
-    {
+  if (cmSystemTools::FileExists(file.c_str()) && hash.get()) {
     std::string msg;
     std::string actualHash = hash->HashFile(file);
-    if(actualHash == expectedHash)
-      {
+    if (actualHash == expectedHash) {
       msg = "returning early; file already exists with expected ";
       msg += hashMatchMSG;
       msg += "\"";
-      if(!statusVar.empty())
-        {
+      if (!statusVar.empty()) {
         std::ostringstream result;
         result << (int)0 << ";\"" << msg;
-        this->Makefile->AddDefinition(statusVar,
-                                      result.str().c_str());
-        }
-      return true;
+        this->Makefile->AddDefinition(statusVar, result.str().c_str());
       }
+      return true;
     }
+  }
   // Make sure parent directory exists so we can write to the file
   // as we receive downloaded bits from curl...
   //
   std::string dir = cmSystemTools::GetFilenamePath(file);
-  if(!cmSystemTools::FileExists(dir.c_str()) &&
-     !cmSystemTools::MakeDirectory(dir.c_str()))
-    {
-    std::string errstring = "DOWNLOAD error: cannot create directory '"
-      + dir + "' - Specify file by full path name and verify that you "
+  if (!cmSystemTools::FileExists(dir.c_str()) &&
+      !cmSystemTools::MakeDirectory(dir.c_str())) {
+    std::string errstring = "DOWNLOAD error: cannot create directory '" + dir +
+      "' - Specify file by full path name and verify that you "
       "have directory creation and file write privileges.";
     this->SetError(errstring);
     return false;
-    }
+  }
 
   cmsys::ofstream fout(file.c_str(), std::ios::binary);
-  if(!fout)
-    {
+  if (!fout) {
     this->SetError("DOWNLOAD cannot open file for write.");
     return false;
-    }
+  }
 
 #if defined(_WIN32) && defined(CMAKE_ENCODING_UTF8)
   url = fix_file_url_windows(url);
 #endif
 
-  ::CURL *curl;
+  ::CURL* curl;
   ::curl_global_init(CURL_GLOBAL_DEFAULT);
   curl = ::curl_easy_init();
-  if(!curl)
-    {
+  if (!curl) {
     this->SetError("DOWNLOAD error initializing curl.");
     return false;
-    }
+  }
 
   cURLEasyGuard g_curl(curl);
   ::CURLcode res = ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
@@ -3157,8 +2626,7 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   res = ::curl_easy_setopt(curl, CURLOPT_USERAGENT, "curl/" LIBCURL_VERSION);
   check_curl_result(res, "DOWNLOAD cannot set user agent option: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                           cmWriteToFileCallback);
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmWriteToFileCallback);
   check_curl_result(res, "DOWNLOAD cannot set write function: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
@@ -3166,54 +2634,47 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   check_curl_result(res, "DOWNLOAD cannot set debug function: ");
 
   // check to see if TLS verification is requested
-  if(tls_verify)
-    {
+  if (tls_verify) {
     res = ::curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
     check_curl_result(res, "Unable to set TLS/SSL Verify on: ");
-    }
-  else
-    {
+  } else {
     res = ::curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
     check_curl_result(res, "Unable to set TLS/SSL Verify off: ");
-    }
+  }
   // check to see if a CAINFO file has been specified
   // command arg comes first
   std::string const& cainfo_err = cmCurlSetCAInfo(curl, cainfo);
-  if (!cainfo_err.empty())
-    {
+  if (!cainfo_err.empty()) {
     this->SetError(cainfo_err);
     return false;
-    }
+  }
 
   cmFileCommandVectorOfChar chunkDebug;
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&fout);
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&fout);
   check_curl_result(res, "DOWNLOAD cannot set write data: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
   check_curl_result(res, "DOWNLOAD cannot set debug data: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
   check_curl_result(res, "DOWNLOAD cannot set follow-redirect option: ");
 
-  if(!logVar.empty())
-    {
+  if (!logVar.empty()) {
     res = ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
     check_curl_result(res, "DOWNLOAD cannot set verbose: ");
-    }
+  }
 
-  if(timeout > 0)
-    {
-    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout );
+  if (timeout > 0) {
+    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
     check_curl_result(res, "DOWNLOAD cannot set timeout: ");
-    }
+  }
 
-  if(inactivity_timeout > 0)
-    {
+  if (inactivity_timeout > 0) {
     // Give up if there is no progress for a long time.
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, inactivity_timeout);
-    }
+  }
 
   // Need the progress helper's scope to last through the duration of
   // the curl_easy_perform call... so this object is declared at function
@@ -3222,19 +2683,18 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   //
   cURLProgressHelper helper(this, "download");
 
-  if(showProgress)
-    {
+  if (showProgress) {
     res = ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
     check_curl_result(res, "DOWNLOAD cannot set noprogress value: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSFUNCTION, cmFileDownloadProgressCallback);
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION,
+                             cmFileDownloadProgressCallback);
     check_curl_result(res, "DOWNLOAD cannot set progress function: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSDATA, reinterpret_cast<void*>(&helper));
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSDATA,
+                             reinterpret_cast<void*>(&helper));
     check_curl_result(res, "DOWNLOAD cannot set progress data: ");
-    }
+  }
 
   res = ::curl_easy_perform(curl);
 
@@ -3242,13 +2702,11 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
   g_curl.release();
   ::curl_easy_cleanup(curl);
 
-  if(!statusVar.empty())
-    {
+  if (!statusVar.empty()) {
     std::ostringstream result;
     result << (int)res << ";\"" << ::curl_easy_strerror(res) << "\"";
-    this->Makefile->AddDefinition(statusVar,
-                                  result.str().c_str());
-    }
+    this->Makefile->AddDefinition(statusVar, result.str().c_str());
+  }
 
   ::curl_global_cleanup();
 
@@ -3259,44 +2717,38 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
 
   // Verify MD5 sum if requested:
   //
-  if (hash.get())
-    {
+  if (hash.get()) {
     std::string actualHash = hash->HashFile(file);
-    if (actualHash.empty())
-      {
+    if (actualHash.empty()) {
       this->SetError("DOWNLOAD cannot compute hash on downloaded file");
       return false;
-      }
+    }
 
-    if (expectedHash != actualHash)
-      {
+    if (expectedHash != actualHash) {
       std::ostringstream oss;
       oss << "DOWNLOAD HASH mismatch" << std::endl
-        << "  for file: [" << file << "]" << std::endl
-        << "    expected hash: [" << expectedHash << "]" << std::endl
-        << "      actual hash: [" << actualHash << "]" << std::endl
-        << "           status: [" << (int)res << ";\""
-          << ::curl_easy_strerror(res) << "\"]" << std::endl
-        ;
-
-      if(!statusVar.empty() && res == 0)
-        {
+          << "  for file: [" << file << "]" << std::endl
+          << "    expected hash: [" << expectedHash << "]" << std::endl
+          << "      actual hash: [" << actualHash << "]" << std::endl
+          << "           status: [" << (int)res << ";\""
+          << ::curl_easy_strerror(res) << "\"]" << std::endl;
+
+      if (!statusVar.empty() && res == 0) {
         std::string status = "1;HASH mismatch: "
-          "expected: " + expectedHash +
-          " actual: " + actualHash;
+                             "expected: " +
+          expectedHash + " actual: " + actualHash;
         this->Makefile->AddDefinition(statusVar, status.c_str());
-        }
+      }
 
       this->SetError(oss.str());
       return false;
-      }
     }
+  }
 
-  if (!logVar.empty())
-    {
+  if (!logVar.empty()) {
     chunkDebug.push_back(0);
     this->Makefile->AddDefinition(logVar, &*chunkDebug.begin());
-    }
+  }
 
   return true;
 #else
@@ -3305,16 +2757,13 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
 #endif
 }
 
-
-bool
-cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
+bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("UPLOAD must be called with at least three arguments.");
     return false;
-    }
+  }
   std::vector<std::string>::const_iterator i = args.begin();
   ++i;
   std::string filename = *i;
@@ -3328,72 +2777,53 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   std::string statusVar;
   bool showProgress = false;
 
-  while(i != args.end())
-    {
-    if(*i == "TIMEOUT")
-      {
+  while (i != args.end()) {
+    if (*i == "TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("UPLOAD missing time for TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "INACTIVITY_TIMEOUT")
-      {
+    } else if (*i == "INACTIVITY_TIMEOUT") {
       ++i;
-      if(i != args.end())
-        {
+      if (i != args.end()) {
         inactivity_timeout = atol(i->c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("UPLOAD missing time for INACTIVITY_TIMEOUT.");
         return false;
-        }
       }
-    else if(*i == "LOG")
-      {
+    } else if (*i == "LOG") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("UPLOAD missing VAR for LOG.");
         return false;
-        }
-      logVar = *i;
       }
-    else if(*i == "STATUS")
-      {
+      logVar = *i;
+    } else if (*i == "STATUS") {
       ++i;
-      if( i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("UPLOAD missing VAR for STATUS.");
         return false;
-        }
-      statusVar = *i;
       }
-    else if(*i == "SHOW_PROGRESS")
-      {
+      statusVar = *i;
+    } else if (*i == "SHOW_PROGRESS") {
       showProgress = true;
-      }
+    }
 
     ++i;
-    }
+  }
 
   // Open file for reading:
   //
-  FILE *fin = cmsys::SystemTools::Fopen(filename, "rb");
-  if(!fin)
-    {
+  FILE* fin = cmsys::SystemTools::Fopen(filename, "rb");
+  if (!fin) {
     std::string errStr = "UPLOAD cannot open file '";
     errStr += filename + "' for reading.";
     this->SetError(errStr);
     return false;
-    }
+  }
 
   unsigned long file_size = cmsys::SystemTools::FileLength(filename);
 
@@ -3401,15 +2831,14 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   url = fix_file_url_windows(url);
 #endif
 
-  ::CURL *curl;
+  ::CURL* curl;
   ::curl_global_init(CURL_GLOBAL_DEFAULT);
   curl = ::curl_easy_init();
-  if(!curl)
-    {
+  if (!curl) {
     this->SetError("UPLOAD error initializing curl.");
     fclose(fin);
     return false;
-    }
+  }
 
   cURLEasyGuard g_curl(curl);
 
@@ -3424,8 +2853,8 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   res = ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
   check_curl_result(res, "UPLOAD cannot set url: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                           cmWriteToMemoryCallback);
+  res =
+    ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmWriteToMemoryCallback);
   check_curl_result(res, "UPLOAD cannot set write function: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
@@ -3435,33 +2864,30 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   cmFileCommandVectorOfChar chunkResponse;
   cmFileCommandVectorOfChar chunkDebug;
 
-  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunkResponse);
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&chunkResponse);
   check_curl_result(res, "UPLOAD cannot set write data: ");
 
-  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void*)&chunkDebug);
   check_curl_result(res, "UPLOAD cannot set debug data: ");
 
   res = ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
   check_curl_result(res, "UPLOAD cannot set follow-redirect option: ");
 
-  if(!logVar.empty())
-    {
+  if (!logVar.empty()) {
     res = ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
     check_curl_result(res, "UPLOAD cannot set verbose: ");
-    }
+  }
 
-  if(timeout > 0)
-    {
-    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout );
+  if (timeout > 0) {
+    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
     check_curl_result(res, "UPLOAD cannot set timeout: ");
-    }
+  }
 
-  if(inactivity_timeout > 0)
-    {
+  if (inactivity_timeout > 0) {
     // Give up if there is no progress for a long time.
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 1);
     ::curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, inactivity_timeout);
-    }
+  }
 
   // Need the progress helper's scope to last through the duration of
   // the curl_easy_perform call... so this object is declared at function
@@ -3470,27 +2896,26 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   //
   cURLProgressHelper helper(this, "upload");
 
-  if(showProgress)
-    {
+  if (showProgress) {
     res = ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
     check_curl_result(res, "UPLOAD cannot set noprogress value: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSFUNCTION, cmFileUploadProgressCallback);
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION,
+                             cmFileUploadProgressCallback);
     check_curl_result(res, "UPLOAD cannot set progress function: ");
 
-    res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSDATA, reinterpret_cast<void*>(&helper));
+    res = ::curl_easy_setopt(curl, CURLOPT_PROGRESSDATA,
+                             reinterpret_cast<void*>(&helper));
     check_curl_result(res, "UPLOAD cannot set progress data: ");
-    }
+  }
 
   // now specify which file to upload
   res = ::curl_easy_setopt(curl, CURLOPT_INFILE, fin);
   check_curl_result(res, "UPLOAD cannot set input file: ");
 
   // and give the size of the upload (optional)
-  res = ::curl_easy_setopt(curl,
-    CURLOPT_INFILESIZE, static_cast<long>(file_size));
+  res =
+    ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(file_size));
   check_curl_result(res, "UPLOAD cannot set input file size: ");
 
   res = ::curl_easy_perform(curl);
@@ -3499,41 +2924,36 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
   g_curl.release();
   ::curl_easy_cleanup(curl);
 
-  if(!statusVar.empty())
-    {
+  if (!statusVar.empty()) {
     std::ostringstream result;
     result << (int)res << ";\"" << ::curl_easy_strerror(res) << "\"";
-    this->Makefile->AddDefinition(statusVar,
-                                  result.str().c_str());
-    }
+    this->Makefile->AddDefinition(statusVar, result.str().c_str());
+  }
 
   ::curl_global_cleanup();
 
   fclose(fin);
   fin = NULL;
 
-  if(!logVar.empty())
-    {
+  if (!logVar.empty()) {
     std::string log;
 
-    if(!chunkResponse.empty())
-      {
+    if (!chunkResponse.empty()) {
       chunkResponse.push_back(0);
       log += "Response:\n";
       log += &*chunkResponse.begin();
       log += "\n";
-      }
+    }
 
-    if(!chunkDebug.empty())
-      {
+    if (!chunkDebug.empty()) {
       chunkDebug.push_back(0);
       log += "Debug:\n";
       log += &*chunkDebug.begin();
       log += "\n";
-      }
+    }
 
     this->Makefile->AddDefinition(logVar, log.c_str());
-    }
+  }
 
   return true;
 #else
@@ -3542,81 +2962,72 @@ cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
 #endif
 }
 
-void cmFileCommand::AddEvaluationFile(const std::string &inputName,
-                                      const std::string &outputExpr,
-                                      const std::string &condition,
-                                      bool inputIsContent
-                                     )
+void cmFileCommand::AddEvaluationFile(const std::string& inputName,
+                                      const std::string& outputExpr,
+                                      const std::string& condition,
+                                      bool inputIsContent)
 {
   cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
 
   cmGeneratorExpression outputGe(lfbt);
-  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputCge
-                                                = outputGe.Parse(outputExpr);
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputCge =
+    outputGe.Parse(outputExpr);
 
   cmGeneratorExpression conditionGe(lfbt);
-  cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge
-                                              = conditionGe.Parse(condition);
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge =
+    conditionGe.Parse(condition);
 
-  this->Makefile->AddEvaluationFile(inputName, outputCge,
-                                    conditionCge, inputIsContent);
+  this->Makefile->AddEvaluationFile(inputName, outputCge, conditionCge,
+                                    inputIsContent);
 }
 
-bool cmFileCommand::HandleGenerateCommand(
-  std::vector<std::string> const& args)
+bool cmFileCommand::HandleGenerateCommand(std::vector<std::string> const& args)
 {
-  if (args.size() < 5)
-    {
+  if (args.size() < 5) {
     this->SetError("Incorrect arguments to GENERATE subcommand.");
     return false;
-    }
-  if (args[1] != "OUTPUT")
-    {
+  }
+  if (args[1] != "OUTPUT") {
     this->SetError("Incorrect arguments to GENERATE subcommand.");
     return false;
-    }
+  }
   std::string condition;
-  if (args.size() > 5)
-    {
-    if (args[5] != "CONDITION")
-      {
+  if (args.size() > 5) {
+    if (args[5] != "CONDITION") {
       this->SetError("Incorrect arguments to GENERATE subcommand.");
       return false;
-      }
-    if (args.size() != 7)
-      {
+    }
+    if (args.size() != 7) {
       this->SetError("Incorrect arguments to GENERATE subcommand.");
       return false;
-      }
+    }
     condition = args[6];
-    if (condition.empty())
-      {
+    if (condition.empty()) {
       this->SetError("CONDITION of sub-command GENERATE must not be empty if "
-        "specified.");
+                     "specified.");
       return false;
-      }
     }
+  }
   std::string output = args[2];
   const bool inputIsContent = args[3] != "INPUT";
-  if (inputIsContent && args[3] != "CONTENT")
-    {
+  if (inputIsContent && args[3] != "CONTENT") {
     this->SetError("Incorrect arguments to GENERATE subcommand.");
     return false;
-    }
+  }
   std::string input = args[4];
 
   this->AddEvaluationFile(input, output, condition, inputIsContent);
   return true;
 }
 
-bool cmFileCommand::HandleLockCommand(
-  std::vector<std::string> const& args)
+bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   // Default values
   bool directory = false;
   bool release = false;
-  enum Guard {
+  enum Guard
+  {
     GUARD_FUNCTION,
     GUARD_FILE,
     GUARD_PROCESS
@@ -3626,148 +3037,111 @@ bool cmFileCommand::HandleLockCommand(
   unsigned long timeout = static_cast<unsigned long>(-1);
 
   // Parse arguments
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->Makefile->IssueMessage(
-        cmake::FATAL_ERROR,
-        "sub-command LOCK requires at least two arguments.");
+      cmake::FATAL_ERROR, "sub-command LOCK requires at least two arguments.");
     return false;
-    }
+  }
 
   std::string path = args[1];
-  for (unsigned i = 2; i < args.size(); ++i)
-    {
-    if (args[i] == "DIRECTORY")
-      {
+  for (unsigned i = 2; i < args.size(); ++i) {
+    if (args[i] == "DIRECTORY") {
       directory = true;
-      }
-    else if (args[i] == "RELEASE")
-      {
+    } else if (args[i] == "RELEASE") {
       release = true;
-      }
-    else if (args[i] == "GUARD")
-      {
+    } else if (args[i] == "GUARD") {
       ++i;
       const char* merr = "expected FUNCTION, FILE or PROCESS after GUARD";
-      if (i >= args.size())
-        {
+      if (i >= args.size()) {
         this->Makefile->IssueMessage(cmake::FATAL_ERROR, merr);
         return false;
-        }
-      else
-        {
-        if (args[i] == "FUNCTION")
-          {
+      } else {
+        if (args[i] == "FUNCTION") {
           guard = GUARD_FUNCTION;
-          }
-        else if (args[i] == "FILE")
-          {
+        } else if (args[i] == "FILE") {
           guard = GUARD_FILE;
-          }
-        else if (args[i] == "PROCESS")
-          {
+        } else if (args[i] == "PROCESS") {
           guard = GUARD_PROCESS;
-          }
-        else
-          {
+        } else {
           std::ostringstream e;
           e << merr << ", but got:\n  \"" << args[i] << "\".";
           this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
           return false;
-          }
         }
       }
-    else if (args[i] == "RESULT_VARIABLE")
-      {
+    } else if (args[i] == "RESULT_VARIABLE") {
       ++i;
-      if (i >= args.size())
-        {
+      if (i >= args.size()) {
         this->Makefile->IssueMessage(
-            cmake::FATAL_ERROR,
-            "expected variable name after RESULT_VARIABLE");
+          cmake::FATAL_ERROR, "expected variable name after RESULT_VARIABLE");
         return false;
-        }
-      resultVariable = args[i];
       }
-    else if (args[i] == "TIMEOUT")
-      {
+      resultVariable = args[i];
+    } else if (args[i] == "TIMEOUT") {
       ++i;
-      if (i >= args.size())
-        {
-        this->Makefile->IssueMessage(
-            cmake::FATAL_ERROR,
-            "expected timeout value after TIMEOUT");
+      if (i >= args.size()) {
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                     "expected timeout value after TIMEOUT");
         return false;
-        }
+      }
       long scanned;
-      if(!cmSystemTools::StringToLong(args[i].c_str(), &scanned)
-         || scanned < 0)
-        {
+      if (!cmSystemTools::StringToLong(args[i].c_str(), &scanned) ||
+          scanned < 0) {
         std::ostringstream e;
         e << "TIMEOUT value \"" << args[i] << "\" is not an unsigned integer.";
         this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
         return false;
-        }
-      timeout = static_cast<unsigned long>(scanned);
       }
-    else
-      {
+      timeout = static_cast<unsigned long>(scanned);
+    } else {
       std::ostringstream e;
       e << "expected DIRECTORY, RELEASE, GUARD, RESULT_VARIABLE or TIMEOUT\n";
       e << "but got: \"" << args[i] << "\".";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
     }
+  }
 
-  if (directory)
-    {
+  if (directory) {
     path += "/cmake.lock";
-    }
+  }
 
-  if (!cmsys::SystemTools::FileIsFullPath(path))
-    {
+  if (!cmsys::SystemTools::FileIsFullPath(path)) {
     path = this->Makefile->GetCurrentSourceDirectory() + ("/" + path);
-    }
+  }
 
   // Unify path (remove '//', '/../', ...)
   path = cmSystemTools::CollapseFullPath(path);
 
   // Create file and directories if needed
   std::string parentDir = cmSystemTools::GetParentDirectory(path);
-  if (!cmSystemTools::MakeDirectory(parentDir))
-    {
+  if (!cmSystemTools::MakeDirectory(parentDir)) {
     std::ostringstream e;
     e << "directory\n  \"" << parentDir << "\"\ncreation failed ";
     e << "(check permissions).";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
-  FILE *file = cmsys::SystemTools::Fopen(path, "w");
-  if (!file)
-    {
+  }
+  FILE* file = cmsys::SystemTools::Fopen(path, "w");
+  if (!file) {
     std::ostringstream e;
     e << "file\n  \"" << path << "\"\ncreation failed (check permissions).";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
   fclose(file);
 
   // Actual lock/unlock
-  cmFileLockPool& lockPool = this->Makefile->GetGlobalGenerator()
-                                           ->GetFileLockPool();
+  cmFileLockPool& lockPool =
+    this->Makefile->GetGlobalGenerator()->GetFileLockPool();
 
   cmFileLockResult fileLockResult(cmFileLockResult::MakeOk());
-  if (release)
-    {
+  if (release) {
     fileLockResult = lockPool.Release(path);
-    }
-  else
-    {
-    switch (guard)
-      {
+  } else {
+    switch (guard) {
       case GUARD_FUNCTION:
         fileLockResult = lockPool.LockFunctionScope(path, timeout);
         break;
@@ -3780,24 +3154,22 @@ bool cmFileCommand::HandleLockCommand(
       default:
         cmSystemTools::SetFatalErrorOccured();
         return false;
-      }
     }
+  }
 
   const std::string result = fileLockResult.GetOutputMessage();
 
-  if (resultVariable.empty() && !fileLockResult.IsOk())
-    {
+  if (resultVariable.empty() && !fileLockResult.IsOk()) {
     std::ostringstream e;
     e << "error locking file\n  \"" << path << "\"\n" << result << ".";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 
-  if (!resultVariable.empty())
-    {
+  if (!resultVariable.empty()) {
     this->Makefile->AddDefinition(resultVariable, result.c_str());
-    }
+  }
 
   return true;
 #else
@@ -3810,16 +3182,13 @@ bool cmFileCommand::HandleLockCommand(
 bool cmFileCommand::HandleTimestampCommand(
   std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command TIMESTAMP requires at least two arguments.");
     return false;
-    }
-  else if(args.size() > 5)
-    {
+  } else if (args.size() > 5) {
     this->SetError("sub-command TIMESTAMP takes at most four arguments.");
     return false;
-    }
+  }
 
   unsigned int argsIndex = 1;
 
@@ -3828,30 +3197,25 @@ bool cmFileCommand::HandleTimestampCommand(
   const std::string& outputVariable = args[argsIndex++];
 
   std::string formatString;
-  if(args.size() > argsIndex && args[argsIndex] != "UTC")
-    {
+  if (args.size() > argsIndex && args[argsIndex] != "UTC") {
     formatString = args[argsIndex++];
-    }
+  }
 
   bool utcFlag = false;
-  if(args.size() > argsIndex)
-    {
-    if(args[argsIndex] == "UTC")
-      {
+  if (args.size() > argsIndex) {
+    if (args[argsIndex] == "UTC") {
       utcFlag = true;
-      }
-    else
-      {
+    } else {
       std::string e = " TIMESTAMP sub-command does not recognize option " +
-          args[argsIndex] + ".";
+        args[argsIndex] + ".";
       this->SetError(e);
       return false;
-      }
     }
+  }
 
   cmTimestamp timestamp;
-  std::string result = timestamp.FileModificationTime(
-    filename.c_str(), formatString, utcFlag);
+  std::string result =
+    timestamp.FileModificationTime(filename.c_str(), formatString, utcFlag);
   this->Makefile->AddDefinition(outputVariable, result.c_str());
 
   return true;
diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h
index a4d341f..84bb456 100644
--- a/Source/cmFileCommand.h
+++ b/Source/cmFileCommand.h
@@ -26,17 +26,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFileCommand;
-    }
+  virtual cmCommand* Clone() { return new cmFileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -46,7 +43,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "file";}
+  virtual std::string GetName() const { return "file"; }
 
   cmTypeMacro(cmFileCommand, cmCommand);
 
@@ -78,11 +75,9 @@ protected:
   bool HandleLockCommand(std::vector<std::string> const& args);
 
 private:
-  void AddEvaluationFile(const std::string &inputName,
-                         const std::string &outputExpr,
-                         const std::string &condition,
-                         bool inputIsContent);
+  void AddEvaluationFile(const std::string& inputName,
+                         const std::string& outputExpr,
+                         const std::string& condition, bool inputIsContent);
 };
 
-
 #endif
diff --git a/Source/cmFileLock.cxx b/Source/cmFileLock.cxx
index 0d41c53..828511f 100644
--- a/Source/cmFileLock.cxx
+++ b/Source/cmFileLock.cxx
@@ -19,49 +19,41 @@
 
 cmFileLock::~cmFileLock()
 {
-  if (!this->Filename.empty())
-    {
+  if (!this->Filename.empty()) {
     const cmFileLockResult result = this->Release();
     static_cast<void>(result);
     assert(result.IsOk());
-    }
+  }
 }
 
-cmFileLockResult cmFileLock::Lock(
-    const std::string& filename, unsigned long timeout)
+cmFileLockResult cmFileLock::Lock(const std::string& filename,
+                                  unsigned long timeout)
 {
-  if (filename.empty())
-    {
+  if (filename.empty()) {
     // Error is internal since all the directories and file must be created
     // before actual lock called.
     return cmFileLockResult::MakeInternal();
-    }
+  }
 
-  if (!this->Filename.empty())
-    {
+  if (!this->Filename.empty()) {
     // Error is internal since double-lock must be checked in class
     // cmFileLockPool by the cmFileLock::IsLocked method.
     return cmFileLockResult::MakeInternal();
-    }
+  }
 
   this->Filename = filename;
   cmFileLockResult result = this->OpenFile();
-  if (result.IsOk())
-    {
-    if (timeout == static_cast<unsigned long>(-1))
-      {
+  if (result.IsOk()) {
+    if (timeout == static_cast<unsigned long>(-1)) {
       result = this->LockWithoutTimeout();
-      }
-    else
-      {
+    } else {
       result = this->LockWithTimeout(timeout);
-      }
     }
+  }
 
-  if (!result.IsOk())
-    {
+  if (!result.IsOk()) {
     this->Filename = "";
-    }
+  }
 
   return result;
 }
@@ -72,7 +64,7 @@ bool cmFileLock::IsLocked(const std::string& filename) const
 }
 
 #if defined(_WIN32)
-# include "cmFileLockWin32.cxx"
+#include "cmFileLockWin32.cxx"
 #else
-# include "cmFileLockUnix.cxx"
+#include "cmFileLockUnix.cxx"
 #endif
diff --git a/Source/cmFileLock.h b/Source/cmFileLock.h
index dd959a7..538b716 100644
--- a/Source/cmFileLock.h
+++ b/Source/cmFileLock.h
@@ -16,7 +16,7 @@
 #include "cmStandardIncludes.h"
 
 #if defined(_WIN32)
-# include <windows.h> // HANDLE
+#include <windows.h> // HANDLE
 #endif
 
 class cmFileLockResult;
@@ -29,7 +29,7 @@ class cmFileLockResult;
   */
 class cmFileLock
 {
- public:
+public:
   cmFileLock();
   ~cmFileLock();
 
@@ -51,7 +51,7 @@ class cmFileLock
     */
   bool IsLocked(const std::string& filename) const;
 
- private:
+private:
   cmFileLock(const cmFileLock&);
   cmFileLock& operator=(const cmFileLock&);
 
diff --git a/Source/cmFileLockPool.cxx b/Source/cmFileLockPool.cxx
index 939a8f5..7c51459 100644
--- a/Source/cmFileLockPool.cxx
+++ b/Source/cmFileLockPool.cxx
@@ -52,85 +52,73 @@ void cmFileLockPool::PopFileScope()
   this->FileScopes.pop_back();
 }
 
-cmFileLockResult cmFileLockPool::LockFunctionScope(
-    const std::string& filename, unsigned long timeoutSec)
+cmFileLockResult cmFileLockPool::LockFunctionScope(const std::string& filename,
+                                                   unsigned long timeoutSec)
 {
-  if (this->IsAlreadyLocked(filename))
-    {
+  if (this->IsAlreadyLocked(filename)) {
     return cmFileLockResult::MakeAlreadyLocked();
-    }
-  if (this->FunctionScopes.empty())
-    {
+  }
+  if (this->FunctionScopes.empty()) {
     return cmFileLockResult::MakeNoFunction();
-    }
+  }
   return this->FunctionScopes.back()->Lock(filename, timeoutSec);
 }
 
-cmFileLockResult cmFileLockPool::LockFileScope(
-    const std::string& filename, unsigned long timeoutSec)
+cmFileLockResult cmFileLockPool::LockFileScope(const std::string& filename,
+                                               unsigned long timeoutSec)
 {
-  if (this->IsAlreadyLocked(filename))
-    {
+  if (this->IsAlreadyLocked(filename)) {
     return cmFileLockResult::MakeAlreadyLocked();
-    }
+  }
   assert(!this->FileScopes.empty());
   return this->FileScopes.back()->Lock(filename, timeoutSec);
 }
 
-cmFileLockResult cmFileLockPool::LockProcessScope(
-    const std::string& filename, unsigned long timeoutSec)
+cmFileLockResult cmFileLockPool::LockProcessScope(const std::string& filename,
+                                                  unsigned long timeoutSec)
 {
-  if (this->IsAlreadyLocked(filename))
-    {
+  if (this->IsAlreadyLocked(filename)) {
     return cmFileLockResult::MakeAlreadyLocked();
-    }
+  }
   return this->ProcessScope.Lock(filename, timeoutSec);
 }
 
 cmFileLockResult cmFileLockPool::Release(const std::string& filename)
 {
-  for (It i = this->FunctionScopes.begin();
-      i != this->FunctionScopes.end(); ++i)
-    {
+  for (It i = this->FunctionScopes.begin(); i != this->FunctionScopes.end();
+       ++i) {
     const cmFileLockResult result = (*i)->Release(filename);
-    if (!result.IsOk())
-      {
+    if (!result.IsOk()) {
       return result;
-      }
     }
+  }
 
-  for (It i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i)
-    {
+  for (It i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i) {
     const cmFileLockResult result = (*i)->Release(filename);
-    if (!result.IsOk())
-      {
+    if (!result.IsOk()) {
       return result;
-      }
     }
+  }
 
   return this->ProcessScope.Release(filename);
 }
 
 bool cmFileLockPool::IsAlreadyLocked(const std::string& filename) const
 {
-  for (CIt i = this->FunctionScopes.begin();
-      i != this->FunctionScopes.end(); ++i)
-    {
+  for (CIt i = this->FunctionScopes.begin(); i != this->FunctionScopes.end();
+       ++i) {
     const bool result = (*i)->IsAlreadyLocked(filename);
-    if (result)
-      {
+    if (result) {
       return true;
-      }
     }
+  }
 
-  for (CIt i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i)
-    {
+  for (CIt i = this->FileScopes.begin(); i != this->FileScopes.end(); ++i) {
     const bool result = (*i)->IsAlreadyLocked(filename);
-    if (result)
-      {
+    if (result) {
       return true;
-      }
     }
+  }
 
   return this->ProcessScope.IsAlreadyLocked(filename);
 }
@@ -144,45 +132,38 @@ cmFileLockPool::ScopePool::~ScopePool()
   cmDeleteAll(this->Locks);
 }
 
-cmFileLockResult cmFileLockPool::ScopePool::Lock(
-    const std::string& filename, unsigned long timeoutSec)
+cmFileLockResult cmFileLockPool::ScopePool::Lock(const std::string& filename,
+                                                 unsigned long timeoutSec)
 {
-  cmFileLock *lock = new cmFileLock();
+  cmFileLock* lock = new cmFileLock();
   const cmFileLockResult result = lock->Lock(filename, timeoutSec);
-  if (result.IsOk())
-    {
+  if (result.IsOk()) {
     this->Locks.push_back(lock);
     return cmFileLockResult::MakeOk();
-    }
-  else
-    {
+  } else {
     delete lock;
     return result;
-    }
+  }
 }
 
 cmFileLockResult cmFileLockPool::ScopePool::Release(
-    const std::string& filename)
+  const std::string& filename)
 {
-  for (It i = this->Locks.begin(); i != this->Locks.end(); ++i)
-    {
-    if ((*i)->IsLocked(filename))
-      {
+  for (It i = this->Locks.begin(); i != this->Locks.end(); ++i) {
+    if ((*i)->IsLocked(filename)) {
       return (*i)->Release();
-      }
     }
+  }
   return cmFileLockResult::MakeOk();
 }
 
 bool cmFileLockPool::ScopePool::IsAlreadyLocked(
-    const std::string& filename) const
+  const std::string& filename) const
 {
-  for (CIt i = this->Locks.begin(); i != this->Locks.end(); ++i)
-    {
-    if ((*i)->IsLocked(filename))
-      {
+  for (CIt i = this->Locks.begin(); i != this->Locks.end(); ++i) {
+    if ((*i)->IsLocked(filename)) {
       return true;
-      }
     }
+  }
   return false;
 }
diff --git a/Source/cmFileLockPool.h b/Source/cmFileLockPool.h
index f0614a3..dc42e6f 100644
--- a/Source/cmFileLockPool.h
+++ b/Source/cmFileLockPool.h
@@ -21,7 +21,7 @@ class cmFileLock;
 
 class cmFileLockPool
 {
- public:
+public:
   cmFileLockPool();
   ~cmFileLockPool();
 
@@ -46,15 +46,12 @@ class cmFileLockPool
     * @brief Lock the file in given scope.
     * @param timeoutSec Lock timeout. If -1 try until success or fatal error.
     */
-  cmFileLockResult LockFunctionScope(
-      const std::string& filename, unsigned long timeoutSec
-  );
-  cmFileLockResult LockFileScope(
-      const std::string& filename, unsigned long timeoutSec
-  );
-  cmFileLockResult LockProcessScope(
-      const std::string& filename, unsigned long timeoutSec
-  );
+  cmFileLockResult LockFunctionScope(const std::string& filename,
+                                     unsigned long timeoutSec);
+  cmFileLockResult LockFileScope(const std::string& filename,
+                                 unsigned long timeoutSec);
+  cmFileLockResult LockProcessScope(const std::string& filename,
+                                    unsigned long timeoutSec);
   //@}
 
   /**
@@ -62,7 +59,7 @@ class cmFileLockPool
     */
   cmFileLockResult Release(const std::string& filename);
 
- private:
+private:
   cmFileLockPool(const cmFileLockPool&);
   cmFileLockPool& operator=(const cmFileLockPool&);
 
@@ -70,17 +67,16 @@ class cmFileLockPool
 
   class ScopePool
   {
-   public:
+  public:
     ScopePool();
     ~ScopePool();
 
-    cmFileLockResult Lock(
-        const std::string& filename, unsigned long timeoutSec
-    );
+    cmFileLockResult Lock(const std::string& filename,
+                          unsigned long timeoutSec);
     cmFileLockResult Release(const std::string& filename);
     bool IsAlreadyLocked(const std::string& filename) const;
 
-   private:
+  private:
     ScopePool(const ScopePool&);
     ScopePool& operator=(const ScopePool&);
 
diff --git a/Source/cmFileLockResult.cxx b/Source/cmFileLockResult.cxx
index 045e7ee..090fe60 100644
--- a/Source/cmFileLockResult.cxx
+++ b/Source/cmFileLockResult.cxx
@@ -56,40 +56,29 @@ bool cmFileLockResult::IsOk() const
 
 std::string cmFileLockResult::GetOutputMessage() const
 {
-  switch (this->Type)
-    {
+  switch (this->Type) {
     case OK:
       return "0";
     case SYSTEM:
 #if defined(_WIN32)
-      {
+    {
       char* errorText = NULL;
 
       // http://stackoverflow.com/a/455533/2288008
       DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM |
-          FORMAT_MESSAGE_ALLOCATE_BUFFER |
-          FORMAT_MESSAGE_IGNORE_INSERTS;
-      ::FormatMessageA(
-          flags,
-          NULL,
-          this->ErrorValue,
-          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-          (LPSTR)&errorText,
-          0,
-          NULL
-      );
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS;
+      ::FormatMessageA(flags, NULL, this->ErrorValue,
+                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                       (LPSTR)&errorText, 0, NULL);
 
-      if (errorText != NULL)
-        {
+      if (errorText != NULL) {
         const std::string message = errorText;
         ::LocalFree(errorText);
         return message;
-        }
-      else
-        {
+      } else {
         return "Internal error (FormatMessageA failed)";
-        }
       }
+    }
 #else
       return strerror(this->ErrorValue);
 #endif
@@ -102,10 +91,11 @@ std::string cmFileLockResult::GetOutputMessage() const
     case INTERNAL:
     default:
       return "Internal error";
-    }
+  }
 }
 
-cmFileLockResult::cmFileLockResult(ErrorType typeValue, Error errorValue):
-    Type(typeValue), ErrorValue(errorValue)
+cmFileLockResult::cmFileLockResult(ErrorType typeValue, Error errorValue)
+  : Type(typeValue)
+  , ErrorValue(errorValue)
 {
 }
diff --git a/Source/cmFileLockResult.h b/Source/cmFileLockResult.h
index 531fb49..d5ac354 100644
--- a/Source/cmFileLockResult.h
+++ b/Source/cmFileLockResult.h
@@ -16,7 +16,7 @@
 #include "cmStandardIncludes.h"
 
 #if defined(_WIN32)
-# include <windows.h> // DWORD
+#include <windows.h> // DWORD
 #endif
 
 /**
@@ -25,7 +25,7 @@
   */
 class cmFileLockResult
 {
- public:
+public:
 #if defined(_WIN32)
   typedef DWORD Error;
 #else
@@ -65,7 +65,7 @@ class cmFileLockResult
   bool IsOk() const;
   std::string GetOutputMessage() const;
 
- private:
+private:
   enum ErrorType
   {
     OK,
diff --git a/Source/cmFileLockUnix.cxx b/Source/cmFileLockUnix.cxx
index f5e77be..6be6abc 100644
--- a/Source/cmFileLockUnix.cxx
+++ b/Source/cmFileLockUnix.cxx
@@ -18,16 +18,16 @@
 #include <stdio.h> // SEEK_SET
 #include <unistd.h>
 
-cmFileLock::cmFileLock(): File(-1)
+cmFileLock::cmFileLock()
+  : File(-1)
 {
 }
 
 cmFileLockResult cmFileLock::Release()
 {
-  if (this->Filename.empty())
-    {
+  if (this->Filename.empty()) {
     return cmFileLockResult::MakeOk();
-    }
+  }
   const int lockResult = this->LockFile(F_SETLK, F_UNLCK);
 
   this->Filename = "";
@@ -35,71 +35,56 @@ cmFileLockResult cmFileLock::Release()
   ::close(this->File);
   this->File = -1;
 
-  if (lockResult == 0)
-    {
+  if (lockResult == 0) {
     return cmFileLockResult::MakeOk();
-    }
-  else
-    {
+  } else {
     return cmFileLockResult::MakeSystem();
-    }
+  }
 }
 
 cmFileLockResult cmFileLock::OpenFile()
 {
   this->File = ::open(this->Filename.c_str(), O_RDWR);
-  if (this->File == -1)
-    {
+  if (this->File == -1) {
     return cmFileLockResult::MakeSystem();
-    }
-  else
-    {
+  } else {
     return cmFileLockResult::MakeOk();
-    }
+  }
 }
 
 cmFileLockResult cmFileLock::LockWithoutTimeout()
 {
-  if (this->LockFile(F_SETLKW, F_WRLCK) == -1)
-    {
+  if (this->LockFile(F_SETLKW, F_WRLCK) == -1) {
     return cmFileLockResult::MakeSystem();
-    }
-  else
-    {
+  } else {
     return cmFileLockResult::MakeOk();
-    }
+  }
 }
 
 cmFileLockResult cmFileLock::LockWithTimeout(unsigned long seconds)
 {
-  while (true)
-    {
-    if (this->LockFile(F_SETLK, F_WRLCK) == -1)
-      {
-      if (errno != EACCES && errno != EAGAIN)
-        {
+  while (true) {
+    if (this->LockFile(F_SETLK, F_WRLCK) == -1) {
+      if (errno != EACCES && errno != EAGAIN) {
         return cmFileLockResult::MakeSystem();
-        }
       }
-    else
-      {
+    } else {
       return cmFileLockResult::MakeOk();
-      }
-    if (seconds == 0)
-      {
+    }
+    if (seconds == 0) {
       return cmFileLockResult::MakeTimeout();
-      }
+    }
     --seconds;
     cmSystemTools::Delay(1000);
-    }
+  }
 }
 
 int cmFileLock::LockFile(int cmd, int type)
 {
   struct ::flock lock;
   lock.l_start = 0;
-  lock.l_len = 0; // lock all bytes
-  lock.l_pid = 0; // unused (for F_GETLK only)
+  lock.l_len = 0;                         // lock all bytes
+  lock.l_pid = 0;                         // unused (for F_GETLK only)
   lock.l_type = static_cast<short>(type); // exclusive lock
   lock.l_whence = SEEK_SET;
   return ::fcntl(this->File, cmd, &lock);
diff --git a/Source/cmFileLockWin32.cxx b/Source/cmFileLockWin32.cxx
index e40ae2c..0ba1e9a 100644
--- a/Source/cmFileLockWin32.cxx
+++ b/Source/cmFileLockWin32.cxx
@@ -15,40 +15,32 @@
 #include "cmSystemTools.h"
 #include <windows.h> // CreateFileW
 
-cmFileLock::cmFileLock(): File(INVALID_HANDLE_VALUE)
+cmFileLock::cmFileLock()
+  : File(INVALID_HANDLE_VALUE)
 {
 }
 
 cmFileLockResult cmFileLock::Release()
 {
-  if (this->Filename.empty())
-    {
+  if (this->Filename.empty()) {
     return cmFileLockResult::MakeOk();
-    }
+  }
   const unsigned long len = static_cast<unsigned long>(-1);
   static OVERLAPPED overlapped;
   const DWORD reserved = 0;
-  const BOOL unlockResult = UnlockFileEx(
-      File,
-      reserved,
-      len,
-      len,
-      &overlapped
-  );
+  const BOOL unlockResult =
+    UnlockFileEx(File, reserved, len, len, &overlapped);
 
   this->Filename = "";
 
   CloseHandle(this->File);
   this->File = INVALID_HANDLE_VALUE;
 
-  if (unlockResult)
-    {
+  if (unlockResult) {
     return cmFileLockResult::MakeOk();
-    }
-  else
-    {
+  } else {
     return cmFileLockResult::MakeSystem();
-    }
+  }
 }
 
 cmFileLockResult cmFileLock::OpenFile()
@@ -59,58 +51,42 @@ cmFileLockResult cmFileLock::OpenFile()
   const DWORD attr = 0;
   const HANDLE templ = NULL;
   this->File = CreateFileW(
-      cmSystemTools::ConvertToWindowsExtendedPath(this->Filename).c_str(),
-      access,
-      shareMode,
-      security,
-      OPEN_EXISTING,
-      attr,
-      templ
-  );
-  if (this->File == INVALID_HANDLE_VALUE)
-    {
+    cmSystemTools::ConvertToWindowsExtendedPath(this->Filename).c_str(),
+    access, shareMode, security, OPEN_EXISTING, attr, templ);
+  if (this->File == INVALID_HANDLE_VALUE) {
     return cmFileLockResult::MakeSystem();
-    }
-  else
-    {
+  } else {
     return cmFileLockResult::MakeOk();
-    }
+  }
 }
 
 cmFileLockResult cmFileLock::LockWithoutTimeout()
 {
-  if (!this->LockFile(LOCKFILE_EXCLUSIVE_LOCK))
-    {
+  if (!this->LockFile(LOCKFILE_EXCLUSIVE_LOCK)) {
     return cmFileLockResult::MakeSystem();
-    }
-  else
-    {
+  } else {
     return cmFileLockResult::MakeOk();
-    }
+  }
 }
 
 cmFileLockResult cmFileLock::LockWithTimeout(unsigned long seconds)
 {
   const DWORD flags = LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY;
-  while (true)
-    {
+  while (true) {
     const BOOL result = this->LockFile(flags);
-    if (result)
-      {
+    if (result) {
       return cmFileLockResult::MakeOk();
-      }
+    }
     const DWORD error = GetLastError();
-    if (error != ERROR_LOCK_VIOLATION)
-      {
+    if (error != ERROR_LOCK_VIOLATION) {
       return cmFileLockResult::MakeSystem();
-      }
-    if (seconds == 0)
-      {
+    }
+    if (seconds == 0) {
       return cmFileLockResult::MakeTimeout();
-      }
+    }
     --seconds;
     cmSystemTools::Delay(1000);
-    }
+  }
 }
 
 BOOL cmFileLock::LockFile(DWORD flags)
@@ -118,12 +94,5 @@ BOOL cmFileLock::LockFile(DWORD flags)
   const DWORD reserved = 0;
   const unsigned long len = static_cast<unsigned long>(-1);
   static OVERLAPPED overlapped;
-  return LockFileEx(
-      this->File,
-      flags,
-      reserved,
-      len,
-      len,
-      &overlapped
-  );
+  return LockFileEx(this->File, flags, reserved, len, len, &overlapped);
 }
diff --git a/Source/cmFileTimeComparison.cxx b/Source/cmFileTimeComparison.cxx
index 88b5d99..7efe194 100644
--- a/Source/cmFileTimeComparison.cxx
+++ b/Source/cmFileTimeComparison.cxx
@@ -16,7 +16,7 @@
 #ifdef CMake_HAVE_CXX11_UNORDERED_MAP
 #include <unordered_map>
 #else
-# include <cmsys/hash_map.hxx>
+#include <cmsys/hash_map.hxx>
 #endif
 #endif
 
@@ -24,12 +24,12 @@
 
 // Use a platform-specific API to get file times efficiently.
 #if !defined(_WIN32) || defined(__CYGWIN__)
-#  define cmFileTimeComparison_Type struct stat
-#  include <ctype.h>
-#  include <sys/stat.h>
+#define cmFileTimeComparison_Type struct stat
+#include <ctype.h>
+#include <sys/stat.h>
 #else
-#  define cmFileTimeComparison_Type FILETIME
-#  include <windows.h>
+#define cmFileTimeComparison_Type FILETIME
+#include <windows.h>
 #endif
 
 class cmFileTimeComparisonInternal
@@ -44,24 +44,22 @@ private:
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   // Use a hash table to efficiently map from file name to modification time.
   class HashString
-    {
+  {
   public:
-    size_t operator()(const std::string& s) const
-      {
-      return h(s.c_str());
-      }
+    size_t operator()(const std::string& s) const { return h(s.c_str()); }
 #ifdef CMake_HAVE_CXX11_UNORDERED_MAP
     std::hash<const char*> h;
 #else
     cmsys::hash<const char*> h;
 #endif
-    };
+  };
 #ifdef CMake_HAVE_CXX11_UNORDERED_MAP
   typedef std::unordered_map<std::string,
 #else
   typedef cmsys::hash_map<std::string,
 #endif
-                          cmFileTimeComparison_Type, HashString> FileStatsMap;
+                             cmFileTimeComparison_Type, HashString>
+    FileStatsMap;
   FileStatsMap Files;
 #endif
 
@@ -80,29 +78,26 @@ bool cmFileTimeComparisonInternal::Stat(const char* fname,
   // Use the stored time if available.
   cmFileTimeComparisonInternal::FileStatsMap::iterator fit =
     this->Files.find(fname);
-  if ( fit != this->Files.end() )
-    {
+  if (fit != this->Files.end()) {
     *st = fit->second;
     return true;
-    }
+  }
 #endif
 
 #if !defined(_WIN32) || defined(__CYGWIN__)
   // POSIX version.  Use the stat function.
   int res = ::stat(fname, st);
-  if ( res != 0 )
-    {
+  if (res != 0) {
     return false;
-    }
+  }
 #else
   // Windows version.  Get the modification time from extended file
   // attributes.
   WIN32_FILE_ATTRIBUTE_DATA fdata;
-  if(!GetFileAttributesExW(cmsys::Encoding::ToWide(fname).c_str(),
-                           GetFileExInfoStandard, &fdata))
-    {
+  if (!GetFileAttributesExW(cmsys::Encoding::ToWide(fname).c_str(),
+                            GetFileExInfoStandard, &fdata)) {
     return false;
-    }
+  }
 
   // Copy the file time to the output location.
   *st = fdata.ftLastWriteTime;
@@ -126,8 +121,8 @@ cmFileTimeComparison::~cmFileTimeComparison()
   delete this->Internals;
 }
 
-bool cmFileTimeComparison::FileTimeCompare(const char* f1,
-                                           const char* f2, int* result)
+bool cmFileTimeComparison::FileTimeCompare(const char* f1, const char* f2,
+                                           int* result)
 {
   return this->Internals->FileTimeCompare(f1, f2, result);
 }
@@ -141,53 +136,36 @@ int cmFileTimeComparisonInternal::Compare(cmFileTimeComparison_Type* s1,
                                           cmFileTimeComparison_Type* s2)
 {
 #if !defined(_WIN32) || defined(__CYGWIN__)
-# if CMake_STAT_HAS_ST_MTIM
+#if CMake_STAT_HAS_ST_MTIM
   // Compare using nanosecond resolution.
-  if(s1->st_mtim.tv_sec < s2->st_mtim.tv_sec)
-    {
+  if (s1->st_mtim.tv_sec < s2->st_mtim.tv_sec) {
     return -1;
-    }
-  else if(s1->st_mtim.tv_sec > s2->st_mtim.tv_sec)
-    {
+  } else if (s1->st_mtim.tv_sec > s2->st_mtim.tv_sec) {
     return 1;
-    }
-  else if(s1->st_mtim.tv_nsec < s2->st_mtim.tv_nsec)
-    {
+  } else if (s1->st_mtim.tv_nsec < s2->st_mtim.tv_nsec) {
     return -1;
-    }
-  else if(s1->st_mtim.tv_nsec > s2->st_mtim.tv_nsec)
-    {
+  } else if (s1->st_mtim.tv_nsec > s2->st_mtim.tv_nsec) {
     return 1;
-    }
-# elif CMake_STAT_HAS_ST_MTIMESPEC
+  }
+#elif CMake_STAT_HAS_ST_MTIMESPEC
   // Compare using nanosecond resolution.
-  if(s1->st_mtimespec.tv_sec < s2->st_mtimespec.tv_sec)
-    {
+  if (s1->st_mtimespec.tv_sec < s2->st_mtimespec.tv_sec) {
     return -1;
-    }
-  else if(s1->st_mtimespec.tv_sec > s2->st_mtimespec.tv_sec)
-    {
+  } else if (s1->st_mtimespec.tv_sec > s2->st_mtimespec.tv_sec) {
     return 1;
-    }
-  else if(s1->st_mtimespec.tv_nsec < s2->st_mtimespec.tv_nsec)
-    {
+  } else if (s1->st_mtimespec.tv_nsec < s2->st_mtimespec.tv_nsec) {
     return -1;
-    }
-  else if(s1->st_mtimespec.tv_nsec > s2->st_mtimespec.tv_nsec)
-    {
+  } else if (s1->st_mtimespec.tv_nsec > s2->st_mtimespec.tv_nsec) {
     return 1;
-    }
-# else
+  }
+#else
   // Compare using 1 second resolution.
-  if(s1->st_mtime < s2->st_mtime)
-    {
+  if (s1->st_mtime < s2->st_mtime) {
     return -1;
-    }
-  else if(s1->st_mtime > s2->st_mtime)
-    {
+  } else if (s1->st_mtime > s2->st_mtime) {
     return 1;
-    }
-# endif
+  }
+#endif
   // Files have the same time.
   return 0;
 #else
@@ -200,55 +178,40 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
                                                cmFileTimeComparison_Type* s2)
 {
 #if !defined(_WIN32) || defined(__CYGWIN__)
-# if CMake_STAT_HAS_ST_MTIM
+#if CMake_STAT_HAS_ST_MTIM
   // Times are integers in units of 1ns.
   long long bil = 1000000000;
   long long t1 = s1->st_mtim.tv_sec * bil + s1->st_mtim.tv_nsec;
   long long t2 = s2->st_mtim.tv_sec * bil + s2->st_mtim.tv_nsec;
-  if(t1 < t2)
-    {
+  if (t1 < t2) {
     return (t2 - t1) >= bil;
-    }
-  else if(t2 < t1)
-    {
+  } else if (t2 < t1) {
     return (t1 - t2) >= bil;
-    }
-  else
-    {
+  } else {
     return false;
-    }
-# elif CMake_STAT_HAS_ST_MTIMESPEC
+  }
+#elif CMake_STAT_HAS_ST_MTIMESPEC
   // Times are integers in units of 1ns.
   long long bil = 1000000000;
   long long t1 = s1->st_mtimespec.tv_sec * bil + s1->st_mtimespec.tv_nsec;
   long long t2 = s2->st_mtimespec.tv_sec * bil + s2->st_mtimespec.tv_nsec;
-  if(t1 < t2)
-    {
+  if (t1 < t2) {
     return (t2 - t1) >= bil;
-    }
-  else if(t2 < t1)
-    {
+  } else if (t2 < t1) {
     return (t1 - t2) >= bil;
-    }
-  else
-    {
+  } else {
     return false;
-    }
-# else
+  }
+#else
   // Times are integers in units of 1s.
-  if(s1->st_mtime < s2->st_mtime)
-    {
+  if (s1->st_mtime < s2->st_mtime) {
     return (s2->st_mtime - s1->st_mtime) >= 1;
-    }
-  else if(s1->st_mtime > s2->st_mtime)
-    {
+  } else if (s1->st_mtime > s2->st_mtime) {
     return (s1->st_mtime - s2->st_mtime) >= 1;
-    }
-  else
-    {
+  } else {
     return false;
-    }
-# endif
+  }
+#endif
 #else
   // Times are integers in units of 100ns.
   LARGE_INTEGER t1;
@@ -257,41 +220,31 @@ bool cmFileTimeComparisonInternal::TimesDiffer(cmFileTimeComparison_Type* s1,
   t1.HighPart = s1->dwHighDateTime;
   t2.LowPart = s2->dwLowDateTime;
   t2.HighPart = s2->dwHighDateTime;
-  if(t1.QuadPart < t2.QuadPart)
-    {
+  if (t1.QuadPart < t2.QuadPart) {
     return (t2.QuadPart - t1.QuadPart) >= static_cast<LONGLONG>(10000000);
-    }
-  else if(t2.QuadPart < t1.QuadPart)
-    {
+  } else if (t2.QuadPart < t1.QuadPart) {
     return (t1.QuadPart - t2.QuadPart) >= static_cast<LONGLONG>(10000000);
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 #endif
 }
 
 bool cmFileTimeComparisonInternal::FileTimeCompare(const char* f1,
-                                                   const char* f2,
-                                                   int* result)
+                                                   const char* f2, int* result)
 {
   // Get the modification time for each file.
   cmFileTimeComparison_Type s1;
   cmFileTimeComparison_Type s2;
-  if(this->Stat(f1, &s1) &&
-     this->Stat(f2, &s2))
-    {
+  if (this->Stat(f1, &s1) && this->Stat(f2, &s2)) {
     // Compare the two modification times.
     *result = this->Compare(&s1, &s2);
     return true;
-    }
-  else
-    {
+  } else {
     // No comparison available.  Default to the same time.
     *result = 0;
     return false;
-    }
+  }
 }
 
 bool cmFileTimeComparisonInternal::FileTimesDiffer(const char* f1,
@@ -300,15 +253,11 @@ bool cmFileTimeComparisonInternal::FileTimesDiffer(const char* f1,
   // Get the modification time for each file.
   cmFileTimeComparison_Type s1;
   cmFileTimeComparison_Type s2;
-  if(this->Stat(f1, &s1) &&
-     this->Stat(f2, &s2))
-    {
+  if (this->Stat(f1, &s1) && this->Stat(f2, &s2)) {
     // Compare the two modification times.
     return this->TimesDiffer(&s1, &s2);
-    }
-  else
-    {
+  } else {
     // No comparison available.  Default to different times.
     return true;
-    }
+  }
 }
diff --git a/Source/cmFileTimeComparison.h b/Source/cmFileTimeComparison.h
index cc1ef63..409bd64 100644
--- a/Source/cmFileTimeComparison.h
+++ b/Source/cmFileTimeComparison.h
@@ -42,10 +42,7 @@ public:
   bool FileTimesDiffer(const char* f1, const char* f2);
 
 protected:
-
   cmFileTimeComparisonInternal* Internals;
 };
 
-
 #endif
-
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index 995097f..082bbf0 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -24,59 +24,46 @@ cmFindBase::cmFindBase()
 
 bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
 {
-  if(argsIn.size() < 2 )
-    {
+  if (argsIn.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // copy argsIn into args so it can be modified,
   // in the process extract the DOC "documentation"
   size_t size = argsIn.size();
   std::vector<std::string> args;
   bool foundDoc = false;
-  for(unsigned int j = 0; j < size; ++j)
-    {
-    if(foundDoc  || argsIn[j] != "DOC" )
-      {
-      if(argsIn[j] == "ENV")
-        {
-        if(j+1 < size)
-          {
+  for (unsigned int j = 0; j < size; ++j) {
+    if (foundDoc || argsIn[j] != "DOC") {
+      if (argsIn[j] == "ENV") {
+        if (j + 1 < size) {
           j++;
           cmSystemTools::GetPath(args, argsIn[j].c_str());
-          }
         }
-      else
-        {
+      } else {
         args.push_back(argsIn[j]);
-        }
       }
-    else
-      {
-      if(j+1 < size)
-        {
+    } else {
+      if (j + 1 < size) {
         foundDoc = true;
-        this->VariableDocumentation = argsIn[j+1];
+        this->VariableDocumentation = argsIn[j + 1];
         j++;
-        if(j >= size)
-          {
+        if (j >= size) {
           break;
-          }
         }
       }
     }
-  if(args.size() < 2 )
-    {
+  }
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   this->VariableName = args[0];
-  if(this->CheckForVariableInCache())
-    {
+  if (this->CheckForVariableInCache()) {
     this->AlreadyInCache = true;
     return true;
-    }
+  }
   this->AlreadyInCache = false;
 
   // Find the current root path mode.
@@ -86,107 +73,81 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
   this->SelectDefaultMacMode();
 
   bool newStyle = false;
-  enum Doing { DoingNone, DoingNames, DoingPaths, DoingPathSuffixes,
-               DoingHints };
+  enum Doing
+  {
+    DoingNone,
+    DoingNames,
+    DoingPaths,
+    DoingPathSuffixes,
+    DoingHints
+  };
   Doing doing = DoingNames; // assume it starts with a name
-  for (unsigned int j = 1; j < args.size(); ++j)
-    {
-    if(args[j] == "NAMES")
-      {
+  for (unsigned int j = 1; j < args.size(); ++j) {
+    if (args[j] == "NAMES") {
       doing = DoingNames;
       newStyle = true;
-      }
-    else if (args[j] == "PATHS")
-      {
+    } else if (args[j] == "PATHS") {
       doing = DoingPaths;
       newStyle = true;
-      }
-    else if (args[j] == "HINTS")
-      {
+    } else if (args[j] == "HINTS") {
       doing = DoingHints;
       newStyle = true;
-      }
-    else if (args[j] == "PATH_SUFFIXES")
-      {
+    } else if (args[j] == "PATH_SUFFIXES") {
       doing = DoingPathSuffixes;
       newStyle = true;
-      }
-    else if (args[j] == "NAMES_PER_DIR")
-      {
+    } else if (args[j] == "NAMES_PER_DIR") {
       doing = DoingNone;
-      if(this->NamesPerDirAllowed)
-        {
+      if (this->NamesPerDirAllowed) {
         this->NamesPerDir = true;
-        }
-      else
-        {
+      } else {
         this->SetError("does not support NAMES_PER_DIR");
         return false;
-        }
       }
-    else if (args[j] == "NO_SYSTEM_PATH")
-      {
+    } else if (args[j] == "NO_SYSTEM_PATH") {
       doing = DoingNone;
       this->NoDefaultPath = true;
-      }
-    else if (this->CheckCommonArgument(args[j]))
-      {
+    } else if (this->CheckCommonArgument(args[j])) {
       doing = DoingNone;
       // Some common arguments were accidentally supported by CMake
       // 2.4 and 2.6.0 in the short-hand form of the command, so we
       // must support it even though it is not documented.
-      }
-    else if(doing == DoingNames)
-      {
+    } else if (doing == DoingNames) {
       this->Names.push_back(args[j]);
-      }
-    else if(doing == DoingPaths)
-      {
+    } else if (doing == DoingPaths) {
       this->UserGuessArgs.push_back(args[j]);
-      }
-    else if(doing == DoingHints)
-      {
+    } else if (doing == DoingHints) {
       this->UserHintsArgs.push_back(args[j]);
-      }
-    else if(doing == DoingPathSuffixes)
-      {
+    } else if (doing == DoingPathSuffixes) {
       this->AddPathSuffix(args[j]);
-      }
     }
+  }
 
-  if(this->VariableDocumentation.empty())
-    {
+  if (this->VariableDocumentation.empty()) {
     this->VariableDocumentation = "Where can ";
-    if(this->Names.empty())
-      {
+    if (this->Names.empty()) {
       this->VariableDocumentation += "the (unknown) library be found";
-      }
-    else if(this->Names.size() == 1)
-      {
-      this->VariableDocumentation += "the "
-        + this->Names[0] + " library be found";
-      }
-    else
-      {
+    } else if (this->Names.size() == 1) {
+      this->VariableDocumentation +=
+        "the " + this->Names[0] + " library be found";
+    } else {
       this->VariableDocumentation += "one of the ";
       this->VariableDocumentation +=
         cmJoin(cmMakeRange(this->Names).retreat(1), ", ");
-      this->VariableDocumentation += " or "
-        + this->Names[this->Names.size() - 1] + " libraries be found";
-      }
+      this->VariableDocumentation +=
+        " or " + this->Names[this->Names.size() - 1] + " libraries be found";
     }
+  }
 
   // look for old style
   // FIND_*(VAR name path1 path2 ...)
-  if(!newStyle)
-    {
+  if (!newStyle) {
     // All the short-hand arguments have been recorded as names.
     std::vector<std::string> shortArgs = this->Names;
     this->Names.clear(); // clear out any values in Names
     this->Names.push_back(shortArgs[0]);
     this->UserGuessArgs.insert(this->UserGuessArgs.end(),
                                shortArgs.begin() + 1, shortArgs.end());
-    }
+  }
   this->ExpandPaths();
 
   this->ComputeFinalPaths();
@@ -196,35 +157,29 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
 
 void cmFindBase::ExpandPaths()
 {
-  if(!this->NoDefaultPath)
-    {
-    if(!this->NoCMakePath)
-      {
+  if (!this->NoDefaultPath) {
+    if (!this->NoCMakePath) {
       this->FillCMakeVariablePath();
-      }
-    if(!this->NoCMakeEnvironmentPath)
-      {
+    }
+    if (!this->NoCMakeEnvironmentPath) {
       this->FillCMakeEnvironmentPath();
-      }
     }
+  }
   this->FillUserHintsPath();
-  if(!this->NoDefaultPath)
-    {
-    if(!this->NoSystemEnvironmentPath)
-      {
+  if (!this->NoDefaultPath) {
+    if (!this->NoSystemEnvironmentPath) {
       this->FillSystemEnvironmentPath();
-      }
-    if(!this->NoCMakeSystemPath)
-      {
+    }
+    if (!this->NoCMakeSystemPath) {
       this->FillCMakeSystemVariablePath();
-      }
     }
+  }
   this->FillUserGuessPath();
 }
 
 void cmFindBase::FillCMakeEnvironmentPath()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
 
   // Add CMAKE_*_PATH environment variables
   std::string var = "CMAKE_";
@@ -233,20 +188,17 @@ void cmFindBase::FillCMakeEnvironmentPath()
   paths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
   paths.AddEnvPath(var);
 
-  if(this->CMakePathName == "PROGRAM")
-    {
+  if (this->CMakePathName == "PROGRAM") {
     paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
-    }
-  else
-    {
+  } else {
     paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
-    }
+  }
   paths.AddSuffixes(this->SearchPathSuffixes);
 }
 
 void cmFindBase::FillCMakeVariablePath()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::CMake];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMake];
 
   // Add CMake varibles of the same name as the previous environment
   // varibles CMAKE_*_PATH to be used most of the time with -D
@@ -257,41 +209,35 @@ void cmFindBase::FillCMakeVariablePath()
   paths.AddCMakePrefixPath("CMAKE_PREFIX_PATH");
   paths.AddCMakePath(var);
 
-  if(this->CMakePathName == "PROGRAM")
-    {
+  if (this->CMakePathName == "PROGRAM") {
     paths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
-    }
-  else
-    {
+  } else {
     paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
-    }
+  }
   paths.AddSuffixes(this->SearchPathSuffixes);
 }
 
 void cmFindBase::FillSystemEnvironmentPath()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemEnvironment];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemEnvironment];
 
   // Add LIB or INCLUDE
-  if(!this->EnvironmentPath.empty())
-    {
+  if (!this->EnvironmentPath.empty()) {
     paths.AddEnvPath(this->EnvironmentPath);
 #if defined(_WIN32) || defined(__CYGWIN__)
     paths.AddEnvPrefixPath("PATH", true);
     paths.AddEnvPath("PATH");
 #endif
-    }
-  else
-    {
+  } else {
     // Add PATH
     paths.AddEnvPath("PATH");
-    }
+  }
   paths.AddSuffixes(this->SearchPathSuffixes);
 }
 
 void cmFindBase::FillCMakeSystemVariablePath()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeSystem];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeSystem];
 
   std::string var = "CMAKE_SYSTEM_";
   var += this->CMakePathName;
@@ -299,38 +245,35 @@ void cmFindBase::FillCMakeSystemVariablePath()
   paths.AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
   paths.AddCMakePath(var);
 
-  if(this->CMakePathName == "PROGRAM")
-    {
+  if (this->CMakePathName == "PROGRAM") {
     paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
-    }
-  else
-    {
+  } else {
     paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
-    }
+  }
   paths.AddSuffixes(this->SearchPathSuffixes);
 }
 
 void cmFindBase::FillUserHintsPath()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::Hints];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints];
 
-  for(std::vector<std::string>::const_iterator p = this->UserHintsArgs.begin();
-      p != this->UserHintsArgs.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p =
+         this->UserHintsArgs.begin();
+       p != this->UserHintsArgs.end(); ++p) {
     paths.AddUserPath(*p);
-    }
+  }
   paths.AddSuffixes(this->SearchPathSuffixes);
 }
 
 void cmFindBase::FillUserGuessPath()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::Guess];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess];
 
-  for(std::vector<std::string>::const_iterator p = this->UserGuessArgs.begin();
-      p != this->UserGuessArgs.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p =
+         this->UserGuessArgs.begin();
+       p != this->UserGuessArgs.end(); ++p) {
     paths.AddUserPath(*p);
-    }
+  }
   paths.AddSuffixes(this->SearchPathSuffixes);
 }
 
@@ -343,14 +286,13 @@ void cmFindBase::PrintFindStuff()
   std::cerr << "SearchAppBundleOnly: " << this->SearchAppBundleOnly << "\n";
   std::cerr << "SearchAppBundleFirst: " << this->SearchAppBundleFirst << "\n";
   std::cerr << "VariableName " << this->VariableName << "\n";
-  std::cerr << "VariableDocumentation "
-            << this->VariableDocumentation << "\n";
+  std::cerr << "VariableDocumentation " << this->VariableDocumentation << "\n";
   std::cerr << "NoDefaultPath " << this->NoDefaultPath << "\n";
-  std::cerr << "NoCMakeEnvironmentPath "
-            << this->NoCMakeEnvironmentPath << "\n";
+  std::cerr << "NoCMakeEnvironmentPath " << this->NoCMakeEnvironmentPath
+            << "\n";
   std::cerr << "NoCMakePath " << this->NoCMakePath << "\n";
-  std::cerr << "NoSystemEnvironmentPath "
-            << this->NoSystemEnvironmentPath << "\n";
+  std::cerr << "NoSystemEnvironmentPath " << this->NoSystemEnvironmentPath
+            << "\n";
   std::cerr << "NoCMakeSystemPath " << this->NoCMakeSystemPath << "\n";
   std::cerr << "EnvironmentPath " << this->EnvironmentPath << "\n";
   std::cerr << "CMakePathName " << this->CMakePathName << "\n";
@@ -364,32 +306,28 @@ void cmFindBase::PrintFindStuff()
 
 bool cmFindBase::CheckForVariableInCache()
 {
-  if(const char* cacheValue =
-     this->Makefile->GetDefinition(this->VariableName))
-    {
+  if (const char* cacheValue =
+        this->Makefile->GetDefinition(this->VariableName)) {
     cmState* state = this->Makefile->GetState();
     const char* cacheEntry = state->GetCacheEntryValue(this->VariableName);
     bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
     bool cached = cacheEntry ? true : false;
-    if(found)
-      {
+    if (found) {
       // If the user specifies the entry on the command line without a
       // type we should add the type and docstring but keep the
       // original value.  Tell the subclass implementations to do
       // this.
-      if(cached && state->GetCacheEntryType(this->VariableName)
-                                            == cmState::UNINITIALIZED)
-        {
+      if (cached &&
+          state->GetCacheEntryType(this->VariableName) ==
+            cmState::UNINITIALIZED) {
         this->AlreadyInCacheWithoutMetaInfo = true;
-        }
-      return true;
-      }
-    else if(cached)
-      {
-      const char* hs = state->GetCacheEntryProperty(this->VariableName,
-                                                     "HELPSTRING");
-      this->VariableDocumentation = hs?hs:"(none)";
       }
+      return true;
+    } else if (cached) {
+      const char* hs =
+        state->GetCacheEntryProperty(this->VariableName, "HELPSTRING");
+      this->VariableDocumentation = hs ? hs : "(none)";
     }
+  }
   return false;
 }
diff --git a/Source/cmFindBase.h b/Source/cmFindBase.h
index 8ca311d..054c33b 100644
--- a/Source/cmFindBase.h
+++ b/Source/cmFindBase.h
@@ -52,6 +52,7 @@ protected:
 
   bool AlreadyInCache;
   bool AlreadyInCacheWithoutMetaInfo;
+
 private:
   // Add pieces of the search.
   void FillCMakeVariablePath();
@@ -62,6 +63,4 @@ private:
   void FillUserGuessPath();
 };
 
-
-
 #endif
diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx
index 2758c18..638c1d1 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -16,11 +16,11 @@
 
 cmFindCommon::PathGroup cmFindCommon::PathGroup::All("ALL");
 cmFindCommon::PathLabel cmFindCommon::PathLabel::CMake("CMAKE");
-cmFindCommon::PathLabel
-  cmFindCommon::PathLabel::CMakeEnvironment("CMAKE_ENVIRONMENT");
+cmFindCommon::PathLabel cmFindCommon::PathLabel::CMakeEnvironment(
+  "CMAKE_ENVIRONMENT");
 cmFindCommon::PathLabel cmFindCommon::PathLabel::Hints("HINTS");
-cmFindCommon::PathLabel
-  cmFindCommon::PathLabel::SystemEnvironment("SYSTM_ENVIRONMENT");
+cmFindCommon::PathLabel cmFindCommon::PathLabel::SystemEnvironment(
+  "SYSTM_ENVIRONMENT");
 cmFindCommon::PathLabel cmFindCommon::PathLabel::CMakeSystem("CMAKE_SYSTEM");
 cmFindCommon::PathLabel cmFindCommon::PathLabel::Guess("GUESS");
 
@@ -33,8 +33,8 @@ cmFindCommon::cmFindCommon()
   this->NoSystemEnvironmentPath = false;
   this->NoCMakeSystemPath = false;
 
-  // OS X Bundle and Framework search policy.  The default is to
-  // search frameworks first on apple.
+// OS X Bundle and Framework search policy.  The default is to
+// search frameworks first on apple.
 #if defined(__APPLE__)
   this->SearchFrameworkFirst = true;
   this->SearchAppBundleFirst = true;
@@ -73,18 +73,18 @@ void cmFindCommon::InitializeSearchPathGroups()
   this->PathGroupOrder.push_back(PathGroup::All);
 
   // Create the idividual labeld search paths
-  this->LabeledPaths.insert(std::make_pair(PathLabel::CMake,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::CMakeEnvironment,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::Hints,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::SystemEnvironment,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::CMakeSystem,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::Guess,
-    cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::CMake, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::CMakeEnvironment, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::Hints, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::SystemEnvironment, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::CMakeSystem, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::Guess, cmSearchPath(this)));
 }
 
 void cmFindCommon::SelectDefaultRootPathMode()
@@ -94,73 +94,54 @@ void cmFindCommon::SelectDefaultRootPathMode()
   findRootPathVar += this->CMakePathName;
   std::string rootPathMode =
     this->Makefile->GetSafeDefinition(findRootPathVar);
-  if (rootPathMode=="NEVER")
-    {
+  if (rootPathMode == "NEVER") {
     this->FindRootPathMode = RootPathModeNever;
-    }
-  else if (rootPathMode=="ONLY")
-    {
+  } else if (rootPathMode == "ONLY") {
     this->FindRootPathMode = RootPathModeOnly;
-    }
-  else if (rootPathMode=="BOTH")
-    {
+  } else if (rootPathMode == "BOTH") {
     this->FindRootPathMode = RootPathModeBoth;
-    }
+  }
 }
 
 void cmFindCommon::SelectDefaultMacMode()
 {
   std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
-  if(ff == "NEVER")
-    {
+  if (ff == "NEVER") {
     this->SearchFrameworkLast = false;
     this->SearchFrameworkFirst = false;
     this->SearchFrameworkOnly = false;
-    }
-  else if(ff == "ONLY")
-    {
+  } else if (ff == "ONLY") {
     this->SearchFrameworkLast = false;
     this->SearchFrameworkFirst = false;
     this->SearchFrameworkOnly = true;
-    }
-  else if(ff == "FIRST")
-    {
+  } else if (ff == "FIRST") {
     this->SearchFrameworkLast = false;
     this->SearchFrameworkFirst = true;
     this->SearchFrameworkOnly = false;
-    }
-  else if(ff == "LAST")
-    {
+  } else if (ff == "LAST") {
     this->SearchFrameworkLast = true;
     this->SearchFrameworkFirst = false;
     this->SearchFrameworkOnly = false;
-    }
+  }
 
   std::string fab = this->Makefile->GetSafeDefinition("CMAKE_FIND_APPBUNDLE");
-  if(fab == "NEVER")
-    {
+  if (fab == "NEVER") {
     this->SearchAppBundleLast = false;
     this->SearchAppBundleFirst = false;
     this->SearchAppBundleOnly = false;
-    }
-  else if(fab == "ONLY")
-    {
+  } else if (fab == "ONLY") {
     this->SearchAppBundleLast = false;
     this->SearchAppBundleFirst = false;
     this->SearchAppBundleOnly = true;
-    }
-  else if(fab == "FIRST")
-    {
+  } else if (fab == "FIRST") {
     this->SearchAppBundleLast = false;
     this->SearchAppBundleFirst = true;
     this->SearchAppBundleOnly = false;
-    }
-  else if(fab == "LAST")
-    {
+  } else if (fab == "LAST") {
     this->SearchAppBundleLast = true;
     this->SearchAppBundleFirst = false;
     this->SearchAppBundleOnly = false;
-    }
+  }
 }
 
 void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
@@ -173,125 +154,105 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
     }
 #endif
   // Short-circuit if there is nothing to do.
-  if(this->FindRootPathMode == RootPathModeNever)
-    {
+  if (this->FindRootPathMode == RootPathModeNever) {
     return;
-    }
+  }
 
-  const char* sysroot =
-    this->Makefile->GetDefinition("CMAKE_SYSROOT");
-  const char* rootPath =
-    this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
+  const char* sysroot = this->Makefile->GetDefinition("CMAKE_SYSROOT");
+  const char* rootPath = this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
   const bool noSysroot = !sysroot || !*sysroot;
   const bool noRootPath = !rootPath || !*rootPath;
-  if(noSysroot && noRootPath)
-    {
+  if (noSysroot && noRootPath) {
     return;
-    }
+  }
 
   // Construct the list of path roots with no trailing slashes.
   std::vector<std::string> roots;
-  if (rootPath)
-    {
+  if (rootPath) {
     cmSystemTools::ExpandListArgument(rootPath, roots);
-    }
-  if (sysroot)
-    {
+  }
+  if (sysroot) {
     roots.push_back(sysroot);
-    }
-  for(std::vector<std::string>::iterator ri = roots.begin();
-      ri != roots.end(); ++ri)
-    {
+  }
+  for (std::vector<std::string>::iterator ri = roots.begin();
+       ri != roots.end(); ++ri) {
     cmSystemTools::ConvertToUnixSlashes(*ri);
-    }
+  }
 
   const char* stagePrefix =
-      this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
+    this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
 
   // Copy the original set of unrooted paths.
   std::vector<std::string> unrootedPaths = paths;
   paths.clear();
 
-  for(std::vector<std::string>::const_iterator ri = roots.begin();
-      ri != roots.end(); ++ri)
-    {
-    for(std::vector<std::string>::const_iterator ui = unrootedPaths.begin();
-        ui != unrootedPaths.end(); ++ui)
-      {
+  for (std::vector<std::string>::const_iterator ri = roots.begin();
+       ri != roots.end(); ++ri) {
+    for (std::vector<std::string>::const_iterator ui = unrootedPaths.begin();
+         ui != unrootedPaths.end(); ++ui) {
       // Place the unrooted path under the current root if it is not
       // already inside.  Skip the unrooted path if it is relative to
       // a user home directory or is empty.
       std::string rootedDir;
-      if(cmSystemTools::IsSubDirectory(*ui, *ri)
-          || (stagePrefix
-            && cmSystemTools::IsSubDirectory(*ui, stagePrefix)))
-        {
+      if (cmSystemTools::IsSubDirectory(*ui, *ri) ||
+          (stagePrefix && cmSystemTools::IsSubDirectory(*ui, stagePrefix))) {
         rootedDir = *ui;
-        }
-      else if(!ui->empty() && (*ui)[0] != '~')
-        {
+      } else if (!ui->empty() && (*ui)[0] != '~') {
         // Start with the new root.
         rootedDir = *ri;
         rootedDir += "/";
 
         // Append the original path with its old root removed.
         rootedDir += cmSystemTools::SplitPathRootComponent(*ui);
-        }
+      }
 
       // Store the new path.
       paths.push_back(rootedDir);
-      }
     }
+  }
 
   // If searching both rooted and unrooted paths add the original
   // paths again.
-  if(this->FindRootPathMode == RootPathModeBoth)
-    {
+  if (this->FindRootPathMode == RootPathModeBoth) {
     paths.insert(paths.end(), unrootedPaths.begin(), unrootedPaths.end());
-    }
+  }
 }
 
 void cmFindCommon::FilterPaths(const std::vector<std::string>& inPaths,
                                const std::set<std::string>& ignore,
                                std::vector<std::string>& outPaths)
 {
-  for(std::vector<std::string>::const_iterator i = inPaths.begin();
-      i != inPaths.end(); ++i)
-    {
-    if(ignore.count(*i) == 0)
-      {
+  for (std::vector<std::string>::const_iterator i = inPaths.begin();
+       i != inPaths.end(); ++i) {
+    if (ignore.count(*i) == 0) {
       outPaths.push_back(*i);
-      }
     }
+  }
 }
 
 void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore)
 {
   // null-terminated list of paths.
-  static const char *paths[] =
-    { "CMAKE_SYSTEM_IGNORE_PATH", "CMAKE_IGNORE_PATH", 0 };
+  static const char* paths[] = { "CMAKE_SYSTEM_IGNORE_PATH",
+                                 "CMAKE_IGNORE_PATH", 0 };
 
   // Construct the list of path roots with no trailing slashes.
-  for(const char **pathName = paths; *pathName; ++pathName)
-    {
+  for (const char** pathName = paths; *pathName; ++pathName) {
     // Get the list of paths to ignore from the variable.
     const char* ignorePath = this->Makefile->GetDefinition(*pathName);
-    if((ignorePath == 0) || (strlen(ignorePath) == 0))
-      {
+    if ((ignorePath == 0) || (strlen(ignorePath) == 0)) {
       continue;
-      }
+    }
 
     cmSystemTools::ExpandListArgument(ignorePath, ignore);
-    }
+  }
 
-  for(std::vector<std::string>::iterator i = ignore.begin();
-      i != ignore.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = ignore.begin();
+       i != ignore.end(); ++i) {
     cmSystemTools::ConvertToUnixSlashes(*i);
-    }
+  }
 }
 
-
 void cmFindCommon::GetIgnoredPaths(std::set<std::string>& ignore)
 {
   std::vector<std::string> ignoreVec;
@@ -301,43 +262,26 @@ void cmFindCommon::GetIgnoredPaths(std::set<std::string>& ignore)
 
 bool cmFindCommon::CheckCommonArgument(std::string const& arg)
 {
-  if(arg == "NO_DEFAULT_PATH")
-    {
+  if (arg == "NO_DEFAULT_PATH") {
     this->NoDefaultPath = true;
-    }
-  else if(arg == "NO_CMAKE_ENVIRONMENT_PATH")
-    {
+  } else if (arg == "NO_CMAKE_ENVIRONMENT_PATH") {
     this->NoCMakeEnvironmentPath = true;
-    }
-  else if(arg == "NO_CMAKE_PATH")
-    {
+  } else if (arg == "NO_CMAKE_PATH") {
     this->NoCMakePath = true;
-    }
-  else if(arg == "NO_SYSTEM_ENVIRONMENT_PATH")
-    {
+  } else if (arg == "NO_SYSTEM_ENVIRONMENT_PATH") {
     this->NoSystemEnvironmentPath = true;
-    }
-  else if(arg == "NO_CMAKE_SYSTEM_PATH")
-    {
+  } else if (arg == "NO_CMAKE_SYSTEM_PATH") {
     this->NoCMakeSystemPath = true;
-    }
-    else if(arg == "NO_CMAKE_FIND_ROOT_PATH")
-    {
+  } else if (arg == "NO_CMAKE_FIND_ROOT_PATH") {
     this->FindRootPathMode = RootPathModeNever;
-    }
-  else if(arg == "ONLY_CMAKE_FIND_ROOT_PATH")
-    {
+  } else if (arg == "ONLY_CMAKE_FIND_ROOT_PATH") {
     this->FindRootPathMode = RootPathModeOnly;
-    }
-  else if(arg == "CMAKE_FIND_ROOT_PATH_BOTH")
-    {
+  } else if (arg == "CMAKE_FIND_ROOT_PATH_BOTH") {
     this->FindRootPathMode = RootPathModeBoth;
-    }
-  else
-    {
+  } else {
     // The argument is not one of the above.
     return false;
-    }
+  }
 
   // The argument is one of the above.
   return true;
@@ -348,26 +292,21 @@ void cmFindCommon::AddPathSuffix(std::string const& arg)
   std::string suffix = arg;
 
   // Strip leading and trailing slashes.
-  if(suffix.empty())
-    {
+  if (suffix.empty()) {
     return;
-    }
-  if(suffix[0] == '/')
-    {
+  }
+  if (suffix[0] == '/') {
     suffix = suffix.substr(1, suffix.npos);
-    }
-  if(suffix.empty())
-    {
+  }
+  if (suffix.empty()) {
     return;
-    }
-  if(suffix[suffix.size()-1] == '/')
-    {
-    suffix = suffix.substr(0, suffix.size()-1);
-    }
-  if(suffix.empty())
-    {
+  }
+  if (suffix[suffix.size() - 1] == '/') {
+    suffix = suffix.substr(0, suffix.size() - 1);
+  }
+  if (suffix.empty()) {
     return;
-    }
+  }
 
   // Store the suffix.
   this->SearchPathSuffixes.push_back(suffix);
@@ -375,10 +314,9 @@ void cmFindCommon::AddPathSuffix(std::string const& arg)
 
 void AddTrailingSlash(std::string& s)
 {
-  if(!s.empty() && *s.rbegin() != '/')
-    {
+  if (!s.empty() && *s.rbegin() != '/') {
     s += '/';
-    }
+  }
 }
 void cmFindCommon::ComputeFinalPaths()
 {
@@ -389,11 +327,10 @@ void cmFindCommon::ComputeFinalPaths()
   // Combine the seperate path types, filtering out ignores
   this->SearchPaths.clear();
   std::vector<PathLabel>& allLabels = this->PathGroupLabelMap[PathGroup::All];
-  for(std::vector<PathLabel>::const_iterator l = allLabels.begin();
-      l != allLabels.end(); ++l)
-    {
+  for (std::vector<PathLabel>::const_iterator l = allLabels.begin();
+       l != allLabels.end(); ++l) {
     this->LabeledPaths[*l].ExtractWithout(ignored, this->SearchPaths);
-    }
+  }
 
   // Expand list of paths inside all search roots.
   this->RerootPaths(this->SearchPaths);
@@ -409,9 +346,8 @@ void cmFindCommon::SetMakefile(cmMakefile* makefile)
 
   // If we are building for Apple (OSX or also iphone), make sure
   // that frameworks and bundles are searched first.
-  if(this->Makefile->IsOn("APPLE"))
-    {
+  if (this->Makefile->IsOn("APPLE")) {
     this->SearchFrameworkFirst = true;
     this->SearchAppBundleFirst = true;
-    }
+  }
 }
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index 2b87427..ebec884 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -38,8 +38,12 @@ protected:
   {
   protected:
     PathGroup();
+
   public:
-    PathGroup(const std::string& label) : cmPathLabel(label) { }
+    PathGroup(const std::string& label)
+      : cmPathLabel(label)
+    {
+    }
     static PathGroup All;
   };
 
@@ -48,8 +52,12 @@ protected:
   {
   protected:
     PathLabel();
+
   public:
-    PathLabel(const std::string& label) : cmPathLabel(label) { }
+    PathLabel(const std::string& label)
+      : cmPathLabel(label)
+    {
+    }
     static PathLabel CMake;
     static PathLabel CMakeEnvironment;
     static PathLabel Hints;
@@ -58,9 +66,12 @@ protected:
     static PathLabel Guess;
   };
 
-  enum RootPathMode { RootPathModeNever,
-                      RootPathModeOnly,
-                      RootPathModeBoth };
+  enum RootPathMode
+  {
+    RootPathModeNever,
+    RootPathModeOnly,
+    RootPathModeBoth
+  };
 
   /** Construct the various path groups and labels */
   void InitializeSearchPathGroups();
diff --git a/Source/cmFindFileCommand.h b/Source/cmFindFileCommand.h
index daf1d65..74b01f1 100644
--- a/Source/cmFindFileCommand.h
+++ b/Source/cmFindFileCommand.h
@@ -29,15 +29,10 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFindFileCommand;
-    }
-  virtual std::string GetName() const { return "find_file";}
+  virtual cmCommand* Clone() { return new cmFindFileCommand; }
+  virtual std::string GetName() const { return "find_file"; }
 
   cmTypeMacro(cmFindFileCommand, cmFindPathCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index a37b0bd..a4d4dbb 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -20,63 +20,53 @@ cmFindLibraryCommand::cmFindLibraryCommand()
 }
 
 // cmFindLibraryCommand
-bool cmFindLibraryCommand
-::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
+bool cmFindLibraryCommand::InitialPass(std::vector<std::string> const& argsIn,
+                                       cmExecutionStatus&)
 {
   this->VariableDocumentation = "Path to a library.";
   this->CMakePathName = "LIBRARY";
-  if(!this->ParseArguments(argsIn))
-    {
+  if (!this->ParseArguments(argsIn)) {
     return false;
-    }
-  if(this->AlreadyInCache)
-    {
+  }
+  if (this->AlreadyInCache) {
     // If the user specifies the entry on the command line without a
     // type we should add the type and docstring but keep the original
     // value.
-    if(this->AlreadyInCacheWithoutMetaInfo)
-      {
+    if (this->AlreadyInCacheWithoutMetaInfo) {
       this->Makefile->AddCacheDefinition(this->VariableName, "",
                                          this->VariableDocumentation.c_str(),
                                          cmState::FILEPATH);
-      }
-    return true;
     }
+    return true;
+  }
 
-  if(const char* abi_name =
-     this->Makefile->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI"))
-    {
+  if (const char* abi_name =
+        this->Makefile->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI")) {
     std::string abi = abi_name;
-    if(abi.find("ELF N32") != abi.npos)
-      {
+    if (abi.find("ELF N32") != abi.npos) {
       // Convert lib to lib32.
       this->AddArchitecturePaths("32");
-      }
     }
+  }
 
-  if(this->Makefile->GetState()
-         ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS"))
-    {
+  if (this->Makefile->GetState()->GetGlobalPropertyAsBool(
+        "FIND_LIBRARY_USE_LIB64_PATHS")) {
     // add special 64 bit paths if this is a 64 bit compile.
-    if(this->Makefile->PlatformIs64Bit())
-      {
+    if (this->Makefile->PlatformIs64Bit()) {
       this->AddArchitecturePaths("64");
-      }
     }
+  }
 
   std::string library = this->FindLibrary();
-  if(library != "")
-    {
+  if (library != "") {
     // Save the value in the cache
-    this->Makefile->AddCacheDefinition(this->VariableName,
-                                       library.c_str(),
+    this->Makefile->AddCacheDefinition(this->VariableName, library.c_str(),
                                        this->VariableDocumentation.c_str(),
                                        cmState::FILEPATH);
     return true;
-    }
+  }
   std::string notfound = this->VariableName + "-NOTFOUND";
-  this->Makefile->AddCacheDefinition(this->VariableName,
-                                     notfound.c_str(),
+  this->Makefile->AddCacheDefinition(this->VariableName, notfound.c_str(),
                                      this->VariableDocumentation.c_str(),
                                      cmState::FILEPATH);
   return true;
@@ -86,69 +76,59 @@ void cmFindLibraryCommand::AddArchitecturePaths(const char* suffix)
 {
   std::vector<std::string> original;
   original.swap(this->SearchPaths);
-  for(std::vector<std::string>::const_iterator i = original.begin();
-      i != original.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = original.begin();
+       i != original.end(); ++i) {
     this->AddArchitecturePath(*i, 0, suffix);
-    }
+  }
 }
 
 void cmFindLibraryCommand::AddArchitecturePath(
-  std::string const& dir, std::string::size_type start_pos,
-  const char* suffix, bool fresh)
+  std::string const& dir, std::string::size_type start_pos, const char* suffix,
+  bool fresh)
 {
   std::string::size_type pos = dir.find("lib/", start_pos);
-  if(pos != std::string::npos)
-    {
-    std::string cur_dir  = dir.substr(0,pos+3);
+  if (pos != std::string::npos) {
+    std::string cur_dir = dir.substr(0, pos + 3);
 
     // Follow "lib<suffix>".
     std::string next_dir = cur_dir + suffix;
-    if(cmSystemTools::FileIsDirectory(next_dir))
-      {
-      next_dir += dir.substr(pos+3);
-      std::string::size_type next_pos = pos+3+strlen(suffix)+1;
+    if (cmSystemTools::FileIsDirectory(next_dir)) {
+      next_dir += dir.substr(pos + 3);
+      std::string::size_type next_pos = pos + 3 + strlen(suffix) + 1;
       this->AddArchitecturePath(next_dir, next_pos, suffix);
-      }
+    }
 
     // Follow "lib".
-    if(cmSystemTools::FileIsDirectory(cur_dir))
-      {
-      this->AddArchitecturePath(dir, pos+3+1, suffix, false);
-      }
+    if (cmSystemTools::FileIsDirectory(cur_dir)) {
+      this->AddArchitecturePath(dir, pos + 3 + 1, suffix, false);
     }
-  if(fresh)
-    {
+  }
+  if (fresh) {
     // Check for <dir><suffix>/.
-    std::string cur_dir  = dir + suffix + "/";
-    if(cmSystemTools::FileIsDirectory(cur_dir))
-      {
+    std::string cur_dir = dir + suffix + "/";
+    if (cmSystemTools::FileIsDirectory(cur_dir)) {
       this->SearchPaths.push_back(cur_dir);
-      }
+    }
 
     // Now add the original unchanged path
-    if(cmSystemTools::FileIsDirectory(dir))
-      {
+    if (cmSystemTools::FileIsDirectory(dir)) {
       this->SearchPaths.push_back(dir);
-      }
     }
+  }
 }
 
 std::string cmFindLibraryCommand::FindLibrary()
 {
   std::string library;
-  if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
-    {
+  if (this->SearchFrameworkFirst || this->SearchFrameworkOnly) {
     library = this->FindFrameworkLibrary();
-    }
-  if(library.empty() && !this->SearchFrameworkOnly)
-    {
+  }
+  if (library.empty() && !this->SearchFrameworkOnly) {
     library = this->FindNormalLibrary();
-    }
-  if(library.empty() && this->SearchFrameworkLast)
-    {
+  }
+  if (library.empty() && this->SearchFrameworkLast) {
     library = this->FindFrameworkLibrary();
-    }
+  }
   return library;
 }
 
@@ -179,7 +159,10 @@ struct cmFindLibraryHelper
     bool TryRaw;
     std::string Raw;
     cmsys::RegularExpression Regex;
-    Name(): TryRaw(false) {}
+    Name()
+      : TryRaw(false)
+    {
+    }
   };
   std::vector<Name> Names;
 
@@ -189,15 +172,15 @@ struct cmFindLibraryHelper
   void RegexFromLiteral(std::string& out, std::string const& in);
   void RegexFromList(std::string& out, std::vector<std::string> const& in);
   size_type GetPrefixIndex(std::string const& prefix)
-    {
-    return std::find(this->Prefixes.begin(), this->Prefixes.end(),
-                           prefix) - this->Prefixes.begin();
-    }
+  {
+    return std::find(this->Prefixes.begin(), this->Prefixes.end(), prefix) -
+      this->Prefixes.begin();
+  }
   size_type GetSuffixIndex(std::string const& suffix)
-    {
-    return std::find(this->Suffixes.begin(), this->Suffixes.end(),
-                           suffix) - this->Suffixes.begin();
-    }
+  {
+    return std::find(this->Suffixes.begin(), this->Suffixes.end(), suffix) -
+      this->Suffixes.begin();
+  }
   bool HasValidSuffix(std::string const& name);
   void AddName(std::string const& name);
   void SetName(std::string const& name);
@@ -205,8 +188,8 @@ struct cmFindLibraryHelper
   bool CheckDirectoryForName(std::string const& path, Name& name);
 };
 
-cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf):
-  Makefile(mf)
+cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf)
+  : Makefile(mf)
 {
   this->GG = this->Makefile->GetGlobalGenerator();
 
@@ -221,29 +204,26 @@ cmFindLibraryHelper::cmFindLibraryHelper(cmMakefile* mf):
   this->RegexFromList(this->SuffixRegexStr, this->Suffixes);
 
   // Check whether to use OpenBSD-style library version comparisons.
-  this->OpenBSD =
-    this->Makefile->GetState()
-        ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_OPENBSD_VERSIONING");
+  this->OpenBSD = this->Makefile->GetState()->GetGlobalPropertyAsBool(
+    "FIND_LIBRARY_USE_OPENBSD_VERSIONING");
 }
 
 void cmFindLibraryHelper::RegexFromLiteral(std::string& out,
                                            std::string const& in)
 {
-  for(std::string::const_iterator ci = in.begin(); ci != in.end(); ++ci)
-    {
+  for (std::string::const_iterator ci = in.begin(); ci != in.end(); ++ci) {
     char ch = *ci;
-    if(ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == '\\' ||
-       ch == '.' || ch == '*' || ch == '+' || ch == '?' || ch == '-' ||
-       ch == '^' || ch == '$')
-      {
+    if (ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == '\\' ||
+        ch == '.' || ch == '*' || ch == '+' || ch == '?' || ch == '-' ||
+        ch == '^' || ch == '$') {
       out += "\\";
-      }
+    }
 #if defined(_WIN32) || defined(__APPLE__)
     out += tolower(ch);
 #else
     out += ch;
 #endif
-    }
+  }
 }
 
 void cmFindLibraryHelper::RegexFromList(std::string& out,
@@ -253,42 +233,37 @@ void cmFindLibraryHelper::RegexFromList(std::string& out,
   // else and the result can be checked after matching.
   out += "(";
   const char* sep = "";
-  for(std::vector<std::string>::const_iterator si = in.begin();
-      si != in.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si = in.begin();
+       si != in.end(); ++si) {
     // Separate from previous item.
     out += sep;
     sep = "|";
 
     // Append this item.
     this->RegexFromLiteral(out, *si);
-    }
+  }
   out += ")";
 }
 
 bool cmFindLibraryHelper::HasValidSuffix(std::string const& name)
 {
-  for(std::vector<std::string>::const_iterator si = this->Suffixes.begin();
-      si != this->Suffixes.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si = this->Suffixes.begin();
+       si != this->Suffixes.end(); ++si) {
     std::string suffix = *si;
-    if(name.length() <= suffix.length())
-      {
+    if (name.length() <= suffix.length()) {
       continue;
-      }
+    }
     // Check if the given name ends in a valid library suffix.
-    if(name.substr(name.size()-suffix.length()) == suffix)
-      {
+    if (name.substr(name.size() - suffix.length()) == suffix) {
       return true;
-      }
+    }
     // Check if a valid library suffix is somewhere in the name,
     // this may happen e.g. for versioned shared libraries: libfoo.so.2
     suffix += ".";
-    if(name.find(suffix) != name.npos)
-      {
+    if (name.find(suffix) != name.npos) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -305,10 +280,9 @@ void cmFindLibraryHelper::AddName(std::string const& name)
   regex += this->PrefixRegexStr;
   this->RegexFromLiteral(regex, name);
   regex += this->SuffixRegexStr;
-  if(this->OpenBSD)
-    {
+  if (this->OpenBSD) {
     regex += "(\\.[0-9]+\\.[0-9]+)?";
-    }
+  }
   regex += "$";
   entry.Regex.compile(regex.c_str());
   this->Names.push_back(entry);
@@ -322,14 +296,12 @@ void cmFindLibraryHelper::SetName(std::string const& name)
 
 bool cmFindLibraryHelper::CheckDirectory(std::string const& path)
 {
-  for(std::vector<Name>::iterator i = this->Names.begin();
-      i != this->Names.end(); ++i)
-    {
-    if(this->CheckDirectoryForName(path, *i))
-      {
+  for (std::vector<Name>::iterator i = this->Names.begin();
+       i != this->Names.end(); ++i) {
+    if (this->CheckDirectoryForName(path, *i)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -341,18 +313,15 @@ bool cmFindLibraryHelper::CheckDirectoryForName(std::string const& path,
   // specifically for a static library on some platforms (on MS tools
   // one cannot tell just from the library name whether it is a static
   // library or an import library).
-  if(name.TryRaw)
-    {
+  if (name.TryRaw) {
     this->TestPath = path;
     this->TestPath += name.Raw;
-    if(cmSystemTools::FileExists(this->TestPath.c_str(), true))
-      {
-      this->BestPath =
-        cmSystemTools::CollapseFullPath(this->TestPath);
+    if (cmSystemTools::FileExists(this->TestPath.c_str(), true)) {
+      this->BestPath = cmSystemTools::CollapseFullPath(this->TestPath);
       cmSystemTools::ConvertToUnixSlashes(this->BestPath);
       return true;
-      }
     }
+  }
 
   // No library file has yet been found.
   size_type bestPrefix = this->Prefixes.size();
@@ -364,21 +333,18 @@ bool cmFindLibraryHelper::CheckDirectoryForName(std::string const& path,
   std::string dir = path;
   cmSystemTools::ConvertToUnixSlashes(dir);
   std::set<std::string> const& files = this->GG->GetDirectoryContent(dir);
-  for(std::set<std::string>::const_iterator fi = files.begin();
-      fi != files.end(); ++fi)
-    {
+  for (std::set<std::string>::const_iterator fi = files.begin();
+       fi != files.end(); ++fi) {
     std::string const& origName = *fi;
 #if defined(_WIN32) || defined(__APPLE__)
     std::string testName = cmSystemTools::LowerCase(origName);
 #else
     std::string const& testName = origName;
 #endif
-    if(name.Regex.find(testName))
-      {
+    if (name.Regex.find(testName)) {
       this->TestPath = path;
       this->TestPath += origName;
-      if(!cmSystemTools::FileIsDirectory(this->TestPath))
-        {
+      if (!cmSystemTools::FileIsDirectory(this->TestPath)) {
         // This is a matching file.  Check if it is better than the
         // best name found so far.  Earlier prefixes are preferred,
         // followed by earlier suffixes.  For OpenBSD, shared library
@@ -387,25 +353,23 @@ bool cmFindLibraryHelper::CheckDirectoryForName(std::string const& path,
         size_type suffix = this->GetSuffixIndex(name.Regex.match(2));
         unsigned int major = 0;
         unsigned int minor = 0;
-        if(this->OpenBSD)
-          {
+        if (this->OpenBSD) {
           sscanf(name.Regex.match(3).c_str(), ".%u.%u", &major, &minor);
-          }
-        if(this->BestPath.empty() || prefix < bestPrefix ||
-           (prefix == bestPrefix && suffix < bestSuffix) ||
-           (prefix == bestPrefix && suffix == bestSuffix &&
-            (major > bestMajor ||
-             (major == bestMajor && minor > bestMinor))))
-          {
+        }
+        if (this->BestPath.empty() || prefix < bestPrefix ||
+            (prefix == bestPrefix && suffix < bestSuffix) ||
+            (prefix == bestPrefix && suffix == bestSuffix &&
+             (major > bestMajor ||
+              (major == bestMajor && minor > bestMinor)))) {
           this->BestPath = this->TestPath;
           bestPrefix = prefix;
           bestSuffix = suffix;
           bestMajor = major;
           bestMinor = minor;
-          }
         }
       }
     }
+  }
 
   // Use the best candidate found in this directory, if any.
   return !this->BestPath.empty();
@@ -413,34 +377,28 @@ bool cmFindLibraryHelper::CheckDirectoryForName(std::string const& path,
 
 std::string cmFindLibraryCommand::FindNormalLibrary()
 {
-  if(this->NamesPerDir)
-    {
+  if (this->NamesPerDir) {
     return this->FindNormalLibraryNamesPerDir();
-    }
-  else
-    {
+  } else {
     return this->FindNormalLibraryDirsPerName();
-    }
+  }
 }
 
 std::string cmFindLibraryCommand::FindNormalLibraryNamesPerDir()
 {
   // Search for all names in each directory.
   cmFindLibraryHelper helper(this->Makefile);
-  for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end() ; ++ni)
-    {
+  for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
     helper.AddName(*ni);
-    }
+  }
   // Search every directory.
-  for(std::vector<std::string>::const_iterator
-        p = this->SearchPaths.begin(); p != this->SearchPaths.end(); ++p)
-    {
-    if(helper.CheckDirectory(*p))
-      {
+  for (std::vector<std::string>::const_iterator p = this->SearchPaths.begin();
+       p != this->SearchPaths.end(); ++p) {
+    if (helper.CheckDirectory(*p)) {
       return helper.BestPath;
-      }
     }
+  }
   // Couldn't find the library.
   return "";
 }
@@ -449,58 +407,49 @@ std::string cmFindLibraryCommand::FindNormalLibraryDirsPerName()
 {
   // Search the entire path for each name.
   cmFindLibraryHelper helper(this->Makefile);
-  for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end() ; ++ni)
-    {
+  for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
     // Switch to searching for this name.
     helper.SetName(*ni);
 
     // Search every directory.
-    for(std::vector<std::string>::const_iterator
-          p = this->SearchPaths.begin();
-        p != this->SearchPaths.end(); ++p)
-      {
-      if(helper.CheckDirectory(*p))
-        {
+    for (std::vector<std::string>::const_iterator p =
+           this->SearchPaths.begin();
+         p != this->SearchPaths.end(); ++p) {
+      if (helper.CheckDirectory(*p)) {
         return helper.BestPath;
-        }
       }
     }
+  }
   // Couldn't find the library.
   return "";
 }
 
 std::string cmFindLibraryCommand::FindFrameworkLibrary()
 {
-  if(this->NamesPerDir)
-    {
+  if (this->NamesPerDir) {
     return this->FindFrameworkLibraryNamesPerDir();
-    }
-  else
-    {
+  } else {
     return this->FindFrameworkLibraryDirsPerName();
-    }
+  }
 }
 
 std::string cmFindLibraryCommand::FindFrameworkLibraryNamesPerDir()
 {
   std::string fwPath;
   // Search for all names in each search path.
-  for(std::vector<std::string>::const_iterator di = this->SearchPaths.begin();
-      di != this->SearchPaths.end(); ++di)
-    {
-    for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-        ni != this->Names.end() ; ++ni)
-      {
+  for (std::vector<std::string>::const_iterator di = this->SearchPaths.begin();
+       di != this->SearchPaths.end(); ++di) {
+    for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+         ni != this->Names.end(); ++ni) {
       fwPath = *di;
       fwPath += *ni;
       fwPath += ".framework";
-      if(cmSystemTools::FileIsDirectory(fwPath))
-        {
+      if (cmSystemTools::FileIsDirectory(fwPath)) {
         return cmSystemTools::CollapseFullPath(fwPath);
-        }
       }
     }
+  }
 
   // No framework found.
   return "";
@@ -510,22 +459,19 @@ std::string cmFindLibraryCommand::FindFrameworkLibraryDirsPerName()
 {
   std::string fwPath;
   // Search for each name in all search paths.
-  for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end() ; ++ni)
-    {
-    for(std::vector<std::string>::const_iterator
-          di = this->SearchPaths.begin();
-        di != this->SearchPaths.end(); ++di)
-      {
+  for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
+    for (std::vector<std::string>::const_iterator di =
+           this->SearchPaths.begin();
+         di != this->SearchPaths.end(); ++di) {
       fwPath = *di;
       fwPath += *ni;
       fwPath += ".framework";
-      if(cmSystemTools::FileIsDirectory(fwPath))
-        {
+      if (cmSystemTools::FileIsDirectory(fwPath)) {
         return cmSystemTools::CollapseFullPath(fwPath);
-        }
       }
     }
+  }
 
   // No framework found.
   return "";
diff --git a/Source/cmFindLibraryCommand.h b/Source/cmFindLibraryCommand.h
index e257174..a08e151 100644
--- a/Source/cmFindLibraryCommand.h
+++ b/Source/cmFindLibraryCommand.h
@@ -14,7 +14,6 @@
 
 #include "cmFindBase.h"
 
-
 /** \class cmFindLibraryCommand
  * \brief Define a command to search for a library.
  *
@@ -29,17 +28,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFindLibraryCommand;
-    }
+  virtual cmCommand* Clone() { return new cmFindLibraryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -49,7 +45,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "find_library";}
+  virtual std::string GetName() const { return "find_library"; }
 
   cmTypeMacro(cmFindLibraryCommand, cmFindBase);
 
@@ -57,9 +53,9 @@ protected:
   void AddArchitecturePaths(const char* suffix);
   void AddArchitecturePath(std::string const& dir,
                            std::string::size_type start_pos,
-                           const char* suffix,
-                           bool fresh = true);
+                           const char* suffix, bool fresh = true);
   std::string FindLibrary();
+
 private:
   std::string FindNormalLibrary();
   std::string FindNormalLibraryNamesPerDir();
@@ -69,6 +65,4 @@ private:
   std::string FindFrameworkLibraryDirsPerName();
 };
 
-
-
 #endif
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index d08441b..7908afe 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -26,10 +26,10 @@
 #include <string.h>
 #endif
 
-cmFindPackageCommand::PathLabel
-  cmFindPackageCommand::PathLabel::UserRegistry("PACKAGE_REGISTRY");
-cmFindPackageCommand::PathLabel
-  cmFindPackageCommand::PathLabel::Builds("BUILDS");
+cmFindPackageCommand::PathLabel cmFindPackageCommand::PathLabel::UserRegistry(
+  "PACKAGE_REGISTRY");
+cmFindPackageCommand::PathLabel cmFindPackageCommand::PathLabel::Builds(
+  "BUILDS");
 cmFindPackageCommand::PathLabel
   cmFindPackageCommand::PathLabel::SystemRegistry("SYSTEM_PACKAGE_REGISTRY");
 
@@ -67,71 +67,65 @@ void cmFindPackageCommand::AppendSearchPathGroups()
 
   // Update the All group with new paths
   labels = &this->PathGroupLabelMap[PathGroup::All];
-  labels->insert(std::find(labels->begin(), labels->end(),
-                           PathLabel::CMakeSystem),
-                 PathLabel::UserRegistry);
-  labels->insert(std::find(labels->begin(), labels->end(),
-                           PathLabel::CMakeSystem),
-                 PathLabel::Builds);
+  labels->insert(
+    std::find(labels->begin(), labels->end(), PathLabel::CMakeSystem),
+    PathLabel::UserRegistry);
+  labels->insert(
+    std::find(labels->begin(), labels->end(), PathLabel::CMakeSystem),
+    PathLabel::Builds);
   labels->insert(std::find(labels->begin(), labels->end(), PathLabel::Guess),
                  PathLabel::SystemRegistry);
 
   // Create the new path objects
-  this->LabeledPaths.insert(std::make_pair(PathLabel::UserRegistry,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::Builds,
-    cmSearchPath(this)));
-  this->LabeledPaths.insert(std::make_pair(PathLabel::SystemRegistry,
-    cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::UserRegistry, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::Builds, cmSearchPath(this)));
+  this->LabeledPaths.insert(
+    std::make_pair(PathLabel::SystemRegistry, cmSearchPath(this)));
 }
 
-bool cmFindPackageCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Lookup required version of CMake.
-  if(const char* rv =
-     this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"))
-    {
-    unsigned int v[3] = {0,0,0};
+  if (const char* rv =
+        this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION")) {
+    unsigned int v[3] = { 0, 0, 0 };
     sscanf(rv, "%u.%u.%u", &v[0], &v[1], &v[2]);
-    this->RequiredCMakeVersion = CMake_VERSION_ENCODE(v[0],v[1],v[2]);
-    }
+    this->RequiredCMakeVersion = CMake_VERSION_ENCODE(v[0], v[1], v[2]);
+  }
 
   // Check for debug mode.
   this->DebugMode = this->Makefile->IsOn("CMAKE_FIND_DEBUG_MODE");
 
   // Lookup target architecture, if any.
-  if(const char* arch =
-     this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE"))
-    {
+  if (const char* arch =
+        this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
     this->LibraryArchitecture = arch;
-    }
+  }
 
   // Lookup whether lib64 paths should be used.
-  if(this->Makefile->PlatformIs64Bit() &&
-     this->Makefile->GetState()
-         ->GetGlobalPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS"))
-    {
+  if (this->Makefile->PlatformIs64Bit() &&
+      this->Makefile->GetState()->GetGlobalPropertyAsBool(
+        "FIND_LIBRARY_USE_LIB64_PATHS")) {
     this->UseLib64Paths = true;
-    }
+  }
 
   // Check if User Package Registry should be disabled
-  if(this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY"))
-    {
+  if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY")) {
     this->NoUserRegistry = true;
-    }
+  }
 
   // Check if System Package Registry should be disabled
-  if(this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY"))
-    {
+  if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY")) {
     this->NoSystemRegistry = true;
-    }
+  }
 
   // Find the current root path mode.
   this->SelectDefaultRootPathMode();
@@ -150,120 +144,89 @@ bool cmFindPackageCommand
   this->SearchPathSuffixes.push_back("");
 
   // Parse the arguments.
-  enum Doing { DoingNone, DoingComponents, DoingOptionalComponents, DoingNames,
-               DoingPaths, DoingPathSuffixes, DoingConfigs, DoingHints };
+  enum Doing
+  {
+    DoingNone,
+    DoingComponents,
+    DoingOptionalComponents,
+    DoingNames,
+    DoingPaths,
+    DoingPathSuffixes,
+    DoingConfigs,
+    DoingHints
+  };
   Doing doing = DoingNone;
   cmsys::RegularExpression version("^[0-9.]+$");
   bool haveVersion = false;
   std::set<unsigned int> configArgs;
   std::set<unsigned int> moduleArgs;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "QUIET")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "QUIET") {
       this->Quiet = true;
       doing = DoingNone;
-      }
-    else if(args[i] == "EXACT")
-      {
+    } else if (args[i] == "EXACT") {
       this->VersionExact = true;
       doing = DoingNone;
-      }
-    else if(args[i] == "MODULE")
-      {
+    } else if (args[i] == "MODULE") {
       moduleArgs.insert(i);
       doing = DoingNone;
-      }
-    else if(args[i] == "CONFIG")
-      {
+    } else if (args[i] == "CONFIG") {
       configArgs.insert(i);
       doing = DoingNone;
-      }
-    else if(args[i] == "NO_MODULE")
-      {
+    } else if (args[i] == "NO_MODULE") {
       configArgs.insert(i);
       doing = DoingNone;
-      }
-    else if(args[i] == "REQUIRED")
-      {
+    } else if (args[i] == "REQUIRED") {
       this->Required = true;
       doing = DoingComponents;
-      }
-    else if(args[i] == "COMPONENTS")
-      {
+    } else if (args[i] == "COMPONENTS") {
       doing = DoingComponents;
-      }
-    else if(args[i] == "OPTIONAL_COMPONENTS")
-      {
+    } else if (args[i] == "OPTIONAL_COMPONENTS") {
       doing = DoingOptionalComponents;
-      }
-    else if(args[i] == "NAMES")
-      {
+    } else if (args[i] == "NAMES") {
       configArgs.insert(i);
       doing = DoingNames;
-      }
-    else if(args[i] == "PATHS")
-      {
+    } else if (args[i] == "PATHS") {
       configArgs.insert(i);
       doing = DoingPaths;
-      }
-    else if(args[i] == "HINTS")
-      {
+    } else if (args[i] == "HINTS") {
       configArgs.insert(i);
       doing = DoingHints;
-      }
-    else if(args[i] == "PATH_SUFFIXES")
-      {
+    } else if (args[i] == "PATH_SUFFIXES") {
       configArgs.insert(i);
       doing = DoingPathSuffixes;
-      }
-    else if(args[i] == "CONFIGS")
-      {
+    } else if (args[i] == "CONFIGS") {
       configArgs.insert(i);
       doing = DoingConfigs;
-      }
-    else if(args[i] == "NO_POLICY_SCOPE")
-      {
+    } else if (args[i] == "NO_POLICY_SCOPE") {
       this->PolicyScope = false;
       doing = DoingNone;
-      }
-    else if(args[i] == "NO_CMAKE_PACKAGE_REGISTRY")
-      {
+    } else if (args[i] == "NO_CMAKE_PACKAGE_REGISTRY") {
       this->NoUserRegistry = true;
       configArgs.insert(i);
       doing = DoingNone;
-      }
-    else if(args[i] == "NO_CMAKE_SYSTEM_PACKAGE_REGISTRY")
-      {
+    } else if (args[i] == "NO_CMAKE_SYSTEM_PACKAGE_REGISTRY") {
       this->NoSystemRegistry = true;
       configArgs.insert(i);
       doing = DoingNone;
-      }
-    else if(args[i] == "NO_CMAKE_BUILDS_PATH")
-      {
+    } else if (args[i] == "NO_CMAKE_BUILDS_PATH") {
       // Ignore legacy option.
       configArgs.insert(i);
       doing = DoingNone;
-      }
-    else if(this->CheckCommonArgument(args[i]))
-      {
+    } else if (this->CheckCommonArgument(args[i])) {
       configArgs.insert(i);
       doing = DoingNone;
-      }
-    else if((doing == DoingComponents) || (doing == DoingOptionalComponents))
-      {
+    } else if ((doing == DoingComponents) ||
+               (doing == DoingOptionalComponents)) {
       // Set a variable telling the find script whether this component
       // is required.
       const char* isRequired = "1";
-      if (doing == DoingOptionalComponents)
-        {
+      if (doing == DoingOptionalComponents) {
         isRequired = "0";
         optionalComponents.insert(args[i]);
-        }
-      else
-        {
+      } else {
         requiredComponents.insert(args[i]);
-        }
+      }
 
       std::string req_var = this->Name + "_FIND_REQUIRED_" + args[i];
       this->AddFindDefinition(req_var, isRequired);
@@ -272,105 +235,82 @@ bool cmFindPackageCommand
       components += components_sep;
       components += args[i];
       components_sep = ";";
-      }
-    else if(doing == DoingNames)
-      {
+    } else if (doing == DoingNames) {
       this->Names.push_back(args[i]);
-      }
-    else if(doing == DoingPaths)
-      {
+    } else if (doing == DoingPaths) {
       this->UserGuessArgs.push_back(args[i]);
-      }
-    else if(doing == DoingHints)
-      {
+    } else if (doing == DoingHints) {
       this->UserHintsArgs.push_back(args[i]);
-      }
-    else if(doing == DoingPathSuffixes)
-      {
+    } else if (doing == DoingPathSuffixes) {
       this->AddPathSuffix(args[i]);
-      }
-    else if(doing == DoingConfigs)
-      {
-      if(args[i].find_first_of(":/\\") != args[i].npos ||
-         cmSystemTools::GetFilenameLastExtension(args[i]) != ".cmake")
-        {
+    } else if (doing == DoingConfigs) {
+      if (args[i].find_first_of(":/\\") != args[i].npos ||
+          cmSystemTools::GetFilenameLastExtension(args[i]) != ".cmake") {
         std::ostringstream e;
-        e << "given CONFIGS option followed by invalid file name \""
-          << args[i] << "\".  The names given must be file names without "
+        e << "given CONFIGS option followed by invalid file name \"" << args[i]
+          << "\".  The names given must be file names without "
           << "a path and with a \".cmake\" extension.";
         this->SetError(e.str());
         return false;
-        }
-      this->Configs.push_back(args[i]);
       }
-    else if(!haveVersion && version.find(args[i].c_str()))
-      {
+      this->Configs.push_back(args[i]);
+    } else if (!haveVersion && version.find(args[i].c_str())) {
       haveVersion = true;
       this->Version = args[i];
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "called with invalid argument \"" << args[i] << "\"";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   std::vector<std::string> doubledComponents;
   std::set_intersection(requiredComponents.begin(), requiredComponents.end(),
                         optionalComponents.begin(), optionalComponents.end(),
                         std::back_inserter(doubledComponents));
-  if(!doubledComponents.empty())
-    {
+  if (!doubledComponents.empty()) {
     std::ostringstream e;
     e << "called with components that are both required and optional:\n";
     e << cmWrap("  ", doubledComponents, "", "\n") << "\n";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Maybe choose one mode exclusively.
   this->UseFindModules = configArgs.empty();
   this->UseConfigFiles = moduleArgs.empty();
-  if(!this->UseFindModules && !this->UseConfigFiles)
-    {
+  if (!this->UseFindModules && !this->UseConfigFiles) {
     std::ostringstream e;
     e << "given options exclusive to Module mode:\n";
-    for(std::set<unsigned int>::const_iterator si = moduleArgs.begin();
-        si != moduleArgs.end(); ++si)
-      {
+    for (std::set<unsigned int>::const_iterator si = moduleArgs.begin();
+         si != moduleArgs.end(); ++si) {
       e << "  " << args[*si] << "\n";
-      }
+    }
     e << "and options exclusive to Config mode:\n";
-    for(std::set<unsigned int>::const_iterator si = configArgs.begin();
-        si != configArgs.end(); ++si)
-      {
+    for (std::set<unsigned int>::const_iterator si = configArgs.begin();
+         si != configArgs.end(); ++si) {
       e << "  " << args[*si] << "\n";
-      }
+    }
     e << "The options are incompatible.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Ignore EXACT with no version.
-  if(this->Version.empty() && this->VersionExact)
-    {
+  if (this->Version.empty() && this->VersionExact) {
     this->VersionExact = false;
     this->Makefile->IssueMessage(
       cmake::AUTHOR_WARNING, "Ignoring EXACT since no version is requested.");
-    }
+  }
 
-  if(this->Version.empty() || components.empty())
-    {
+  if (this->Version.empty() || components.empty()) {
     // Check whether we are recursing inside "Find<name>.cmake" within
     // another find_package(<name>) call.
     std::string mod = this->Name;
     mod += "_FIND_MODULE";
-    if(this->Makefile->IsOn(mod))
-      {
-      if(this->Version.empty())
-        {
+    if (this->Makefile->IsOn(mod)) {
+      if (this->Version.empty()) {
         // Get version information from the outer call if necessary.
         // Requested version string.
         std::string ver = this->Name;
@@ -381,102 +321,102 @@ bool cmFindPackageCommand
         std::string exact = this->Name;
         exact += "_FIND_VERSION_EXACT";
         this->VersionExact = this->Makefile->IsOn(exact);
-        }
-      if(components.empty())
-        {
+      }
+      if (components.empty()) {
         std::string components_var = this->Name + "_FIND_COMPONENTS";
         components = this->Makefile->GetSafeDefinition(components_var);
-        }
       }
     }
+  }
 
-  if(!this->Version.empty())
-    {
+  if (!this->Version.empty()) {
     // Try to parse the version number and store the results that were
     // successfully parsed.
     unsigned int parsed_major;
     unsigned int parsed_minor;
     unsigned int parsed_patch;
     unsigned int parsed_tweak;
-    this->VersionCount = sscanf(this->Version.c_str(), "%u.%u.%u.%u",
-                                &parsed_major, &parsed_minor,
-                                &parsed_patch, &parsed_tweak);
-    switch(this->VersionCount)
-      {
-      case 4: this->VersionTweak = parsed_tweak; // no break!
-      case 3: this->VersionPatch = parsed_patch; // no break!
-      case 2: this->VersionMinor = parsed_minor; // no break!
-      case 1: this->VersionMajor = parsed_major; // no break!
-      default: break;
-      }
+    this->VersionCount =
+      sscanf(this->Version.c_str(), "%u.%u.%u.%u", &parsed_major,
+             &parsed_minor, &parsed_patch, &parsed_tweak);
+    switch (this->VersionCount) {
+      case 4:
+        this->VersionTweak = parsed_tweak; // no break!
+      case 3:
+        this->VersionPatch = parsed_patch; // no break!
+      case 2:
+        this->VersionMinor = parsed_minor; // no break!
+      case 1:
+        this->VersionMajor = parsed_major; // no break!
+      default:
+        break;
     }
+  }
 
   std::string disableFindPackageVar = "CMAKE_DISABLE_FIND_PACKAGE_";
   disableFindPackageVar += this->Name;
-  if(this->Makefile->IsOn(disableFindPackageVar))
-    {
-    if (this->Required)
-      {
+  if (this->Makefile->IsOn(disableFindPackageVar)) {
+    if (this->Required) {
       std::ostringstream e;
       e << "for module " << this->Name << " called with REQUIRED, but "
         << disableFindPackageVar
         << " is enabled. A REQUIRED package cannot be disabled.";
       this->SetError(e.str());
       return false;
-      }
-
-    return true;
     }
 
+    return true;
+  }
 
   this->SetModuleVariables(components);
 
   // See if there is a Find<package>.cmake module.
-  if(this->UseFindModules)
-    {
+  if (this->UseFindModules) {
     bool foundModule = false;
-    if(!this->FindModule(foundModule))
-      {
+    if (!this->FindModule(foundModule)) {
       this->AppendSuccessInformation();
       return false;
-      }
-    if(foundModule)
-      {
+    }
+    if (foundModule) {
       this->AppendSuccessInformation();
       return true;
-      }
     }
+  }
 
-  if(this->UseFindModules && this->UseConfigFiles &&
-     this->Makefile->IsOn("CMAKE_FIND_PACKAGE_WARN_NO_MODULE"))
-    {
+  if (this->UseFindModules && this->UseConfigFiles &&
+      this->Makefile->IsOn("CMAKE_FIND_PACKAGE_WARN_NO_MODULE")) {
     std::ostringstream aw;
-    if(this->RequiredCMakeVersion >= CMake_VERSION_ENCODE(2,8,8))
-      {
+    if (this->RequiredCMakeVersion >= CMake_VERSION_ENCODE(2, 8, 8)) {
       aw << "find_package called without either MODULE or CONFIG option and "
-        "no Find" << this->Name << ".cmake module is in CMAKE_MODULE_PATH.  "
-        "Add MODULE to exclusively request Module mode and fail if "
-        "Find" << this->Name << ".cmake is missing.  "
-        "Add CONFIG to exclusively request Config mode and search for a "
-        "package configuration file provided by " << this->Name <<
-        " (" << this->Name << "Config.cmake or " <<
-        cmSystemTools::LowerCase(this->Name) << "-config.cmake).  ";
-      }
-    else
-      {
-      aw << "find_package called without NO_MODULE option and no "
-        "Find" << this->Name << ".cmake module is in CMAKE_MODULE_PATH.  "
-        "Add NO_MODULE to exclusively request Config mode and search for a "
-        "package configuration file provided by " << this->Name <<
-        " (" << this->Name << "Config.cmake or " <<
-        cmSystemTools::LowerCase(this->Name) << "-config.cmake).  "
-        "Otherwise make Find" << this->Name << ".cmake available in "
-        "CMAKE_MODULE_PATH.";
-      }
+            "no Find"
+         << this->Name
+         << ".cmake module is in CMAKE_MODULE_PATH.  "
+            "Add MODULE to exclusively request Module mode and fail if "
+            "Find"
+         << this->Name
+         << ".cmake is missing.  "
+            "Add CONFIG to exclusively request Config mode and search for a "
+            "package configuration file provided by "
+         << this->Name << " (" << this->Name << "Config.cmake or "
+         << cmSystemTools::LowerCase(this->Name) << "-config.cmake).  ";
+    } else {
+      aw
+        << "find_package called without NO_MODULE option and no "
+           "Find"
+        << this->Name
+        << ".cmake module is in CMAKE_MODULE_PATH.  "
+           "Add NO_MODULE to exclusively request Config mode and search for a "
+           "package configuration file provided by "
+        << this->Name << " (" << this->Name << "Config.cmake or "
+        << cmSystemTools::LowerCase(this->Name) << "-config.cmake).  "
+                                                   "Otherwise make Find"
+        << this->Name << ".cmake available in "
+                         "CMAKE_MODULE_PATH.";
+    }
     aw << "\n"
-      "(Variable CMAKE_FIND_PACKAGE_WARN_NO_MODULE enabled this warning.)";
+          "(Variable CMAKE_FIND_PACKAGE_WARN_NO_MODULE enabled this warning.)";
     this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, aw.str());
-    }
+  }
 
   // No find module.  Assume the project has a CMake config file.  Use
   // a <package>_DIR cache variable to locate it.
@@ -484,17 +424,14 @@ bool cmFindPackageCommand
   this->Variable += "_DIR";
 
   // Add the default name.
-  if(this->Names.empty())
-    {
+  if (this->Names.empty()) {
     this->Names.push_back(this->Name);
-    }
+  }
 
   // Add the default configs.
-  if(this->Configs.empty())
-    {
-    for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-        ni != this->Names.end(); ++ni)
-      {
+  if (this->Configs.empty()) {
+    for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+         ni != this->Names.end(); ++ni) {
       std::string config = *ni;
       config += "Config.cmake";
       this->Configs.push_back(config);
@@ -502,8 +439,8 @@ bool cmFindPackageCommand
       config = cmSystemTools::LowerCase(*ni);
       config += "-config.cmake";
       this->Configs.push_back(config);
-      }
     }
+  }
 
   // get igonored paths from vars and reroot them.
   std::vector<std::string> ignored;
@@ -520,7 +457,6 @@ bool cmFindPackageCommand
   return result;
 }
 
-
 void cmFindPackageCommand::SetModuleVariables(const std::string& components)
 {
   this->AddFindDefinition("CMAKE_FIND_PACKAGE_NAME", this->Name.c_str());
@@ -529,26 +465,23 @@ void cmFindPackageCommand::SetModuleVariables(const std::string& components)
   std::string components_var = this->Name + "_FIND_COMPONENTS";
   this->AddFindDefinition(components_var, components.c_str());
 
-  if(this->Quiet)
-    {
+  if (this->Quiet) {
     // Tell the module that is about to be read that it should find
     // quietly.
     std::string quietly = this->Name;
     quietly += "_FIND_QUIETLY";
     this->AddFindDefinition(quietly, "1");
-    }
+  }
 
-  if(this->Required)
-    {
+  if (this->Required) {
     // Tell the module that is about to be read that it should report
     // a fatal error if the package is not found.
     std::string req = this->Name;
     req += "_FIND_REQUIRED";
     this->AddFindDefinition(req, "1");
-    }
+  }
 
-  if(!this->Version.empty())
-    {
+  if (!this->Version.empty()) {
     // Tell the module that is about to be read what version of the
     // package has been requested.
     std::string ver = this->Name;
@@ -556,53 +489,47 @@ void cmFindPackageCommand::SetModuleVariables(const std::string& components)
     this->AddFindDefinition(ver, this->Version.c_str());
     char buf[64];
     sprintf(buf, "%u", this->VersionMajor);
-    this->AddFindDefinition(ver+"_MAJOR", buf);
+    this->AddFindDefinition(ver + "_MAJOR", buf);
     sprintf(buf, "%u", this->VersionMinor);
-    this->AddFindDefinition(ver+"_MINOR", buf);
+    this->AddFindDefinition(ver + "_MINOR", buf);
     sprintf(buf, "%u", this->VersionPatch);
-    this->AddFindDefinition(ver+"_PATCH", buf);
+    this->AddFindDefinition(ver + "_PATCH", buf);
     sprintf(buf, "%u", this->VersionTweak);
-    this->AddFindDefinition(ver+"_TWEAK", buf);
+    this->AddFindDefinition(ver + "_TWEAK", buf);
     sprintf(buf, "%u", this->VersionCount);
-    this->AddFindDefinition(ver+"_COUNT", buf);
+    this->AddFindDefinition(ver + "_COUNT", buf);
 
     // Tell the module whether an exact version has been requested.
     std::string exact = this->Name;
     exact += "_FIND_VERSION_EXACT";
-    this->AddFindDefinition(exact, this->VersionExact? "1":"0");
-   }
+    this->AddFindDefinition(exact, this->VersionExact ? "1" : "0");
+  }
 }
 
 void cmFindPackageCommand::AddFindDefinition(const std::string& var,
                                              const char* val)
 {
-  if(const char* old = this->Makefile->GetDefinition(var))
-    {
+  if (const char* old = this->Makefile->GetDefinition(var)) {
     this->OriginalDefs[var].exists = true;
     this->OriginalDefs[var].value = old;
-    }
-  else
-    {
+  } else {
     this->OriginalDefs[var].exists = false;
-    }
+  }
   this->Makefile->AddDefinition(var, val);
 }
 
 void cmFindPackageCommand::RestoreFindDefinitions()
 {
-  for(std::map<std::string, OriginalDef>::iterator
-        i = this->OriginalDefs.begin(); i != this->OriginalDefs.end(); ++i)
-    {
+  for (std::map<std::string, OriginalDef>::iterator i =
+         this->OriginalDefs.begin();
+       i != this->OriginalDefs.end(); ++i) {
     OriginalDef const& od = i->second;
-    if(od.exists)
-      {
+    if (od.exists) {
       this->Makefile->AddDefinition(i->first, od.value.c_str());
-      }
-    else
-      {
+    } else {
       this->Makefile->RemoveDefinition(i->first);
-      }
     }
+  }
 }
 
 bool cmFindPackageCommand::FindModule(bool& found)
@@ -611,8 +538,7 @@ bool cmFindPackageCommand::FindModule(bool& found)
   module += this->Name;
   module += ".cmake";
   std::string mfile = this->Makefile->GetModulesFile(module.c_str());
-  if (!mfile.empty())
-    {
+  if (!mfile.empty()) {
     // Load the module we found, and set "<name>_FIND_MODULE" to true
     // while inside it.
     found = true;
@@ -622,7 +548,7 @@ bool cmFindPackageCommand::FindModule(bool& found)
     bool result = this->ReadListFile(mfile.c_str(), DoPolicyScope);
     this->Makefile->RemoveDefinition(var);
     return result;
-    }
+  }
   return true;
 }
 
@@ -641,44 +567,38 @@ bool cmFindPackageCommand::HandlePackageMode()
 
   // Try to load the config file if the directory is known
   bool fileFound = false;
-  if (this->UseConfigFiles)
-    {
-    if(!cmSystemTools::IsOff(def))
-      {
+  if (this->UseConfigFiles) {
+    if (!cmSystemTools::IsOff(def)) {
       // Get the directory from the variable value.
       std::string dir = def;
       cmSystemTools::ConvertToUnixSlashes(dir);
 
       // Treat relative paths with respect to the current source dir.
-      if(!cmSystemTools::FileIsFullPath(dir.c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(dir.c_str())) {
         dir = "/" + dir;
         dir = this->Makefile->GetCurrentSourceDirectory() + dir;
-        }
+      }
       // The file location was cached.  Look for the correct file.
       std::string file;
-      if (this->FindConfigFile(dir, file))
-        {
+      if (this->FindConfigFile(dir, file)) {
         this->FileFound = file;
         fileFound = true;
-        }
-      def = this->Makefile->GetDefinition(this->Variable);
       }
+      def = this->Makefile->GetDefinition(this->Variable);
+    }
 
     // Search for the config file if it is not already found.
-    if(cmSystemTools::IsOff(def) || !fileFound)
-      {
+    if (cmSystemTools::IsOff(def) || !fileFound) {
       fileFound = this->FindConfig();
-      }
+    }
 
     // Sanity check.
-    if(fileFound && this->FileFound.empty())
-      {
+    if (fileFound && this->FileFound.empty()) {
       this->Makefile->IssueMessage(
         cmake::INTERNAL_ERROR, "fileFound is true but FileFound is empty!");
       fileFound = false;
-      }
     }
+  }
 
   std::string foundVar = this->Name;
   foundVar += "_FOUND";
@@ -691,17 +611,15 @@ bool cmFindPackageCommand::HandlePackageMode()
   bool found = false;
   bool configFileSetFOUNDFalse = false;
 
-  if(fileFound)
-    {
-    if ((this->Makefile->IsDefinitionSet(foundVar))
-      && (this->Makefile->IsOn(foundVar) == false))
-      {
+  if (fileFound) {
+    if ((this->Makefile->IsDefinitionSet(foundVar)) &&
+        (this->Makefile->IsOn(foundVar) == false)) {
       // by removing Foo_FOUND here if it is FALSE, we don't really change
       // the situation for the Config file which is about to be included,
       // but we make it possible to detect later on whether the Config file
       // has set Foo_FOUND to FALSE itself:
       this->Makefile->RemoveDefinition(foundVar);
-      }
+    }
     this->Makefile->RemoveDefinition(notFoundMessageVar);
 
     // Set the version variables before loading the config file.
@@ -709,151 +627,135 @@ bool cmFindPackageCommand::HandlePackageMode()
     this->StoreVersionFound();
 
     // Parse the configuration file.
-    if(this->ReadListFile(this->FileFound.c_str(), DoPolicyScope))
-      {
+    if (this->ReadListFile(this->FileFound.c_str(), DoPolicyScope)) {
       // The package has been found.
       found = true;
 
       // Check whether the Config file has set Foo_FOUND to FALSE:
-      if ((this->Makefile->IsDefinitionSet(foundVar))
-           && (this->Makefile->IsOn(foundVar) == false))
-        {
+      if ((this->Makefile->IsDefinitionSet(foundVar)) &&
+          (this->Makefile->IsOn(foundVar) == false)) {
         // we get here if the Config file has set Foo_FOUND actively to FALSE
         found = false;
         configFileSetFOUNDFalse = true;
-        notFoundMessage = this->Makefile->GetSafeDefinition(
-                                                   notFoundMessageVar);
-        }
+        notFoundMessage =
+          this->Makefile->GetSafeDefinition(notFoundMessageVar);
       }
-    else
-      {
+    } else {
       // The configuration file is invalid.
       result = false;
-      }
     }
+  }
 
-  if (result && !found && (!this->Quiet || this->Required))
-    {
+  if (result && !found && (!this->Quiet || this->Required)) {
     // The variable is not set.
     std::ostringstream e;
     std::ostringstream aw;
-    if (configFileSetFOUNDFalse)
-      {
+    if (configFileSetFOUNDFalse) {
       /* clang-format off */
       e << "Found package configuration file:\n"
         "  " << this->FileFound << "\n"
         "but it set " << foundVar << " to FALSE so package \"" <<
         this->Name << "\" is considered to be NOT FOUND.";
       /* clang-format on */
-      if (!notFoundMessage.empty())
-        {
+      if (!notFoundMessage.empty()) {
         e << " Reason given by package: \n" << notFoundMessage << "\n";
-        }
       }
+    }
     // If there are files in ConsideredConfigs, it means that FooConfig.cmake
     // have been found, but they didn't have appropriate versions.
-    else if (!this->ConsideredConfigs.empty())
-      {
-      e << "Could not find a configuration file for package \""
-        << this->Name << "\" that "
-        << (this->VersionExact? "exactly matches" : "is compatible with")
+    else if (!this->ConsideredConfigs.empty()) {
+      e << "Could not find a configuration file for package \"" << this->Name
+        << "\" that "
+        << (this->VersionExact ? "exactly matches" : "is compatible with")
         << " requested version \"" << this->Version << "\".\n"
         << "The following configuration files were considered but not "
            "accepted:\n";
-      for(std::vector<ConfigFileInfo>::size_type i=0;
-          i<this->ConsideredConfigs.size(); i++)
-        {
+      for (std::vector<ConfigFileInfo>::size_type i = 0;
+           i < this->ConsideredConfigs.size(); i++) {
         e << "  " << this->ConsideredConfigs[i].filename
           << ", version: " << this->ConsideredConfigs[i].version << "\n";
-        }
       }
-    else
-      {
+    } else {
       std::string requestedVersionString;
-      if(!this->Version.empty())
-        {
+      if (!this->Version.empty()) {
         requestedVersionString = " (requested version ";
         requestedVersionString += this->Version;
         requestedVersionString += ")";
-        }
+      }
 
-      if (this->UseConfigFiles)
-        {
-        if(this->UseFindModules)
-          {
-          e << "By not providing \"Find" << this->Name << ".cmake\" in "
+      if (this->UseConfigFiles) {
+        if (this->UseFindModules) {
+          e << "By not providing \"Find" << this->Name
+            << ".cmake\" in "
                "CMAKE_MODULE_PATH this project has asked CMake to find a "
-               "package configuration file provided by \""<<this->Name<< "\", "
-               "but CMake did not find one.\n";
-          }
+               "package configuration file provided by \""
+            << this->Name << "\", "
+                             "but CMake did not find one.\n";
+        }
 
-        if(this->Configs.size() == 1)
-          {
+        if (this->Configs.size() == 1) {
           e << "Could not find a package configuration file named \""
-            << this->Configs[0] << "\" provided by package \""
-            << this->Name << "\"" << requestedVersionString <<".\n";
-          }
-        else
-          {
+            << this->Configs[0] << "\" provided by package \"" << this->Name
+            << "\"" << requestedVersionString << ".\n";
+        } else {
           e << "Could not find a package configuration file provided by \""
             << this->Name << "\"" << requestedVersionString
             << " with any of the following names:\n"
             << cmWrap("  ", this->Configs, "", "\n") << "\n";
-          }
-
-        e << "Add the installation prefix of \"" << this->Name << "\" to "
-          "CMAKE_PREFIX_PATH or set \"" << this->Variable << "\" to a "
-          "directory containing one of the above files. "
-          "If \"" << this->Name << "\" provides a separate development "
-          "package or SDK, be sure it has been installed.";
         }
-      else // if(!this->UseFindModules && !this->UseConfigFiles)
-        {
+
+        e << "Add the installation prefix of \"" << this->Name
+          << "\" to "
+             "CMAKE_PREFIX_PATH or set \""
+          << this->Variable << "\" to a "
+                               "directory containing one of the above files. "
+                               "If \""
+          << this->Name << "\" provides a separate development "
+                           "package or SDK, be sure it has been installed.";
+      } else // if(!this->UseFindModules && !this->UseConfigFiles)
+      {
         e << "No \"Find" << this->Name << ".cmake\" found in "
           << "CMAKE_MODULE_PATH.";
 
-        aw<< "Find"<< this->Name <<".cmake must either be part of this "
-             "project itself, in this case adjust CMAKE_MODULE_PATH so that "
-             "it points to the correct location inside its source tree.\n"
-             "Or it must be installed by a package which has already been "
-             "found via find_package().  In this case make sure that "
-             "package has indeed been found and adjust CMAKE_MODULE_PATH to "
-             "contain the location where that package has installed "
-             "Find" << this->Name << ".cmake.  This must be a location "
-             "provided by that package.  This error in general means that "
-             "the buildsystem of this project is relying on a Find-module "
-             "without ensuring that it is actually available.\n";
-        }
+        aw << "Find" << this->Name
+           << ".cmake must either be part of this "
+              "project itself, in this case adjust CMAKE_MODULE_PATH so that "
+              "it points to the correct location inside its source tree.\n"
+              "Or it must be installed by a package which has already been "
+              "found via find_package().  In this case make sure that "
+              "package has indeed been found and adjust CMAKE_MODULE_PATH to "
+              "contain the location where that package has installed "
+              "Find"
+           << this->Name
+           << ".cmake.  This must be a location "
+              "provided by that package.  This error in general means that "
+              "the buildsystem of this project is relying on a Find-module "
+              "without ensuring that it is actually available.\n";
       }
-
+    }
 
     this->Makefile->IssueMessage(
-      this->Required? cmake::FATAL_ERROR : cmake::WARNING, e.str());
-    if (this->Required)
-      {
+      this->Required ? cmake::FATAL_ERROR : cmake::WARNING, e.str());
+    if (this->Required) {
       cmSystemTools::SetFatalErrorOccured();
-      }
+    }
 
-    if (!aw.str().empty())
-      {
-      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,aw.str());
-      }
+    if (!aw.str().empty()) {
+      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, aw.str());
     }
+  }
 
   // Set a variable marking whether the package was found.
-  this->Makefile->AddDefinition(foundVar, found? "1":"0");
+  this->Makefile->AddDefinition(foundVar, found ? "1" : "0");
 
   // Set a variable naming the configuration file that was found.
   std::string fileVar = this->Name;
   fileVar += "_CONFIG";
-  if(found)
-    {
+  if (found) {
     this->Makefile->AddDefinition(fileVar, this->FileFound.c_str());
-    }
-  else
-    {
+  } else {
     this->Makefile->RemoveDefinition(fileVar);
-    }
+  }
 
   std::string consideredConfigsVar = this->Name;
   consideredConfigsVar += "_CONSIDERED_CONFIGS";
@@ -864,15 +766,14 @@ bool cmFindPackageCommand::HandlePackageMode()
   std::string consideredVersions;
 
   const char* sep = "";
-  for(std::vector<ConfigFileInfo>::size_type i=0;
-      i<this->ConsideredConfigs.size(); i++)
-    {
+  for (std::vector<ConfigFileInfo>::size_type i = 0;
+       i < this->ConsideredConfigs.size(); i++) {
     consideredConfigFiles += sep;
     consideredVersions += sep;
     consideredConfigFiles += this->ConsideredConfigs[i].filename;
     consideredVersions += this->ConsideredConfigs[i].version;
     sep = ";";
-    }
+  }
 
   this->Makefile->AddDefinition(consideredConfigsVar,
                                 consideredConfigFiles.c_str());
@@ -892,105 +793,89 @@ bool cmFindPackageCommand::FindConfig()
   bool found = false;
 
   // Search for frameworks.
-  if(!found && (this->SearchFrameworkFirst || this->SearchFrameworkOnly))
-    {
+  if (!found && (this->SearchFrameworkFirst || this->SearchFrameworkOnly)) {
     found = this->FindFrameworkConfig();
-    }
+  }
 
   // Search for apps.
-  if(!found && (this->SearchAppBundleFirst || this->SearchAppBundleOnly))
-    {
+  if (!found && (this->SearchAppBundleFirst || this->SearchAppBundleOnly)) {
     found = this->FindAppBundleConfig();
-    }
+  }
 
   // Search prefixes.
-  if(!found && !(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
-    {
+  if (!found && !(this->SearchFrameworkOnly || this->SearchAppBundleOnly)) {
     found = this->FindPrefixedConfig();
-    }
+  }
 
   // Search for frameworks.
-  if(!found && this->SearchFrameworkLast)
-    {
+  if (!found && this->SearchFrameworkLast) {
     found = this->FindFrameworkConfig();
-    }
+  }
 
   // Search for apps.
-  if(!found && this->SearchAppBundleLast)
-    {
+  if (!found && this->SearchAppBundleLast) {
     found = this->FindAppBundleConfig();
-    }
+  }
 
   // Store the entry in the cache so it can be set by the user.
   std::string init;
-  if(found)
-    {
+  if (found) {
     init = cmSystemTools::GetFilenamePath(this->FileFound);
-    }
-  else
-    {
+  } else {
     init = this->Variable + "-NOTFOUND";
-    }
+  }
   std::string help =
     "The directory containing a CMake configuration file for ";
   help += this->Name;
   help += ".";
   // We force the value since we do not get here if it was already set.
-  this->Makefile->AddCacheDefinition(this->Variable,
-                                     init.c_str(), help.c_str(),
-                                     cmState::PATH, true);
+  this->Makefile->AddCacheDefinition(this->Variable, init.c_str(),
+                                     help.c_str(), cmState::PATH, true);
   return found;
 }
 
 bool cmFindPackageCommand::FindPrefixedConfig()
 {
   std::vector<std::string>& prefixes = this->SearchPaths;
-  for(std::vector<std::string>::const_iterator pi = prefixes.begin();
-      pi != prefixes.end(); ++pi)
-    {
-    if(this->SearchPrefix(*pi))
-      {
+  for (std::vector<std::string>::const_iterator pi = prefixes.begin();
+       pi != prefixes.end(); ++pi) {
+    if (this->SearchPrefix(*pi)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmFindPackageCommand::FindFrameworkConfig()
 {
   std::vector<std::string>& prefixes = this->SearchPaths;
-  for(std::vector<std::string>::const_iterator i = prefixes.begin();
-      i != prefixes.end(); ++i)
-    {
-    if(this->SearchFrameworkPrefix(*i))
-      {
+  for (std::vector<std::string>::const_iterator i = prefixes.begin();
+       i != prefixes.end(); ++i) {
+    if (this->SearchFrameworkPrefix(*i)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmFindPackageCommand::FindAppBundleConfig()
 {
   std::vector<std::string>& prefixes = this->SearchPaths;
-  for(std::vector<std::string>::const_iterator i = prefixes.begin();
-      i != prefixes.end(); ++i)
-    {
-    if(this->SearchAppBundlePrefix(*i))
-      {
+  for (std::vector<std::string>::const_iterator i = prefixes.begin();
+       i != prefixes.end(); ++i) {
+    if (this->SearchAppBundlePrefix(*i)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmFindPackageCommand::ReadListFile(const char* f, PolicyScopeRule psr)
 {
   const bool noPolicyScope = !this->PolicyScope || psr == NoPolicyScope;
-  if(this->Makefile->ReadDependentFile(f, noPolicyScope))
-    {
+  if (this->Makefile->ReadDependentFile(f, noPolicyScope)) {
     return true;
-    }
+  }
   std::string e = "Error reading CMake code from \"";
   e += f;
   e += "\".";
@@ -1001,64 +886,53 @@ bool cmFindPackageCommand::ReadListFile(const char* f, PolicyScopeRule psr)
 void cmFindPackageCommand::AppendToFoundProperty(bool found)
 {
   std::vector<std::string> foundContents;
-  const char *foundProp = this->Makefile->GetState()
-                              ->GetGlobalProperty("PACKAGES_FOUND");
-  if (foundProp && *foundProp)
-    {
+  const char* foundProp =
+    this->Makefile->GetState()->GetGlobalProperty("PACKAGES_FOUND");
+  if (foundProp && *foundProp) {
     std::string tmp = foundProp;
 
     cmSystemTools::ExpandListArgument(tmp, foundContents, false);
-    std::vector<std::string>::iterator nameIt = std::find(
-                       foundContents.begin(), foundContents.end(), this->Name);
-    if(nameIt != foundContents.end())
-      {
+    std::vector<std::string>::iterator nameIt =
+      std::find(foundContents.begin(), foundContents.end(), this->Name);
+    if (nameIt != foundContents.end()) {
       foundContents.erase(nameIt);
-      }
     }
+  }
 
   std::vector<std::string> notFoundContents;
-  const char *notFoundProp =
-         this->Makefile->GetState()
-             ->GetGlobalProperty("PACKAGES_NOT_FOUND");
-  if (notFoundProp && *notFoundProp)
-    {
+  const char* notFoundProp =
+    this->Makefile->GetState()->GetGlobalProperty("PACKAGES_NOT_FOUND");
+  if (notFoundProp && *notFoundProp) {
     std::string tmp = notFoundProp;
 
     cmSystemTools::ExpandListArgument(tmp, notFoundContents, false);
-    std::vector<std::string>::iterator nameIt = std::find(
-                 notFoundContents.begin(), notFoundContents.end(), this->Name);
-    if(nameIt != notFoundContents.end())
-      {
+    std::vector<std::string>::iterator nameIt =
+      std::find(notFoundContents.begin(), notFoundContents.end(), this->Name);
+    if (nameIt != notFoundContents.end()) {
       notFoundContents.erase(nameIt);
-      }
     }
+  }
 
-  if(found)
-    {
+  if (found) {
     foundContents.push_back(this->Name);
-    }
-  else
-    {
+  } else {
     notFoundContents.push_back(this->Name);
-    }
-
+  }
 
   std::string tmp = cmJoin(foundContents, ";");
-  this->Makefile->GetState()
-      ->SetGlobalProperty("PACKAGES_FOUND", tmp.c_str());
+  this->Makefile->GetState()->SetGlobalProperty("PACKAGES_FOUND", tmp.c_str());
 
   tmp = cmJoin(notFoundContents, ";");
-  this->Makefile->GetState()
-      ->SetGlobalProperty("PACKAGES_NOT_FOUND", tmp.c_str());
+  this->Makefile->GetState()->SetGlobalProperty("PACKAGES_NOT_FOUND",
+                                                tmp.c_str());
 }
 
 void cmFindPackageCommand::AppendSuccessInformation()
 {
   {
-  std::string transitivePropName = "_CMAKE_";
-  transitivePropName += this->Name + "_TRANSITIVE_DEPENDENCY";
-  this->Makefile->GetState()
-                ->SetGlobalProperty(transitivePropName, "False");
+    std::string transitivePropName = "_CMAKE_";
+    transitivePropName += this->Name + "_TRANSITIVE_DEPENDENCY";
+    this->Makefile->GetState()->SetGlobalProperty(transitivePropName, "False");
   }
   std::string found = this->Name;
   found += "_FOUND";
@@ -1066,8 +940,8 @@ void cmFindPackageCommand::AppendSuccessInformation()
 
   const char* upperResult = this->Makefile->GetDefinition(upperFound);
   const char* result = this->Makefile->GetDefinition(found);
-  bool packageFound = ((cmSystemTools::IsOn(result))
-                                        || (cmSystemTools::IsOn(upperResult)));
+  bool packageFound =
+    ((cmSystemTools::IsOn(result)) || (cmSystemTools::IsOn(upperResult)));
 
   this->AppendToFoundProperty(packageFound);
 
@@ -1076,31 +950,28 @@ void cmFindPackageCommand::AppendSuccessInformation()
   std::string quietInfoPropName = "_CMAKE_";
   quietInfoPropName += this->Name;
   quietInfoPropName += "_QUIET";
-  this->Makefile->GetState()
-      ->SetGlobalProperty(quietInfoPropName, this->Quiet ? "TRUE" : "FALSE");
+  this->Makefile->GetState()->SetGlobalProperty(
+    quietInfoPropName, this->Quiet ? "TRUE" : "FALSE");
 
   // set a global property to record the required version of this package
   std::string versionInfoPropName = "_CMAKE_";
   versionInfoPropName += this->Name;
   versionInfoPropName += "_REQUIRED_VERSION";
   std::string versionInfo;
-  if(!this->Version.empty())
-    {
+  if (!this->Version.empty()) {
     versionInfo = this->VersionExact ? "==" : ">=";
     versionInfo += " ";
     versionInfo += this->Version;
-    }
-  this->Makefile->GetState()
-      ->SetGlobalProperty(versionInfoPropName, versionInfo.c_str());
-  if (this->Required)
-    {
+  }
+  this->Makefile->GetState()->SetGlobalProperty(versionInfoPropName,
+                                                versionInfo.c_str());
+  if (this->Required) {
     std::string requiredInfoPropName = "_CMAKE_";
     requiredInfoPropName += this->Name;
     requiredInfoPropName += "_TYPE";
-    this->Makefile->GetState()
-        ->SetGlobalProperty(requiredInfoPropName, "REQUIRED");
-    }
-
+    this->Makefile->GetState()->SetGlobalProperty(requiredInfoPropName,
+                                                  "REQUIRED");
+  }
 
   // Restore original state of "_FIND_" variables we set.
   this->RestoreFindDefinitions();
@@ -1108,37 +979,29 @@ void cmFindPackageCommand::AppendSuccessInformation()
 
 void cmFindPackageCommand::ComputePrefixes()
 {
-  if(!this->NoDefaultPath)
-    {
-    if(!this->NoCMakePath)
-      {
+  if (!this->NoDefaultPath) {
+    if (!this->NoCMakePath) {
       this->FillPrefixesCMakeVariable();
-      }
-    if(!this->NoCMakeEnvironmentPath)
-      {
+    }
+    if (!this->NoCMakeEnvironmentPath) {
       this->FillPrefixesCMakeEnvironment();
-      }
     }
+  }
   this->FillPrefixesUserHints();
-  if(!this->NoDefaultPath)
-    {
-    if(!this->NoSystemEnvironmentPath)
-      {
+  if (!this->NoDefaultPath) {
+    if (!this->NoSystemEnvironmentPath) {
       this->FillPrefixesSystemEnvironment();
-      }
-    if(!this->NoUserRegistry)
-      {
+    }
+    if (!this->NoUserRegistry) {
       this->FillPrefixesUserRegistry();
-      }
-    if(!this->NoCMakeSystemPath)
-      {
+    }
+    if (!this->NoCMakeSystemPath) {
       this->FillPrefixesCMakeSystemVariable();
-      }
-    if(!this->NoSystemRegistry)
-      {
+    }
+    if (!this->NoSystemRegistry) {
       this->FillPrefixesSystemRegistry();
-      }
     }
+  }
   this->FillPrefixesUserGuess();
 
   this->ComputeFinalPaths();
@@ -1146,7 +1009,7 @@ void cmFindPackageCommand::ComputePrefixes()
 
 void cmFindPackageCommand::FillPrefixesCMakeEnvironment()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
 
   // Check the environment variable with the same name as the cache
   // entry.
@@ -1160,7 +1023,7 @@ void cmFindPackageCommand::FillPrefixesCMakeEnvironment()
 
 void cmFindPackageCommand::FillPrefixesCMakeVariable()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::CMake];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMake];
 
   paths.AddCMakePath("CMAKE_PREFIX_PATH");
   paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
@@ -1169,27 +1032,23 @@ void cmFindPackageCommand::FillPrefixesCMakeVariable()
 
 void cmFindPackageCommand::FillPrefixesSystemEnvironment()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemEnvironment];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemEnvironment];
 
   // Use the system search path to generate prefixes.
   // Relative paths are interpreted with respect to the current
   // working directory.
   std::vector<std::string> tmp;
   cmSystemTools::GetPath(tmp);
-  for(std::vector<std::string>::iterator i = tmp.begin();
-      i != tmp.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = tmp.begin(); i != tmp.end();
+       ++i) {
     // If the path is a PREFIX/bin case then add its parent instead.
-    if((cmHasLiteralSuffix(*i, "/bin")) ||
-       (cmHasLiteralSuffix(*i, "/sbin")))
-      {
+    if ((cmHasLiteralSuffix(*i, "/bin")) ||
+        (cmHasLiteralSuffix(*i, "/sbin"))) {
       paths.AddPath(cmSystemTools::GetFilenamePath(*i));
-      }
-    else
-      {
+    } else {
       paths.AddPath(*i);
-      }
     }
+  }
 }
 
 void cmFindPackageCommand::FillPrefixesUserRegistry()
@@ -1199,32 +1058,29 @@ void cmFindPackageCommand::FillPrefixesUserRegistry()
 #elif defined(__HAIKU__)
   char dir[B_PATH_NAME_LENGTH];
   if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) ==
-      B_OK)
-    {
+      B_OK) {
     std::string fname = dir;
     fname += "/cmake/packages/";
     fname += Name;
     this->LoadPackageRegistryDir(fname,
                                  this->LabeledPaths[PathLabel::UserRegistry]);
-    }
+  }
 #else
-  if(const char* home = cmSystemTools::GetEnv("HOME"))
-    {
+  if (const char* home = cmSystemTools::GetEnv("HOME")) {
     std::string dir = home;
     dir += "/.cmake/packages/";
     dir += this->Name;
     this->LoadPackageRegistryDir(dir,
                                  this->LabeledPaths[PathLabel::UserRegistry]);
-    }
+  }
 #endif
 }
 
 void cmFindPackageCommand::FillPrefixesSystemRegistry()
 {
-  if(this->NoSystemRegistry || this->NoDefaultPath)
-    {
+  if (this->NoSystemRegistry || this->NoDefaultPath) {
     return;
-    }
+  }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
   this->LoadPackageRegistryWinSystem();
@@ -1232,15 +1088,15 @@ void cmFindPackageCommand::FillPrefixesSystemRegistry()
 }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-# include <windows.h>
-# undef GetCurrentDirectory
-  // http://msdn.microsoft.com/en-us/library/aa384253%28v=vs.85%29.aspx
-# if !defined(KEY_WOW64_32KEY)
-#  define KEY_WOW64_32KEY 0x0200
-# endif
-# if !defined(KEY_WOW64_64KEY)
-#  define KEY_WOW64_64KEY 0x0100
-# endif
+#include <windows.h>
+#undef GetCurrentDirectory
+// http://msdn.microsoft.com/en-us/library/aa384253%28v=vs.85%29.aspx
+#if !defined(KEY_WOW64_32KEY)
+#define KEY_WOW64_32KEY 0x0200
+#endif
+#if !defined(KEY_WOW64_64KEY)
+#define KEY_WOW64_64KEY 0x0100
+#endif
 void cmFindPackageCommand::LoadPackageRegistryWinUser()
 {
   // HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views.
@@ -1250,20 +1106,17 @@ void cmFindPackageCommand::LoadPackageRegistryWinUser()
 
 void cmFindPackageCommand::LoadPackageRegistryWinSystem()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemRegistry];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemRegistry];
 
   // HKEY_LOCAL_MACHINE\\SOFTWARE has separate 32-bit and 64-bit views.
   // Prefer the target platform view first.
-  if(this->Makefile->PlatformIs64Bit())
-    {
+  if (this->Makefile->PlatformIs64Bit()) {
     this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths);
     this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths);
-    }
-  else
-    {
+  } else {
     this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths);
     this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths);
-    }
+  }
 }
 
 void cmFindPackageCommand::LoadPackageRegistryWin(bool user, unsigned int view,
@@ -1273,64 +1126,68 @@ void cmFindPackageCommand::LoadPackageRegistryWin(bool user, unsigned int view,
   key += cmsys::Encoding::ToWide(this->Name);
   std::set<std::wstring> bad;
   HKEY hKey;
-  if(RegOpenKeyExW(user? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, key.c_str(),
-                   0, KEY_QUERY_VALUE|view, &hKey) == ERROR_SUCCESS)
-    {
+  if (RegOpenKeyExW(user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, key.c_str(),
+                    0, KEY_QUERY_VALUE | view, &hKey) == ERROR_SUCCESS) {
     DWORD valueType = REG_NONE;
     wchar_t name[16383]; // RegEnumValue docs limit name to 32767 _bytes_
     std::vector<wchar_t> data(512);
     bool done = false;
     DWORD index = 0;
-    while(!done)
-      {
+    while (!done) {
       DWORD nameSize = static_cast<DWORD>(sizeof(name));
-      DWORD dataSize = static_cast<DWORD>(data.size()*sizeof(data[0]));
-      switch(RegEnumValueW(hKey, index, name, &nameSize,
-                          0, &valueType, (BYTE*)&data[0], &dataSize))
-        {
+      DWORD dataSize = static_cast<DWORD>(data.size() * sizeof(data[0]));
+      switch (RegEnumValueW(hKey, index, name, &nameSize, 0, &valueType,
+                            (BYTE*)&data[0], &dataSize)) {
         case ERROR_SUCCESS:
           ++index;
-          if(valueType == REG_SZ)
-            {
+          if (valueType == REG_SZ) {
             data[dataSize] = 0;
-            if(!this->CheckPackageRegistryEntry(
-                  cmsys::Encoding::ToNarrow(&data[0]), outPaths))
-              {
+            if (!this->CheckPackageRegistryEntry(
+                  cmsys::Encoding::ToNarrow(&data[0]), outPaths)) {
               // The entry is invalid.
               bad.insert(name);
-              }
             }
+          }
           break;
         case ERROR_MORE_DATA:
-          data.resize((dataSize+sizeof(data[0])-1)/sizeof(data[0]));
+          data.resize((dataSize + sizeof(data[0]) - 1) / sizeof(data[0]));
+          break;
+        case ERROR_NO_MORE_ITEMS:
+        default:
+          done = true;
           break;
-        case ERROR_NO_MORE_ITEMS: default: done = true; break;
-        }
       }
-    RegCloseKey(hKey);
     }
+    RegCloseKey(hKey);
+  }
 
   // Remove bad values if possible.
-  if(user && !bad.empty() &&
-     RegOpenKeyExW(HKEY_CURRENT_USER, key.c_str(),
-                  0, KEY_SET_VALUE|view, &hKey) == ERROR_SUCCESS)
-    {
-    for(std::set<std::wstring>::const_iterator vi = bad.begin();
-        vi != bad.end(); ++vi)
-      {
+  if (user && !bad.empty() &&
+      RegOpenKeyExW(HKEY_CURRENT_USER, key.c_str(), 0, KEY_SET_VALUE | view,
+                    &hKey) == ERROR_SUCCESS) {
+    for (std::set<std::wstring>::const_iterator vi = bad.begin();
+         vi != bad.end(); ++vi) {
       RegDeleteValueW(hKey, vi->c_str());
-      }
-    RegCloseKey(hKey);
     }
+    RegCloseKey(hKey);
+  }
 }
 #else
 class cmFindPackageCommandHoldFile
 {
   const char* File;
+
 public:
-  cmFindPackageCommandHoldFile(const char* f): File(f) {}
+  cmFindPackageCommandHoldFile(const char* f)
+    : File(f)
+  {
+  }
   ~cmFindPackageCommandHoldFile()
-    { if(this->File) { cmSystemTools::RemoveFile(this->File); } }
+  {
+    if (this->File) {
+      cmSystemTools::RemoveFile(this->File);
+    }
+  }
   void Release() { this->File = 0; }
 };
 
@@ -1338,34 +1195,30 @@ void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir,
                                                   cmSearchPath& outPaths)
 {
   cmsys::Directory files;
-  if(!files.Load(dir))
-    {
+  if (!files.Load(dir)) {
     return;
-    }
+  }
 
   std::string fname;
-  for(unsigned long i=0; i < files.GetNumberOfFiles(); ++i)
-    {
+  for (unsigned long i = 0; i < files.GetNumberOfFiles(); ++i) {
     fname = dir;
     fname += "/";
     fname += files.GetFile(i);
 
-    if(!cmSystemTools::FileIsDirectory(fname))
-      {
+    if (!cmSystemTools::FileIsDirectory(fname)) {
       // Hold this file hostage until it behaves.
       cmFindPackageCommandHoldFile holdFile(fname.c_str());
 
       // Load the file.
       cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
       std::string fentry;
-      if(fin && cmSystemTools::GetLineFromStream(fin, fentry) &&
-         this->CheckPackageRegistryEntry(fentry, outPaths))
-        {
+      if (fin && cmSystemTools::GetLineFromStream(fin, fentry) &&
+          this->CheckPackageRegistryEntry(fentry, outPaths)) {
         // The file references an existing package, so release it.
         holdFile.Release();
-        }
       }
     }
+  }
 
   // TODO: Wipe out the directory if it is empty.
 }
@@ -1375,43 +1228,34 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(const std::string& fname,
                                                      cmSearchPath& outPaths)
 {
   // Parse the content of one package registry entry.
-  if(cmSystemTools::FileIsFullPath(fname.c_str()))
-    {
+  if (cmSystemTools::FileIsFullPath(fname.c_str())) {
     // The first line in the stream is the full path to a file or
     // directory containing the package.
-    if(cmSystemTools::FileExists(fname.c_str()))
-      {
+    if (cmSystemTools::FileExists(fname.c_str())) {
       // The path exists.  Look for the package here.
-      if(!cmSystemTools::FileIsDirectory(fname))
-        {
+      if (!cmSystemTools::FileIsDirectory(fname)) {
         outPaths.AddPath(cmSystemTools::GetFilenamePath(fname));
-        }
-      else
-        {
+      } else {
         outPaths.AddPath(fname);
-        }
-      return true;
       }
-    else
-      {
+      return true;
+    } else {
       // The path does not exist.  Assume the stream content is
       // associated with an old package that no longer exists, and
       // delete it to keep the package registry clean.
       return false;
-      }
     }
-  else
-    {
+  } else {
     // The first line in the stream is not the full path to a file or
     // directory.  Assume the stream content was created by a future
     // version of CMake that uses a different format, and leave it.
     return true;
-    }
+  }
 }
 
 void cmFindPackageCommand::FillPrefixesCMakeSystemVariable()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeSystem];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeSystem];
 
   paths.AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH");
   paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
@@ -1420,88 +1264,80 @@ void cmFindPackageCommand::FillPrefixesCMakeSystemVariable()
 
 void cmFindPackageCommand::FillPrefixesUserGuess()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::Guess];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess];
 
-  for(std::vector<std::string>::const_iterator p = this->UserGuessArgs.begin();
-      p != this->UserGuessArgs.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p =
+         this->UserGuessArgs.begin();
+       p != this->UserGuessArgs.end(); ++p) {
     paths.AddUserPath(*p);
-    }
+  }
 }
 
 void cmFindPackageCommand::FillPrefixesUserHints()
 {
-  cmSearchPath &paths = this->LabeledPaths[PathLabel::Hints];
+  cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints];
 
-  for(std::vector<std::string>::const_iterator p = this->UserHintsArgs.begin();
-      p != this->UserHintsArgs.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p =
+         this->UserHintsArgs.begin();
+       p != this->UserHintsArgs.end(); ++p) {
     paths.AddUserPath(*p);
-    }
+  }
 }
 
 bool cmFindPackageCommand::SearchDirectory(std::string const& dir)
 {
-  assert(!dir.empty() && dir[dir.size()-1] == '/');
+  assert(!dir.empty() && dir[dir.size() - 1] == '/');
 
   // Check each path suffix on this directory.
-  for(std::vector<std::string>::const_iterator
-        si = this->SearchPathSuffixes.begin();
-      si != this->SearchPathSuffixes.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si =
+         this->SearchPathSuffixes.begin();
+       si != this->SearchPathSuffixes.end(); ++si) {
     std::string d = dir;
-    if(!si->empty())
-      {
+    if (!si->empty()) {
       d += *si;
       d += "/";
-      }
-    if(this->CheckDirectory(d))
-      {
+    }
+    if (this->CheckDirectory(d)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 bool cmFindPackageCommand::CheckDirectory(std::string const& dir)
 {
-  assert(!dir.empty() && dir[dir.size()-1] == '/');
+  assert(!dir.empty() && dir[dir.size() - 1] == '/');
 
   // Look for the file in this directory.
-  std::string d = dir.substr(0, dir.size()-1);
-  if(this->FindConfigFile(d, this->FileFound))
-    {
+  std::string d = dir.substr(0, dir.size() - 1);
+  if (this->FindConfigFile(d, this->FileFound)) {
     // Remove duplicate slashes.
     cmSystemTools::ConvertToUnixSlashes(this->FileFound);
     return true;
-    }
+  }
   return false;
 }
 
 bool cmFindPackageCommand::FindConfigFile(std::string const& dir,
                                           std::string& file)
 {
-  if (this->IgnoredPaths.count(dir))
-    {
+  if (this->IgnoredPaths.count(dir)) {
     return false;
-    }
+  }
 
-  for(std::vector<std::string>::const_iterator ci = this->Configs.begin();
-      ci != this->Configs.end(); ++ci)
-    {
+  for (std::vector<std::string>::const_iterator ci = this->Configs.begin();
+       ci != this->Configs.end(); ++ci) {
     file = dir;
     file += "/";
     file += *ci;
-    if(this->DebugMode)
-      {
+    if (this->DebugMode) {
       fprintf(stderr, "Checking file [%s]\n", file.c_str());
-      }
-    if(cmSystemTools::FileExists(file.c_str(), true) &&
-       this->CheckVersion(file))
-      {
+    }
+    if (cmSystemTools::FileExists(file.c_str(), true) &&
+        this->CheckVersion(file)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -1518,29 +1354,25 @@ bool cmFindPackageCommand::CheckVersion(std::string const& config_file)
   // Look for foo-config-version.cmake
   std::string version_file = version_file_base;
   version_file += "-version.cmake";
-  if ((haveResult == false)
-       && (cmSystemTools::FileExists(version_file.c_str(), true)))
-    {
+  if ((haveResult == false) &&
+      (cmSystemTools::FileExists(version_file.c_str(), true))) {
     result = this->CheckVersionFile(version_file, version);
     haveResult = true;
-    }
+  }
 
   // Look for fooConfigVersion.cmake
   version_file = version_file_base;
   version_file += "Version.cmake";
-  if ((haveResult == false)
-       && (cmSystemTools::FileExists(version_file.c_str(), true)))
-    {
+  if ((haveResult == false) &&
+      (cmSystemTools::FileExists(version_file.c_str(), true))) {
     result = this->CheckVersionFile(version_file, version);
     haveResult = true;
-    }
-
+  }
 
   // If no version was requested a versionless package is acceptable.
-  if ((haveResult == false) && (this->Version.empty()))
-    {
+  if ((haveResult == false) && (this->Version.empty())) {
     result = true;
-    }
+  }
 
   ConfigFileInfo configFileInfo;
   configFileInfo.filename = config_file;
@@ -1567,8 +1399,7 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file,
 
   // Set the input variables.
   this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name.c_str());
-  this->Makefile->AddDefinition("PACKAGE_FIND_VERSION",
-                                this->Version.c_str());
+  this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version.c_str());
   char buf[64];
   sprintf(buf, "%u", this->VersionMajor);
   this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MAJOR", buf);
@@ -1584,21 +1415,18 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file,
   // Load the version check file.  Pass NoPolicyScope because we do
   // our own policy push/pop independent of CMP0011.
   bool suitable = false;
-  if(this->ReadListFile(version_file.c_str(), NoPolicyScope))
-    {
+  if (this->ReadListFile(version_file.c_str(), NoPolicyScope)) {
     // Check the output variables.
     bool okay = this->Makefile->IsOn("PACKAGE_VERSION_EXACT");
     bool unsuitable = this->Makefile->IsOn("PACKAGE_VERSION_UNSUITABLE");
-    if(!okay && !this->VersionExact)
-      {
+    if (!okay && !this->VersionExact) {
       okay = this->Makefile->IsOn("PACKAGE_VERSION_COMPATIBLE");
-      }
+    }
 
     // The package is suitable if the version is okay and not
     // explicitly unsuitable.
     suitable = !unsuitable && (okay || this->Version.empty());
-    if(suitable)
-      {
+    if (suitable) {
       // Get the version found.
       this->VersionFound =
         this->Makefile->GetSafeDefinition("PACKAGE_VERSION");
@@ -1610,25 +1438,27 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file,
       unsigned int parsed_patch;
       unsigned int parsed_tweak;
       this->VersionFoundCount =
-        sscanf(this->VersionFound.c_str(), "%u.%u.%u.%u",
-               &parsed_major, &parsed_minor,
-               &parsed_patch, &parsed_tweak);
-      switch(this->VersionFoundCount)
-        {
-        case 4: this->VersionFoundTweak = parsed_tweak; // no break!
-        case 3: this->VersionFoundPatch = parsed_patch; // no break!
-        case 2: this->VersionFoundMinor = parsed_minor; // no break!
-        case 1: this->VersionFoundMajor = parsed_major; // no break!
-        default: break;
-        }
+        sscanf(this->VersionFound.c_str(), "%u.%u.%u.%u", &parsed_major,
+               &parsed_minor, &parsed_patch, &parsed_tweak);
+      switch (this->VersionFoundCount) {
+        case 4:
+          this->VersionFoundTweak = parsed_tweak; // no break!
+        case 3:
+          this->VersionFoundPatch = parsed_patch; // no break!
+        case 2:
+          this->VersionFoundMinor = parsed_minor; // no break!
+        case 1:
+          this->VersionFoundMajor = parsed_major; // no break!
+        default:
+          break;
       }
     }
+  }
 
   result_version = this->Makefile->GetSafeDefinition("PACKAGE_VERSION");
-  if (result_version.empty())
-    {
+  if (result_version.empty()) {
     result_version = "unknown";
-    }
+  }
 
   // Succeed if the version is suitable.
   return suitable;
@@ -1639,27 +1469,24 @@ void cmFindPackageCommand::StoreVersionFound()
   // Store the whole version string.
   std::string ver = this->Name;
   ver += "_VERSION";
-  if(this->VersionFound.empty())
-    {
+  if (this->VersionFound.empty()) {
     this->Makefile->RemoveDefinition(ver);
-    }
-  else
-    {
+  } else {
     this->Makefile->AddDefinition(ver, this->VersionFound.c_str());
-    }
+  }
 
   // Store the version components.
   char buf[64];
   sprintf(buf, "%u", this->VersionFoundMajor);
-  this->Makefile->AddDefinition(ver+"_MAJOR", buf);
+  this->Makefile->AddDefinition(ver + "_MAJOR", buf);
   sprintf(buf, "%u", this->VersionFoundMinor);
-  this->Makefile->AddDefinition(ver+"_MINOR", buf);
+  this->Makefile->AddDefinition(ver + "_MINOR", buf);
   sprintf(buf, "%u", this->VersionFoundPatch);
-  this->Makefile->AddDefinition(ver+"_PATCH", buf);
+  this->Makefile->AddDefinition(ver + "_PATCH", buf);
   sprintf(buf, "%u", this->VersionFoundTweak);
-  this->Makefile->AddDefinition(ver+"_TWEAK", buf);
+  this->Makefile->AddDefinition(ver + "_TWEAK", buf);
   sprintf(buf, "%u", this->VersionFoundCount);
-  this->Makefile->AddDefinition(ver+"_COUNT", buf);
+  this->Makefile->AddDefinition(ver + "_COUNT", buf);
 }
 
 #include <cmsys/Glob.hxx>
@@ -1673,6 +1500,7 @@ public:
   virtual ~cmFileListGeneratorBase() {}
 protected:
   bool Consider(std::string const& fullPath, cmFileList& listing);
+
 private:
   bool Search(cmFileList&);
   virtual bool Search(std::string const& parent, cmFileList&) = 0;
@@ -1685,29 +1513,30 @@ private:
 class cmFileList
 {
 public:
-  cmFileList(): First(), Last(0) {}
+  cmFileList()
+    : First()
+    , Last(0)
+  {
+  }
   virtual ~cmFileList() {}
   cmFileList& operator/(cmFileListGeneratorBase const& rhs)
-    {
-    if(this->Last)
-      {
+  {
+    if (this->Last) {
       this->Last = this->Last->SetNext(rhs);
-      }
-    else
-      {
+    } else {
       this->First = rhs.Clone();
       this->Last = this->First.get();
-      }
-    return *this;
     }
+    return *this;
+  }
   bool Search()
-    {
-    if(this->First.get())
-      {
+  {
+    if (this->First.get()) {
       return this->First->Search(*this);
-      }
-    return false;
     }
+    return false;
+  }
+
 private:
   virtual bool Visit(std::string const& fullPath) = 0;
   friend class cmFileListGeneratorBase;
@@ -1715,24 +1544,25 @@ private:
   cmFileListGeneratorBase* Last;
 };
 
-class cmFindPackageFileList: public cmFileList
+class cmFindPackageFileList : public cmFileList
 {
 public:
-  cmFindPackageFileList(cmFindPackageCommand* fpc,
-                        bool use_suffixes = true):
-    cmFileList(), FPC(fpc), UseSuffixes(use_suffixes) {}
+  cmFindPackageFileList(cmFindPackageCommand* fpc, bool use_suffixes = true)
+    : cmFileList()
+    , FPC(fpc)
+    , UseSuffixes(use_suffixes)
+  {
+  }
+
 private:
   bool Visit(std::string const& fullPath)
-    {
-    if(this->UseSuffixes)
-      {
+  {
+    if (this->UseSuffixes) {
       return this->FPC->SearchDirectory(fullPath);
-      }
-    else
-      {
+    } else {
       return this->FPC->CheckDirectory(fullPath);
-      }
     }
+  }
   cmFindPackageCommand* FPC;
   bool UseSuffixes;
 };
@@ -1742,8 +1572,8 @@ bool cmFileListGeneratorBase::Search(cmFileList& listing)
   return this->Search("", listing);
 }
 
-cmFileListGeneratorBase*
-cmFileListGeneratorBase::SetNext(cmFileListGeneratorBase const& next)
+cmFileListGeneratorBase* cmFileListGeneratorBase::SetNext(
+  cmFileListGeneratorBase const& next)
 {
   this->Next = next.Clone();
   return this->Next.get();
@@ -1752,371 +1582,369 @@ cmFileListGeneratorBase::SetNext(cmFileListGeneratorBase const& next)
 bool cmFileListGeneratorBase::Consider(std::string const& fullPath,
                                        cmFileList& listing)
 {
-  if(this->Next.get())
-    {
+  if (this->Next.get()) {
     return this->Next->Search(fullPath + "/", listing);
-    }
-  else
-    {
+  } else {
     return listing.Visit(fullPath + "/");
-    }
+  }
 }
 
-class cmFileListGeneratorFixed: public cmFileListGeneratorBase
+class cmFileListGeneratorFixed : public cmFileListGeneratorBase
 {
 public:
-  cmFileListGeneratorFixed(std::string const& str):
-    cmFileListGeneratorBase(), String(str) {}
-  cmFileListGeneratorFixed(cmFileListGeneratorFixed const& r):
-    cmFileListGeneratorBase(), String(r.String) {}
+  cmFileListGeneratorFixed(std::string const& str)
+    : cmFileListGeneratorBase()
+    , String(str)
+  {
+  }
+  cmFileListGeneratorFixed(cmFileListGeneratorFixed const& r)
+    : cmFileListGeneratorBase()
+    , String(r.String)
+  {
+  }
+
 private:
   std::string String;
   virtual bool Search(std::string const& parent, cmFileList& lister)
-    {
+  {
     std::string fullPath = parent + this->String;
     return this->Consider(fullPath, lister);
-    }
+  }
   virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
-    {
-    cmsys::auto_ptr<cmFileListGeneratorBase>
-      g(new cmFileListGeneratorFixed(*this));
+  {
+    cmsys::auto_ptr<cmFileListGeneratorBase> g(
+      new cmFileListGeneratorFixed(*this));
     return g;
-    }
+  }
 };
 
-class cmFileListGeneratorEnumerate: public cmFileListGeneratorBase
+class cmFileListGeneratorEnumerate : public cmFileListGeneratorBase
 {
 public:
-  cmFileListGeneratorEnumerate(std::vector<std::string> const& v):
-    cmFileListGeneratorBase(), Vector(v) {}
-  cmFileListGeneratorEnumerate(cmFileListGeneratorEnumerate const& r):
-    cmFileListGeneratorBase(), Vector(r.Vector) {}
+  cmFileListGeneratorEnumerate(std::vector<std::string> const& v)
+    : cmFileListGeneratorBase()
+    , Vector(v)
+  {
+  }
+  cmFileListGeneratorEnumerate(cmFileListGeneratorEnumerate const& r)
+    : cmFileListGeneratorBase()
+    , Vector(r.Vector)
+  {
+  }
+
 private:
   std::vector<std::string> const& Vector;
   virtual bool Search(std::string const& parent, cmFileList& lister)
-    {
-    for(std::vector<std::string>::const_iterator i = this->Vector.begin();
-        i != this->Vector.end(); ++i)
-      {
-      if(this->Consider(parent + *i, lister))
-        {
+  {
+    for (std::vector<std::string>::const_iterator i = this->Vector.begin();
+         i != this->Vector.end(); ++i) {
+      if (this->Consider(parent + *i, lister)) {
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
   virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
-    {
-    cmsys::auto_ptr<cmFileListGeneratorBase>
-      g(new cmFileListGeneratorEnumerate(*this));
+  {
+    cmsys::auto_ptr<cmFileListGeneratorBase> g(
+      new cmFileListGeneratorEnumerate(*this));
     return g;
-    }
+  }
 };
 
-class cmFileListGeneratorProject: public cmFileListGeneratorBase
+class cmFileListGeneratorProject : public cmFileListGeneratorBase
 {
 public:
-  cmFileListGeneratorProject(std::vector<std::string> const& names):
-    cmFileListGeneratorBase(), Names(names) {}
-  cmFileListGeneratorProject(cmFileListGeneratorProject const& r):
-    cmFileListGeneratorBase(), Names(r.Names) {}
+  cmFileListGeneratorProject(std::vector<std::string> const& names)
+    : cmFileListGeneratorBase()
+    , Names(names)
+  {
+  }
+  cmFileListGeneratorProject(cmFileListGeneratorProject const& r)
+    : cmFileListGeneratorBase()
+    , Names(r.Names)
+  {
+  }
+
 private:
   std::vector<std::string> const& Names;
   virtual bool Search(std::string const& parent, cmFileList& lister)
-    {
+  {
     // Construct a list of matches.
     std::vector<std::string> matches;
     cmsys::Directory d;
     d.Load(parent);
-    for(unsigned long i=0; i < d.GetNumberOfFiles(); ++i)
-      {
+    for (unsigned long i = 0; i < d.GetNumberOfFiles(); ++i) {
       const char* fname = d.GetFile(i);
-      if(strcmp(fname, ".") == 0 ||
-         strcmp(fname, "..") == 0)
-        {
+      if (strcmp(fname, ".") == 0 || strcmp(fname, "..") == 0) {
         continue;
-        }
-      for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-          ni != this->Names.end(); ++ni)
-        {
-        if(cmsysString_strncasecmp(fname, ni->c_str(),
-                                   ni->length()) == 0)
-          {
+      }
+      for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+           ni != this->Names.end(); ++ni) {
+        if (cmsysString_strncasecmp(fname, ni->c_str(), ni->length()) == 0) {
           matches.push_back(fname);
-          }
         }
       }
+    }
 
-    for(std::vector<std::string>::const_iterator i = matches.begin();
-        i != matches.end(); ++i)
-      {
-      if(this->Consider(parent + *i, lister))
-        {
+    for (std::vector<std::string>::const_iterator i = matches.begin();
+         i != matches.end(); ++i) {
+      if (this->Consider(parent + *i, lister)) {
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
   virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
-    {
-    cmsys::auto_ptr<cmFileListGeneratorBase>
-      g(new cmFileListGeneratorProject(*this));
+  {
+    cmsys::auto_ptr<cmFileListGeneratorBase> g(
+      new cmFileListGeneratorProject(*this));
     return g;
-    }
+  }
 };
 
-class cmFileListGeneratorMacProject: public cmFileListGeneratorBase
+class cmFileListGeneratorMacProject : public cmFileListGeneratorBase
 {
 public:
   cmFileListGeneratorMacProject(std::vector<std::string> const& names,
-                                const char* ext):
-    cmFileListGeneratorBase(), Names(names), Extension(ext) {}
-  cmFileListGeneratorMacProject(cmFileListGeneratorMacProject const& r):
-    cmFileListGeneratorBase(), Names(r.Names), Extension(r.Extension) {}
+                                const char* ext)
+    : cmFileListGeneratorBase()
+    , Names(names)
+    , Extension(ext)
+  {
+  }
+  cmFileListGeneratorMacProject(cmFileListGeneratorMacProject const& r)
+    : cmFileListGeneratorBase()
+    , Names(r.Names)
+    , Extension(r.Extension)
+  {
+  }
+
 private:
   std::vector<std::string> const& Names;
   std::string Extension;
   virtual bool Search(std::string const& parent, cmFileList& lister)
-    {
+  {
     // Construct a list of matches.
     std::vector<std::string> matches;
     cmsys::Directory d;
     d.Load(parent);
-    for(unsigned long i=0; i < d.GetNumberOfFiles(); ++i)
-      {
+    for (unsigned long i = 0; i < d.GetNumberOfFiles(); ++i) {
       const char* fname = d.GetFile(i);
-      if(strcmp(fname, ".") == 0 ||
-         strcmp(fname, "..") == 0)
-        {
+      if (strcmp(fname, ".") == 0 || strcmp(fname, "..") == 0) {
         continue;
-        }
-      for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-          ni != this->Names.end(); ++ni)
-        {
+      }
+      for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+           ni != this->Names.end(); ++ni) {
         std::string name = *ni;
         name += this->Extension;
-        if(cmsysString_strcasecmp(fname, name.c_str()) == 0)
-          {
+        if (cmsysString_strcasecmp(fname, name.c_str()) == 0) {
           matches.push_back(fname);
-          }
         }
       }
+    }
 
-    for(std::vector<std::string>::const_iterator i = matches.begin();
-        i != matches.end(); ++i)
-      {
-      if(this->Consider(parent + *i, lister))
-        {
+    for (std::vector<std::string>::const_iterator i = matches.begin();
+         i != matches.end(); ++i) {
+      if (this->Consider(parent + *i, lister)) {
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
   virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
-    {
-    cmsys::auto_ptr<cmFileListGeneratorBase>
-      g(new cmFileListGeneratorMacProject(*this));
+  {
+    cmsys::auto_ptr<cmFileListGeneratorBase> g(
+      new cmFileListGeneratorMacProject(*this));
     return g;
-    }
+  }
 };
 
-class cmFileListGeneratorCaseInsensitive: public cmFileListGeneratorBase
+class cmFileListGeneratorCaseInsensitive : public cmFileListGeneratorBase
 {
 public:
-  cmFileListGeneratorCaseInsensitive(std::string const& str):
-    cmFileListGeneratorBase(), String(str) {}
+  cmFileListGeneratorCaseInsensitive(std::string const& str)
+    : cmFileListGeneratorBase()
+    , String(str)
+  {
+  }
   cmFileListGeneratorCaseInsensitive(
-    cmFileListGeneratorCaseInsensitive const& r):
-    cmFileListGeneratorBase(), String(r.String) {}
+    cmFileListGeneratorCaseInsensitive const& r)
+    : cmFileListGeneratorBase()
+    , String(r.String)
+  {
+  }
+
 private:
   std::string String;
   virtual bool Search(std::string const& parent, cmFileList& lister)
-    {
+  {
     // Look for matching files.
     std::vector<std::string> matches;
     cmsys::Directory d;
     d.Load(parent);
-    for(unsigned long i=0; i < d.GetNumberOfFiles(); ++i)
-      {
+    for (unsigned long i = 0; i < d.GetNumberOfFiles(); ++i) {
       const char* fname = d.GetFile(i);
-      if(strcmp(fname, ".") == 0 ||
-         strcmp(fname, "..") == 0)
-        {
+      if (strcmp(fname, ".") == 0 || strcmp(fname, "..") == 0) {
         continue;
-        }
-      if(cmsysString_strcasecmp(fname, this->String.c_str()) == 0)
-        {
-        if(this->Consider(parent + fname, lister))
-          {
+      }
+      if (cmsysString_strcasecmp(fname, this->String.c_str()) == 0) {
+        if (this->Consider(parent + fname, lister)) {
           return true;
-          }
         }
       }
-    return false;
     }
+    return false;
+  }
   virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
-    {
-    cmsys::auto_ptr<cmFileListGeneratorBase>
-      g(new cmFileListGeneratorCaseInsensitive(*this));
+  {
+    cmsys::auto_ptr<cmFileListGeneratorBase> g(
+      new cmFileListGeneratorCaseInsensitive(*this));
     return g;
-    }
+  }
 };
 
-class cmFileListGeneratorGlob: public cmFileListGeneratorBase
+class cmFileListGeneratorGlob : public cmFileListGeneratorBase
 {
 public:
-  cmFileListGeneratorGlob(std::string const& str):
-    cmFileListGeneratorBase(), Pattern(str) {}
-  cmFileListGeneratorGlob(cmFileListGeneratorGlob const& r):
-    cmFileListGeneratorBase(), Pattern(r.Pattern) {}
+  cmFileListGeneratorGlob(std::string const& str)
+    : cmFileListGeneratorBase()
+    , Pattern(str)
+  {
+  }
+  cmFileListGeneratorGlob(cmFileListGeneratorGlob const& r)
+    : cmFileListGeneratorBase()
+    , Pattern(r.Pattern)
+  {
+  }
+
 private:
   std::string Pattern;
   virtual bool Search(std::string const& parent, cmFileList& lister)
-    {
+  {
     // Glob the set of matching files.
     std::string expr = parent;
     expr += this->Pattern;
     cmsys::Glob g;
-    if(!g.FindFiles(expr))
-      {
+    if (!g.FindFiles(expr)) {
       return false;
-      }
+    }
     std::vector<std::string> const& files = g.GetFiles();
 
     // Look for directories among the matches.
-    for(std::vector<std::string>::const_iterator fi = files.begin();
-        fi != files.end(); ++fi)
-      {
-      if(cmSystemTools::FileIsDirectory(*fi))
-        {
-        if(this->Consider(*fi, lister))
-          {
+    for (std::vector<std::string>::const_iterator fi = files.begin();
+         fi != files.end(); ++fi) {
+      if (cmSystemTools::FileIsDirectory(*fi)) {
+        if (this->Consider(*fi, lister)) {
           return true;
-          }
         }
       }
-    return false;
     }
+    return false;
+  }
   virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const
-    {
-    cmsys::auto_ptr<cmFileListGeneratorBase>
-      g(new cmFileListGeneratorGlob(*this));
+  {
+    cmsys::auto_ptr<cmFileListGeneratorBase> g(
+      new cmFileListGeneratorGlob(*this));
     return g;
-    }
+  }
 };
 
 bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
 {
-  assert(!prefix_in.empty() && prefix_in[prefix_in.size()-1] == '/');
-  if(this->DebugMode)
-    {
+  assert(!prefix_in.empty() && prefix_in[prefix_in.size() - 1] == '/');
+  if (this->DebugMode) {
     fprintf(stderr, "Checking prefix [%s]\n", prefix_in.c_str());
-    }
+  }
 
   // Skip this if the prefix does not exist.
-  if(!cmSystemTools::FileIsDirectory(prefix_in))
-    {
+  if (!cmSystemTools::FileIsDirectory(prefix_in)) {
     return false;
-    }
+  }
 
   //  PREFIX/ (useful on windows or in build trees)
-  if(this->SearchDirectory(prefix_in))
-    {
+  if (this->SearchDirectory(prefix_in)) {
     return true;
-    }
+  }
 
   // Strip the trailing slash because the path generator is about to
   // add one.
-  std::string prefix = prefix_in.substr(0, prefix_in.size()-1);
+  std::string prefix = prefix_in.substr(0, prefix_in.size() - 1);
 
   //  PREFIX/(cmake|CMake)/ (useful on windows or in build trees)
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorCaseInsensitive("cmake");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorCaseInsensitive("cmake");
+    if (lister.Search()) {
+      return true;
     }
   }
 
   //  PREFIX/(Foo|foo|FOO).*/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorProject(this->Names);
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorProject(this->Names);
+    if (lister.Search()) {
+      return true;
     }
   }
 
   //  PREFIX/(Foo|foo|FOO).*/(cmake|CMake)/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorProject(this->Names)
-    / cmFileListGeneratorCaseInsensitive("cmake");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorProject(this->Names) /
+      cmFileListGeneratorCaseInsensitive("cmake");
+    if (lister.Search()) {
+      return true;
     }
   }
 
   // Construct list of common install locations (lib and share).
   std::vector<std::string> common;
-  if(!this->LibraryArchitecture.empty())
-    {
-    common.push_back("lib/"+this->LibraryArchitecture);
-    }
-  if(this->UseLib64Paths)
-    {
+  if (!this->LibraryArchitecture.empty()) {
+    common.push_back("lib/" + this->LibraryArchitecture);
+  }
+  if (this->UseLib64Paths) {
     common.push_back("lib64");
-    }
+  }
   common.push_back("lib");
   common.push_back("share");
 
   //  PREFIX/(lib/ARCH|lib|share)/cmake/(Foo|foo|FOO).*/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorEnumerate(common)
-    / cmFileListGeneratorFixed("cmake")
-    / cmFileListGeneratorProject(this->Names);
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorEnumerate(common) /
+      cmFileListGeneratorFixed("cmake") /
+      cmFileListGeneratorProject(this->Names);
+    if (lister.Search()) {
+      return true;
     }
   }
 
   //  PREFIX/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorEnumerate(common)
-    / cmFileListGeneratorProject(this->Names);
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorEnumerate(common) /
+      cmFileListGeneratorProject(this->Names);
+    if (lister.Search()) {
+      return true;
     }
   }
 
   //  PREFIX/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/(cmake|CMake)/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorEnumerate(common)
-    / cmFileListGeneratorProject(this->Names)
-    / cmFileListGeneratorCaseInsensitive("cmake");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorEnumerate(common) /
+      cmFileListGeneratorProject(this->Names) /
+      cmFileListGeneratorCaseInsensitive("cmake");
+    if (lister.Search()) {
+      return true;
     }
   }
 
@@ -2125,68 +1953,59 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
 
 bool cmFindPackageCommand::SearchFrameworkPrefix(std::string const& prefix_in)
 {
-  assert(!prefix_in.empty() && prefix_in[prefix_in.size()-1] == '/');
-  if(this->DebugMode)
-    {
+  assert(!prefix_in.empty() && prefix_in[prefix_in.size() - 1] == '/');
+  if (this->DebugMode) {
     fprintf(stderr, "Checking framework prefix [%s]\n", prefix_in.c_str());
-    }
+  }
 
   // Strip the trailing slash because the path generator is about to
   // add one.
-  std::string prefix = prefix_in.substr(0, prefix_in.size()-1);
+  std::string prefix = prefix_in.substr(0, prefix_in.size() - 1);
 
   // <prefix>/Foo.framework/Resources/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorMacProject(this->Names, ".framework")
-    / cmFileListGeneratorFixed("Resources");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorMacProject(this->Names, ".framework") /
+      cmFileListGeneratorFixed("Resources");
+    if (lister.Search()) {
+      return true;
     }
   }
   // <prefix>/Foo.framework/Resources/CMake/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorMacProject(this->Names, ".framework")
-    / cmFileListGeneratorFixed("Resources")
-    / cmFileListGeneratorCaseInsensitive("cmake");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorMacProject(this->Names, ".framework") /
+      cmFileListGeneratorFixed("Resources") /
+      cmFileListGeneratorCaseInsensitive("cmake");
+    if (lister.Search()) {
+      return true;
     }
   }
 
   // <prefix>/Foo.framework/Versions/*/Resources/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorMacProject(this->Names, ".framework")
-    / cmFileListGeneratorFixed("Versions")
-    / cmFileListGeneratorGlob("*/Resources");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorMacProject(this->Names, ".framework") /
+      cmFileListGeneratorFixed("Versions") /
+      cmFileListGeneratorGlob("*/Resources");
+    if (lister.Search()) {
+      return true;
     }
   }
 
   // <prefix>/Foo.framework/Versions/*/Resources/CMake/
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorMacProject(this->Names, ".framework")
-    / cmFileListGeneratorFixed("Versions")
-    / cmFileListGeneratorGlob("*/Resources")
-    / cmFileListGeneratorCaseInsensitive("cmake");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorMacProject(this->Names, ".framework") /
+      cmFileListGeneratorFixed("Versions") /
+      cmFileListGeneratorGlob("*/Resources") /
+      cmFileListGeneratorCaseInsensitive("cmake");
+    if (lister.Search()) {
+      return true;
     }
   }
 
@@ -2195,40 +2014,35 @@ bool cmFindPackageCommand::SearchFrameworkPrefix(std::string const& prefix_in)
 
 bool cmFindPackageCommand::SearchAppBundlePrefix(std::string const& prefix_in)
 {
-  assert(!prefix_in.empty() && prefix_in[prefix_in.size()-1] == '/');
-  if(this->DebugMode)
-    {
+  assert(!prefix_in.empty() && prefix_in[prefix_in.size() - 1] == '/');
+  if (this->DebugMode) {
     fprintf(stderr, "Checking bundle prefix [%s]\n", prefix_in.c_str());
-    }
+  }
 
   // Strip the trailing slash because the path generator is about to
   // add one.
-  std::string prefix = prefix_in.substr(0, prefix_in.size()-1);
+  std::string prefix = prefix_in.substr(0, prefix_in.size() - 1);
 
   // <prefix>/Foo.app/Contents/Resources
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorMacProject(this->Names, ".app")
-    / cmFileListGeneratorFixed("Contents/Resources");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorMacProject(this->Names, ".app") /
+      cmFileListGeneratorFixed("Contents/Resources");
+    if (lister.Search()) {
+      return true;
     }
   }
 
   // <prefix>/Foo.app/Contents/Resources/CMake
   {
-  cmFindPackageFileList lister(this);
-  lister
-    / cmFileListGeneratorFixed(prefix)
-    / cmFileListGeneratorMacProject(this->Names, ".app")
-    / cmFileListGeneratorFixed("Contents/Resources")
-    / cmFileListGeneratorCaseInsensitive("cmake");
-  if(lister.Search())
-    {
-    return true;
+    cmFindPackageFileList lister(this);
+    lister / cmFileListGeneratorFixed(prefix) /
+      cmFileListGeneratorMacProject(this->Names, ".app") /
+      cmFileListGeneratorFixed("Contents/Resources") /
+      cmFileListGeneratorCaseInsensitive("cmake");
+    if (lister.Search()) {
+      return true;
     }
   }
 
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 8bfd405..eff6b80 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -29,17 +29,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFindPackageCommand;
-    }
+  virtual cmCommand* Clone() { return new cmFindPackageCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -49,16 +46,21 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "find_package";}
+  virtual std::string GetName() const { return "find_package"; }
 
   cmTypeMacro(cmFindPackageCommand, cmFindCommon);
+
 private:
   class PathLabel : public cmFindCommon::PathLabel
   {
   protected:
     PathLabel();
+
   public:
-    PathLabel(const std::string& label) : cmFindCommon::PathLabel(label) { }
+    PathLabel(const std::string& label)
+      : cmFindCommon::PathLabel(label)
+    {
+    }
     static PathLabel UserRegistry;
     static PathLabel Builds;
     static PathLabel SystemRegistry;
@@ -79,7 +81,11 @@ private:
   bool FindPrefixedConfig();
   bool FindFrameworkConfig();
   bool FindAppBundleConfig();
-  enum PolicyScopeRule { NoPolicyScope, DoPolicyScope };
+  enum PolicyScopeRule
+  {
+    NoPolicyScope,
+    DoPolicyScope
+  };
   bool ReadListFile(const char* f, PolicyScopeRule psr);
   void StoreVersionFound();
 
@@ -111,7 +117,11 @@ private:
 
   friend class cmFindPackageFileList;
 
-  struct OriginalDef { bool exists; std::string value; };
+  struct OriginalDef
+  {
+    bool exists;
+    std::string value;
+  };
   std::map<std::string, OriginalDef> OriginalDefs;
 
   std::string Name;
@@ -145,7 +155,11 @@ private:
   std::vector<std::string> Configs;
   std::set<std::string> IgnoredPaths;
 
-  struct ConfigFileInfo { std::string filename; std::string version; };
+  struct ConfigFileInfo
+  {
+    std::string filename;
+    std::string version;
+  };
   std::vector<ConfigFileInfo> ConsideredConfigs;
 };
 
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index c34a98c..d24be6a 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -20,72 +20,57 @@ cmFindPathCommand::cmFindPathCommand()
 }
 
 // cmFindPathCommand
-bool cmFindPathCommand
-::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
+bool cmFindPathCommand::InitialPass(std::vector<std::string> const& argsIn,
+                                    cmExecutionStatus&)
 {
   this->VariableDocumentation = "Path to a file.";
   this->CMakePathName = "INCLUDE";
-  if(!this->ParseArguments(argsIn))
-    {
+  if (!this->ParseArguments(argsIn)) {
     return false;
-    }
-  if(this->AlreadyInCache)
-    {
+  }
+  if (this->AlreadyInCache) {
     // If the user specifies the entry on the command line without a
     // type we should add the type and docstring but keep the original
     // value.
-    if(this->AlreadyInCacheWithoutMetaInfo)
-      {
+    if (this->AlreadyInCacheWithoutMetaInfo) {
       this->Makefile->AddCacheDefinition(
-        this->VariableName, "",
-        this->VariableDocumentation.c_str(),
-        (this->IncludeFileInPath ?
-         cmState::FILEPATH :cmState::PATH)
-        );
-      }
-    return true;
+        this->VariableName, "", this->VariableDocumentation.c_str(),
+        (this->IncludeFileInPath ? cmState::FILEPATH : cmState::PATH));
     }
+    return true;
+  }
 
   std::string result = this->FindHeader();
-  if(!result.empty())
-    {
-    this->Makefile->AddCacheDefinition
-      (this->VariableName, result.c_str(),
-       this->VariableDocumentation.c_str(),
-       (this->IncludeFileInPath) ?
-       cmState::FILEPATH :cmState::PATH);
+  if (!result.empty()) {
+    this->Makefile->AddCacheDefinition(
+      this->VariableName, result.c_str(), this->VariableDocumentation.c_str(),
+      (this->IncludeFileInPath) ? cmState::FILEPATH : cmState::PATH);
     return true;
-    }
-  this->Makefile->AddCacheDefinition
-    (this->VariableName,
-     (this->VariableName + "-NOTFOUND").c_str(),
-     this->VariableDocumentation.c_str(),
-     (this->IncludeFileInPath) ?
-     cmState::FILEPATH :cmState::PATH);
+  }
+  this->Makefile->AddCacheDefinition(
+    this->VariableName, (this->VariableName + "-NOTFOUND").c_str(),
+    this->VariableDocumentation.c_str(),
+    (this->IncludeFileInPath) ? cmState::FILEPATH : cmState::PATH);
   return true;
 }
 
 std::string cmFindPathCommand::FindHeader()
 {
   std::string header;
-  if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
-    {
+  if (this->SearchFrameworkFirst || this->SearchFrameworkOnly) {
     header = this->FindFrameworkHeader();
-    }
-  if(header.empty() && !this->SearchFrameworkOnly)
-    {
+  }
+  if (header.empty() && !this->SearchFrameworkOnly) {
     header = this->FindNormalHeader();
-    }
-  if(header.empty() && this->SearchFrameworkLast)
-    {
+  }
+  if (header.empty() && this->SearchFrameworkLast) {
     header = this->FindFrameworkHeader();
-    }
+  }
   return header;
 }
 
-std::string
-cmFindPathCommand::FindHeaderInFramework(std::string const& file,
-                                         std::string const& dir)
+std::string cmFindPathCommand::FindHeaderInFramework(std::string const& file,
+                                                     std::string const& dir)
 {
   std::string fileName = file;
   std::string frameWorkName;
@@ -93,37 +78,32 @@ cmFindPathCommand::FindHeaderInFramework(std::string const& file,
   // if there is a / in the name try to find the header as a framework
   // For example bar/foo.h would look for:
   // bar.framework/Headers/foo.h
-  if(pos != fileName.npos)
-    {
+  if (pos != fileName.npos) {
     // remove the name from the slash;
-    fileName = fileName.substr(pos+1);
+    fileName = fileName.substr(pos + 1);
     frameWorkName = file;
     frameWorkName =
-      frameWorkName.substr(0, frameWorkName.size()-fileName.size()-1);
+      frameWorkName.substr(0, frameWorkName.size() - fileName.size() - 1);
     // if the framework has a path in it then just use the filename
-    if(frameWorkName.find("/") != frameWorkName.npos)
-      {
+    if (frameWorkName.find("/") != frameWorkName.npos) {
       fileName = file;
       frameWorkName = "";
-      }
-    if(!frameWorkName.empty())
-      {
+    }
+    if (!frameWorkName.empty()) {
       std::string fpath = dir;
       fpath += frameWorkName;
       fpath += ".framework";
       std::string intPath = fpath;
       intPath += "/Headers/";
       intPath += fileName;
-      if(cmSystemTools::FileExists(intPath.c_str()))
-        {
-        if(this->IncludeFileInPath)
-          {
+      if (cmSystemTools::FileExists(intPath.c_str())) {
+        if (this->IncludeFileInPath) {
           return intPath;
-          }
-        return fpath;
         }
+        return fpath;
       }
     }
+  }
   // if it is not found yet or not a framework header, then do a glob search
   // for all frameworks in the directory: dir/*.framework/Headers/<file>
   std::string glob = dir;
@@ -132,62 +112,51 @@ cmFindPathCommand::FindHeaderInFramework(std::string const& file,
   cmsys::Glob globIt;
   globIt.FindFiles(glob);
   std::vector<std::string> files = globIt.GetFiles();
-  if(!files.empty())
-    {
+  if (!files.empty()) {
     std::string fheader = cmSystemTools::CollapseFullPath(files[0]);
-    if(this->IncludeFileInPath)
-      {
+    if (this->IncludeFileInPath) {
       return fheader;
-      }
+    }
     fheader = cmSystemTools::GetFilenamePath(fheader);
     return fheader;
-    }
+  }
   return "";
 }
 
 std::string cmFindPathCommand::FindNormalHeader()
 {
   std::string tryPath;
-  for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end() ; ++ni)
-    {
-    for(std::vector<std::string>::const_iterator
-          p = this->SearchPaths.begin();
-        p != this->SearchPaths.end(); ++p)
-      {
+  for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
+    for (std::vector<std::string>::const_iterator p =
+           this->SearchPaths.begin();
+         p != this->SearchPaths.end(); ++p) {
       tryPath = *p;
       tryPath += *ni;
-      if(cmSystemTools::FileExists(tryPath.c_str()))
-        {
-        if(this->IncludeFileInPath)
-          {
+      if (cmSystemTools::FileExists(tryPath.c_str())) {
+        if (this->IncludeFileInPath) {
           return tryPath;
-          }
-        else
-          {
+        } else {
           return *p;
-          }
         }
       }
     }
+  }
   return "";
 }
 
 std::string cmFindPathCommand::FindFrameworkHeader()
 {
-  for(std::vector<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end() ; ++ni)
-    {
-    for(std::vector<std::string>::const_iterator
-          p = this->SearchPaths.begin();
-        p != this->SearchPaths.end(); ++p)
-      {
+  for (std::vector<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
+    for (std::vector<std::string>::const_iterator p =
+           this->SearchPaths.begin();
+         p != this->SearchPaths.end(); ++p) {
       std::string fwPath = this->FindHeaderInFramework(*ni, *p);
-      if(!fwPath.empty())
-        {
+      if (!fwPath.empty()) {
         return fwPath;
-        }
       }
     }
+  }
   return "";
 }
diff --git a/Source/cmFindPathCommand.h b/Source/cmFindPathCommand.h
index a51da79..e14626a 100644
--- a/Source/cmFindPathCommand.h
+++ b/Source/cmFindPathCommand.h
@@ -14,7 +14,6 @@
 
 #include "cmFindBase.h"
 
-
 /** \class cmFindPathCommand
  * \brief Define a command to search for a library.
  *
@@ -29,17 +28,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFindPathCommand;
-    }
+  virtual cmCommand* Clone() { return new cmFindPathCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -49,10 +45,11 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "find_path";}
+  virtual std::string GetName() const { return "find_path"; }
 
   cmTypeMacro(cmFindPathCommand, cmFindBase);
   bool IncludeFileInPath;
+
 private:
   std::string FindHeaderInFramework(std::string const& file,
                                     std::string const& dir);
@@ -61,6 +58,4 @@ private:
   std::string FindFrameworkHeader();
 };
 
-
-
 #endif
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 423bf62..8d142c9 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -20,15 +20,15 @@
 struct cmFindProgramHelper
 {
   cmFindProgramHelper()
-    {
-#if defined (_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
+  {
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
     // Consider platform-specific extensions.
     this->Extensions.push_back(".com");
     this->Extensions.push_back(".exe");
 #endif
     // Consider original name with no extensions.
     this->Extensions.push_back("");
-    }
+  }
 
   // List of valid extensions.
   std::vector<std::string> Extensions;
@@ -42,47 +42,39 @@ struct cmFindProgramHelper
   // Current full path under consideration.
   std::string TestPath;
 
-  void AddName(std::string const& name)
-    {
-    this->Names.push_back(name);
-    }
+  void AddName(std::string const& name) { this->Names.push_back(name); }
   void SetName(std::string const& name)
-    {
+  {
     this->Names.clear();
     this->AddName(name);
-    }
+  }
   bool CheckDirectory(std::string const& path)
-    {
+  {
     for (std::vector<std::string>::iterator i = this->Names.begin();
-         i != this->Names.end(); ++i)
-      {
-      if (this->CheckDirectoryForName(path, *i))
-        {
+         i != this->Names.end(); ++i) {
+      if (this->CheckDirectoryForName(path, *i)) {
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
   bool CheckDirectoryForName(std::string const& path, std::string const& name)
-    {
+  {
     for (std::vector<std::string>::iterator ext = this->Extensions.begin();
-         ext != this->Extensions.end(); ++ext)
-      {
+         ext != this->Extensions.end(); ++ext) {
       this->TestPath = path;
       this->TestPath += name;
-      if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str()))
-        {
+      if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str())) {
         continue;
-        }
+      }
       this->TestPath += *ext;
-      if (cmSystemTools::FileExists(this->TestPath, true))
-        {
+      if (cmSystemTools::FileExists(this->TestPath, true)) {
         this->BestPath = cmSystemTools::CollapseFullPath(this->TestPath);
         return true;
-        }
       }
-    return false;
     }
+    return false;
+  }
 };
 
 cmFindProgramCommand::cmFindProgramCommand()
@@ -91,45 +83,39 @@ cmFindProgramCommand::cmFindProgramCommand()
 }
 
 // cmFindProgramCommand
-bool cmFindProgramCommand
-::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
+bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn,
+                                       cmExecutionStatus&)
 {
   this->VariableDocumentation = "Path to a program.";
   this->CMakePathName = "PROGRAM";
   // call cmFindBase::ParseArguments
-  if(!this->ParseArguments(argsIn))
-    {
+  if (!this->ParseArguments(argsIn)) {
     return false;
-    }
-  if(this->AlreadyInCache)
-    {
+  }
+  if (this->AlreadyInCache) {
     // If the user specifies the entry on the command line without a
     // type we should add the type and docstring but keep the original
     // value.
-    if(this->AlreadyInCacheWithoutMetaInfo)
-      {
+    if (this->AlreadyInCacheWithoutMetaInfo) {
       this->Makefile->AddCacheDefinition(this->VariableName, "",
                                          this->VariableDocumentation.c_str(),
                                          cmState::FILEPATH);
-      }
-    return true;
     }
+    return true;
+  }
 
   std::string result = FindProgram();
-  if(result != "")
-    {
+  if (result != "") {
     // Save the value in the cache
-    this->Makefile->AddCacheDefinition(this->VariableName,
-                                       result.c_str(),
+    this->Makefile->AddCacheDefinition(this->VariableName, result.c_str(),
                                        this->VariableDocumentation.c_str(),
                                        cmState::FILEPATH);
 
     return true;
-    }
-  this->Makefile->AddCacheDefinition(this->VariableName,
-                                 (this->VariableName + "-NOTFOUND").c_str(),
-                                 this->VariableDocumentation.c_str(),
-                                 cmState::FILEPATH);
+  }
+  this->Makefile->AddCacheDefinition(
+    this->VariableName, (this->VariableName + "-NOTFOUND").c_str(),
+    this->VariableDocumentation.c_str(), cmState::FILEPATH);
   return true;
 }
 
@@ -137,32 +123,26 @@ std::string cmFindProgramCommand::FindProgram()
 {
   std::string program = "";
 
-  if(this->SearchAppBundleFirst || this->SearchAppBundleOnly)
-    {
+  if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
     program = FindAppBundle();
-    }
-  if(program.empty() && !this->SearchAppBundleOnly)
-    {
+  }
+  if (program.empty() && !this->SearchAppBundleOnly) {
     program = this->FindNormalProgram();
-    }
+  }
 
-  if(program.empty() && this->SearchAppBundleLast)
-    {
+  if (program.empty() && this->SearchAppBundleLast) {
     program = this->FindAppBundle();
-    }
+  }
   return program;
 }
 
 std::string cmFindProgramCommand::FindNormalProgram()
 {
-  if(this->NamesPerDir)
-    {
+  if (this->NamesPerDir) {
     return this->FindNormalProgramNamesPerDir();
-    }
-  else
-    {
+  } else {
     return this->FindNormalProgramDirsPerName();
-    }
+  }
 }
 
 std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
@@ -170,26 +150,22 @@ std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
   // Search for all names in each directory.
   cmFindProgramHelper helper;
   for (std::vector<std::string>::const_iterator ni = this->Names.begin();
-       ni != this->Names.end() ; ++ni)
-    {
+       ni != this->Names.end(); ++ni) {
     helper.AddName(*ni);
-    }
+  }
 
   // Check for the names themselves (e.g. absolute paths).
-  if (helper.CheckDirectory(std::string()))
-    {
+  if (helper.CheckDirectory(std::string())) {
     return helper.BestPath;
-    }
+  }
 
   // Search every directory.
-  for (std::vector<std::string>::const_iterator
-         p = this->SearchPaths.begin(); p != this->SearchPaths.end(); ++p)
-    {
-    if(helper.CheckDirectory(*p))
-      {
+  for (std::vector<std::string>::const_iterator p = this->SearchPaths.begin();
+       p != this->SearchPaths.end(); ++p) {
+    if (helper.CheckDirectory(*p)) {
       return helper.BestPath;
-      }
     }
+  }
   // Couldn't find the program.
   return "";
 }
@@ -199,52 +175,44 @@ std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
   // Search the entire path for each name.
   cmFindProgramHelper helper;
   for (std::vector<std::string>::const_iterator ni = this->Names.begin();
-       ni != this->Names.end() ; ++ni)
-    {
+       ni != this->Names.end(); ++ni) {
     // Switch to searching for this name.
     helper.SetName(*ni);
 
     // Check for the name by itself (e.g. an absolute path).
-    if (helper.CheckDirectory(std::string()))
-      {
+    if (helper.CheckDirectory(std::string())) {
       return helper.BestPath;
-      }
+    }
 
     // Search every directory.
-    for (std::vector<std::string>::const_iterator
-           p = this->SearchPaths.begin();
-         p != this->SearchPaths.end(); ++p)
-      {
-      if (helper.CheckDirectory(*p))
-        {
+    for (std::vector<std::string>::const_iterator p =
+           this->SearchPaths.begin();
+         p != this->SearchPaths.end(); ++p) {
+      if (helper.CheckDirectory(*p)) {
         return helper.BestPath;
-        }
       }
     }
+  }
   // Couldn't find the program.
   return "";
 }
 
 std::string cmFindProgramCommand::FindAppBundle()
 {
-  for(std::vector<std::string>::const_iterator name = this->Names.begin();
-      name != this->Names.end() ; ++name)
-    {
+  for (std::vector<std::string>::const_iterator name = this->Names.begin();
+       name != this->Names.end(); ++name) {
 
     std::string appName = *name + std::string(".app");
-    std::string appPath = cmSystemTools::FindDirectory(appName,
-                                                       this->SearchPaths,
-                                                       true);
+    std::string appPath =
+      cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
 
-    if ( !appPath.empty() )
-      {
+    if (!appPath.empty()) {
       std::string executable = GetBundleExecutable(appPath);
-      if (!executable.empty())
-        {
+      if (!executable.empty()) {
         return cmSystemTools::CollapseFullPath(executable);
-        }
       }
     }
+  }
 
   // Couldn't find app bundle
   return "";
@@ -260,45 +228,40 @@ std::string cmFindProgramCommand::GetBundleExecutable(std::string bundlePath)
 
   // Get a CFString of the app bundle path
   // XXX - Is it safe to assume everything is in UTF8?
-  CFStringRef bundlePathCFS =
-    CFStringCreateWithCString(kCFAllocatorDefault ,
-                              bundlePath.c_str(), kCFStringEncodingUTF8 );
+  CFStringRef bundlePathCFS = CFStringCreateWithCString(
+    kCFAllocatorDefault, bundlePath.c_str(), kCFStringEncodingUTF8);
 
   // Make a CFURLRef from the CFString representation of the
   // bundle’s path.
-  CFURLRef bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
-                                                     bundlePathCFS,
-                                                     kCFURLPOSIXPathStyle,
-                                                     true );
+  CFURLRef bundleURL = CFURLCreateWithFileSystemPath(
+    kCFAllocatorDefault, bundlePathCFS, kCFURLPOSIXPathStyle, true);
 
   // Make a bundle instance using the URLRef.
-  CFBundleRef appBundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );
+  CFBundleRef appBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
 
   // returned executableURL is relative to <appbundle>/Contents/MacOS/
   CFURLRef executableURL = CFBundleCopyExecutableURL(appBundle);
 
-  if (executableURL != NULL)
-    {
+  if (executableURL != NULL) {
     const int MAX_OSX_PATH_SIZE = 1024;
     char buffer[MAX_OSX_PATH_SIZE];
 
     // Convert the CFString to a C string
-    CFStringGetCString( CFURLGetString(executableURL), buffer,
-                        MAX_OSX_PATH_SIZE, kCFStringEncodingUTF8 );
+    CFStringGetCString(CFURLGetString(executableURL), buffer,
+                       MAX_OSX_PATH_SIZE, kCFStringEncodingUTF8);
 
     // And finally to a c++ string
     executable = bundlePath + "/Contents/MacOS/" + std::string(buffer);
     // Only release CFURLRef if it's not null
-    CFRelease( executableURL );
-    }
+    CFRelease(executableURL);
+  }
 
   // Any CF objects returned from functions with "create" or
   // "copy" in their names must be released by us!
-  CFRelease( bundlePathCFS );
-  CFRelease( bundleURL );
-  CFRelease( appBundle );
+  CFRelease(bundlePathCFS);
+  CFRelease(bundleURL);
+  CFRelease(appBundle);
 #endif
 
   return executable;
 }
-
diff --git a/Source/cmFindProgramCommand.h b/Source/cmFindProgramCommand.h
index f88186b..3f2ac0e 100644
--- a/Source/cmFindProgramCommand.h
+++ b/Source/cmFindProgramCommand.h
@@ -29,17 +29,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFindProgramCommand;
-    }
+  virtual cmCommand* Clone() { return new cmFindProgramCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -49,7 +46,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "find_program";}
+  virtual std::string GetName() const { return "find_program"; }
 
   cmTypeMacro(cmFindProgramCommand, cmFindBase);
 
@@ -60,9 +57,6 @@ private:
   std::string FindNormalProgramNamesPerDir();
   std::string FindAppBundle();
   std::string GetBundleExecutable(std::string bundlePath);
-
 };
 
-
-
 #endif
diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx
index b138e33..daf43e6 100644
--- a/Source/cmForEachCommand.cxx
+++ b/Source/cmForEachCommand.cxx
@@ -13,8 +13,9 @@
 
 #include <cmsys/auto_ptr.hxx>
 
-cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile* mf):
-  Makefile(mf), Depth(0)
+cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile* mf)
+  : Makefile(mf)
+  , Depth(0)
 {
   this->Makefile->PushLoopBlock();
 }
@@ -24,79 +25,68 @@ cmForEachFunctionBlocker::~cmForEachFunctionBlocker()
   this->Makefile->PopLoopBlock();
 }
 
-bool cmForEachFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
-                  cmExecutionStatus &inStatus)
+bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
+                                                 cmMakefile& mf,
+                                                 cmExecutionStatus& inStatus)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(),"foreach"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "foreach")) {
     // record the number of nested foreach commands
     this->Depth++;
-    }
-  else if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endforeach"))
-    {
+  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endforeach")) {
     // if this is the endofreach for this statement
-    if (!this->Depth)
-      {
+    if (!this->Depth) {
       // Remove the function blocker for this scope or bail.
-      cmsys::auto_ptr<cmFunctionBlocker>
-        fb(mf.RemoveFunctionBlocker(this, lff));
-      if(!fb.get()) { return false; }
+      cmsys::auto_ptr<cmFunctionBlocker> fb(
+        mf.RemoveFunctionBlocker(this, lff));
+      if (!fb.get()) {
+        return false;
+      }
 
       // at end of for each execute recorded commands
       // store the old value
       std::string oldDef;
-      if (mf.GetDefinition(this->Args[0]))
-        {
+      if (mf.GetDefinition(this->Args[0])) {
         oldDef = mf.GetDefinition(this->Args[0]);
-        }
+      }
       std::vector<std::string>::const_iterator j = this->Args.begin();
       ++j;
 
-      for( ; j != this->Args.end(); ++j)
-        {
+      for (; j != this->Args.end(); ++j) {
         // set the variable to the loop value
-        mf.AddDefinition(this->Args[0],j->c_str());
+        mf.AddDefinition(this->Args[0], j->c_str());
         // Invoke all the functions that were collected in the block.
         cmExecutionStatus status;
-        for(unsigned int c = 0; c < this->Functions.size(); ++c)
-          {
+        for (unsigned int c = 0; c < this->Functions.size(); ++c) {
           status.Clear();
-          mf.ExecuteCommand(this->Functions[c],status);
-          if (status.GetReturnInvoked())
-            {
+          mf.ExecuteCommand(this->Functions[c], status);
+          if (status.GetReturnInvoked()) {
             inStatus.SetReturnInvoked(true);
             // restore the variable to its prior value
-            mf.AddDefinition(this->Args[0],oldDef.c_str());
+            mf.AddDefinition(this->Args[0], oldDef.c_str());
             return true;
-            }
-          if (status.GetBreakInvoked())
-            {
+          }
+          if (status.GetBreakInvoked()) {
             // restore the variable to its prior value
-            mf.AddDefinition(this->Args[0],oldDef.c_str());
+            mf.AddDefinition(this->Args[0], oldDef.c_str());
             return true;
-            }
-          if (status.GetContinueInvoked())
-            {
+          }
+          if (status.GetContinueInvoked()) {
             break;
-            }
-          if(cmSystemTools::GetFatalErrorOccured() )
-            {
+          }
+          if (cmSystemTools::GetFatalErrorOccured()) {
             return true;
-            }
           }
         }
+      }
 
       // restore the variable to its prior value
-      mf.AddDefinition(this->Args[0],oldDef.c_str());
+      mf.AddDefinition(this->Args[0], oldDef.c_str());
       return true;
-      }
-    else
-      {
+    } else {
       // close out a nested foreach
       this->Depth--;
-      }
     }
+  }
 
   // record the command
   this->Functions.push_back(lff);
@@ -105,112 +95,88 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
   return true;
 }
 
-bool cmForEachFunctionBlocker::
-ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf)
+bool cmForEachFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
+                                            cmMakefile& mf)
 {
-  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endforeach"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endforeach")) {
     std::vector<std::string> expandedArguments;
     mf.ExpandArguments(lff.Arguments, expandedArguments);
     // if the endforeach has arguments then make sure
     // they match the begin foreach arguments
     if ((expandedArguments.empty() ||
-         (expandedArguments[0] == this->Args[0])))
-      {
+         (expandedArguments[0] == this->Args[0]))) {
       return true;
-      }
     }
+  }
   return false;
 }
 
-bool cmForEachCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmForEachCommand::InitialPass(std::vector<std::string> const& args,
+                                   cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
-  if(args.size() > 1 && args[1] == "IN")
-    {
+  }
+  if (args.size() > 1 && args[1] == "IN") {
     return this->HandleInMode(args);
-    }
+  }
 
   // create a function blocker
-  cmForEachFunctionBlocker *f = new cmForEachFunctionBlocker(this->Makefile);
-  if ( args.size() > 1 )
-    {
-    if ( args[1] == "RANGE" )
-      {
+  cmForEachFunctionBlocker* f = new cmForEachFunctionBlocker(this->Makefile);
+  if (args.size() > 1) {
+    if (args[1] == "RANGE") {
       int start = 0;
       int stop = 0;
       int step = 0;
-      if ( args.size() == 3 )
-        {
+      if (args.size() == 3) {
         stop = atoi(args[2].c_str());
-        }
-      if ( args.size() == 4 )
-        {
+      }
+      if (args.size() == 4) {
         start = atoi(args[2].c_str());
         stop = atoi(args[3].c_str());
-        }
-      if ( args.size() == 5 )
-        {
+      }
+      if (args.size() == 5) {
         start = atoi(args[2].c_str());
         stop = atoi(args[3].c_str());
         step = atoi(args[4].c_str());
-        }
-      if ( step == 0 )
-        {
-        if ( start > stop )
-          {
+      }
+      if (step == 0) {
+        if (start > stop) {
           step = -1;
-          }
-        else
-          {
+        } else {
           step = 1;
-          }
         }
-      if (
-        (start > stop && step > 0) ||
-        (start < stop && step < 0) ||
-        step == 0
-        )
-        {
+      }
+      if ((start > stop && step > 0) || (start < stop && step < 0) ||
+          step == 0) {
         std::ostringstream str;
         str << "called with incorrect range specification: start ";
         str << start << ", stop " << stop << ", step " << step;
         this->SetError(str.str());
         return false;
-        }
+      }
       std::vector<std::string> range;
       char buffer[100];
       range.push_back(args[0]);
       int cc;
-      for ( cc = start; ; cc += step )
-        {
-        if ( (step > 0 && cc > stop) || (step < 0 && cc < stop) )
-          {
+      for (cc = start;; cc += step) {
+        if ((step > 0 && cc > stop) || (step < 0 && cc < stop)) {
           break;
-          }
+        }
         sprintf(buffer, "%d", cc);
         range.push_back(buffer);
-        if ( cc == stop )
-          {
+        if (cc == stop) {
           break;
-          }
         }
-      f->Args = range;
       }
-    else
-      {
+      f->Args = range;
+    } else {
       f->Args = args;
-      }
     }
-  else
-    {
+  } else {
     f->Args = args;
-    }
+  }
   this->Makefile->AddFunctionBlocker(f);
 
   return true;
@@ -218,42 +184,37 @@ bool cmForEachCommand
 
 bool cmForEachCommand::HandleInMode(std::vector<std::string> const& args)
 {
-  cmsys::auto_ptr<cmForEachFunctionBlocker>
-    f(new cmForEachFunctionBlocker(this->Makefile));
+  cmsys::auto_ptr<cmForEachFunctionBlocker> f(
+    new cmForEachFunctionBlocker(this->Makefile));
   f->Args.push_back(args[0]);
 
-  enum Doing { DoingNone, DoingLists, DoingItems };
+  enum Doing
+  {
+    DoingNone,
+    DoingLists,
+    DoingItems
+  };
   Doing doing = DoingNone;
-  for(unsigned int i=2; i < args.size(); ++i)
-    {
-    if(doing == DoingItems)
-      {
+  for (unsigned int i = 2; i < args.size(); ++i) {
+    if (doing == DoingItems) {
       f->Args.push_back(args[i]);
-      }
-    else if(args[i] == "LISTS")
-      {
+    } else if (args[i] == "LISTS") {
       doing = DoingLists;
-      }
-    else if(args[i] == "ITEMS")
-      {
+    } else if (args[i] == "ITEMS") {
       doing = DoingItems;
-      }
-    else if(doing == DoingLists)
-      {
+    } else if (doing == DoingLists) {
       const char* value = this->Makefile->GetDefinition(args[i]);
-      if(value && *value)
-        {
+      if (value && *value) {
         cmSystemTools::ExpandListArgument(value, f->Args, true);
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream e;
-      e << "Unknown argument:\n" << "  " << args[i] << "\n";
+      e << "Unknown argument:\n"
+        << "  " << args[i] << "\n";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       return true;
-      }
     }
+  }
 
   this->Makefile->AddFunctionBlocker(f.release()); // TODO: pass auto_ptr
 
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index 027b8cb..60956aa 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -22,13 +22,13 @@ class cmForEachFunctionBlocker : public cmFunctionBlocker
 public:
   cmForEachFunctionBlocker(cmMakefile* mf);
   ~cmForEachFunctionBlocker();
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
-                                 cmMakefile &mf,
-                                 cmExecutionStatus &);
-  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                                 cmExecutionStatus&);
+  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf);
 
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
+
 private:
   cmMakefile* Makefile;
   int Depth;
@@ -41,17 +41,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmForEachCommand;
-    }
+  virtual cmCommand* Clone() { return new cmForEachCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -61,12 +58,12 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "foreach";}
+  virtual std::string GetName() const { return "foreach"; }
 
   cmTypeMacro(cmForEachCommand, cmCommand);
+
 private:
   bool HandleInMode(std::vector<std::string> const& args);
 };
 
-
 #endif
diff --git a/Source/cmFortranParser.h b/Source/cmFortranParser.h
index 2ad951e..07e1b1c 100644
--- a/Source/cmFortranParser.h
+++ b/Source/cmFortranParser.h
@@ -13,7 +13,7 @@
 #define cmFortranParser_h
 
 #if !defined(cmFortranLexer_cxx) && !defined(cmFortranParser_cxx)
-# include "cmStandardIncludes.h"
+#include "cmStandardIncludes.h"
 #endif
 
 #include <stddef.h> /* size_t */
@@ -22,53 +22,37 @@
 typedef struct cmFortranParser_s cmFortranParser;
 
 /* Functions to enter/exit #include'd files in order.  */
-bool cmFortranParser_FilePush(cmFortranParser* parser,
-                                    const char* fname);
+bool cmFortranParser_FilePush(cmFortranParser* parser, const char* fname);
 bool cmFortranParser_FilePop(cmFortranParser* parser);
 
 /* Callbacks for lexer.  */
-int cmFortranParser_Input(cmFortranParser* parser,
-                                 char* buffer, size_t bufferSize);
-
+int cmFortranParser_Input(cmFortranParser* parser, char* buffer,
+                          size_t bufferSize);
 
 void cmFortranParser_StringStart(cmFortranParser* parser);
 const char* cmFortranParser_StringEnd(cmFortranParser* parser);
-void cmFortranParser_StringAppend(cmFortranParser* parser,
-                                         char c);
+void cmFortranParser_StringAppend(cmFortranParser* parser, char c);
 
-void cmFortranParser_SetInInterface(cmFortranParser* parser,
-                                           bool is_in);
+void cmFortranParser_SetInInterface(cmFortranParser* parser, bool is_in);
 bool cmFortranParser_GetInInterface(cmFortranParser* parser);
 
-
-void cmFortranParser_SetInPPFalseBranch(cmFortranParser* parser,
-                                               bool is_in);
+void cmFortranParser_SetInPPFalseBranch(cmFortranParser* parser, bool is_in);
 bool cmFortranParser_GetInPPFalseBranch(cmFortranParser* parser);
 
-
-void cmFortranParser_SetOldStartcond(cmFortranParser* parser,
-                                            int arg);
+void cmFortranParser_SetOldStartcond(cmFortranParser* parser, int arg);
 int cmFortranParser_GetOldStartcond(cmFortranParser* parser);
 
 /* Callbacks for parser.  */
-void cmFortranParser_Error(cmFortranParser* parser,
-                                  const char* message);
-void cmFortranParser_RuleUse(cmFortranParser* parser,
-                                    const char* name);
+void cmFortranParser_Error(cmFortranParser* parser, const char* message);
+void cmFortranParser_RuleUse(cmFortranParser* parser, const char* name);
 void cmFortranParser_RuleLineDirective(cmFortranParser* parser,
                                        const char* filename);
-void cmFortranParser_RuleInclude(cmFortranParser* parser,
-                                        const char* name);
-void cmFortranParser_RuleModule(cmFortranParser* parser,
-                                       const char* name);
-void cmFortranParser_RuleDefine(cmFortranParser* parser,
-                                       const char* name);
-void cmFortranParser_RuleUndef(cmFortranParser* parser,
-                                      const char* name);
-void cmFortranParser_RuleIfdef(cmFortranParser* parser,
-                                      const char* name);
-void cmFortranParser_RuleIfndef(cmFortranParser* parser,
-                                       const char* name);
+void cmFortranParser_RuleInclude(cmFortranParser* parser, const char* name);
+void cmFortranParser_RuleModule(cmFortranParser* parser, const char* name);
+void cmFortranParser_RuleDefine(cmFortranParser* parser, const char* name);
+void cmFortranParser_RuleUndef(cmFortranParser* parser, const char* name);
+void cmFortranParser_RuleIfdef(cmFortranParser* parser, const char* name);
+void cmFortranParser_RuleIfndef(cmFortranParser* parser, const char* name);
 void cmFortranParser_RuleIf(cmFortranParser* parser);
 void cmFortranParser_RuleElif(cmFortranParser* parser);
 void cmFortranParser_RuleElse(cmFortranParser* parser);
@@ -83,19 +67,18 @@ union cmFortran_yystype_u
 
 /* Setup the proper yylex interface.  */
 #define YY_EXTRA_TYPE cmFortranParser*
-#define YY_DECL \
-int cmFortran_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
+#define YY_DECL int cmFortran_yylex(YYSTYPE* yylvalp, yyscan_t yyscanner)
 #define YYSTYPE cmFortran_yystype
 #define YYSTYPE_IS_DECLARED 1
 #if !defined(cmFortranLexer_cxx)
-# include "cmFortranLexer.h"
+#include "cmFortranLexer.h"
 #endif
 #if !defined(cmFortranLexer_cxx)
 #if !defined(cmFortranParser_cxx)
-# undef YY_EXTRA_TYPE
-# undef YY_DECL
-# undef YYSTYPE
-# undef YYSTYPE_IS_DECLARED
+#undef YY_EXTRA_TYPE
+#undef YY_DECL
+#undef YYSTYPE
+#undef YYSTYPE_IS_DECLARED
 #endif
 #endif
 
@@ -128,9 +111,12 @@ int cmFortran_yyparse(yyscan_t);
 // Define parser object internal structure.
 struct cmFortranFile
 {
-  cmFortranFile(FILE* file, YY_BUFFER_STATE buffer,
-                       const std::string& dir):
-    File(file), Buffer(buffer), Directory(dir) {}
+  cmFortranFile(FILE* file, YY_BUFFER_STATE buffer, const std::string& dir)
+    : File(file)
+    , Buffer(buffer)
+    , Directory(dir)
+  {
+  }
   FILE* File;
   YY_BUFFER_STATE Buffer;
   std::string Directory;
diff --git a/Source/cmFortranParserImpl.cxx b/Source/cmFortranParserImpl.cxx
index c26ad88..934e928 100644
--- a/Source/cmFortranParserImpl.cxx
+++ b/Source/cmFortranParserImpl.cxx
@@ -19,46 +19,42 @@ bool cmFortranParser_s::FindIncludeFile(const char* dir,
                                         std::string& fileName)
 {
   // If the file is a full path, include it directly.
-  if(cmSystemTools::FileIsFullPath(includeName))
-    {
+  if (cmSystemTools::FileIsFullPath(includeName)) {
     fileName = includeName;
     return cmSystemTools::FileExists(fileName.c_str(), true);
-    }
-  else
-    {
+  } else {
     // Check for the file in the directory containing the including
     // file.
     std::string fullName = dir;
     fullName += "/";
     fullName += includeName;
-    if(cmSystemTools::FileExists(fullName.c_str(), true))
-      {
+    if (cmSystemTools::FileExists(fullName.c_str(), true)) {
       fileName = fullName;
       return true;
-      }
+    }
 
     // Search the include path for the file.
-    for(std::vector<std::string>::const_iterator i =
-          this->IncludePath.begin(); i != this->IncludePath.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i =
+           this->IncludePath.begin();
+         i != this->IncludePath.end(); ++i) {
       fullName = *i;
       fullName += "/";
       fullName += includeName;
-      if(cmSystemTools::FileExists(fullName.c_str(), true))
-        {
+      if (cmSystemTools::FileExists(fullName.c_str(), true)) {
         fileName = fullName;
         return true;
-        }
       }
     }
+  }
   return false;
 }
 
-cmFortranParser_s
-::cmFortranParser_s(std::vector<std::string> const& includes,
-                    std::set<std::string> const& defines,
-                    cmFortranSourceInfo& info):
-  IncludePath(includes), PPDefinitions(defines), Info(info)
+cmFortranParser_s::cmFortranParser_s(std::vector<std::string> const& includes,
+                                     std::set<std::string> const& defines,
+                                     cmFortranSourceInfo& info)
+  : IncludePath(includes)
+  , PPDefinitions(defines)
+  , Info(info)
 {
   this->InInterface = 0;
   this->InPPFalseBranch = 0;
@@ -69,8 +65,7 @@ cmFortranParser_s
 
   // Create a dummy buffer that is never read but is the fallback
   // buffer when the last file is popped off the stack.
-  YY_BUFFER_STATE buffer =
-    cmFortran_yy_create_buffer(0, 4, this->Scanner);
+  YY_BUFFER_STATE buffer = cmFortran_yy_create_buffer(0, 4, this->Scanner);
   cmFortran_yy_switch_to_buffer(buffer, this->Scanner);
 }
 
@@ -79,15 +74,12 @@ cmFortranParser_s::~cmFortranParser_s()
   cmFortran_yylex_destroy(this->Scanner);
 }
 
-bool cmFortranParser_FilePush(cmFortranParser* parser,
-                                    const char* fname)
+bool cmFortranParser_FilePush(cmFortranParser* parser, const char* fname)
 {
   // Open the new file and push it onto the stack.  Save the old
   // buffer with it on the stack.
-  if(FILE* file = cmsys::SystemTools::Fopen(fname, "rb"))
-    {
-    YY_BUFFER_STATE current =
-      cmFortranLexer_GetCurrentBuffer(parser->Scanner);
+  if (FILE* file = cmsys::SystemTools::Fopen(fname, "rb")) {
+    YY_BUFFER_STATE current = cmFortranLexer_GetCurrentBuffer(parser->Scanner);
     std::string dir = cmSystemTools::GetParentDirectory(fname);
     cmFortranFile f(file, current, dir);
     YY_BUFFER_STATE buffer =
@@ -95,43 +87,37 @@ bool cmFortranParser_FilePush(cmFortranParser* parser,
     cmFortran_yy_switch_to_buffer(buffer, parser->Scanner);
     parser->FileStack.push(f);
     return 1;
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 bool cmFortranParser_FilePop(cmFortranParser* parser)
 {
   // Pop one file off the stack and close it.  Switch the lexer back
   // to the next one on the stack.
-  if(parser->FileStack.empty())
-    {
+  if (parser->FileStack.empty()) {
     return 0;
-    }
-  else
-    {
-    cmFortranFile f = parser->FileStack.top(); parser->FileStack.pop();
+  } else {
+    cmFortranFile f = parser->FileStack.top();
+    parser->FileStack.pop();
     fclose(f.File);
-    YY_BUFFER_STATE current =
-      cmFortranLexer_GetCurrentBuffer(parser->Scanner);
+    YY_BUFFER_STATE current = cmFortranLexer_GetCurrentBuffer(parser->Scanner);
     cmFortran_yy_delete_buffer(current, parser->Scanner);
     cmFortran_yy_switch_to_buffer(f.Buffer, parser->Scanner);
     return 1;
-    }
+  }
 }
 
-int cmFortranParser_Input(cmFortranParser* parser,
-                                 char* buffer, size_t bufferSize)
+int cmFortranParser_Input(cmFortranParser* parser, char* buffer,
+                          size_t bufferSize)
 {
   // Read from the file on top of the stack.  If the stack is empty,
   // the end of the translation unit has been reached.
-  if(!parser->FileStack.empty())
-    {
+  if (!parser->FileStack.empty()) {
     FILE* file = parser->FileStack.top().File;
     return (int)fread(buffer, 1, bufferSize, file);
-    }
+  }
   return 0;
 }
 
@@ -145,19 +131,16 @@ const char* cmFortranParser_StringEnd(cmFortranParser* parser)
   return parser->TokenString.c_str();
 }
 
-void cmFortranParser_StringAppend(cmFortranParser* parser,
-                                         char c)
+void cmFortranParser_StringAppend(cmFortranParser* parser, char c)
 {
   parser->TokenString += c;
 }
 
-void cmFortranParser_SetInInterface(cmFortranParser* parser,
-                                           bool in)
+void cmFortranParser_SetInInterface(cmFortranParser* parser, bool in)
 {
-  if(parser->InPPFalseBranch)
-    {
+  if (parser->InPPFalseBranch) {
     return;
-    }
+  }
 
   parser->InInterface = in;
 }
@@ -167,8 +150,7 @@ bool cmFortranParser_GetInInterface(cmFortranParser* parser)
   return parser->InInterface;
 }
 
-void cmFortranParser_SetOldStartcond(cmFortranParser* parser,
-                                            int arg)
+void cmFortranParser_SetOldStartcond(cmFortranParser* parser, int arg)
 {
   parser->OldStartcond = arg;
 }
@@ -185,13 +167,11 @@ void cmFortranParser_Error(cmFortranParser*, const char*)
   // to be regenerated anyway.
 }
 
-void cmFortranParser_RuleUse(cmFortranParser* parser,
-                                    const char* name)
+void cmFortranParser_RuleUse(cmFortranParser* parser, const char* name)
 {
-  if(!parser->InPPFalseBranch)
-    {
-    parser->Info.Requires.insert(cmSystemTools::LowerCase(name) );
-    }
+  if (!parser->InPPFalseBranch) {
+    parser->Info.Requires.insert(cmSystemTools::LowerCase(name));
+  }
 }
 
 void cmFortranParser_RuleLineDirective(cmFortranParser* parser,
@@ -202,10 +182,9 @@ void cmFortranParser_RuleLineDirective(cmFortranParser* parser,
 
   // Skip #line directives referencing non-files like
   // "<built-in>" or "<command-line>".
-  if (included.empty() || included[0] == '<')
-    {
+  if (included.empty() || included[0] == '<') {
     return;
-    }
+  }
 
   // Fix windows file path separators since our lexer does not
   // process escape sequences in string literals.
@@ -213,19 +192,16 @@ void cmFortranParser_RuleLineDirective(cmFortranParser* parser,
   cmSystemTools::ConvertToUnixSlashes(included);
 
   // Save the named file as included in the source.
-  if (cmSystemTools::FileExists(included, true))
-    {
+  if (cmSystemTools::FileExists(included, true)) {
     parser->Info.Includes.insert(included);
-    }
+  }
 }
 
-void cmFortranParser_RuleInclude(cmFortranParser* parser,
-                                        const char* name)
+void cmFortranParser_RuleInclude(cmFortranParser* parser, const char* name)
 {
-  if(parser->InPPFalseBranch)
-    {
+  if (parser->InPPFalseBranch) {
     return;
-    }
+  }
 
   // If processing an include statement there must be an open file.
   assert(!parser->FileStack.empty());
@@ -239,87 +215,69 @@ void cmFortranParser_RuleInclude(cmFortranParser* parser,
   // problem because either the source will not compile or the user
   // does not care about depending on this included source.
   std::string fullName;
-  if(parser->FindIncludeFile(dir.c_str(), name, fullName))
-    {
+  if (parser->FindIncludeFile(dir.c_str(), name, fullName)) {
     // Found the included file.  Save it in the set of included files.
     parser->Info.Includes.insert(fullName);
 
     // Parse it immediately to translate the source inline.
     cmFortranParser_FilePush(parser, fullName.c_str());
-    }
+  }
 }
 
-void cmFortranParser_RuleModule(cmFortranParser* parser,
-                                       const char* name)
+void cmFortranParser_RuleModule(cmFortranParser* parser, const char* name)
 {
-  if(!parser->InPPFalseBranch && !parser->InInterface)
-    {
+  if (!parser->InPPFalseBranch && !parser->InInterface) {
     parser->Info.Provides.insert(cmSystemTools::LowerCase(name));
-    }
+  }
 }
 
-void cmFortranParser_RuleDefine(cmFortranParser* parser,
-                                       const char* macro)
+void cmFortranParser_RuleDefine(cmFortranParser* parser, const char* macro)
 {
-  if(!parser->InPPFalseBranch)
-    {
+  if (!parser->InPPFalseBranch) {
     parser->PPDefinitions.insert(macro);
-    }
+  }
 }
 
-void cmFortranParser_RuleUndef(cmFortranParser* parser,
-                                      const char* macro)
+void cmFortranParser_RuleUndef(cmFortranParser* parser, const char* macro)
 {
-  if(!parser->InPPFalseBranch)
-    {
+  if (!parser->InPPFalseBranch) {
     std::set<std::string>::iterator match;
     match = parser->PPDefinitions.find(macro);
-    if(match != parser->PPDefinitions.end())
-      {
+    if (match != parser->PPDefinitions.end()) {
       parser->PPDefinitions.erase(match);
-      }
     }
+  }
 }
 
-void cmFortranParser_RuleIfdef(cmFortranParser* parser,
-                                      const char* macro)
+void cmFortranParser_RuleIfdef(cmFortranParser* parser, const char* macro)
 {
   // A new PP branch has been opened
   parser->SkipToEnd.push(false);
 
-  if (parser->InPPFalseBranch)
-    {
+  if (parser->InPPFalseBranch) {
     parser->InPPFalseBranch++;
-    }
-  else if(parser->PPDefinitions.find(macro) == parser->PPDefinitions.end())
-    {
-    parser->InPPFalseBranch=1;
-    }
-  else
-    {
+  } else if (parser->PPDefinitions.find(macro) ==
+             parser->PPDefinitions.end()) {
+    parser->InPPFalseBranch = 1;
+  } else {
     parser->SkipToEnd.top() = true;
-    }
+  }
 }
 
-void cmFortranParser_RuleIfndef(cmFortranParser* parser,
-  const char* macro)
+void cmFortranParser_RuleIfndef(cmFortranParser* parser, const char* macro)
 {
   // A new PP branch has been opened
   parser->SkipToEnd.push(false);
 
-  if (parser->InPPFalseBranch)
-    {
+  if (parser->InPPFalseBranch) {
     parser->InPPFalseBranch++;
-    }
-  else if(parser->PPDefinitions.find(macro) != parser->PPDefinitions.end())
-    {
+  } else if (parser->PPDefinitions.find(macro) !=
+             parser->PPDefinitions.end()) {
     parser->InPPFalseBranch = 1;
-    }
-  else
-    {
+  } else {
     // ignore other branches
     parser->SkipToEnd.top() = true;
-    }
+  }
 }
 
 void cmFortranParser_RuleIf(cmFortranParser* parser)
@@ -364,45 +322,37 @@ void cmFortranParser_RuleElif(cmFortranParser* parser)
   // Always taken unless an #ifdef or #ifndef-branch has been taken
   // already.  If the second condition isn't meet already
   // (parser->InPPFalseBranch == 0) correct it.
-  if(!parser->SkipToEnd.empty() &&
-     parser->SkipToEnd.top() && !parser->InPPFalseBranch)
-    {
+  if (!parser->SkipToEnd.empty() && parser->SkipToEnd.top() &&
+      !parser->InPPFalseBranch) {
     parser->InPPFalseBranch = 1;
-    }
+  }
 }
 
 void cmFortranParser_RuleElse(cmFortranParser* parser)
 {
   // if the parent branch is false do nothing!
-  if(parser->InPPFalseBranch > 1)
-    {
+  if (parser->InPPFalseBranch > 1) {
     return;
-    }
+  }
 
   // parser->InPPFalseBranch is either 0 or 1.  We change it depending on
   // parser->SkipToEnd.top()
-  if(!parser->SkipToEnd.empty() &&
-     parser->SkipToEnd.top())
-    {
+  if (!parser->SkipToEnd.empty() && parser->SkipToEnd.top()) {
     parser->InPPFalseBranch = 1;
-    }
-  else
-    {
+  } else {
     parser->InPPFalseBranch = 0;
-    }
+  }
 }
 
 void cmFortranParser_RuleEndif(cmFortranParser* parser)
 {
-  if(!parser->SkipToEnd.empty())
-    {
+  if (!parser->SkipToEnd.empty()) {
     parser->SkipToEnd.pop();
-    }
+  }
 
   // #endif doesn't know if there was a "#else" in before, so it
   // always decreases InPPFalseBranch
-  if(parser->InPPFalseBranch)
-    {
+  if (parser->InPPFalseBranch) {
     parser->InPPFalseBranch--;
-    }
+  }
 }
diff --git a/Source/cmFunctionBlocker.h b/Source/cmFunctionBlocker.h
index d0d52ce..c7e3b71 100644
--- a/Source/cmFunctionBlocker.h
+++ b/Source/cmFunctionBlocker.h
@@ -24,24 +24,30 @@ public:
   /**
    * should a function be blocked
    */
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
-                                 cmMakefile&mf,
-                                 cmExecutionStatus &status) = 0;
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                                 cmExecutionStatus& status) = 0;
 
   /**
    * should this function blocker be removed, useful when one function adds a
    * blocker and another must remove it
    */
-  virtual bool ShouldRemove(const cmListFileFunction&,
-                            cmMakefile&) {return false;}
+  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile&)
+  {
+    return false;
+  }
 
   virtual ~cmFunctionBlocker() {}
 
   /** Set/Get the context in which this blocker is created.  */
   void SetStartingContext(cmListFileContext const& lfc)
-    { this->StartingContext = lfc; }
+  {
+    this->StartingContext = lfc;
+  }
   cmListFileContext const& GetStartingContext() const
-    { return this->StartingContext; }
+  {
+    return this->StartingContext;
+  }
+
 private:
   cmListFileContext StartingContext;
 };
diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
index c883ad7..de9887e 100644
--- a/Source/cmFunctionCommand.cxx
+++ b/Source/cmFunctionCommand.cxx
@@ -28,17 +28,14 @@ public:
    * cmMacroHelperCommand and cmFunctionHelperCommand
    * which cannot provide appropriate documentation.
    */
-  virtual bool ShouldAppearInDocumentation() const
-    {
-    return false;
-    }
+  virtual bool ShouldAppearInDocumentation() const { return false; }
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
   {
-    cmFunctionHelperCommand *newC = new cmFunctionHelperCommand;
+    cmFunctionHelperCommand* newC = new cmFunctionHelperCommand;
     // we must copy when we clone
     newC->Args = this->Args;
     newC->Functions = this->Functions;
@@ -57,10 +54,12 @@ public:
    * the CMakeLists.txt file.
    */
   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) { return false; }
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
@@ -75,9 +74,8 @@ public:
   std::string FilePath;
 };
 
-bool cmFunctionHelperCommand::InvokeInitialPass
-(const std::vector<cmListFileArgument>& args,
- cmExecutionStatus & inStatus)
+bool cmFunctionHelperCommand::InvokeInitialPass(
+  const std::vector<cmListFileArgument>& args, cmExecutionStatus& inStatus)
 {
   // Expand the argument list to the function.
   std::vector<std::string> expandedArgs;
@@ -85,46 +83,40 @@ bool cmFunctionHelperCommand::InvokeInitialPass
 
   // make sure the number of arguments passed is at least the number
   // required by the signature
-  if (expandedArgs.size() < this->Args.size() - 1)
-    {
+  if (expandedArgs.size() < this->Args.size() - 1) {
     std::string errorMsg =
       "Function invoked with incorrect arguments for function named: ";
     errorMsg += this->Args[0];
     this->SetError(errorMsg);
     return false;
-    }
+  }
 
-  cmMakefile::FunctionPushPop functionScope(this->Makefile,
-                                            this->FilePath,
+  cmMakefile::FunctionPushPop functionScope(this->Makefile, this->FilePath,
                                             this->Policies);
 
   // set the value of argc
   std::ostringstream strStream;
   strStream << expandedArgs.size();
-  this->Makefile->AddDefinition("ARGC",strStream.str().c_str());
+  this->Makefile->AddDefinition("ARGC", strStream.str().c_str());
   this->Makefile->MarkVariableAsUsed("ARGC");
 
   // set the values for ARGV0 ARGV1 ...
-  for (unsigned int t = 0; t < expandedArgs.size(); ++t)
-    {
+  for (unsigned int t = 0; t < expandedArgs.size(); ++t) {
     std::ostringstream tmpStream;
     tmpStream << "ARGV" << t;
-    this->Makefile->AddDefinition(tmpStream.str(),
-                                  expandedArgs[t].c_str());
+    this->Makefile->AddDefinition(tmpStream.str(), expandedArgs[t].c_str());
     this->Makefile->MarkVariableAsUsed(tmpStream.str());
-    }
+  }
 
   // define the formal arguments
-  for (unsigned int j = 1; j < this->Args.size(); ++j)
-    {
-    this->Makefile->AddDefinition(this->Args[j],
-                                  expandedArgs[j-1].c_str());
-    }
+  for (unsigned int j = 1; j < this->Args.size(); ++j) {
+    this->Makefile->AddDefinition(this->Args[j], expandedArgs[j - 1].c_str());
+  }
 
   // define ARGV and ARGN
   std::string argvDef = cmJoin(expandedArgs, ";");
-  std::vector<std::string>::const_iterator eit
-      = expandedArgs.begin() + (this->Args.size()-1);
+  std::vector<std::string>::const_iterator eit =
+    expandedArgs.begin() + (this->Args.size() - 1);
   std::string argnDef = cmJoin(cmMakeRange(eit, expandedArgs.end()), ";");
   this->Makefile->AddDefinition("ARGV", argvDef.c_str());
   this->Makefile->MarkVariableAsUsed("ARGV");
@@ -133,45 +125,37 @@ bool cmFunctionHelperCommand::InvokeInitialPass
 
   // Invoke all the functions that were collected in the block.
   // for each function
-  for(unsigned int c = 0; c < this->Functions.size(); ++c)
-    {
+  for (unsigned int c = 0; c < this->Functions.size(); ++c) {
     cmExecutionStatus status;
-    if (!this->Makefile->ExecuteCommand(this->Functions[c],status) ||
-        status.GetNestedError())
-      {
+    if (!this->Makefile->ExecuteCommand(this->Functions[c], status) ||
+        status.GetNestedError()) {
       // The error message should have already included the call stack
       // so we do not need to report an error here.
       functionScope.Quiet();
       inStatus.SetNestedError(true);
       return false;
-      }
-    if (status.GetReturnInvoked())
-      {
+    }
+    if (status.GetReturnInvoked()) {
       return true;
-      }
     }
+  }
 
   // pop scope on the makefile
   return true;
 }
 
-bool cmFunctionFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
-                  cmExecutionStatus &)
+bool cmFunctionFunctionBlocker::IsFunctionBlocked(
+  const cmListFileFunction& lff, cmMakefile& mf, cmExecutionStatus&)
 {
   // record commands until we hit the ENDFUNCTION
   // at the ENDFUNCTION call we shift gears and start looking for invocations
-  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"function"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "function")) {
     this->Depth++;
-    }
-  else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
-    {
+  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endfunction")) {
     // if this is the endfunction for this function then execute
-    if (!this->Depth)
-      {
+    if (!this->Depth) {
       // create a new command and add it to cmake
-      cmFunctionHelperCommand *f = new cmFunctionHelperCommand();
+      cmFunctionHelperCommand* f = new cmFunctionHelperCommand();
       f->Args = this->Args;
       f->Functions = this->Functions;
       f->FilePath = this->GetStartingContext().FilePath;
@@ -184,13 +168,11 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
       // remove the function blocker now that the function is defined
       mf.RemoveFunctionBlocker(this, lff);
       return true;
-      }
-    else
-      {
+    } else {
       // decrement for each nested function that ends
       this->Depth--;
-      }
     }
+  }
 
   // if it wasn't an endfunction and we are not executing then we must be
   // recording
@@ -198,40 +180,35 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
   return true;
 }
 
-
-bool cmFunctionFunctionBlocker::
-ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
+bool cmFunctionFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
+                                             cmMakefile& mf)
 {
-  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endfunction"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endfunction")) {
     std::vector<std::string> expandedArguments;
     mf.ExpandArguments(lff.Arguments, expandedArguments,
                        this->GetStartingContext().FilePath.c_str());
     // if the endfunction has arguments then make sure
     // they match the ones in the opening function command
     if ((expandedArguments.empty() ||
-         (expandedArguments[0] == this->Args[0])))
-      {
+         (expandedArguments[0] == this->Args[0]))) {
       return true;
-      }
     }
+  }
 
   return false;
 }
 
-bool cmFunctionCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmFunctionCommand::InitialPass(std::vector<std::string> const& args,
+                                    cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // create a function blocker
-  cmFunctionFunctionBlocker *f = new cmFunctionFunctionBlocker();
+  cmFunctionFunctionBlocker* f = new cmFunctionFunctionBlocker();
   f->Args.insert(f->Args.end(), args.begin(), args.end());
   this->Makefile->AddFunctionBlocker(f);
   return true;
 }
-
diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h
index 1a5ce59..08f7f0f 100644
--- a/Source/cmFunctionCommand.h
+++ b/Source/cmFunctionCommand.h
@@ -19,12 +19,11 @@
 class cmFunctionFunctionBlocker : public cmFunctionBlocker
 {
 public:
-  cmFunctionFunctionBlocker() {this->Depth=0;}
+  cmFunctionFunctionBlocker() { this->Depth = 0; }
   virtual ~cmFunctionFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction&,
-                                 cmMakefile &mf,
-                                 cmExecutionStatus &);
-  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf,
+                                 cmExecutionStatus&);
+  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf);
 
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
@@ -38,17 +37,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmFunctionCommand;
-    }
+  virtual cmCommand* Clone() { return new cmFunctionCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -58,10 +54,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "function";}
+  virtual std::string GetName() const { return "function"; }
 
   cmTypeMacro(cmFunctionCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmGeneratedFileStream.cxx b/Source/cmGeneratedFileStream.cxx
index 78d863c..2c05913 100644
--- a/Source/cmGeneratedFileStream.cxx
+++ b/Source/cmGeneratedFileStream.cxx
@@ -14,25 +14,25 @@
 #include "cmSystemTools.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include <cm_zlib.h>
+#include <cm_zlib.h>
 #endif
 
-cmGeneratedFileStream::cmGeneratedFileStream():
-  cmGeneratedFileStreamBase(), Stream()
+cmGeneratedFileStream::cmGeneratedFileStream()
+  : cmGeneratedFileStreamBase()
+  , Stream()
 {
 }
 
-cmGeneratedFileStream::cmGeneratedFileStream(const char* name, bool quiet):
-  cmGeneratedFileStreamBase(name),
-  Stream(TempName.c_str())
+cmGeneratedFileStream::cmGeneratedFileStream(const char* name, bool quiet)
+  : cmGeneratedFileStreamBase(name)
+  , Stream(TempName.c_str())
 {
   // Check if the file opened.
-  if(!*this && !quiet)
-    {
+  if (!*this && !quiet) {
     cmSystemTools::Error("Cannot open file for write: ",
                          this->TempName.c_str());
     cmSystemTools::ReportLastSystemError("");
-    }
+  }
 }
 
 cmGeneratedFileStream::~cmGeneratedFileStream()
@@ -42,41 +42,36 @@ cmGeneratedFileStream::~cmGeneratedFileStream()
   // stream will be destroyed which will close the temporary file.
   // Finally the base destructor will be called to replace the
   // destination file.
-  this->Okay = (*this)?true:false;
+  this->Okay = (*this) ? true : false;
 }
 
-cmGeneratedFileStream&
-cmGeneratedFileStream::Open(const char* name, bool quiet, bool binaryFlag)
+cmGeneratedFileStream& cmGeneratedFileStream::Open(const char* name,
+                                                   bool quiet, bool binaryFlag)
 {
   // Store the file name and construct the temporary file name.
   this->cmGeneratedFileStreamBase::Open(name);
 
   // Open the temporary output file.
-  if ( binaryFlag )
-    {
+  if (binaryFlag) {
     this->Stream::open(this->TempName.c_str(),
                        std::ios::out | std::ios::binary);
-    }
-  else
-    {
+  } else {
     this->Stream::open(this->TempName.c_str(), std::ios::out);
-    }
+  }
 
   // Check if the file opened.
-  if(!*this && !quiet)
-    {
+  if (!*this && !quiet) {
     cmSystemTools::Error("Cannot open file for write: ",
                          this->TempName.c_str());
     cmSystemTools::ReportLastSystemError("");
-    }
+  }
   return *this;
 }
 
-bool
-cmGeneratedFileStream::Close()
+bool cmGeneratedFileStream::Close()
 {
   // Save whether the temporary output file is valid before closing.
-  this->Okay = (*this)?true:false;
+  this->Okay = (*this) ? true : false;
 
   // Close the temporary output file.
   this->Stream::close();
@@ -100,23 +95,23 @@ void cmGeneratedFileStream::SetCompressionExtraExtension(bool ext)
   this->CompressExtraExtension = ext;
 }
 
-cmGeneratedFileStreamBase::cmGeneratedFileStreamBase():
-  Name(),
-  TempName(),
-  CopyIfDifferent(false),
-  Okay(false),
-  Compress(false),
-  CompressExtraExtension(true)
+cmGeneratedFileStreamBase::cmGeneratedFileStreamBase()
+  : Name()
+  , TempName()
+  , CopyIfDifferent(false)
+  , Okay(false)
+  , Compress(false)
+  , CompressExtraExtension(true)
 {
 }
 
-cmGeneratedFileStreamBase::cmGeneratedFileStreamBase(const char* name):
-  Name(),
-  TempName(),
-  CopyIfDifferent(false),
-  Okay(false),
-  Compress(false),
-  CompressExtraExtension(true)
+cmGeneratedFileStreamBase::cmGeneratedFileStreamBase(const char* name)
+  : Name()
+  , TempName()
+  , CopyIfDifferent(false)
+  , Okay(false)
+  , Compress(false)
+  , CompressExtraExtension(true)
 {
   this->Open(name);
 }
@@ -151,36 +146,29 @@ bool cmGeneratedFileStreamBase::Close()
   bool replaced = false;
 
   std::string resname = this->Name;
-  if ( this->Compress && this->CompressExtraExtension )
-    {
+  if (this->Compress && this->CompressExtraExtension) {
     resname += ".gz";
-    }
+  }
 
   // Only consider replacing the destination file if no error
   // occurred.
-  if(!this->Name.empty() &&
-    this->Okay &&
-    (!this->CopyIfDifferent ||
-     cmSystemTools::FilesDiffer(this->TempName, resname)))
-    {
+  if (!this->Name.empty() && this->Okay &&
+      (!this->CopyIfDifferent ||
+       cmSystemTools::FilesDiffer(this->TempName, resname))) {
     // The destination is to be replaced.  Rename the temporary to the
     // destination atomically.
-    if ( this->Compress )
-      {
+    if (this->Compress) {
       std::string gzname = this->TempName + ".temp.gz";
-      if ( this->CompressFile(this->TempName.c_str(), gzname.c_str()) )
-        {
+      if (this->CompressFile(this->TempName.c_str(), gzname.c_str())) {
         this->RenameFile(gzname.c_str(), resname.c_str());
-        }
-      cmSystemTools::RemoveFile(gzname);
       }
-    else
-      {
+      cmSystemTools::RemoveFile(gzname);
+    } else {
       this->RenameFile(this->TempName.c_str(), resname.c_str());
-      }
+    }
 
     replaced = true;
-    }
+  }
 
   // Else, the destination was not replaced.
   //
@@ -195,27 +183,23 @@ int cmGeneratedFileStreamBase::CompressFile(const char* oldname,
                                             const char* newname)
 {
   gzFile gf = gzopen(newname, "w");
-  if ( !gf )
-    {
+  if (!gf) {
     return 0;
-    }
+  }
   FILE* ifs = cmsys::SystemTools::Fopen(oldname, "r");
-  if ( !ifs )
-    {
+  if (!ifs) {
     return 0;
-    }
+  }
   size_t res;
   const size_t BUFFER_SIZE = 1024;
   char buffer[BUFFER_SIZE];
-  while ( (res = fread(buffer, 1, BUFFER_SIZE, ifs)) > 0 )
-    {
-    if ( !gzwrite(gf, buffer, static_cast<int>(res)) )
-      {
+  while ((res = fread(buffer, 1, BUFFER_SIZE, ifs)) > 0) {
+    if (!gzwrite(gf, buffer, static_cast<int>(res))) {
       fclose(ifs);
       gzclose(gf);
       return 0;
-      }
     }
+  }
   fclose(ifs);
   gzclose(gf);
   return 1;
diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h
index cb397c1..a2de5bc 100644
--- a/Source/cmGeneratedFileStream.h
+++ b/Source/cmGeneratedFileStream.h
@@ -74,8 +74,8 @@ protected:
  * contents have changed to prevent the file modification time from
  * being updated.
  */
-class cmGeneratedFileStream: private cmGeneratedFileStreamBase,
-                             public cmsys::ofstream
+class cmGeneratedFileStream : private cmGeneratedFileStreamBase,
+                              public cmsys::ofstream
 {
 public:
   typedef cmsys::ofstream Stream;
@@ -92,7 +92,7 @@ public:
    * file cannot be opened an error message is produced unless the
    * second argument is set to true.
    */
-  cmGeneratedFileStream(const char* name, bool quiet=false);
+  cmGeneratedFileStream(const char* name, bool quiet = false);
 
   /**
    * The destructor checks the stream status to be sure the temporary
@@ -107,8 +107,8 @@ public:
    * temporary file.  If the file cannot be opened an error message is
    * produced unless the second argument is set to true.
    */
-  cmGeneratedFileStream& Open(const char* name, bool quiet=false,
-    bool binaryFlag=false);
+  cmGeneratedFileStream& Open(const char* name, bool quiet = false,
+                              bool binaryFlag = false);
 
   /**
    * Close the output file.  This should be used only with an open
diff --git a/Source/cmGeneratorExpression.cxx b/Source/cmGeneratorExpression.cxx
index 0566662..002f9ec 100644
--- a/Source/cmGeneratorExpression.cxx
+++ b/Source/cmGeneratorExpression.cxx
@@ -21,20 +21,20 @@
 #include "cmGeneratorExpressionParser.h"
 
 cmGeneratorExpression::cmGeneratorExpression(
-    const cmListFileBacktrace& backtrace):
-  Backtrace(backtrace)
+  const cmListFileBacktrace& backtrace)
+  : Backtrace(backtrace)
 {
 }
 
-cmsys::auto_ptr<cmCompiledGeneratorExpression>
-cmGeneratorExpression::Parse(std::string const& input)
+cmsys::auto_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
+  std::string const& input)
 {
   return cmsys::auto_ptr<cmCompiledGeneratorExpression>(
     new cmCompiledGeneratorExpression(this->Backtrace, input));
 }
 
-cmsys::auto_ptr<cmCompiledGeneratorExpression>
-cmGeneratorExpression::Parse(const char* input)
+cmsys::auto_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
+  const char* input)
 {
   return this->Parse(std::string(input ? input : ""));
 }
@@ -43,73 +43,62 @@ cmGeneratorExpression::~cmGeneratorExpression()
 {
 }
 
-const char *cmCompiledGeneratorExpression::Evaluate(cmLocalGenerator* lg,
-  const std::string& config, bool quiet,
+const char* cmCompiledGeneratorExpression::Evaluate(
+  cmLocalGenerator* lg, const std::string& config, bool quiet,
   const cmGeneratorTarget* headTarget,
-  cmGeneratorExpressionDAGChecker *dagChecker,
-                       std::string const& language) const
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  std::string const& language) const
 {
-  return this->Evaluate(lg,
-                        config,
-                        quiet,
-                        headTarget,
-                        headTarget,
-                        dagChecker,
+  return this->Evaluate(lg, config, quiet, headTarget, headTarget, dagChecker,
                         language);
 }
 
-const char *cmCompiledGeneratorExpression::Evaluate(
+const char* cmCompiledGeneratorExpression::Evaluate(
   cmLocalGenerator* lg, const std::string& config, bool quiet,
-  const cmGeneratorTarget* headTarget,
-  const cmGeneratorTarget* currentTarget,
-  cmGeneratorExpressionDAGChecker *dagChecker,
+  const cmGeneratorTarget* headTarget, const cmGeneratorTarget* currentTarget,
+  cmGeneratorExpressionDAGChecker* dagChecker,
   std::string const& language) const
 {
-  cmGeneratorExpressionContext context(lg, config, quiet, headTarget,
-                                  currentTarget ? currentTarget : headTarget,
-                                  this->EvaluateForBuildsystem,
-                                  this->Backtrace, language);
+  cmGeneratorExpressionContext context(
+    lg, config, quiet, headTarget, currentTarget ? currentTarget : headTarget,
+    this->EvaluateForBuildsystem, this->Backtrace, language);
 
   return this->EvaluateWithContext(context, dagChecker);
 }
 
 const char* cmCompiledGeneratorExpression::EvaluateWithContext(
-                            cmGeneratorExpressionContext& context,
-                            cmGeneratorExpressionDAGChecker *dagChecker) const
+  cmGeneratorExpressionContext& context,
+  cmGeneratorExpressionDAGChecker* dagChecker) const
 {
-  if (!this->NeedsEvaluation)
-    {
+  if (!this->NeedsEvaluation) {
     return this->Input.c_str();
-    }
+  }
 
   this->Output = "";
 
-  std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
-                                                  = this->Evaluators.begin();
-  const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
-                                                  = this->Evaluators.end();
+  std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
+    this->Evaluators.begin();
+  const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end =
+    this->Evaluators.end();
 
-  for ( ; it != end; ++it)
-    {
+  for (; it != end; ++it) {
     this->Output += (*it)->Evaluate(&context, dagChecker);
 
     this->SeenTargetProperties.insert(context.SeenTargetProperties.begin(),
                                       context.SeenTargetProperties.end());
-    if (context.HadError)
-      {
+    if (context.HadError) {
       this->Output = "";
       break;
-      }
     }
+  }
 
   this->MaxLanguageStandard = context.MaxLanguageStandard;
 
-  if (!context.HadError)
-    {
+  if (!context.HadError) {
     this->HadContextSensitiveCondition = context.HadContextSensitiveCondition;
     this->HadHeadSensitiveCondition = context.HadHeadSensitiveCondition;
     this->SourceSensitiveTargets = context.SourceSensitiveTargets;
-    }
+  }
 
   this->DependTargets = context.DependTargets;
   this->AllTargetsSeen = context.AllTargets;
@@ -118,325 +107,270 @@ const char* cmCompiledGeneratorExpression::EvaluateWithContext(
 }
 
 cmCompiledGeneratorExpression::cmCompiledGeneratorExpression(
-              cmListFileBacktrace const& backtrace,
-              const std::string& input)
-  : Backtrace(backtrace), Input(input),
-    HadContextSensitiveCondition(false),
-    HadHeadSensitiveCondition(false),
-    EvaluateForBuildsystem(false)
+  cmListFileBacktrace const& backtrace, const std::string& input)
+  : Backtrace(backtrace)
+  , Input(input)
+  , HadContextSensitiveCondition(false)
+  , HadHeadSensitiveCondition(false)
+  , EvaluateForBuildsystem(false)
 {
   cmGeneratorExpressionLexer l;
-  std::vector<cmGeneratorExpressionToken> tokens =
-                                              l.Tokenize(this->Input);
+  std::vector<cmGeneratorExpressionToken> tokens = l.Tokenize(this->Input);
   this->NeedsEvaluation = l.GetSawGeneratorExpression();
 
-  if (this->NeedsEvaluation)
-    {
+  if (this->NeedsEvaluation) {
     cmGeneratorExpressionParser p(tokens);
     p.Parse(this->Evaluators);
-    }
+  }
 }
 
-
 cmCompiledGeneratorExpression::~cmCompiledGeneratorExpression()
 {
   cmDeleteAll(this->Evaluators);
 }
 
 std::string cmGeneratorExpression::StripEmptyListElements(
-                                                    const std::string &input)
+  const std::string& input)
 {
-  if (input.find(';') == input.npos)
-    {
+  if (input.find(';') == input.npos) {
     return input;
-    }
+  }
   std::string result;
   result.reserve(input.size());
 
-  const char *c = input.c_str();
-  const char *last = c;
+  const char* c = input.c_str();
+  const char* last = c;
   bool skipSemiColons = true;
-  for ( ; *c; ++c)
-    {
-    if(*c == ';')
-      {
-      if(skipSemiColons)
-        {
+  for (; *c; ++c) {
+    if (*c == ';') {
+      if (skipSemiColons) {
         result.append(last, c - last);
         last = c + 1;
-        }
-      skipSemiColons = true;
       }
-    else
-      {
+      skipSemiColons = true;
+    } else {
       skipSemiColons = false;
-      }
     }
+  }
   result.append(last);
 
-  if (!result.empty() && *(result.end() - 1) == ';')
-    {
+  if (!result.empty() && *(result.end() - 1) == ';') {
     result.resize(result.size() - 1);
-    }
+  }
 
   return result;
 }
 
-static std::string stripAllGeneratorExpressions(const std::string &input)
+static std::string stripAllGeneratorExpressions(const std::string& input)
 {
   std::string result;
   std::string::size_type pos = 0;
   std::string::size_type lastPos = pos;
   int nestingLevel = 0;
-  while((pos = input.find("$<", lastPos)) != input.npos)
-    {
+  while ((pos = input.find("$<", lastPos)) != input.npos) {
     result += input.substr(lastPos, pos - lastPos);
     pos += 2;
     nestingLevel = 1;
-    const char *c = input.c_str() + pos;
-    const char * const cStart = c;
-    for ( ; *c; ++c)
-      {
-      if(c[0] == '$' && c[1] == '<')
-        {
+    const char* c = input.c_str() + pos;
+    const char* const cStart = c;
+    for (; *c; ++c) {
+      if (c[0] == '$' && c[1] == '<') {
         ++nestingLevel;
         ++c;
         continue;
-        }
-      if(c[0] == '>')
-        {
+      }
+      if (c[0] == '>') {
         --nestingLevel;
-        if (nestingLevel == 0)
-          {
+        if (nestingLevel == 0) {
           break;
-          }
         }
       }
+    }
     const std::string::size_type traversed = (c - cStart) + 1;
-    if (!*c)
-      {
+    if (!*c) {
       result += "$<" + input.substr(pos, traversed);
-      }
+    }
     pos += traversed;
     lastPos = pos;
-    }
-  if (nestingLevel == 0)
-    {
+  }
+  if (nestingLevel == 0) {
     result += input.substr(lastPos);
-    }
+  }
   return cmGeneratorExpression::StripEmptyListElements(result);
 }
 
-static void prefixItems(const std::string &content, std::string &result,
-                        const std::string &prefix)
+static void prefixItems(const std::string& content, std::string& result,
+                        const std::string& prefix)
 {
   std::vector<std::string> entries;
   cmGeneratorExpression::Split(content, entries);
-  const char *sep = "";
-  for(std::vector<std::string>::const_iterator ei = entries.begin();
-      ei != entries.end(); ++ei)
-    {
+  const char* sep = "";
+  for (std::vector<std::string>::const_iterator ei = entries.begin();
+       ei != entries.end(); ++ei) {
     result += sep;
     sep = ";";
-    if (!cmSystemTools::FileIsFullPath(ei->c_str())
-        && cmGeneratorExpression::Find(*ei) != 0)
-      {
+    if (!cmSystemTools::FileIsFullPath(ei->c_str()) &&
+        cmGeneratorExpression::Find(*ei) != 0) {
       result += prefix;
-      }
-    result += *ei;
     }
+    result += *ei;
+  }
 }
 
-static std::string stripExportInterface(const std::string &input,
-                          cmGeneratorExpression::PreprocessContext context,
-                          bool resolveRelative)
+static std::string stripExportInterface(
+  const std::string& input, cmGeneratorExpression::PreprocessContext context,
+  bool resolveRelative)
 {
   std::string result;
 
   int nestingLevel = 0;
   std::string::size_type pos = 0;
   std::string::size_type lastPos = pos;
-  while (true)
-    {
+  while (true) {
     std::string::size_type bPos = input.find("$<BUILD_INTERFACE:", lastPos);
     std::string::size_type iPos = input.find("$<INSTALL_INTERFACE:", lastPos);
 
-    if (bPos == std::string::npos && iPos == std::string::npos)
-      {
+    if (bPos == std::string::npos && iPos == std::string::npos) {
       break;
-      }
+    }
 
-    if (bPos == std::string::npos)
-      {
+    if (bPos == std::string::npos) {
       pos = iPos;
-      }
-    else if (iPos == std::string::npos)
-      {
+    } else if (iPos == std::string::npos) {
       pos = bPos;
-      }
-    else
-      {
+    } else {
       pos = (bPos < iPos) ? bPos : iPos;
-      }
+    }
 
     result += input.substr(lastPos, pos - lastPos);
     const bool gotInstallInterface = input[pos + 2] == 'I';
     pos += gotInstallInterface ? sizeof("$<INSTALL_INTERFACE:") - 1
                                : sizeof("$<BUILD_INTERFACE:") - 1;
     nestingLevel = 1;
-    const char *c = input.c_str() + pos;
-    const char * const cStart = c;
-    for ( ; *c; ++c)
-      {
-      if(c[0] == '$' && c[1] == '<')
-        {
+    const char* c = input.c_str() + pos;
+    const char* const cStart = c;
+    for (; *c; ++c) {
+      if (c[0] == '$' && c[1] == '<') {
         ++nestingLevel;
         ++c;
         continue;
-        }
-      if(c[0] == '>')
-        {
+      }
+      if (c[0] == '>') {
         --nestingLevel;
-        if (nestingLevel != 0)
-          {
+        if (nestingLevel != 0) {
           continue;
-          }
-        if(context == cmGeneratorExpression::BuildInterface
-            && !gotInstallInterface)
-          {
+        }
+        if (context == cmGeneratorExpression::BuildInterface &&
+            !gotInstallInterface) {
           result += input.substr(pos, c - cStart);
-          }
-        else if(context == cmGeneratorExpression::InstallInterface
-            && gotInstallInterface)
-          {
+        } else if (context == cmGeneratorExpression::InstallInterface &&
+                   gotInstallInterface) {
           const std::string content = input.substr(pos, c - cStart);
-          if (resolveRelative)
-            {
+          if (resolveRelative) {
             prefixItems(content, result, "${_IMPORT_PREFIX}/");
-            }
-          else
-            {
+          } else {
             result += content;
-            }
           }
-        break;
         }
+        break;
       }
+    }
     const std::string::size_type traversed = (c - cStart) + 1;
-    if (!*c)
-      {
+    if (!*c) {
       result += std::string(gotInstallInterface ? "$<INSTALL_INTERFACE:"
-                                                : "$<BUILD_INTERFACE:")
-             + input.substr(pos, traversed);
-      }
+                                                : "$<BUILD_INTERFACE:") +
+        input.substr(pos, traversed);
+    }
     pos += traversed;
     lastPos = pos;
-    }
-  if (nestingLevel == 0)
-    {
+  }
+  if (nestingLevel == 0) {
     result += input.substr(lastPos);
-    }
+  }
 
   return cmGeneratorExpression::StripEmptyListElements(result);
 }
 
-void cmGeneratorExpression::Split(const std::string &input,
-                                  std::vector<std::string> &output)
+void cmGeneratorExpression::Split(const std::string& input,
+                                  std::vector<std::string>& output)
 {
   std::string::size_type pos = 0;
   std::string::size_type lastPos = pos;
-  while((pos = input.find("$<", lastPos)) != input.npos)
-    {
+  while ((pos = input.find("$<", lastPos)) != input.npos) {
     std::string part = input.substr(lastPos, pos - lastPos);
     std::string preGenex;
-    if (!part.empty())
-      {
+    if (!part.empty()) {
       std::string::size_type startPos = input.rfind(";", pos);
-      if (startPos == std::string::npos)
-        {
+      if (startPos == std::string::npos) {
         preGenex = part;
         part = "";
-        }
-      else if (startPos != pos - 1 && startPos >= lastPos)
-        {
+      } else if (startPos != pos - 1 && startPos >= lastPos) {
         part = input.substr(lastPos, startPos - lastPos);
         preGenex = input.substr(startPos + 1, pos - startPos - 1);
-        }
-      if(!part.empty())
-        {
+      }
+      if (!part.empty()) {
         cmSystemTools::ExpandListArgument(part, output);
-        }
       }
+    }
     pos += 2;
     int nestingLevel = 1;
-    const char *c = input.c_str() + pos;
-    const char * const cStart = c;
-    for ( ; *c; ++c)
-      {
-      if(c[0] == '$' && c[1] == '<')
-        {
+    const char* c = input.c_str() + pos;
+    const char* const cStart = c;
+    for (; *c; ++c) {
+      if (c[0] == '$' && c[1] == '<') {
         ++nestingLevel;
         ++c;
         continue;
-        }
-      if(c[0] == '>')
-        {
+      }
+      if (c[0] == '>') {
         --nestingLevel;
-        if (nestingLevel == 0)
-          {
+        if (nestingLevel == 0) {
           break;
-          }
         }
       }
-    for ( ; *c; ++c)
-      {
+    }
+    for (; *c; ++c) {
       // Capture the part after the genex and before the next ';'
-      if(c[0] == ';')
-        {
+      if (c[0] == ';') {
         --c;
         break;
-        }
       }
+    }
     const std::string::size_type traversed = (c - cStart) + 1;
     output.push_back(preGenex + "$<" + input.substr(pos, traversed));
     pos += traversed;
     lastPos = pos;
-    }
-  if (lastPos < input.size())
-    {
+  }
+  if (lastPos < input.size()) {
     cmSystemTools::ExpandListArgument(input.substr(lastPos), output);
-    }
+  }
 }
 
-std::string cmGeneratorExpression::Preprocess(const std::string &input,
+std::string cmGeneratorExpression::Preprocess(const std::string& input,
                                               PreprocessContext context,
                                               bool resolveRelative)
 {
-  if (context == StripAllGeneratorExpressions)
-    {
+  if (context == StripAllGeneratorExpressions) {
     return stripAllGeneratorExpressions(input);
-    }
-  else if (context == BuildInterface || context == InstallInterface)
-    {
+  } else if (context == BuildInterface || context == InstallInterface) {
     return stripExportInterface(input, context, resolveRelative);
-    }
+  }
 
   assert(0 && "cmGeneratorExpression::Preprocess called with invalid args");
   return std::string();
 }
 
-std::string::size_type cmGeneratorExpression::Find(const std::string &input)
+std::string::size_type cmGeneratorExpression::Find(const std::string& input)
 {
   const std::string::size_type openpos = input.find("$<");
-  if (openpos != std::string::npos
-      && input.find(">", openpos) != std::string::npos)
-    {
+  if (openpos != std::string::npos &&
+      input.find(">", openpos) != std::string::npos) {
     return openpos;
-    }
+  }
   return std::string::npos;
 }
 
-bool cmGeneratorExpression::IsValidTargetName(const std::string &input)
+bool cmGeneratorExpression::IsValidTargetName(const std::string& input)
 {
   // The ':' is supported to allow use with IMPORTED targets. At least
   // Qt 4 and 5 IMPORTED targets use ':' as the namespace delimiter.
@@ -445,16 +379,14 @@ bool cmGeneratorExpression::IsValidTargetName(const std::string &input)
   return targetNameValidator.find(input);
 }
 
-void
-cmCompiledGeneratorExpression::GetMaxLanguageStandard(
-    const cmGeneratorTarget* tgt,
-                  std::map<std::string, std::string>& mapping)
+void cmCompiledGeneratorExpression::GetMaxLanguageStandard(
+  const cmGeneratorTarget* tgt, std::map<std::string, std::string>& mapping)
 {
   typedef std::map<cmGeneratorTarget const*,
-                   std::map<std::string, std::string> > MapType;
+                   std::map<std::string, std::string> >
+    MapType;
   MapType::const_iterator it = this->MaxLanguageStandard.find(tgt);
-  if (it != this->MaxLanguageStandard.end())
-    {
+  if (it != this->MaxLanguageStandard.end()) {
     mapping = it->second;
-    }
+  }
 }
diff --git a/Source/cmGeneratorExpression.h b/Source/cmGeneratorExpression.h
index 001f2df..71fbba3 100644
--- a/Source/cmGeneratorExpression.h
+++ b/Source/cmGeneratorExpression.h
@@ -44,34 +44,36 @@ class cmGeneratorExpression
 public:
   /** Construct. */
   cmGeneratorExpression(
-      cmListFileBacktrace const& backtrace = cmListFileBacktrace());
+    cmListFileBacktrace const& backtrace = cmListFileBacktrace());
   ~cmGeneratorExpression();
 
   cmsys::auto_ptr<cmCompiledGeneratorExpression> Parse(
-                                                std::string const& input);
+    std::string const& input);
   cmsys::auto_ptr<cmCompiledGeneratorExpression> Parse(const char* input);
 
-  enum PreprocessContext {
+  enum PreprocessContext
+  {
     StripAllGeneratorExpressions,
     BuildInterface,
     InstallInterface
   };
 
-  static std::string Preprocess(const std::string &input,
+  static std::string Preprocess(const std::string& input,
                                 PreprocessContext context,
                                 bool resolveRelative = false);
 
-  static void Split(const std::string &input,
-                    std::vector<std::string> &output);
+  static void Split(const std::string& input,
+                    std::vector<std::string>& output);
+
+  static std::string::size_type Find(const std::string& input);
 
-  static std::string::size_type Find(const std::string &input);
+  static bool IsValidTargetName(const std::string& input);
 
-  static bool IsValidTargetName(const std::string &input);
+  static std::string StripEmptyListElements(const std::string& input);
 
-  static std::string StripEmptyListElements(const std::string &input);
 private:
-  cmGeneratorExpression(const cmGeneratorExpression &);
-  void operator=(const cmGeneratorExpression &);
+  cmGeneratorExpression(const cmGeneratorExpression&);
+  void operator=(const cmGeneratorExpression&);
 
   cmListFileBacktrace Backtrace;
 };
@@ -83,35 +85,34 @@ public:
                        bool quiet = false,
                        cmGeneratorTarget const* headTarget = 0,
                        cmGeneratorTarget const* currentTarget = 0,
-                       cmGeneratorExpressionDAGChecker *dagChecker = 0,
+                       cmGeneratorExpressionDAGChecker* dagChecker = 0,
                        std::string const& language = std::string()) const;
   const char* Evaluate(cmLocalGenerator* lg, const std::string& config,
-                       bool quiet,
-                       cmGeneratorTarget const* headTarget,
-                       cmGeneratorExpressionDAGChecker *dagChecker,
+                       bool quiet, cmGeneratorTarget const* headTarget,
+                       cmGeneratorExpressionDAGChecker* dagChecker,
                        std::string const& language = std::string()) const;
 
   /** Get set of targets found during evaluations.  */
   std::set<cmGeneratorTarget*> const& GetTargets() const
-    { return this->DependTargets; }
+  {
+    return this->DependTargets;
+  }
 
   std::set<std::string> const& GetSeenTargetProperties() const
-    { return this->SeenTargetProperties; }
+  {
+    return this->SeenTargetProperties;
+  }
 
   std::set<cmGeneratorTarget const*> const& GetAllTargetsSeen() const
-    { return this->AllTargetsSeen; }
+  {
+    return this->AllTargetsSeen;
+  }
 
   ~cmCompiledGeneratorExpression();
 
-  std::string const& GetInput() const
-  {
-    return this->Input;
-  }
+  std::string const& GetInput() const { return this->Input; }
 
-  cmListFileBacktrace GetBacktrace() const
-  {
-    return this->Backtrace;
-  }
+  cmListFileBacktrace GetBacktrace() const { return this->Backtrace; }
   bool GetHadContextSensitiveCondition() const
   {
     return this->HadContextSensitiveCondition;
@@ -131,19 +132,20 @@ public:
   }
 
   void GetMaxLanguageStandard(cmGeneratorTarget const* tgt,
-                    std::map<std::string, std::string>& mapping);
+                              std::map<std::string, std::string>& mapping);
 
 private:
-  const char* EvaluateWithContext(cmGeneratorExpressionContext& context,
-                           cmGeneratorExpressionDAGChecker *dagChecker) const;
+  const char* EvaluateWithContext(
+    cmGeneratorExpressionContext& context,
+    cmGeneratorExpressionDAGChecker* dagChecker) const;
 
   cmCompiledGeneratorExpression(cmListFileBacktrace const& backtrace,
-              const std::string& input);
+                                const std::string& input);
 
   friend class cmGeneratorExpression;
 
-  cmCompiledGeneratorExpression(const cmCompiledGeneratorExpression &);
-  void operator=(const cmCompiledGeneratorExpression &);
+  cmCompiledGeneratorExpression(const cmCompiledGeneratorExpression&);
+  void operator=(const cmCompiledGeneratorExpression&);
 
   cmListFileBacktrace Backtrace;
   std::vector<cmGeneratorExpressionEvaluator*> Evaluators;
@@ -154,11 +156,12 @@ private:
   mutable std::set<cmGeneratorTarget const*> AllTargetsSeen;
   mutable std::set<std::string> SeenTargetProperties;
   mutable std::map<cmGeneratorTarget const*,
-                   std::map<std::string, std::string> > MaxLanguageStandard;
+                   std::map<std::string, std::string> >
+    MaxLanguageStandard;
   mutable std::string Output;
   mutable bool HadContextSensitiveCondition;
   mutable bool HadHeadSensitiveCondition;
-  mutable std::set<cmGeneratorTarget const*>  SourceSensitiveTargets;
+  mutable std::set<cmGeneratorTarget const*> SourceSensitiveTargets;
   bool EvaluateForBuildsystem;
 };
 
diff --git a/Source/cmGeneratorExpressionContext.cxx b/Source/cmGeneratorExpressionContext.cxx
index b3bcb50..8da6b50 100644
--- a/Source/cmGeneratorExpressionContext.cxx
+++ b/Source/cmGeneratorExpressionContext.cxx
@@ -15,22 +15,20 @@
 #include "cmGeneratorTarget.h"
 
 cmGeneratorExpressionContext::cmGeneratorExpressionContext(
-      cmLocalGenerator* lg, std::string const& config,
-      bool quiet, cmGeneratorTarget const* headTarget,
-      const cmGeneratorTarget* currentTarget,
-      bool evaluateForBuildsystem,
-      cmListFileBacktrace const& backtrace,
-      std::string const& language)
-  : Backtrace(backtrace),
-    LG(lg),
-    Config(config),
-    Language(language),
-    HeadTarget(headTarget),
-    CurrentTarget(currentTarget),
-    Quiet(quiet),
-    HadError(false),
-    HadContextSensitiveCondition(false),
-    HadHeadSensitiveCondition(false),
-    EvaluateForBuildsystem(evaluateForBuildsystem)
+  cmLocalGenerator* lg, std::string const& config, bool quiet,
+  cmGeneratorTarget const* headTarget, const cmGeneratorTarget* currentTarget,
+  bool evaluateForBuildsystem, cmListFileBacktrace const& backtrace,
+  std::string const& language)
+  : Backtrace(backtrace)
+  , LG(lg)
+  , Config(config)
+  , Language(language)
+  , HeadTarget(headTarget)
+  , CurrentTarget(currentTarget)
+  , Quiet(quiet)
+  , HadError(false)
+  , HadContextSensitiveCondition(false)
+  , HadHeadSensitiveCondition(false)
+  , EvaluateForBuildsystem(evaluateForBuildsystem)
 {
 }
diff --git a/Source/cmGeneratorExpressionContext.h b/Source/cmGeneratorExpressionContext.h
index 8228e89..cff7289 100644
--- a/Source/cmGeneratorExpressionContext.h
+++ b/Source/cmGeneratorExpressionContext.h
@@ -30,15 +30,14 @@ struct cmGeneratorExpressionContext
                                cmListFileBacktrace const& backtrace,
                                std::string const& language);
 
-
   cmListFileBacktrace Backtrace;
   std::set<cmGeneratorTarget*> DependTargets;
   std::set<cmGeneratorTarget const*> AllTargets;
   std::set<std::string> SeenTargetProperties;
   std::set<cmGeneratorTarget const*> SourceSensitiveTargets;
   std::map<cmGeneratorTarget const*, std::map<std::string, std::string> >
-                                                          MaxLanguageStandard;
-  cmLocalGenerator *LG;
+    MaxLanguageStandard;
+  cmLocalGenerator* LG;
   std::string Config;
   std::string Language;
   // The target whose property is being evaluated.
diff --git a/Source/cmGeneratorExpressionDAGChecker.cxx b/Source/cmGeneratorExpressionDAGChecker.cxx
index 17bafde..c700156 100644
--- a/Source/cmGeneratorExpressionDAGChecker.cxx
+++ b/Source/cmGeneratorExpressionDAGChecker.cxx
@@ -16,63 +16,62 @@
 #include "cmLocalGenerator.h"
 
 cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
-                const cmListFileBacktrace &backtrace,
-                const std::string &target,
-                const std::string &property,
-                const GeneratorExpressionContent *content,
-                cmGeneratorExpressionDAGChecker *parent)
-  : Parent(parent), Target(target), Property(property),
-    Content(content), Backtrace(backtrace), TransitivePropertiesOnly(false)
+  const cmListFileBacktrace& backtrace, const std::string& target,
+  const std::string& property, const GeneratorExpressionContent* content,
+  cmGeneratorExpressionDAGChecker* parent)
+  : Parent(parent)
+  , Target(target)
+  , Property(property)
+  , Content(content)
+  , Backtrace(backtrace)
+  , TransitivePropertiesOnly(false)
 {
   Initialize();
 }
 
 cmGeneratorExpressionDAGChecker::cmGeneratorExpressionDAGChecker(
-                const std::string &target,
-                const std::string &property,
-                const GeneratorExpressionContent *content,
-                cmGeneratorExpressionDAGChecker *parent)
-  : Parent(parent), Target(target), Property(property),
-    Content(content), Backtrace(), TransitivePropertiesOnly(false)
+  const std::string& target, const std::string& property,
+  const GeneratorExpressionContent* content,
+  cmGeneratorExpressionDAGChecker* parent)
+  : Parent(parent)
+  , Target(target)
+  , Property(property)
+  , Content(content)
+  , Backtrace()
+  , TransitivePropertiesOnly(false)
 {
   Initialize();
 }
 
-void
-cmGeneratorExpressionDAGChecker::Initialize()
+void cmGeneratorExpressionDAGChecker::Initialize()
 {
-  const cmGeneratorExpressionDAGChecker *top = this;
-  const cmGeneratorExpressionDAGChecker *p = this->Parent;
-  while (p)
-    {
+  const cmGeneratorExpressionDAGChecker* top = this;
+  const cmGeneratorExpressionDAGChecker* p = this->Parent;
+  while (p) {
     top = p;
     p = p->Parent;
-    }
+  }
   this->CheckResult = this->CheckGraph();
 
-#define TEST_TRANSITIVE_PROPERTY_METHOD(METHOD) \
-  top->METHOD () ||
+#define TEST_TRANSITIVE_PROPERTY_METHOD(METHOD) top->METHOD() ||
 
-  if (CheckResult == DAG && (
-      CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(TEST_TRANSITIVE_PROPERTY_METHOD)
-      false)
-     )
+  if (CheckResult == DAG && (CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(
+                              TEST_TRANSITIVE_PROPERTY_METHOD) false))
 #undef TEST_TRANSITIVE_PROPERTY_METHOD
-    {
-    std::map<std::string, std::set<std::string> >::const_iterator it
-                                              = top->Seen.find(this->Target);
-    if (it != top->Seen.end())
-      {
-      const std::set<std::string> &propSet = it->second;
-      if (propSet.find(this->Property) != propSet.end())
-        {
+  {
+    std::map<std::string, std::set<std::string> >::const_iterator it =
+      top->Seen.find(this->Target);
+    if (it != top->Seen.end()) {
+      const std::set<std::string>& propSet = it->second;
+      if (propSet.find(this->Property) != propSet.end()) {
         this->CheckResult = ALREADY_SEEN;
         return;
-        }
       }
-    const_cast<cmGeneratorExpressionDAGChecker *>(top)
-      ->Seen[this->Target].insert(this->Property);
     }
+    const_cast<cmGeneratorExpressionDAGChecker*>(top)
+      ->Seen[this->Target]
+      .insert(this->Property);
+  }
 }
 
 cmGeneratorExpressionDAGChecker::Result
@@ -82,158 +81,144 @@ cmGeneratorExpressionDAGChecker::Check() const
 }
 
 void cmGeneratorExpressionDAGChecker::ReportError(
-                  cmGeneratorExpressionContext *context,
-                  const std::string &expr)
+  cmGeneratorExpressionContext* context, const std::string& expr)
 {
-  if (this->CheckResult == DAG)
-    {
+  if (this->CheckResult == DAG) {
     return;
-    }
+  }
 
   context->HadError = true;
-  if (context->Quiet)
-    {
+  if (context->Quiet) {
     return;
-    }
+  }
 
-  const cmGeneratorExpressionDAGChecker *parent = this->Parent;
+  const cmGeneratorExpressionDAGChecker* parent = this->Parent;
 
-  if (parent && !parent->Parent)
-    {
+  if (parent && !parent->Parent) {
     std::ostringstream e;
     e << "Error evaluating generator expression:\n"
       << "  " << expr << "\n"
-      << "Self reference on target \""
-      << context->HeadTarget->GetName() << "\".\n";
-    context->LG->GetCMakeInstance()
-      ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                      parent->Backtrace);
+      << "Self reference on target \"" << context->HeadTarget->GetName()
+      << "\".\n";
+    context->LG->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, e.str(),
+                                                  parent->Backtrace);
     return;
-    }
+  }
 
   {
-  std::ostringstream e;
-  /* clang-format off */
+    std::ostringstream e;
+    /* clang-format off */
   e << "Error evaluating generator expression:\n"
     << "  " << expr << "\n"
     << "Dependency loop found.";
-  /* clang-format on */
-  context->LG->GetCMakeInstance()
-    ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                    context->Backtrace);
+    /* clang-format on */
+    context->LG->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, e.str(),
+                                                  context->Backtrace);
   }
 
   int loopStep = 1;
-  while (parent)
-    {
+  while (parent) {
     std::ostringstream e;
     e << "Loop step " << loopStep << "\n"
       << "  "
       << (parent->Content ? parent->Content->GetOriginalExpression() : expr)
       << "\n";
-    context->LG->GetCMakeInstance()
-      ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                      parent->Backtrace);
+    context->LG->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, e.str(),
+                                                  parent->Backtrace);
     parent = parent->Parent;
     ++loopStep;
-    }
+  }
 }
 
 cmGeneratorExpressionDAGChecker::Result
 cmGeneratorExpressionDAGChecker::CheckGraph() const
 {
-  const cmGeneratorExpressionDAGChecker *parent = this->Parent;
-  while (parent)
-    {
-    if (this->Target == parent->Target && this->Property == parent->Property)
-      {
+  const cmGeneratorExpressionDAGChecker* parent = this->Parent;
+  while (parent) {
+    if (this->Target == parent->Target && this->Property == parent->Property) {
       return (parent == this->Parent) ? SELF_REFERENCE : CYCLIC_REFERENCE;
-      }
-    parent = parent->Parent;
     }
+    parent = parent->Parent;
+  }
   return DAG;
 }
 
 bool cmGeneratorExpressionDAGChecker::GetTransitivePropertiesOnly()
 {
-  const cmGeneratorExpressionDAGChecker *top = this;
-  const cmGeneratorExpressionDAGChecker *parent = this->Parent;
-  while (parent)
-    {
+  const cmGeneratorExpressionDAGChecker* top = this;
+  const cmGeneratorExpressionDAGChecker* parent = this->Parent;
+  while (parent) {
     top = parent;
     parent = parent->Parent;
-    }
+  }
 
   return top->TransitivePropertiesOnly;
 }
 
-bool cmGeneratorExpressionDAGChecker::EvaluatingLinkLibraries(const char *tgt)
+bool cmGeneratorExpressionDAGChecker::EvaluatingLinkLibraries(const char* tgt)
 {
-  const cmGeneratorExpressionDAGChecker *top = this;
-  const cmGeneratorExpressionDAGChecker *parent = this->Parent;
-  while (parent)
-    {
+  const cmGeneratorExpressionDAGChecker* top = this;
+  const cmGeneratorExpressionDAGChecker* parent = this->Parent;
+  while (parent) {
     top = parent;
     parent = parent->Parent;
-    }
+  }
 
-  const char *prop = top->Property.c_str();
+  const char* prop = top->Property.c_str();
 
-  if (tgt)
-    {
+  if (tgt) {
     return top->Target == tgt && strcmp(prop, "LINK_LIBRARIES") == 0;
-    }
+  }
 
-  return (strcmp(prop, "LINK_LIBRARIES") == 0
-       || strcmp(prop, "LINK_INTERFACE_LIBRARIES") == 0
-       || strcmp(prop, "IMPORTED_LINK_INTERFACE_LIBRARIES") == 0
-       || cmHasLiteralPrefix(prop, "LINK_INTERFACE_LIBRARIES_")
-       || cmHasLiteralPrefix(prop, "IMPORTED_LINK_INTERFACE_LIBRARIES_"))
-       || strcmp(prop, "INTERFACE_LINK_LIBRARIES") == 0;
+  return (strcmp(prop, "LINK_LIBRARIES") == 0 ||
+          strcmp(prop, "LINK_INTERFACE_LIBRARIES") == 0 ||
+          strcmp(prop, "IMPORTED_LINK_INTERFACE_LIBRARIES") == 0 ||
+          cmHasLiteralPrefix(prop, "LINK_INTERFACE_LIBRARIES_") ||
+          cmHasLiteralPrefix(prop, "IMPORTED_LINK_INTERFACE_LIBRARIES_")) ||
+    strcmp(prop, "INTERFACE_LINK_LIBRARIES") == 0;
 }
 
 std::string cmGeneratorExpressionDAGChecker::TopTarget() const
 {
-  const cmGeneratorExpressionDAGChecker *top = this;
-  const cmGeneratorExpressionDAGChecker *parent = this->Parent;
-  while (parent)
-    {
+  const cmGeneratorExpressionDAGChecker* top = this;
+  const cmGeneratorExpressionDAGChecker* parent = this->Parent;
+  while (parent) {
     top = parent;
     parent = parent->Parent;
-    }
+  }
   return top->Target;
 }
 
-enum TransitiveProperty {
+enum TransitiveProperty
+{
 #define DEFINE_ENUM_ENTRY(NAME) NAME,
   CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(DEFINE_ENUM_ENTRY)
 #undef DEFINE_ENUM_ENTRY
-  TransitivePropertyTerminal
+    TransitivePropertyTerminal
 };
 
-template<TransitiveProperty>
+template <TransitiveProperty>
 bool additionalTest(const char* const)
 {
   return false;
 }
 
-template<>
+template <>
 bool additionalTest<COMPILE_DEFINITIONS>(const char* const prop)
 {
   return cmHasLiteralPrefix(prop, "COMPILE_DEFINITIONS_");
 }
 
-#define DEFINE_TRANSITIVE_PROPERTY_METHOD(METHOD, PROPERTY) \
-bool cmGeneratorExpressionDAGChecker::METHOD() const \
-{ \
-  const char* const prop = this->Property.c_str(); \
-  if (strcmp(prop, #PROPERTY) == 0 \
-      || strcmp(prop, "INTERFACE_" #PROPERTY) == 0) \
-    { \
-    return true; \
-    } \
-  return additionalTest<PROPERTY>(prop); \
-}
+#define DEFINE_TRANSITIVE_PROPERTY_METHOD(METHOD, PROPERTY)                   \
+  bool cmGeneratorExpressionDAGChecker::METHOD() const                        \
+  {                                                                           \
+    const char* const prop = this->Property.c_str();                          \
+    if (strcmp(prop, #PROPERTY) == 0 ||                                       \
+        strcmp(prop, "INTERFACE_" #PROPERTY) == 0) {                          \
+      return true;                                                            \
+    }                                                                         \
+    return additionalTest<PROPERTY>(prop);                                    \
+  }
 
 CM_FOR_EACH_TRANSITIVE_PROPERTY(DEFINE_TRANSITIVE_PROPERTY_METHOD)
 
diff --git a/Source/cmGeneratorExpressionDAGChecker.h b/Source/cmGeneratorExpressionDAGChecker.h
index c6c8901..28ca824 100644
--- a/Source/cmGeneratorExpressionDAGChecker.h
+++ b/Source/cmGeneratorExpressionDAGChecker.h
@@ -20,37 +20,38 @@
 #define CM_SELECT_FIRST(F, A1, A2) F(A1)
 #define CM_SELECT_SECOND(F, A1, A2) F(A2)
 
-#define CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, SELECT) \
-  SELECT(F, EvaluatingIncludeDirectories,       INCLUDE_DIRECTORIES) \
-  SELECT(F, EvaluatingSystemIncludeDirectories, SYSTEM_INCLUDE_DIRECTORIES) \
-  SELECT(F, EvaluatingCompileDefinitions,       COMPILE_DEFINITIONS) \
-  SELECT(F, EvaluatingCompileOptions,           COMPILE_OPTIONS) \
-  SELECT(F, EvaluatingAutoUicOptions,           AUTOUIC_OPTIONS) \
-  SELECT(F, EvaluatingSources,                  SOURCES) \
-  SELECT(F, EvaluatingCompileFeatures,          COMPILE_FEATURES)
-
-#define CM_FOR_EACH_TRANSITIVE_PROPERTY(F) \
+#define CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, SELECT)                       \
+  SELECT(F, EvaluatingIncludeDirectories, INCLUDE_DIRECTORIES)                \
+  SELECT(F, EvaluatingSystemIncludeDirectories, SYSTEM_INCLUDE_DIRECTORIES)   \
+  SELECT(F, EvaluatingCompileDefinitions, COMPILE_DEFINITIONS)                \
+  SELECT(F, EvaluatingCompileOptions, COMPILE_OPTIONS)                        \
+  SELECT(F, EvaluatingAutoUicOptions, AUTOUIC_OPTIONS)                        \
+  SELECT(F, EvaluatingSources, SOURCES)                                       \
+  SELECT(F, EvaluatingCompileFeatures, COMPILE_FEATURES)
+
+#define CM_FOR_EACH_TRANSITIVE_PROPERTY(F)                                    \
   CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, CM_SELECT_BOTH)
 
-#define CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(F) \
+#define CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(F)                             \
   CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, CM_SELECT_FIRST)
 
-#define CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(F) \
+#define CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(F)                               \
   CM_FOR_EACH_TRANSITIVE_PROPERTY_IMPL(F, CM_SELECT_SECOND)
 
 struct cmGeneratorExpressionDAGChecker
 {
-  cmGeneratorExpressionDAGChecker(const cmListFileBacktrace &backtrace,
-                                  const std::string &target,
-                                  const std::string &property,
-                                  const GeneratorExpressionContent *content,
-                                  cmGeneratorExpressionDAGChecker *parent);
-  cmGeneratorExpressionDAGChecker(const std::string &target,
-                                  const std::string &property,
-                                  const GeneratorExpressionContent *content,
-                                  cmGeneratorExpressionDAGChecker *parent);
-
-  enum Result {
+  cmGeneratorExpressionDAGChecker(const cmListFileBacktrace& backtrace,
+                                  const std::string& target,
+                                  const std::string& property,
+                                  const GeneratorExpressionContent* content,
+                                  cmGeneratorExpressionDAGChecker* parent);
+  cmGeneratorExpressionDAGChecker(const std::string& target,
+                                  const std::string& property,
+                                  const GeneratorExpressionContent* content,
+                                  cmGeneratorExpressionDAGChecker* parent);
+
+  enum Result
+  {
     DAG,
     SELF_REFERENCE,
     CYCLIC_REFERENCE,
@@ -59,21 +60,19 @@ struct cmGeneratorExpressionDAGChecker
 
   Result Check() const;
 
-  void ReportError(cmGeneratorExpressionContext *context,
-                   const std::string &expr);
+  void ReportError(cmGeneratorExpressionContext* context,
+                   const std::string& expr);
 
-  bool EvaluatingLinkLibraries(const char *tgt = 0);
+  bool EvaluatingLinkLibraries(const char* tgt = 0);
 
-#define DECLARE_TRANSITIVE_PROPERTY_METHOD(METHOD) \
-  bool METHOD () const;
+#define DECLARE_TRANSITIVE_PROPERTY_METHOD(METHOD) bool METHOD() const;
 
   CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(DECLARE_TRANSITIVE_PROPERTY_METHOD)
 
 #undef DECLARE_TRANSITIVE_PROPERTY_METHOD
 
   bool GetTransitivePropertiesOnly();
-  void SetTransitivePropertiesOnly()
-    { this->TransitivePropertiesOnly = true; }
+  void SetTransitivePropertiesOnly() { this->TransitivePropertiesOnly = true; }
 
   std::string TopTarget() const;
 
@@ -82,11 +81,11 @@ private:
   void Initialize();
 
 private:
-  const cmGeneratorExpressionDAGChecker * const Parent;
+  const cmGeneratorExpressionDAGChecker* const Parent;
   const std::string Target;
   const std::string Property;
   std::map<std::string, std::set<std::string> > Seen;
-  const GeneratorExpressionContent * const Content;
+  const GeneratorExpressionContent* const Content;
   const cmListFileBacktrace Backtrace;
   Result CheckResult;
   bool TransitivePropertiesOnly;
diff --git a/Source/cmGeneratorExpressionEvaluationFile.cxx b/Source/cmGeneratorExpressionEvaluationFile.cxx
index 75ddd28..c69e362 100644
--- a/Source/cmGeneratorExpressionEvaluationFile.cxx
+++ b/Source/cmGeneratorExpressionEvaluationFile.cxx
@@ -22,67 +22,59 @@
 #include <assert.h>
 
 cmGeneratorExpressionEvaluationFile::cmGeneratorExpressionEvaluationFile(
-        const std::string &input,
-        cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
-        cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
-        bool inputIsContent)
-  : Input(input),
-    OutputFileExpr(outputFileExpr),
-    Condition(condition),
-    InputIsContent(inputIsContent)
+  const std::string& input,
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
+  bool inputIsContent)
+  : Input(input)
+  , OutputFileExpr(outputFileExpr)
+  , Condition(condition)
+  , InputIsContent(inputIsContent)
 {
 }
 
-void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg,
-              const std::string& config,
-              const std::string& lang,
-              cmCompiledGeneratorExpression* inputExpression,
-              std::map<std::string, std::string> &outputFiles, mode_t perm)
+void cmGeneratorExpressionEvaluationFile::Generate(
+  cmLocalGenerator* lg, const std::string& config, const std::string& lang,
+  cmCompiledGeneratorExpression* inputExpression,
+  std::map<std::string, std::string>& outputFiles, mode_t perm)
 {
   std::string rawCondition = this->Condition->GetInput();
-  if (!rawCondition.empty())
-    {
-    std::string condResult = this->Condition->Evaluate(lg,
-                                                       config,
-                                                       false, 0, 0, 0, lang);
-    if (condResult == "0")
-      {
+  if (!rawCondition.empty()) {
+    std::string condResult =
+      this->Condition->Evaluate(lg, config, false, 0, 0, 0, lang);
+    if (condResult == "0") {
       return;
-      }
-    if (condResult != "1")
-      {
+    }
+    if (condResult != "1") {
       std::ostringstream e;
-      e << "Evaluation file condition \"" << rawCondition << "\" did "
-          "not evaluate to valid content. Got \"" << condResult << "\".";
+      e << "Evaluation file condition \"" << rawCondition
+        << "\" did "
+           "not evaluate to valid content. Got \""
+        << condResult << "\".";
       lg->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
     }
+  }
+
+  const std::string outputFileName =
+    this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, lang);
+  const std::string outputContent =
+    inputExpression->Evaluate(lg, config, false, 0, 0, 0, lang);
+
+  std::map<std::string, std::string>::iterator it =
+    outputFiles.find(outputFileName);
 
-  const std::string outputFileName
-                    = this->OutputFileExpr->Evaluate(lg, config,
-                                                     false, 0, 0, 0, lang);
-  const std::string outputContent
-                          = inputExpression->Evaluate(lg,
-                                                      config,
-                                                      false, 0, 0, 0, lang);
-
-  std::map<std::string, std::string>::iterator it
-                                          = outputFiles.find(outputFileName);
-
-  if(it != outputFiles.end())
-    {
-    if (it->second == outputContent)
-      {
+  if (it != outputFiles.end()) {
+    if (it->second == outputContent) {
       return;
-      }
+    }
     std::ostringstream e;
     e << "Evaluation file to be written multiple times for different "
          "configurations or languages with different content:\n  "
       << outputFileName;
     lg->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
+  }
 
   lg->GetMakefile()->AddCMakeOutputFile(outputFileName.c_str());
   this->Files.push_back(outputFileName);
@@ -91,94 +83,82 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg,
   cmGeneratedFileStream fout(outputFileName.c_str());
   fout.SetCopyIfDifferent(true);
   fout << outputContent;
-  if (fout.Close() && perm)
-    {
+  if (fout.Close() && perm) {
     cmSystemTools::SetPermissions(outputFileName.c_str(), perm);
-    }
+  }
 }
 
 void cmGeneratorExpressionEvaluationFile::CreateOutputFile(
-    cmLocalGenerator *lg, std::string const& config)
+  cmLocalGenerator* lg, std::string const& config)
 {
   std::vector<std::string> enabledLanguages;
-  cmGlobalGenerator *gg = lg->GetGlobalGenerator();
+  cmGlobalGenerator* gg = lg->GetGlobalGenerator();
   gg->GetEnabledLanguages(enabledLanguages);
 
-  for(std::vector<std::string>::const_iterator le = enabledLanguages.begin();
-      le != enabledLanguages.end(); ++le)
-    {
-    std::string name = this->OutputFileExpr->Evaluate(lg,
-                                                      config,
-                                                      false, 0, 0, 0, *le);
+  for (std::vector<std::string>::const_iterator le = enabledLanguages.begin();
+       le != enabledLanguages.end(); ++le) {
+    std::string name =
+      this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, *le);
     cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name);
     sf->SetProperty("GENERATED", "1");
 
-    gg->SetFilenameTargetDepends(sf,
-                          this->OutputFileExpr->GetSourceSensitiveTargets());
-    }
+    gg->SetFilenameTargetDepends(
+      sf, this->OutputFileExpr->GetSourceSensitiveTargets());
+  }
 }
 
-void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator *lg)
+void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg)
 {
   mode_t perm = 0;
   std::string inputContent;
-  if (this->InputIsContent)
-    {
+  if (this->InputIsContent) {
     inputContent = this->Input;
-    }
-  else
-    {
+  } else {
     lg->GetMakefile()->AddCMakeDependFile(this->Input.c_str());
     cmSystemTools::GetPermissions(this->Input.c_str(), perm);
     cmsys::ifstream fin(this->Input.c_str());
-    if(!fin)
-      {
+    if (!fin) {
       std::ostringstream e;
       e << "Evaluation file \"" << this->Input << "\" cannot be read.";
       lg->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
+    }
 
     std::string line;
     std::string sep;
-    while(cmSystemTools::GetLineFromStream(fin, line))
-      {
+    while (cmSystemTools::GetLineFromStream(fin, line)) {
       inputContent += sep + line;
       sep = "\n";
-      }
-    inputContent += sep;
     }
+    inputContent += sep;
+  }
 
   cmListFileBacktrace lfbt = this->OutputFileExpr->GetBacktrace();
   cmGeneratorExpression contentGE(lfbt);
-  cmsys::auto_ptr<cmCompiledGeneratorExpression> inputExpression
-                                              = contentGE.Parse(inputContent);
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> inputExpression =
+    contentGE.Parse(inputContent);
 
   std::map<std::string, std::string> outputFiles;
 
   std::vector<std::string> allConfigs;
   lg->GetMakefile()->GetConfigurations(allConfigs);
 
-  if (allConfigs.empty())
-    {
+  if (allConfigs.empty()) {
     allConfigs.push_back("");
-    }
+  }
 
   std::vector<std::string> enabledLanguages;
-  cmGlobalGenerator *gg = lg->GetGlobalGenerator();
+  cmGlobalGenerator* gg = lg->GetGlobalGenerator();
   gg->GetEnabledLanguages(enabledLanguages);
 
-  for(std::vector<std::string>::const_iterator le = enabledLanguages.begin();
-      le != enabledLanguages.end(); ++le)
-    {
-    for(std::vector<std::string>::const_iterator li = allConfigs.begin();
-        li != allConfigs.end(); ++li)
-      {
+  for (std::vector<std::string>::const_iterator le = enabledLanguages.begin();
+       le != enabledLanguages.end(); ++le) {
+    for (std::vector<std::string>::const_iterator li = allConfigs.begin();
+         li != allConfigs.end(); ++li) {
       this->Generate(lg, *li, *le, inputExpression.get(), outputFiles, perm);
-      if(cmSystemTools::GetFatalErrorOccured())
-        {
+      if (cmSystemTools::GetFatalErrorOccured()) {
         return;
-        }
       }
     }
+  }
 }
diff --git a/Source/cmGeneratorExpressionEvaluationFile.h b/Source/cmGeneratorExpressionEvaluationFile.h
index 51aa51b..bfd6add 100644
--- a/Source/cmGeneratorExpressionEvaluationFile.h
+++ b/Source/cmGeneratorExpressionEvaluationFile.h
@@ -22,10 +22,11 @@ class cmLocalGenerator;
 class cmGeneratorExpressionEvaluationFile
 {
 public:
-  cmGeneratorExpressionEvaluationFile(const std::string &input,
-        cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
-        cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
-        bool inputIsContent);
+  cmGeneratorExpressionEvaluationFile(
+    const std::string& input,
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
+    bool inputIsContent);
 
   void Generate(cmLocalGenerator* lg);
 
@@ -37,7 +38,7 @@ private:
   void Generate(cmLocalGenerator* lg, const std::string& config,
                 const std::string& lang,
                 cmCompiledGeneratorExpression* inputExpression,
-                std::map<std::string, std::string> &outputFiles, mode_t perm);
+                std::map<std::string, std::string>& outputFiles, mode_t perm);
 
 private:
   const std::string Input;
diff --git a/Source/cmGeneratorExpressionEvaluator.cxx b/Source/cmGeneratorExpressionEvaluator.cxx
index 5645e01..66437eb 100644
--- a/Source/cmGeneratorExpressionEvaluator.cxx
+++ b/Source/cmGeneratorExpressionEvaluator.cxx
@@ -28,11 +28,10 @@
 #include "cmGeneratorExpressionNode.h"
 
 GeneratorExpressionContent::GeneratorExpressionContent(
-                                                    const char *startContent,
-                                                    size_t length)
-  : StartContent(startContent), ContentLength(length)
+  const char* startContent, size_t length)
+  : StartContent(startContent)
+  , ContentLength(length)
 {
-
 }
 
 std::string GeneratorExpressionContent::GetOriginalExpression() const
@@ -41,201 +40,166 @@ std::string GeneratorExpressionContent::GetOriginalExpression() const
 }
 
 std::string GeneratorExpressionContent::ProcessArbitraryContent(
-    const cmGeneratorExpressionNode *node,
-    const std::string &identifier,
-    cmGeneratorExpressionContext *context,
-    cmGeneratorExpressionDAGChecker *dagChecker,
-    std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
+  const cmGeneratorExpressionNode* node, const std::string& identifier,
+  cmGeneratorExpressionContext* context,
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
     pit) const
 {
   std::string result;
 
-  const
-  std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
-                                      pend = this->ParamChildren.end();
-  for ( ; pit != pend; ++pit)
-    {
-    std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
-                                                            = pit->begin();
-    const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
-                                                              = pit->end();
-    for ( ; it != end; ++it)
-      {
-      if (node->RequiresLiteralInput())
-        {
-        if ((*it)->GetType() != cmGeneratorExpressionEvaluator::Text)
-          {
-          reportError(context, this->GetOriginalExpression(),
-                "$<" + identifier + "> expression requires literal input.");
+  const std::vector<
+    std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator pend =
+    this->ParamChildren.end();
+  for (; pit != pend; ++pit) {
+    std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
+      pit->begin();
+    const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end =
+      pit->end();
+    for (; it != end; ++it) {
+      if (node->RequiresLiteralInput()) {
+        if ((*it)->GetType() != cmGeneratorExpressionEvaluator::Text) {
+          reportError(context, this->GetOriginalExpression(), "$<" +
+                        identifier + "> expression requires literal input.");
           return std::string();
-          }
         }
+      }
       result += (*it)->Evaluate(context, dagChecker);
-      if (context->HadError)
-        {
+      if (context->HadError) {
         return std::string();
-        }
       }
-      if ((pit + 1) != pend)
-        {
-        result += ",";
-        }
     }
-  if (node->RequiresLiteralInput())
-    {
+    if ((pit + 1) != pend) {
+      result += ",";
+    }
+  }
+  if (node->RequiresLiteralInput()) {
     std::vector<std::string> parameters;
     parameters.push_back(result);
     return node->Evaluate(parameters, context, this, dagChecker);
-    }
+  }
   return result;
 }
 
 std::string GeneratorExpressionContent::Evaluate(
-                            cmGeneratorExpressionContext *context,
-                            cmGeneratorExpressionDAGChecker *dagChecker) const
+  cmGeneratorExpressionContext* context,
+  cmGeneratorExpressionDAGChecker* dagChecker) const
 {
   std::string identifier;
   {
-  std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it
-                                          = this->IdentifierChildren.begin();
-  const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end
-                                          = this->IdentifierChildren.end();
-  for ( ; it != end; ++it)
-    {
-    identifier += (*it)->Evaluate(context, dagChecker);
-    if (context->HadError)
-      {
-      return std::string();
+    std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
+      this->IdentifierChildren.begin();
+    const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end =
+      this->IdentifierChildren.end();
+    for (; it != end; ++it) {
+      identifier += (*it)->Evaluate(context, dagChecker);
+      if (context->HadError) {
+        return std::string();
       }
     }
   }
 
-  const cmGeneratorExpressionNode *node =
-      cmGeneratorExpressionNode::GetNode(identifier);
+  const cmGeneratorExpressionNode* node =
+    cmGeneratorExpressionNode::GetNode(identifier);
 
-  if (!node)
-    {
+  if (!node) {
     reportError(context, this->GetOriginalExpression(),
-              "Expression did not evaluate to a known generator expression");
+                "Expression did not evaluate to a known generator expression");
     return std::string();
-    }
+  }
 
-  if (!node->GeneratesContent())
-    {
-    if (node->NumExpectedParameters() == 1
-        && node->AcceptsArbitraryContentParameter())
-      {
-      if (this->ParamChildren.empty())
-        {
+  if (!node->GeneratesContent()) {
+    if (node->NumExpectedParameters() == 1 &&
+        node->AcceptsArbitraryContentParameter()) {
+      if (this->ParamChildren.empty()) {
         reportError(context, this->GetOriginalExpression(),
-                  "$<" + identifier + "> expression requires a parameter.");
-        }
+                    "$<" + identifier + "> expression requires a parameter.");
       }
-    else
-      {
+    } else {
       std::vector<std::string> parameters;
       this->EvaluateParameters(node, identifier, context, dagChecker,
                                parameters);
-      }
-    return std::string();
     }
+    return std::string();
+  }
 
   std::vector<std::string> parameters;
   this->EvaluateParameters(node, identifier, context, dagChecker, parameters);
-  if (context->HadError)
-    {
+  if (context->HadError) {
     return std::string();
-    }
+  }
 
   return node->Evaluate(parameters, context, this, dagChecker);
 }
 
 std::string GeneratorExpressionContent::EvaluateParameters(
-                                const cmGeneratorExpressionNode *node,
-                                const std::string &identifier,
-                                cmGeneratorExpressionContext *context,
-                                cmGeneratorExpressionDAGChecker *dagChecker,
-                                std::vector<std::string> &parameters) const
+  const cmGeneratorExpressionNode* node, const std::string& identifier,
+  cmGeneratorExpressionContext* context,
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  std::vector<std::string>& parameters) const
 {
   const int numExpected = node->NumExpectedParameters();
   {
-  std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
-                                        pit = this->ParamChildren.begin();
-  const
-  std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
-                                        pend = this->ParamChildren.end();
-  const bool acceptsArbitraryContent
-                                  = node->AcceptsArbitraryContentParameter();
-  int counter = 1;
-  for ( ; pit != pend; ++pit, ++counter)
-    {
-    if (acceptsArbitraryContent && counter == numExpected)
-      {
-      std::string lastParam = this->ProcessArbitraryContent(node, identifier,
-                                                            context,
-                                                            dagChecker,
-                                                            pit);
-      parameters.push_back(lastParam);
-      return std::string();
-      }
-    else
-      {
-      std::string parameter;
-      std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
-                                                                pit->begin();
-      const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator end =
-                                                                pit->end();
-      for ( ; it != end; ++it)
-        {
-        parameter += (*it)->Evaluate(context, dagChecker);
-        if (context->HadError)
-          {
-          return std::string();
+    std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
+      pit = this->ParamChildren.begin();
+    const std::vector<
+      std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator pend =
+      this->ParamChildren.end();
+    const bool acceptsArbitraryContent =
+      node->AcceptsArbitraryContentParameter();
+    int counter = 1;
+    for (; pit != pend; ++pit, ++counter) {
+      if (acceptsArbitraryContent && counter == numExpected) {
+        std::string lastParam = this->ProcessArbitraryContent(
+          node, identifier, context, dagChecker, pit);
+        parameters.push_back(lastParam);
+        return std::string();
+      } else {
+        std::string parameter;
+        std::vector<cmGeneratorExpressionEvaluator*>::const_iterator it =
+          pit->begin();
+        const std::vector<cmGeneratorExpressionEvaluator*>::const_iterator
+          end = pit->end();
+        for (; it != end; ++it) {
+          parameter += (*it)->Evaluate(context, dagChecker);
+          if (context->HadError) {
+            return std::string();
           }
         }
-      parameters.push_back(parameter);
+        parameters.push_back(parameter);
       }
     }
   }
 
-  if ((numExpected > cmGeneratorExpressionNode::DynamicParameters
-      && (unsigned int)numExpected != parameters.size()))
-    {
-    if (numExpected == 0)
-      {
+  if ((numExpected > cmGeneratorExpressionNode::DynamicParameters &&
+       (unsigned int)numExpected != parameters.size())) {
+    if (numExpected == 0) {
       reportError(context, this->GetOriginalExpression(),
                   "$<" + identifier + "> expression requires no parameters.");
-      }
-    else if (numExpected == 1)
-      {
-      reportError(context, this->GetOriginalExpression(),
-                  "$<" + identifier + "> expression requires "
-                  "exactly one parameter.");
-      }
-    else
-      {
+    } else if (numExpected == 1) {
+      reportError(context, this->GetOriginalExpression(), "$<" + identifier +
+                    "> expression requires "
+                    "exactly one parameter.");
+    } else {
       std::ostringstream e;
-      e << "$<" + identifier + "> expression requires "
-        << numExpected
-        << " comma separated parameters, but got "
-        << parameters.size() << " instead.";
+      e << "$<" + identifier + "> expression requires " << numExpected
+        << " comma separated parameters, but got " << parameters.size()
+        << " instead.";
       reportError(context, this->GetOriginalExpression(), e.str());
-      }
-    return std::string();
     }
+    return std::string();
+  }
 
-  if (numExpected == cmGeneratorExpressionNode::OneOrMoreParameters
-      && parameters.empty())
-    {
-    reportError(context, this->GetOriginalExpression(), "$<" + identifier
-                      + "> expression requires at least one parameter.");
-    }
-  if (numExpected == cmGeneratorExpressionNode::OneOrZeroParameters
-      && parameters.size() > 1)
-    {
-    reportError(context, this->GetOriginalExpression(), "$<" + identifier
-                      + "> expression requires one or zero parameters.");
-    }
+  if (numExpected == cmGeneratorExpressionNode::OneOrMoreParameters &&
+      parameters.empty()) {
+    reportError(context, this->GetOriginalExpression(), "$<" + identifier +
+                  "> expression requires at least one parameter.");
+  }
+  if (numExpected == cmGeneratorExpressionNode::OneOrZeroParameters &&
+      parameters.size() > 1) {
+    reportError(context, this->GetOriginalExpression(), "$<" + identifier +
+                  "> expression requires one or zero parameters.");
+  }
   return std::string();
 }
 
diff --git a/Source/cmGeneratorExpressionEvaluator.h b/Source/cmGeneratorExpressionEvaluator.h
index bce486b..7ca62c5 100644
--- a/Source/cmGeneratorExpressionEvaluator.h
+++ b/Source/cmGeneratorExpressionEvaluator.h
@@ -35,93 +35,80 @@ struct cmGeneratorExpressionEvaluator
 
   virtual Type GetType() const = 0;
 
-  virtual std::string Evaluate(cmGeneratorExpressionContext *context,
-                              cmGeneratorExpressionDAGChecker *) const = 0;
+  virtual std::string Evaluate(cmGeneratorExpressionContext* context,
+                               cmGeneratorExpressionDAGChecker*) const = 0;
 
 private:
-  cmGeneratorExpressionEvaluator(const cmGeneratorExpressionEvaluator &);
-  void operator=(const cmGeneratorExpressionEvaluator &);
+  cmGeneratorExpressionEvaluator(const cmGeneratorExpressionEvaluator&);
+  void operator=(const cmGeneratorExpressionEvaluator&);
 };
 
 struct TextContent : public cmGeneratorExpressionEvaluator
 {
-  TextContent(const char *start, size_t length)
-    : Content(start), Length(length)
+  TextContent(const char* start, size_t length)
+    : Content(start)
+    , Length(length)
   {
-
   }
 
-  std::string Evaluate(cmGeneratorExpressionContext *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(cmGeneratorExpressionContext*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return std::string(this->Content, this->Length);
   }
 
-  Type GetType() const
-  {
-    return cmGeneratorExpressionEvaluator::Text;
-  }
+  Type GetType() const { return cmGeneratorExpressionEvaluator::Text; }
 
-  void Extend(size_t length)
-  {
-    this->Length += length;
-  }
+  void Extend(size_t length) { this->Length += length; }
 
-  size_t GetLength()
-  {
-    return this->Length;
-  }
+  size_t GetLength() { return this->Length; }
 
 private:
-  const char *Content;
+  const char* Content;
   size_t Length;
 };
 
 struct GeneratorExpressionContent : public cmGeneratorExpressionEvaluator
 {
-  GeneratorExpressionContent(const char *startContent, size_t length);
+  GeneratorExpressionContent(const char* startContent, size_t length);
   void SetIdentifier(std::vector<cmGeneratorExpressionEvaluator*> identifier)
   {
     this->IdentifierChildren = identifier;
   }
 
   void SetParameters(
-        std::vector<std::vector<cmGeneratorExpressionEvaluator*> > parameters)
+    std::vector<std::vector<cmGeneratorExpressionEvaluator*> > parameters)
   {
     this->ParamChildren = parameters;
   }
 
-  Type GetType() const
-  {
-    return cmGeneratorExpressionEvaluator::Generator;
-  }
+  Type GetType() const { return cmGeneratorExpressionEvaluator::Generator; }
 
-  std::string Evaluate(cmGeneratorExpressionContext *context,
-                       cmGeneratorExpressionDAGChecker *) const;
+  std::string Evaluate(cmGeneratorExpressionContext* context,
+                       cmGeneratorExpressionDAGChecker*) const;
 
   std::string GetOriginalExpression() const;
 
   ~GeneratorExpressionContent();
 
 private:
-  std::string EvaluateParameters(const cmGeneratorExpressionNode *node,
-                                 const std::string &identifier,
-                                 cmGeneratorExpressionContext *context,
-                                 cmGeneratorExpressionDAGChecker *dagChecker,
-                                 std::vector<std::string> &parameters) const;
+  std::string EvaluateParameters(const cmGeneratorExpressionNode* node,
+                                 const std::string& identifier,
+                                 cmGeneratorExpressionContext* context,
+                                 cmGeneratorExpressionDAGChecker* dagChecker,
+                                 std::vector<std::string>& parameters) const;
 
   std::string ProcessArbitraryContent(
-    const cmGeneratorExpressionNode *node,
-    const std::string &identifier,
-    cmGeneratorExpressionContext *context,
-    cmGeneratorExpressionDAGChecker *dagChecker,
+    const cmGeneratorExpressionNode* node, const std::string& identifier,
+    cmGeneratorExpressionContext* context,
+    cmGeneratorExpressionDAGChecker* dagChecker,
     std::vector<std::vector<cmGeneratorExpressionEvaluator*> >::const_iterator
-    pit) const;
+      pit) const;
 
 private:
   std::vector<cmGeneratorExpressionEvaluator*> IdentifierChildren;
   std::vector<std::vector<cmGeneratorExpressionEvaluator*> > ParamChildren;
-  const char *StartContent;
+  const char* StartContent;
   size_t ContentLength;
 };
 
diff --git a/Source/cmGeneratorExpressionLexer.cxx b/Source/cmGeneratorExpressionLexer.cxx
index 6a1ddf4..5a4eccc 100644
--- a/Source/cmGeneratorExpressionLexer.cxx
+++ b/Source/cmGeneratorExpressionLexer.cxx
@@ -11,68 +11,63 @@
 ============================================================================*/
 #include "cmGeneratorExpressionLexer.h"
 
-
 cmGeneratorExpressionLexer::cmGeneratorExpressionLexer()
-  : SawBeginExpression(false), SawGeneratorExpression(false)
+  : SawBeginExpression(false)
+  , SawGeneratorExpression(false)
 {
-
 }
 
-static void InsertText(const char *upto, const char *c,
-                        std::vector<cmGeneratorExpressionToken> &result)
+static void InsertText(const char* upto, const char* c,
+                       std::vector<cmGeneratorExpressionToken>& result)
 {
-  if (upto != c)
-    {
+  if (upto != c) {
     result.push_back(cmGeneratorExpressionToken(
-                          cmGeneratorExpressionToken::Text, upto, c - upto));
-    }
+      cmGeneratorExpressionToken::Text, upto, c - upto));
+  }
 }
 
-std::vector<cmGeneratorExpressionToken>
-cmGeneratorExpressionLexer::Tokenize(const std::string& input)
+std::vector<cmGeneratorExpressionToken> cmGeneratorExpressionLexer::Tokenize(
+  const std::string& input)
 {
   std::vector<cmGeneratorExpressionToken> result;
 
-  const char *c = input.c_str();
-  const char *upto = c;
+  const char* c = input.c_str();
+  const char* upto = c;
 
-  for ( ; *c; ++c)
-    {
-    switch(*c)
-      {
+  for (; *c; ++c) {
+    switch (*c) {
       case '$':
-        if(c[1] == '<')
-          {
+        if (c[1] == '<') {
           InsertText(upto, c, result);
           result.push_back(cmGeneratorExpressionToken(
-                           cmGeneratorExpressionToken::BeginExpression, c, 2));
+            cmGeneratorExpressionToken::BeginExpression, c, 2));
           upto = c + 2;
           ++c;
           SawBeginExpression = true;
-          }
+        }
         break;
       case '>':
         InsertText(upto, c, result);
         result.push_back(cmGeneratorExpressionToken(
-                            cmGeneratorExpressionToken::EndExpression, c, 1));
+          cmGeneratorExpressionToken::EndExpression, c, 1));
         upto = c + 1;
         SawGeneratorExpression = SawBeginExpression;
         break;
       case ':':
         InsertText(upto, c, result);
         result.push_back(cmGeneratorExpressionToken(
-                            cmGeneratorExpressionToken::ColonSeparator, c, 1));
+          cmGeneratorExpressionToken::ColonSeparator, c, 1));
         upto = c + 1;
         break;
       case ',':
         InsertText(upto, c, result);
         result.push_back(cmGeneratorExpressionToken(
-                            cmGeneratorExpressionToken::CommaSeparator, c, 1));
+          cmGeneratorExpressionToken::CommaSeparator, c, 1));
         upto = c + 1;
         break;
       default:
         break;
-      }
+    }
   }
   InsertText(upto, c, result);
 
diff --git a/Source/cmGeneratorExpressionLexer.h b/Source/cmGeneratorExpressionLexer.h
index 16f2794..72ad731 100644
--- a/Source/cmGeneratorExpressionLexer.h
+++ b/Source/cmGeneratorExpressionLexer.h
@@ -18,11 +18,14 @@
 
 struct cmGeneratorExpressionToken
 {
-  cmGeneratorExpressionToken(unsigned type, const char *c, size_t l)
-    : TokenType(type), Content(c), Length(l)
+  cmGeneratorExpressionToken(unsigned type, const char* c, size_t l)
+    : TokenType(type)
+    , Content(c)
+    , Length(l)
   {
   }
-  enum {
+  enum
+  {
     Text,
     BeginExpression,
     EndExpression,
@@ -30,7 +33,7 @@ struct cmGeneratorExpressionToken
     CommaSeparator
   };
   unsigned TokenType;
-  const char *Content;
+  const char* Content;
   size_t Length;
 };
 
diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx
index 7bd2b1c..e750551 100644
--- a/Source/cmGeneratorExpressionNode.cxx
+++ b/Source/cmGeneratorExpressionNode.cxx
@@ -18,30 +18,23 @@
 #include "cmOutputConverter.h"
 
 std::string cmGeneratorExpressionNode::EvaluateDependentExpression(
-    std::string const& prop, cmLocalGenerator *lg,
-    cmGeneratorExpressionContext *context,
-    cmGeneratorTarget const* headTarget,
-    cmGeneratorTarget const* currentTarget,
-    cmGeneratorExpressionDAGChecker *dagChecker)
+  std::string const& prop, cmLocalGenerator* lg,
+  cmGeneratorExpressionContext* context, cmGeneratorTarget const* headTarget,
+  cmGeneratorTarget const* currentTarget,
+  cmGeneratorExpressionDAGChecker* dagChecker)
 {
   cmGeneratorExpression ge(context->Backtrace);
   cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
   cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem);
-  std::string result = cge->Evaluate(lg,
-                        context->Config,
-                        context->Quiet,
-                        headTarget,
-                        currentTarget,
-                        dagChecker,
-                        context->Language);
-  if (cge->GetHadContextSensitiveCondition())
-    {
+  std::string result =
+    cge->Evaluate(lg, context->Config, context->Quiet, headTarget,
+                  currentTarget, dagChecker, context->Language);
+  if (cge->GetHadContextSensitiveCondition()) {
     context->HadContextSensitiveCondition = true;
-    }
-  if (cge->GetHadHeadSensitiveCondition())
-    {
+  }
+  if (cge->GetHadHeadSensitiveCondition()) {
     context->HadHeadSensitiveCondition = true;
-    }
+  }
   return result;
 }
 
@@ -53,10 +46,10 @@ static const struct ZeroNode : public cmGeneratorExpressionNode
 
   virtual bool AcceptsArbitraryContentParameter() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>&,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return std::string();
   }
@@ -68,10 +61,10 @@ static const struct OneNode : public cmGeneratorExpressionNode
 
   virtual bool AcceptsArbitraryContentParameter() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return parameters.front();
   }
@@ -81,35 +74,32 @@ static const struct OneNode buildInterfaceNode;
 
 static const struct ZeroNode installInterfaceNode;
 
-#define BOOLEAN_OP_NODE(OPNAME, OP, SUCCESS_VALUE, FAILURE_VALUE) \
-static const struct OP ## Node : public cmGeneratorExpressionNode \
-{ \
-  OP ## Node () {} \
-  virtual int NumExpectedParameters() const { return OneOrMoreParameters; } \
- \
-  std::string Evaluate(const std::vector<std::string> &parameters, \
-                       cmGeneratorExpressionContext *context, \
-                       const GeneratorExpressionContent *content, \
-                       cmGeneratorExpressionDAGChecker *) const \
-  { \
-    std::vector<std::string>::const_iterator it = parameters.begin(); \
-    const std::vector<std::string>::const_iterator end = parameters.end(); \
-    for ( ; it != end; ++it) \
-      { \
-      if (*it == #FAILURE_VALUE) \
-        { \
-        return #FAILURE_VALUE; \
-        } \
-      else if (*it != #SUCCESS_VALUE) \
-        { \
-        reportError(context, content->GetOriginalExpression(), \
-        "Parameters to $<" #OP "> must resolve to either '0' or '1'."); \
-        return std::string(); \
-        } \
-      } \
-    return #SUCCESS_VALUE; \
-  } \
-} OPNAME;
+#define BOOLEAN_OP_NODE(OPNAME, OP, SUCCESS_VALUE, FAILURE_VALUE)             \
+  static const struct OP##Node : public cmGeneratorExpressionNode             \
+  {                                                                           \
+    OP##Node() {}                                                             \
+    virtual int NumExpectedParameters() const { return OneOrMoreParameters; } \
+                                                                              \
+    std::string Evaluate(const std::vector<std::string>& parameters,          \
+                         cmGeneratorExpressionContext* context,               \
+                         const GeneratorExpressionContent* content,           \
+                         cmGeneratorExpressionDAGChecker*) const              \
+    {                                                                         \
+      std::vector<std::string>::const_iterator it = parameters.begin();       \
+      const std::vector<std::string>::const_iterator end = parameters.end();  \
+      for (; it != end; ++it) {                                               \
+        if (*it == #FAILURE_VALUE) {                                          \
+          return #FAILURE_VALUE;                                              \
+        } else if (*it != #SUCCESS_VALUE) {                                   \
+          reportError(context, content->GetOriginalExpression(),              \
+                      "Parameters to $<" #OP                                  \
+                      "> must resolve to either '0' or '1'.");                \
+          return std::string();                                               \
+        }                                                                     \
+      }                                                                       \
+      return #SUCCESS_VALUE;                                                  \
+    }                                                                         \
+  } OPNAME;
 
 BOOLEAN_OP_NODE(andNode, AND, 1, 0)
 BOOLEAN_OP_NODE(orNode, OR, 0, 1)
@@ -120,17 +110,17 @@ static const struct NotNode : public cmGeneratorExpressionNode
 {
   NotNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    if (*parameters.begin() != "0" && *parameters.begin() != "1")
-      {
-      reportError(context, content->GetOriginalExpression(),
-            "$<NOT> parameter must resolve to exactly one '0' or '1' value.");
+    if (*parameters.begin() != "0" && *parameters.begin() != "1") {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<NOT> parameter must resolve to exactly one '0' or '1' value.");
       return std::string();
-      }
+    }
     return *parameters.begin() == "0" ? "1" : "0";
   }
 } notNode;
@@ -141,10 +131,10 @@ static const struct BoolNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 1; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return !cmSystemTools::IsOff(parameters.begin()->c_str()) ? "1" : "0";
   }
@@ -156,10 +146,10 @@ static const struct StrEqualNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 2; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return *parameters.begin() == parameters[1] ? "1" : "0";
   }
@@ -171,80 +161,72 @@ static const struct EqualNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 2; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    char *pEnd;
+    char* pEnd;
 
     int base = 0;
     bool flipSign = false;
 
-    const char *lhs = parameters[0].c_str();
-    if (cmHasLiteralPrefix(lhs, "0b") || cmHasLiteralPrefix(lhs, "0B"))
-      {
+    const char* lhs = parameters[0].c_str();
+    if (cmHasLiteralPrefix(lhs, "0b") || cmHasLiteralPrefix(lhs, "0B")) {
       base = 2;
       lhs += 2;
-      }
-    if (cmHasLiteralPrefix(lhs, "-0b") || cmHasLiteralPrefix(lhs, "-0B"))
-      {
+    }
+    if (cmHasLiteralPrefix(lhs, "-0b") || cmHasLiteralPrefix(lhs, "-0B")) {
       base = 2;
       lhs += 3;
       flipSign = true;
-      }
-    if (cmHasLiteralPrefix(lhs, "+0b") || cmHasLiteralPrefix(lhs, "+0B"))
-      {
+    }
+    if (cmHasLiteralPrefix(lhs, "+0b") || cmHasLiteralPrefix(lhs, "+0B")) {
       base = 2;
       lhs += 3;
-      }
+    }
 
     long lnum = strtol(lhs, &pEnd, base);
-    if (pEnd == lhs || *pEnd != '\0' || errno == ERANGE)
-      {
+    if (pEnd == lhs || *pEnd != '\0' || errno == ERANGE) {
       reportError(context, content->GetOriginalExpression(),
-          "$<EQUAL> parameter " + parameters[0] + " is not a valid integer.");
+                  "$<EQUAL> parameter " + parameters[0] +
+                    " is not a valid integer.");
       return std::string();
-      }
+    }
 
-    if (flipSign)
-      {
+    if (flipSign) {
       lnum = -lnum;
-      }
+    }
 
     base = 0;
     flipSign = false;
 
-    const char *rhs = parameters[1].c_str();
-    if (cmHasLiteralPrefix(rhs, "0b") || cmHasLiteralPrefix(rhs, "0B"))
-      {
+    const char* rhs = parameters[1].c_str();
+    if (cmHasLiteralPrefix(rhs, "0b") || cmHasLiteralPrefix(rhs, "0B")) {
       base = 2;
       rhs += 2;
-      }
-    if (cmHasLiteralPrefix(rhs, "-0b") || cmHasLiteralPrefix(rhs, "-0B"))
-      {
+    }
+    if (cmHasLiteralPrefix(rhs, "-0b") || cmHasLiteralPrefix(rhs, "-0B")) {
       base = 2;
       rhs += 3;
       flipSign = true;
-      }
-    if (cmHasLiteralPrefix(rhs, "+0b") || cmHasLiteralPrefix(rhs, "+0B"))
-      {
+    }
+    if (cmHasLiteralPrefix(rhs, "+0b") || cmHasLiteralPrefix(rhs, "+0B")) {
       base = 2;
       rhs += 3;
-      }
+    }
 
     long rnum = strtol(rhs, &pEnd, base);
-    if (pEnd == rhs || *pEnd != '\0' || errno == ERANGE)
-      {
+    if (pEnd == rhs || *pEnd != '\0' || errno == ERANGE) {
       reportError(context, content->GetOriginalExpression(),
-          "$<EQUAL> parameter " + parameters[1] + " is not a valid integer.");
+                  "$<EQUAL> parameter " + parameters[1] +
+                    " is not a valid integer.");
       return std::string();
-      }
+    }
 
-    if (flipSign)
-      {
+    if (flipSign) {
       rnum = -rnum;
-      }
+    }
 
     return lnum == rnum ? "1" : "0";
   }
@@ -256,10 +238,10 @@ static const struct LowerCaseNode : public cmGeneratorExpressionNode
 
   bool AcceptsArbitraryContentParameter() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return cmSystemTools::LowerCase(parameters.front());
   }
@@ -271,10 +253,10 @@ static const struct UpperCaseNode : public cmGeneratorExpressionNode
 
   bool AcceptsArbitraryContentParameter() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return cmSystemTools::UpperCase(parameters.front());
   }
@@ -286,10 +268,10 @@ static const struct MakeCIdentifierNode : public cmGeneratorExpressionNode
 
   bool AcceptsArbitraryContentParameter() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return cmSystemTools::MakeCidentifier(parameters.front());
   }
@@ -301,10 +283,10 @@ static const struct Angle_RNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 0; }
 
-  std::string Evaluate(const std::vector<std::string> &,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>&,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return ">";
   }
@@ -316,10 +298,10 @@ static const struct CommaNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 0; }
 
-  std::string Evaluate(const std::vector<std::string> &,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>&,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return ",";
   }
@@ -331,10 +313,10 @@ static const struct SemicolonNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 0; }
 
-  std::string Evaluate(const std::vector<std::string> &,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>&,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return ";";
   }
@@ -346,56 +328,47 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
 
-  std::string EvaluateWithLanguage(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *,
-                       const std::string &lang) const
+  std::string EvaluateWithLanguage(const std::vector<std::string>& parameters,
+                                   cmGeneratorExpressionContext* context,
+                                   const GeneratorExpressionContent* content,
+                                   cmGeneratorExpressionDAGChecker*,
+                                   const std::string& lang) const
   {
-    const char *compilerId =
-      context->LG->GetMakefile()
-        ->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID");
-    if (parameters.empty())
-      {
+    const char* compilerId = context->LG->GetMakefile()->GetSafeDefinition(
+      "CMAKE_" + lang + "_COMPILER_ID");
+    if (parameters.empty()) {
       return compilerId ? compilerId : "";
-      }
+    }
     static cmsys::RegularExpression compilerIdValidator("^[A-Za-z0-9_]*$");
-    if (!compilerIdValidator.find(*parameters.begin()))
-      {
+    if (!compilerIdValidator.find(*parameters.begin())) {
       reportError(context, content->GetOriginalExpression(),
                   "Expression syntax not recognized.");
       return std::string();
-      }
-    if (!compilerId)
-      {
+    }
+    if (!compilerId) {
       return parameters.front().empty() ? "1" : "0";
-      }
+    }
 
-    if (strcmp(parameters.begin()->c_str(), compilerId) == 0)
-      {
+    if (strcmp(parameters.begin()->c_str(), compilerId) == 0) {
       return "1";
-      }
+    }
 
-    if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0)
-      {
-      switch(context->LG->GetPolicyStatus(cmPolicies::CMP0044))
-        {
-        case cmPolicies::WARN:
-          {
+    if (cmsysString_strcasecmp(parameters.begin()->c_str(), compilerId) == 0) {
+      switch (context->LG->GetPolicyStatus(cmPolicies::CMP0044)) {
+        case cmPolicies::WARN: {
           std::ostringstream e;
           e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0044);
-          context->LG->GetCMakeInstance()
-                 ->IssueMessage(cmake::AUTHOR_WARNING,
-                                e.str(), context->Backtrace);
-          }
+          context->LG->GetCMakeInstance()->IssueMessage(
+            cmake::AUTHOR_WARNING, e.str(), context->Backtrace);
+        }
         case cmPolicies::OLD:
           return "1";
         case cmPolicies::NEW:
         case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::REQUIRED_IF_USED:
           break;
-        }
       }
+    }
     return "0";
   }
 };
@@ -404,20 +377,20 @@ static const struct CCompilerIdNode : public CompilerIdNode
 {
   CCompilerIdNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
-    if (!context->HeadTarget)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<C_COMPILER_ID> may only be used with binary targets.  It may "
-          "not be used with add_custom_command or add_custom_target.");
+    if (!context->HeadTarget) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<C_COMPILER_ID> may only be used with binary targets.  It may "
+        "not be used with add_custom_command or add_custom_target.");
       return std::string();
-      }
-    return this->EvaluateWithLanguage(parameters, context, content,
-                                      dagChecker, "C");
+    }
+    return this->EvaluateWithLanguage(parameters, context, content, dagChecker,
+                                      "C");
   }
 } cCompilerIdNode;
 
@@ -425,20 +398,20 @@ static const struct CXXCompilerIdNode : public CompilerIdNode
 {
   CXXCompilerIdNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
-    if (!context->HeadTarget)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<CXX_COMPILER_ID> may only be used with binary targets.  It may "
-          "not be used with add_custom_command or add_custom_target.");
+    if (!context->HeadTarget) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<CXX_COMPILER_ID> may only be used with binary targets.  It may "
+        "not be used with add_custom_command or add_custom_target.");
       return std::string();
-      }
-    return this->EvaluateWithLanguage(parameters, context, content,
-                                      dagChecker, "CXX");
+    }
+    return this->EvaluateWithLanguage(parameters, context, content, dagChecker,
+                                      "CXX");
   }
 } cxxCompilerIdNode;
 
@@ -448,35 +421,34 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
 
-  std::string EvaluateWithLanguage(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *,
-                       const std::string &lang) const
+  std::string EvaluateWithLanguage(const std::vector<std::string>& parameters,
+                                   cmGeneratorExpressionContext* context,
+                                   const GeneratorExpressionContent* content,
+                                   cmGeneratorExpressionDAGChecker*,
+                                   const std::string& lang) const
   {
-    const char *compilerVersion =
-        context->LG->GetMakefile()->GetSafeDefinition(
-          "CMAKE_" + lang + "_COMPILER_VERSION");
-    if (parameters.empty())
-      {
+    const char* compilerVersion =
+      context->LG->GetMakefile()->GetSafeDefinition("CMAKE_" + lang +
+                                                    "_COMPILER_VERSION");
+    if (parameters.empty()) {
       return compilerVersion ? compilerVersion : "";
-      }
+    }
 
     static cmsys::RegularExpression compilerIdValidator("^[0-9\\.]*$");
-    if (!compilerIdValidator.find(*parameters.begin()))
-      {
+    if (!compilerIdValidator.find(*parameters.begin())) {
       reportError(context, content->GetOriginalExpression(),
                   "Expression syntax not recognized.");
       return std::string();
-      }
-    if (!compilerVersion)
-      {
+    }
+    if (!compilerVersion) {
       return parameters.front().empty() ? "1" : "0";
-      }
+    }
 
     return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
-                                      parameters.begin()->c_str(),
-                                      compilerVersion) ? "1" : "0";
+                                         parameters.begin()->c_str(),
+                                         compilerVersion)
+      ? "1"
+      : "0";
   }
 };
 
@@ -484,20 +456,20 @@ static const struct CCompilerVersionNode : public CompilerVersionNode
 {
   CCompilerVersionNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
-    if (!context->HeadTarget)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<C_COMPILER_VERSION> may only be used with binary targets.  It "
-          "may not be used with add_custom_command or add_custom_target.");
+    if (!context->HeadTarget) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<C_COMPILER_VERSION> may only be used with binary targets.  It "
+        "may not be used with add_custom_command or add_custom_target.");
       return std::string();
-      }
-    return this->EvaluateWithLanguage(parameters, context, content,
-                                      dagChecker, "C");
+    }
+    return this->EvaluateWithLanguage(parameters, context, content, dagChecker,
+                                      "C");
   }
 } cCompilerVersionNode;
 
@@ -505,51 +477,47 @@ static const struct CxxCompilerVersionNode : public CompilerVersionNode
 {
   CxxCompilerVersionNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
-    if (!context->HeadTarget)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<CXX_COMPILER_VERSION> may only be used with binary targets.  It "
-          "may not be used with add_custom_command or add_custom_target.");
+    if (!context->HeadTarget) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<CXX_COMPILER_VERSION> may only be used with binary targets.  It "
+        "may not be used with add_custom_command or add_custom_target.");
       return std::string();
-      }
-    return this->EvaluateWithLanguage(parameters, context, content,
-                                      dagChecker, "CXX");
+    }
+    return this->EvaluateWithLanguage(parameters, context, content, dagChecker,
+                                      "CXX");
   }
 } cxxCompilerVersionNode;
 
-
 struct PlatformIdNode : public cmGeneratorExpressionNode
 {
   PlatformIdNode() {}
 
   virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    const char *platformId =
+    const char* platformId =
       context->LG->GetMakefile()->GetSafeDefinition("CMAKE_SYSTEM_NAME");
-    if (parameters.empty())
-      {
+    if (parameters.empty()) {
       return platformId ? platformId : "";
-      }
+    }
 
-    if (!platformId)
-      {
+    if (!platformId) {
       return parameters.front().empty() ? "1" : "0";
-      }
+    }
 
-    if (strcmp(parameters.begin()->c_str(), platformId) == 0)
-      {
+    if (strcmp(parameters.begin()->c_str(), platformId) == 0) {
       return "1";
-      }
+    }
     return "0";
   }
 } platformIdNode;
@@ -560,14 +528,16 @@ static const struct VersionGreaterNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 2; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
                                          parameters.front().c_str(),
-                                         parameters[1].c_str()) ? "1" : "0";
+                                         parameters[1].c_str())
+      ? "1"
+      : "0";
   }
 } versionGreaterNode;
 
@@ -577,14 +547,16 @@ static const struct VersionLessNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 2; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
                                          parameters.front().c_str(),
-                                         parameters[1].c_str()) ? "1" : "0";
+                                         parameters[1].c_str())
+      ? "1"
+      : "0";
   }
 } versionLessNode;
 
@@ -594,14 +566,16 @@ static const struct VersionEqualNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 2; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
                                          parameters.front().c_str(),
-                                         parameters[1].c_str()) ? "1" : "0";
+                                         parameters[1].c_str())
+      ? "1"
+      : "0";
   }
 } versionEqualNode;
 
@@ -609,15 +583,14 @@ static const struct LinkOnlyNode : public cmGeneratorExpressionNode
 {
   LinkOnlyNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
-    if(!dagChecker->GetTransitivePropertiesOnly())
-      {
+    if (!dagChecker->GetTransitivePropertiesOnly()) {
       return parameters.front();
-      }
+    }
     return "";
   }
 } linkOnlyNode;
@@ -628,10 +601,10 @@ static const struct ConfigurationNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 0; }
 
-  std::string Evaluate(const std::vector<std::string> &,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>&,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     context->HadContextSensitiveCondition = true;
     return context->Config;
@@ -644,62 +617,54 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    if (parameters.empty())
-      {
+    if (parameters.empty()) {
       return configurationNode.Evaluate(parameters, context, content, 0);
-      }
+    }
     static cmsys::RegularExpression configValidator("^[A-Za-z0-9_]*$");
-    if (!configValidator.find(*parameters.begin()))
-      {
+    if (!configValidator.find(*parameters.begin())) {
       reportError(context, content->GetOriginalExpression(),
                   "Expression syntax not recognized.");
       return std::string();
-      }
+    }
     context->HadContextSensitiveCondition = true;
-    if (context->Config.empty())
-      {
+    if (context->Config.empty()) {
       return parameters.front().empty() ? "1" : "0";
-      }
+    }
 
     if (cmsysString_strcasecmp(parameters.begin()->c_str(),
-                               context->Config.c_str()) == 0)
-      {
+                               context->Config.c_str()) == 0) {
       return "1";
-      }
+    }
 
-    if (context->CurrentTarget
-        && context->CurrentTarget->IsImported())
-      {
+    if (context->CurrentTarget && context->CurrentTarget->IsImported()) {
       const char* loc = 0;
       const char* imp = 0;
       std::string suffix;
-      if (context->CurrentTarget->Target->GetMappedConfig(context->Config,
-                                                  &loc,
-                                                  &imp,
-                                                  suffix))
-        {
+      if (context->CurrentTarget->Target->GetMappedConfig(
+            context->Config, &loc, &imp, suffix)) {
         // This imported target has an appropriate location
         // for this (possibly mapped) config.
         // Check if there is a proper config mapping for the tested config.
         std::vector<std::string> mappedConfigs;
         std::string mapProp = "MAP_IMPORTED_CONFIG_";
         mapProp += cmSystemTools::UpperCase(context->Config);
-        if(const char* mapValue =
-                        context->CurrentTarget->GetProperty(mapProp))
-          {
+        if (const char* mapValue =
+              context->CurrentTarget->GetProperty(mapProp)) {
           cmSystemTools::ExpandListArgument(cmSystemTools::UpperCase(mapValue),
                                             mappedConfigs);
           return std::find(mappedConfigs.begin(), mappedConfigs.end(),
-                           cmSystemTools::UpperCase(parameters.front()))
-              != mappedConfigs.end() ? "1" : "0";
-          }
+                           cmSystemTools::UpperCase(parameters.front())) !=
+              mappedConfigs.end()
+            ? "1"
+            : "0";
         }
       }
+    }
     return "0";
   }
 } configurationTestNode;
@@ -712,10 +677,10 @@ static const struct JoinNode : public cmGeneratorExpressionNode
 
   virtual bool AcceptsArbitraryContentParameter() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     std::vector<std::string> list;
     cmSystemTools::ExpandListArgument(parameters.front(), list);
@@ -729,115 +694,97 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return OneOrZeroParameters; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
-    if(context->Language.empty())
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<COMPILE_LANGUAGE:...> may only be used to specify include "
-          "directories compile definitions, compile options and to evaluate "
-          "components of the file(GENERATE) command.");
+    if (context->Language.empty()) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<COMPILE_LANGUAGE:...> may only be used to specify include "
+        "directories compile definitions, compile options and to evaluate "
+        "components of the file(GENERATE) command.");
       return std::string();
-      }
+    }
 
     std::vector<std::string> enabledLanguages;
     cmGlobalGenerator* gg = context->LG->GetGlobalGenerator();
     gg->GetEnabledLanguages(enabledLanguages);
     if (!parameters.empty() &&
-          std::find(enabledLanguages.begin(), enabledLanguages.end(),
-                  parameters.front()) == enabledLanguages.end())
-      {
+        std::find(enabledLanguages.begin(), enabledLanguages.end(),
+                  parameters.front()) == enabledLanguages.end()) {
       reportError(context, content->GetOriginalExpression(),
-          "$<COMPILE_LANGUAGE:...> Unknown language.");
+                  "$<COMPILE_LANGUAGE:...> Unknown language.");
       return std::string();
-      }
+    }
     std::string genName = gg->GetName();
-    if (genName.find("Visual Studio") != std::string::npos)
-      {
+    if (genName.find("Visual Studio") != std::string::npos) {
       reportError(context, content->GetOriginalExpression(),
-          "$<COMPILE_LANGUAGE:...> may not be used with Visual Studio "
-          "generators.");
+                  "$<COMPILE_LANGUAGE:...> may not be used with Visual Studio "
+                  "generators.");
       return std::string();
-      }
-    else if (genName.find("Xcode") != std::string::npos)
-      {
-      if (dagChecker && (dagChecker->EvaluatingCompileDefinitions()
-          || dagChecker->EvaluatingIncludeDirectories()))
-        {
-        reportError(context, content->GetOriginalExpression(),
-            "$<COMPILE_LANGUAGE:...> may only be used with COMPILE_OPTIONS "
-            "with the Xcode generator.");
+    } else if (genName.find("Xcode") != std::string::npos) {
+      if (dagChecker && (dagChecker->EvaluatingCompileDefinitions() ||
+                         dagChecker->EvaluatingIncludeDirectories())) {
+        reportError(
+          context, content->GetOriginalExpression(),
+          "$<COMPILE_LANGUAGE:...> may only be used with COMPILE_OPTIONS "
+          "with the Xcode generator.");
         return std::string();
-        }
       }
-    else
-      {
-      if(genName.find("Makefiles") == std::string::npos &&
-              genName.find("Ninja") == std::string::npos &&
-              genName.find("Watcom WMake") == std::string::npos)
-        {
-        reportError(context, content->GetOriginalExpression(),
-            "$<COMPILE_LANGUAGE:...> not supported for this generator.");
+    } else {
+      if (genName.find("Makefiles") == std::string::npos &&
+          genName.find("Ninja") == std::string::npos &&
+          genName.find("Watcom WMake") == std::string::npos) {
+        reportError(
+          context, content->GetOriginalExpression(),
+          "$<COMPILE_LANGUAGE:...> not supported for this generator.");
         return std::string();
-        }
       }
-    if (parameters.empty())
-      {
+    }
+    if (parameters.empty()) {
       return context->Language;
-      }
+    }
     return context->Language == parameters.front() ? "1" : "0";
   }
 } languageNode;
 
-#define TRANSITIVE_PROPERTY_NAME(PROPERTY) \
-  , "INTERFACE_" #PROPERTY
+#define TRANSITIVE_PROPERTY_NAME(PROPERTY) , "INTERFACE_" #PROPERTY
 
 static const char* targetPropertyTransitiveWhitelist[] = {
-  0
-  CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_NAME)
+  0 CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_NAME)
 };
 
 #undef TRANSITIVE_PROPERTY_NAME
 
 template <typename T>
-std::string
-getLinkedTargetsContent(
-  std::vector<T> const &libraries,
-  cmGeneratorTarget const* target,
-  cmGeneratorTarget const* headTarget,
-  cmGeneratorExpressionContext *context,
-  cmGeneratorExpressionDAGChecker *dagChecker,
-  const std::string &interfacePropertyName)
+std::string getLinkedTargetsContent(
+  std::vector<T> const& libraries, cmGeneratorTarget const* target,
+  cmGeneratorTarget const* headTarget, cmGeneratorExpressionContext* context,
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  const std::string& interfacePropertyName)
 {
   std::string linkedTargetsContent;
   std::string sep;
   std::string depString;
   for (typename std::vector<T>::const_iterator it = libraries.begin();
-       it != libraries.end(); ++it)
-    {
+       it != libraries.end(); ++it) {
     // Broken code can have a target in its own link interface.
     // Don't follow such link interface entries so as not to create a
     // self-referencing loop.
-    if (it->Target && it->Target != target)
-      {
-      depString +=
-        sep + "$<TARGET_PROPERTY:" +
-        it->Target->GetName() + "," + interfacePropertyName + ">";
+    if (it->Target && it->Target != target) {
+      depString += sep + "$<TARGET_PROPERTY:" + it->Target->GetName() + "," +
+        interfacePropertyName + ">";
       sep = ";";
-      }
     }
-  if(!depString.empty())
-    {
+  }
+  if (!depString.empty()) {
     linkedTargetsContent =
-        cmGeneratorExpressionNode::EvaluateDependentExpression(depString,
-                                        target->GetLocalGenerator(),
-                                        context,
-                                        headTarget,
-                                        target, dagChecker);
-    }
+      cmGeneratorExpressionNode::EvaluateDependentExpression(
+        depString, target->GetLocalGenerator(), context, headTarget, target,
+        dagChecker);
+  }
   linkedTargetsContent =
     cmGeneratorExpression::StripEmptyListElements(linkedTargetsContent);
   return linkedTargetsContent;
@@ -850,347 +797,288 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
   // This node handles errors on parameter count itself.
   virtual int NumExpectedParameters() const { return OneOrMoreParameters; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagCheckerParent
-                      ) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagCheckerParent) const
   {
-    if (parameters.size() != 1 && parameters.size() != 2)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<TARGET_PROPERTY:...> expression requires one or two parameters");
+    if (parameters.size() != 1 && parameters.size() != 2) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<TARGET_PROPERTY:...> expression requires one or two parameters");
       return std::string();
-      }
+    }
     static cmsys::RegularExpression propertyNameValidator("^[A-Za-z0-9_]+$");
 
     cmGeneratorTarget const* target = context->HeadTarget;
     std::string propertyName = *parameters.begin();
 
-    if (parameters.size() == 1)
-      {
+    if (parameters.size() == 1) {
       context->HadHeadSensitiveCondition = true;
-      }
-    if (!target && parameters.size() == 1)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<TARGET_PROPERTY:prop>  may only be used with binary targets.  "
-          "It may not be used with add_custom_command or add_custom_target.  "
-          "Specify the target to read a property from using the "
-          "$<TARGET_PROPERTY:tgt,prop> signature instead.");
+    }
+    if (!target && parameters.size() == 1) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<TARGET_PROPERTY:prop>  may only be used with binary targets.  "
+        "It may not be used with add_custom_command or add_custom_target.  "
+        "Specify the target to read a property from using the "
+        "$<TARGET_PROPERTY:tgt,prop> signature instead.");
       return std::string();
-      }
+    }
 
-    if (parameters.size() == 2)
-      {
-      if (parameters.begin()->empty() && parameters[1].empty())
-        {
-        reportError(context, content->GetOriginalExpression(),
-            "$<TARGET_PROPERTY:tgt,prop> expression requires a non-empty "
-            "target name and property name.");
+    if (parameters.size() == 2) {
+      if (parameters.begin()->empty() && parameters[1].empty()) {
+        reportError(
+          context, content->GetOriginalExpression(),
+          "$<TARGET_PROPERTY:tgt,prop> expression requires a non-empty "
+          "target name and property name.");
         return std::string();
-        }
-      if (parameters.begin()->empty())
-        {
-        reportError(context, content->GetOriginalExpression(),
-            "$<TARGET_PROPERTY:tgt,prop> expression requires a non-empty "
-            "target name.");
+      }
+      if (parameters.begin()->empty()) {
+        reportError(
+          context, content->GetOriginalExpression(),
+          "$<TARGET_PROPERTY:tgt,prop> expression requires a non-empty "
+          "target name.");
         return std::string();
-        }
+      }
 
       std::string targetName = parameters.front();
       propertyName = parameters[1];
-      if (!cmGeneratorExpression::IsValidTargetName(targetName))
-        {
-        if (!propertyNameValidator.find(propertyName.c_str()))
-          {
+      if (!cmGeneratorExpression::IsValidTargetName(targetName)) {
+        if (!propertyNameValidator.find(propertyName.c_str())) {
           ::reportError(context, content->GetOriginalExpression(),
                         "Target name and property name not supported.");
           return std::string();
-          }
+        }
         ::reportError(context, content->GetOriginalExpression(),
                       "Target name not supported.");
         return std::string();
-        }
-      if(propertyName == "ALIASED_TARGET")
-        {
-        if(context->LG->GetMakefile()->IsAlias(targetName))
-          {
-          if(cmGeneratorTarget* tgt =
-             context->LG->FindGeneratorTargetToUse(targetName))
-            {
+      }
+      if (propertyName == "ALIASED_TARGET") {
+        if (context->LG->GetMakefile()->IsAlias(targetName)) {
+          if (cmGeneratorTarget* tgt =
+                context->LG->FindGeneratorTargetToUse(targetName)) {
             return tgt->GetName();
-            }
           }
-        return "";
         }
+        return "";
+      }
       target = context->LG->FindGeneratorTargetToUse(targetName);
 
-      if (!target)
-        {
+      if (!target) {
         std::ostringstream e;
-        e << "Target \""
-          << targetName
-          << "\" not found.";
+        e << "Target \"" << targetName << "\" not found.";
         reportError(context, content->GetOriginalExpression(), e.str());
         return std::string();
-        }
-      context->AllTargets.insert(target);
       }
+      context->AllTargets.insert(target);
+    }
 
-    if (target == context->HeadTarget)
-      {
+    if (target == context->HeadTarget) {
       // Keep track of the properties seen while processing.
       // The evaluation of the LINK_LIBRARIES generator expressions
       // will check this to ensure that properties have one consistent
       // value for all evaluations.
       context->SeenTargetProperties.insert(propertyName);
-      }
-    if (propertyName == "SOURCES")
-      {
+    }
+    if (propertyName == "SOURCES") {
       context->SourceSensitiveTargets.insert(target);
-      }
+    }
 
-    if (propertyName.empty())
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<TARGET_PROPERTY:...> expression requires a non-empty property "
-          "name.");
+    if (propertyName.empty()) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<TARGET_PROPERTY:...> expression requires a non-empty property "
+        "name.");
       return std::string();
-      }
+    }
 
-    if (!propertyNameValidator.find(propertyName))
-      {
+    if (!propertyNameValidator.find(propertyName)) {
       ::reportError(context, content->GetOriginalExpression(),
                     "Property name not supported.");
       return std::string();
-      }
+    }
 
     assert(target);
 
-    if (propertyName == "LINKER_LANGUAGE")
-      {
-      if (target->LinkLanguagePropagatesToDependents() &&
-          dagCheckerParent && (dagCheckerParent->EvaluatingLinkLibraries()
-            || dagCheckerParent->EvaluatingSources()))
-        {
-        reportError(context, content->GetOriginalExpression(),
-            "LINKER_LANGUAGE target property can not be used while evaluating "
-            "link libraries for a static library");
+    if (propertyName == "LINKER_LANGUAGE") {
+      if (target->LinkLanguagePropagatesToDependents() && dagCheckerParent &&
+          (dagCheckerParent->EvaluatingLinkLibraries() ||
+           dagCheckerParent->EvaluatingSources())) {
+        reportError(
+          context, content->GetOriginalExpression(),
+          "LINKER_LANGUAGE target property can not be used while evaluating "
+          "link libraries for a static library");
         return std::string();
-        }
-      return target->GetLinkerLanguage(context->Config);
       }
+      return target->GetLinkerLanguage(context->Config);
+    }
 
     cmGeneratorExpressionDAGChecker dagChecker(context->Backtrace,
-                                               target->GetName(),
-                                               propertyName,
-                                               content,
-                                               dagCheckerParent);
-
-    switch (dagChecker.Check())
-      {
-    case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:
-      dagChecker.ReportError(context, content->GetOriginalExpression());
-      return std::string();
-    case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE:
-      // No error. We just skip cyclic references.
-      return std::string();
-    case cmGeneratorExpressionDAGChecker::ALREADY_SEEN:
-      for (size_t i = 1;
-          i < cmArraySize(targetPropertyTransitiveWhitelist);
-          ++i)
-        {
-        if (targetPropertyTransitiveWhitelist[i] == propertyName)
-          {
-          // No error. We're not going to find anything new here.
-          return std::string();
+                                               target->GetName(), propertyName,
+                                               content, dagCheckerParent);
+
+    switch (dagChecker.Check()) {
+      case cmGeneratorExpressionDAGChecker::SELF_REFERENCE:
+        dagChecker.ReportError(context, content->GetOriginalExpression());
+        return std::string();
+      case cmGeneratorExpressionDAGChecker::CYCLIC_REFERENCE:
+        // No error. We just skip cyclic references.
+        return std::string();
+      case cmGeneratorExpressionDAGChecker::ALREADY_SEEN:
+        for (size_t i = 1; i < cmArraySize(targetPropertyTransitiveWhitelist);
+             ++i) {
+          if (targetPropertyTransitiveWhitelist[i] == propertyName) {
+            // No error. We're not going to find anything new here.
+            return std::string();
           }
         }
-    case cmGeneratorExpressionDAGChecker::DAG:
-      break;
-      }
+      case cmGeneratorExpressionDAGChecker::DAG:
+        break;
+    }
 
-    const char *prop = target->GetProperty(propertyName);
-
-    if (dagCheckerParent)
-      {
-      if (dagCheckerParent->EvaluatingLinkLibraries())
-        {
-#define TRANSITIVE_PROPERTY_COMPARE(PROPERTY) \
-    (#PROPERTY == propertyName || "INTERFACE_" #PROPERTY == propertyName) ||
-        if (CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_COMPARE)
-            false)
-          {
-          reportError(context, content->GetOriginalExpression(),
-              "$<TARGET_PROPERTY:...> expression in link libraries "
-              "evaluation depends on target property which is transitive "
-              "over the link libraries, creating a recursion.");
+    const char* prop = target->GetProperty(propertyName);
+
+    if (dagCheckerParent) {
+      if (dagCheckerParent->EvaluatingLinkLibraries()) {
+#define TRANSITIVE_PROPERTY_COMPARE(PROPERTY)                                 \
+  (#PROPERTY == propertyName || "INTERFACE_" #PROPERTY == propertyName) ||
+        if (CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(
+              TRANSITIVE_PROPERTY_COMPARE) false) {
+          reportError(
+            context, content->GetOriginalExpression(),
+            "$<TARGET_PROPERTY:...> expression in link libraries "
+            "evaluation depends on target property which is transitive "
+            "over the link libraries, creating a recursion.");
           return std::string();
-          }
+        }
 #undef TRANSITIVE_PROPERTY_COMPARE
 
-        if(!prop)
-          {
+        if (!prop) {
           return std::string();
-          }
         }
-      else
-        {
-#define ASSERT_TRANSITIVE_PROPERTY_METHOD(METHOD) \
-  dagCheckerParent->METHOD () ||
-
-        assert(
-          CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(
-                                            ASSERT_TRANSITIVE_PROPERTY_METHOD)
-          false);
+      } else {
+#define ASSERT_TRANSITIVE_PROPERTY_METHOD(METHOD) dagCheckerParent->METHOD() ||
+
+        assert(CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(
+          ASSERT_TRANSITIVE_PROPERTY_METHOD) false);
 #undef ASSERT_TRANSITIVE_PROPERTY_METHOD
-        }
       }
+    }
 
     std::string linkedTargetsContent;
 
     std::string interfacePropertyName;
     bool isInterfaceProperty = false;
 
-#define POPULATE_INTERFACE_PROPERTY_NAME(prop) \
-    if (propertyName == #prop) \
-      { \
-      interfacePropertyName = "INTERFACE_" #prop; \
-      } \
-    else if (propertyName == "INTERFACE_" #prop) \
-      { \
-      interfacePropertyName = "INTERFACE_" #prop; \
-      isInterfaceProperty = true; \
-      } \
-    else
+#define POPULATE_INTERFACE_PROPERTY_NAME(prop)                                \
+  if (propertyName == #prop) {                                                \
+    interfacePropertyName = "INTERFACE_" #prop;                               \
+  } else if (propertyName == "INTERFACE_" #prop) {                            \
+    interfacePropertyName = "INTERFACE_" #prop;                               \
+    isInterfaceProperty = true;                                               \
+  } else
 
     CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(POPULATE_INTERFACE_PROPERTY_NAME)
-      // Note that the above macro terminates with an else
+    // Note that the above macro terminates with an else
     /* else */ if (cmHasLiteralPrefix(propertyName.c_str(),
-                           "COMPILE_DEFINITIONS_"))
-      {
+                                      "COMPILE_DEFINITIONS_")) {
       cmPolicies::PolicyStatus polSt =
-          context->LG->GetPolicyStatus(cmPolicies::CMP0043);
-      if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
-        {
+        context->LG->GetPolicyStatus(cmPolicies::CMP0043);
+      if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) {
         interfacePropertyName = "INTERFACE_COMPILE_DEFINITIONS";
-        }
       }
+    }
 #undef POPULATE_INTERFACE_PROPERTY_NAME
     cmGeneratorTarget const* headTarget =
-        context->HeadTarget && isInterfaceProperty
-                               ? context->HeadTarget : target;
-
-    if(isInterfaceProperty)
-      {
-      if(cmLinkInterfaceLibraries const* iface =
-         target->GetLinkInterfaceLibraries(context->Config, headTarget, true))
-        {
+      context->HeadTarget && isInterfaceProperty ? context->HeadTarget
+                                                 : target;
+
+    if (isInterfaceProperty) {
+      if (cmLinkInterfaceLibraries const* iface =
+            target->GetLinkInterfaceLibraries(context->Config, headTarget,
+                                              true)) {
         linkedTargetsContent =
-          getLinkedTargetsContent(iface->Libraries, target,
-                                  headTarget,
-                                  context, &dagChecker,
-                                  interfacePropertyName);
-        }
+          getLinkedTargetsContent(iface->Libraries, target, headTarget,
+                                  context, &dagChecker, interfacePropertyName);
       }
-    else if(!interfacePropertyName.empty())
-      {
-      if(cmLinkImplementationLibraries const* impl =
-         target->GetLinkImplementationLibraries(context->Config))
-        {
+    } else if (!interfacePropertyName.empty()) {
+      if (cmLinkImplementationLibraries const* impl =
+            target->GetLinkImplementationLibraries(context->Config)) {
         linkedTargetsContent =
-          getLinkedTargetsContent(impl->Libraries, target,
-                                  target,
-                                  context, &dagChecker,
-                                  interfacePropertyName);
-        }
+          getLinkedTargetsContent(impl->Libraries, target, target, context,
+                                  &dagChecker, interfacePropertyName);
       }
+    }
 
-    if (!prop)
-      {
-      if (target->IsImported()
-          || target->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+    if (!prop) {
+      if (target->IsImported() ||
+          target->GetType() == cmState::INTERFACE_LIBRARY) {
         return linkedTargetsContent;
-        }
+      }
       if (target->IsLinkInterfaceDependentBoolProperty(propertyName,
-                                                     context->Config))
-        {
+                                                       context->Config)) {
         context->HadContextSensitiveCondition = true;
-        return target->GetLinkInterfaceDependentBoolProperty(
-                                                propertyName,
-                                                context->Config) ? "1" : "0";
-        }
+        return target->GetLinkInterfaceDependentBoolProperty(propertyName,
+                                                             context->Config)
+          ? "1"
+          : "0";
+      }
       if (target->IsLinkInterfaceDependentStringProperty(propertyName,
-                                                       context->Config))
-        {
+                                                         context->Config)) {
         context->HadContextSensitiveCondition = true;
-        const char *propContent =
-                              target->GetLinkInterfaceDependentStringProperty(
-                                                propertyName,
-                                                context->Config);
+        const char* propContent =
+          target->GetLinkInterfaceDependentStringProperty(propertyName,
+                                                          context->Config);
         return propContent ? propContent : "";
-        }
+      }
       if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName,
-                                                          context->Config))
-        {
+                                                            context->Config)) {
         context->HadContextSensitiveCondition = true;
-        const char *propContent =
-                          target->GetLinkInterfaceDependentNumberMinProperty(
-                                                propertyName,
-                                                context->Config);
+        const char* propContent =
+          target->GetLinkInterfaceDependentNumberMinProperty(propertyName,
+                                                             context->Config);
         return propContent ? propContent : "";
-        }
+      }
       if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName,
-                                                          context->Config))
-        {
+                                                            context->Config)) {
         context->HadContextSensitiveCondition = true;
-        const char *propContent =
-                          target->GetLinkInterfaceDependentNumberMaxProperty(
-                                                propertyName,
-                                                context->Config);
+        const char* propContent =
+          target->GetLinkInterfaceDependentNumberMaxProperty(propertyName,
+                                                             context->Config);
         return propContent ? propContent : "";
-        }
+      }
 
       return linkedTargetsContent;
-      }
+    }
 
-    if (!target->IsImported()
-        && dagCheckerParent && !dagCheckerParent->EvaluatingLinkLibraries())
-      {
+    if (!target->IsImported() && dagCheckerParent &&
+        !dagCheckerParent->EvaluatingLinkLibraries()) {
       if (target->IsLinkInterfaceDependentNumberMinProperty(propertyName,
-                                                          context->Config))
-        {
+                                                            context->Config)) {
         context->HadContextSensitiveCondition = true;
-        const char *propContent =
-                            target->GetLinkInterfaceDependentNumberMinProperty(
-                                                propertyName,
-                                                context->Config);
+        const char* propContent =
+          target->GetLinkInterfaceDependentNumberMinProperty(propertyName,
+                                                             context->Config);
         return propContent ? propContent : "";
-        }
+      }
       if (target->IsLinkInterfaceDependentNumberMaxProperty(propertyName,
-                                                          context->Config))
-        {
+                                                            context->Config)) {
         context->HadContextSensitiveCondition = true;
-        const char *propContent =
-                            target->GetLinkInterfaceDependentNumberMaxProperty(
-                                                propertyName,
-                                                context->Config);
+        const char* propContent =
+          target->GetLinkInterfaceDependentNumberMaxProperty(propertyName,
+                                                             context->Config);
         return propContent ? propContent : "";
-        }
       }
-    if(!interfacePropertyName.empty())
-      {
-      std::string result = this->EvaluateDependentExpression(prop,
-                                        context->LG, context,
-                                        headTarget, target, &dagChecker);
-      if (!linkedTargetsContent.empty())
-        {
+    }
+    if (!interfacePropertyName.empty()) {
+      std::string result = this->EvaluateDependentExpression(
+        prop, context->LG, context, headTarget, target, &dagChecker);
+      if (!linkedTargetsContent.empty()) {
         result += (result.empty() ? "" : ";") + linkedTargetsContent;
-        }
-      return result;
       }
+      return result;
+    }
     return prop;
   }
 } targetPropertyNode;
@@ -1204,10 +1092,10 @@ static const struct TargetNameNode : public cmGeneratorExpressionNode
   virtual bool AcceptsArbitraryContentParameter() const { return true; }
   virtual bool RequiresLiteralInput() const { return true; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *,
-                       const GeneratorExpressionContent *,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext*,
+                       const GeneratorExpressionContent*,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     return parameters.front();
   }
@@ -1220,73 +1108,69 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode
 {
   TargetObjectsNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    if (!context->EvaluateForBuildsystem)
-      {
+    if (!context->EvaluateForBuildsystem) {
       std::ostringstream e;
       e << "The evaluation of the TARGET_OBJECTS generator expression "
-        "is only suitable for consumption by CMake.  It is not suitable "
-        "for writing out elsewhere.";
+           "is only suitable for consumption by CMake.  It is not suitable "
+           "for writing out elsewhere.";
       reportError(context, content->GetOriginalExpression(), e.str());
       return std::string();
-      }
+    }
 
     std::string tgtName = parameters.front();
-    cmGeneratorTarget* gt =
-                context->LG->FindGeneratorTargetToUse(tgtName);
-    if (!gt)
-      {
+    cmGeneratorTarget* gt = context->LG->FindGeneratorTargetToUse(tgtName);
+    if (!gt) {
       std::ostringstream e;
       e << "Objects of target \"" << tgtName
         << "\" referenced but no such target exists.";
       reportError(context, content->GetOriginalExpression(), e.str());
       return std::string();
-      }
-    if (gt->GetType() != cmState::OBJECT_LIBRARY)
-      {
+    }
+    if (gt->GetType() != cmState::OBJECT_LIBRARY) {
       std::ostringstream e;
       e << "Objects of target \"" << tgtName
         << "\" referenced but is not an OBJECT library.";
       reportError(context, content->GetOriginalExpression(), e.str());
       return std::string();
-      }
+    }
 
     std::vector<cmSourceFile const*> objectSources;
     gt->GetObjectSources(objectSources, context->Config);
     std::map<cmSourceFile const*, std::string> mapping;
 
-    for(std::vector<cmSourceFile const*>::const_iterator it
-        = objectSources.begin(); it != objectSources.end(); ++it)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator it =
+           objectSources.begin();
+         it != objectSources.end(); ++it) {
       mapping[*it];
-      }
+    }
 
     gt->LocalGenerator->ComputeObjectFilenames(mapping, gt);
 
     std::string obj_dir = gt->ObjectDirectory;
     std::string result;
     const char* sep = "";
-    for(std::vector<cmSourceFile const*>::const_iterator it
-        = objectSources.begin(); it != objectSources.end(); ++it)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator it =
+           objectSources.begin();
+         it != objectSources.end(); ++it) {
       // Find the object file name corresponding to this source file.
-      std::map<cmSourceFile const*, std::string>::const_iterator
-        map_it = mapping.find(*it);
+      std::map<cmSourceFile const*, std::string>::const_iterator map_it =
+        mapping.find(*it);
       // It must exist because we populated the mapping just above.
       assert(!map_it->second.empty());
       result += sep;
       std::string objFile = obj_dir + map_it->second;
       cmSourceFile* sf =
-          context->LG->GetMakefile()->GetOrCreateSource(objFile, true);
+        context->LG->GetMakefile()->GetOrCreateSource(objFile, true);
       sf->SetObjectLibrary(tgtName);
       sf->SetProperty("EXTERNAL_OBJECT", "1");
       result += objFile;
       sep = ";";
-      }
+    }
     return result;
   }
 } targetObjectsNode;
@@ -1297,19 +1181,19 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return OneOrMoreParameters; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
     cmGeneratorTarget const* target = context->HeadTarget;
-    if (!target)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<COMPILE_FEATURE> may only be used with binary targets.  It may "
-          "not be used with add_custom_command or add_custom_target.");
+    if (!target) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<COMPILE_FEATURE> may only be used with binary targets.  It may "
+        "not be used with add_custom_command or add_custom_target.");
       return std::string();
-      }
+    }
     context->HadHeadSensitiveCondition = true;
 
     typedef std::map<std::string, std::vector<std::string> > LangMap;
@@ -1318,85 +1202,69 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
     LangMap testedFeatures;
 
     for (std::vector<std::string>::const_iterator it = parameters.begin();
-        it != parameters.end(); ++it)
-      {
+         it != parameters.end(); ++it) {
       std::string error;
       std::string lang;
       if (!context->LG->GetMakefile()->CompileFeatureKnown(
-            context->HeadTarget->Target,
-                                                  *it, lang, &error))
-        {
+            context->HeadTarget->Target, *it, lang, &error)) {
         reportError(context, content->GetOriginalExpression(), error);
         return std::string();
-        }
+      }
       testedFeatures[lang].push_back(*it);
 
-      if (availableFeatures.find(lang) == availableFeatures.end())
-        {
-        const char* featuresKnown
-            = context->LG->GetMakefile()->CompileFeaturesAvailable(lang,
-                                                                   &error);
-        if (!featuresKnown)
-          {
+      if (availableFeatures.find(lang) == availableFeatures.end()) {
+        const char* featuresKnown =
+          context->LG->GetMakefile()->CompileFeaturesAvailable(lang, &error);
+        if (!featuresKnown) {
           reportError(context, content->GetOriginalExpression(), error);
           return std::string();
-          }
+        }
         cmSystemTools::ExpandListArgument(featuresKnown,
                                           availableFeatures[lang]);
-        }
       }
+    }
 
     bool evalLL = dagChecker && dagChecker->EvaluatingLinkLibraries();
 
     for (LangMap::const_iterator lit = testedFeatures.begin();
-          lit != testedFeatures.end(); ++lit)
-      {
-      std::vector<std::string> const& langAvailable
-                                              = availableFeatures[lit->first];
-      const char* standardDefault = context->LG->GetMakefile()
-        ->GetDefinition("CMAKE_" + lit->first + "_STANDARD_DEFAULT");
+         lit != testedFeatures.end(); ++lit) {
+      std::vector<std::string> const& langAvailable =
+        availableFeatures[lit->first];
+      const char* standardDefault = context->LG->GetMakefile()->GetDefinition(
+        "CMAKE_" + lit->first + "_STANDARD_DEFAULT");
       for (std::vector<std::string>::const_iterator it = lit->second.begin();
-          it != lit->second.end(); ++it)
-        {
-        if (std::find(langAvailable.begin(), langAvailable.end(), *it)
-                                                      == langAvailable.end())
-          {
+           it != lit->second.end(); ++it) {
+        if (std::find(langAvailable.begin(), langAvailable.end(), *it) ==
+            langAvailable.end()) {
           return "0";
-          }
-        if (standardDefault && !*standardDefault)
-          {
+        }
+        if (standardDefault && !*standardDefault) {
           // This compiler has no notion of language standard levels.
           // All features known for the language are always available.
           continue;
-          }
-        if (!context->LG->GetMakefile()->HaveStandardAvailable(target->Target,
-                                                      lit->first, *it))
-          {
-          if (evalLL)
-            {
+        }
+        if (!context->LG->GetMakefile()->HaveStandardAvailable(
+              target->Target, lit->first, *it)) {
+          if (evalLL) {
             const char* l = target->GetProperty(lit->first + "_STANDARD");
-            if (!l)
-              {
+            if (!l) {
               l = standardDefault;
-              }
+            }
             assert(l);
             context->MaxLanguageStandard[target][lit->first] = l;
-            }
-          else
-            {
+          } else {
             return "0";
-            }
           }
         }
       }
+    }
     return "1";
   }
 } compileFeaturesNode;
 
 static const char* targetPolicyWhitelist[] = {
   0
-#define TARGET_POLICY_STRING(POLICY) \
-  , #POLICY
+#define TARGET_POLICY_STRING(POLICY) , #POLICY
 
   CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_STRING)
 
@@ -1404,13 +1272,12 @@ static const char* targetPolicyWhitelist[] = {
 };
 
 cmPolicies::PolicyStatus statusForTarget(cmGeneratorTarget const* tgt,
-                                         const char *policy)
+                                         const char* policy)
 {
-#define RETURN_POLICY(POLICY) \
-  if (strcmp(policy, #POLICY) == 0) \
-  { \
-    return tgt->GetPolicyStatus ## POLICY (); \
-  } \
+#define RETURN_POLICY(POLICY)                                                 \
+  if (strcmp(policy, #POLICY) == 0) {                                         \
+    return tgt->GetPolicyStatus##POLICY();                                    \
+  }
 
   CM_FOR_EACH_TARGET_POLICY(RETURN_POLICY)
 
@@ -1420,13 +1287,12 @@ cmPolicies::PolicyStatus statusForTarget(cmGeneratorTarget const* tgt,
   return cmPolicies::WARN;
 }
 
-cmPolicies::PolicyID policyForString(const char *policy_id)
+cmPolicies::PolicyID policyForString(const char* policy_id)
 {
-#define RETURN_POLICY_ID(POLICY_ID) \
-  if (strcmp(policy_id, #POLICY_ID) == 0) \
-  { \
-    return cmPolicies:: POLICY_ID; \
-  } \
+#define RETURN_POLICY_ID(POLICY_ID)                                           \
+  if (strcmp(policy_id, #POLICY_ID) == 0) {                                   \
+    return cmPolicies::POLICY_ID;                                             \
+  }
 
   CM_FOR_EACH_TARGET_POLICY(RETURN_POLICY_ID)
 
@@ -1442,56 +1308,54 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode
 
   virtual int NumExpectedParameters() const { return 1; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context ,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    if (!context->HeadTarget)
-      {
-      reportError(context, content->GetOriginalExpression(),
-          "$<TARGET_POLICY:prop> may only be used with binary targets.  It "
-          "may not be used with add_custom_command or add_custom_target.");
+    if (!context->HeadTarget) {
+      reportError(
+        context, content->GetOriginalExpression(),
+        "$<TARGET_POLICY:prop> may only be used with binary targets.  It "
+        "may not be used with add_custom_command or add_custom_target.");
       return std::string();
-      }
+    }
 
     context->HadContextSensitiveCondition = true;
     context->HadHeadSensitiveCondition = true;
 
-    for (size_t i = 1; i < cmArraySize(targetPolicyWhitelist); ++i)
-      {
-      const char *policy = targetPolicyWhitelist[i];
-      if (parameters.front() == policy)
-        {
+    for (size_t i = 1; i < cmArraySize(targetPolicyWhitelist); ++i) {
+      const char* policy = targetPolicyWhitelist[i];
+      if (parameters.front() == policy) {
         cmLocalGenerator* lg = context->HeadTarget->GetLocalGenerator();
-        switch(statusForTarget(context->HeadTarget, policy))
-          {
+        switch (statusForTarget(context->HeadTarget, policy)) {
           case cmPolicies::WARN:
-            lg->IssueMessage(cmake::AUTHOR_WARNING,
-                        cmPolicies::GetPolicyWarning(policyForString(policy)));
+            lg->IssueMessage(
+              cmake::AUTHOR_WARNING,
+              cmPolicies::GetPolicyWarning(policyForString(policy)));
           case cmPolicies::REQUIRED_IF_USED:
           case cmPolicies::REQUIRED_ALWAYS:
           case cmPolicies::OLD:
             return "0";
           case cmPolicies::NEW:
             return "1";
-          }
         }
       }
-    reportError(context, content->GetOriginalExpression(),
+    }
+    reportError(
+      context, content->GetOriginalExpression(),
       "$<TARGET_POLICY:prop> may only be used with a limited number of "
       "policies.  Currently it may be used with the following policies:\n"
 
 #define STRINGIFY_HELPER(X) #X
 #define STRINGIFY(X) STRINGIFY_HELPER(X)
 
-#define TARGET_POLICY_LIST_ITEM(POLICY) \
-      " * " STRINGIFY(POLICY) "\n"
+#define TARGET_POLICY_LIST_ITEM(POLICY) " * " STRINGIFY(POLICY) "\n"
 
       CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_LIST_ITEM)
 
 #undef TARGET_POLICY_LIST_ITEM
-      );
+        );
     return std::string();
   }
 
@@ -1504,10 +1368,10 @@ static const struct InstallPrefixNode : public cmGeneratorExpressionNode
   virtual bool GeneratesContent() const { return true; }
   virtual int NumExpectedParameters() const { return 0; }
 
-  std::string Evaluate(const std::vector<std::string> &,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>&,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
     reportError(context, content->GetOriginalExpression(),
                 "INSTALL_PREFIX is a marker for install(EXPORT) only.  It "
@@ -1525,36 +1389,34 @@ class ArtifactPdbTag;
 class ArtifactPathTag;
 class ArtifactDirTag;
 
-template<typename ArtifactT>
+template <typename ArtifactT>
 struct TargetFilesystemArtifactResultCreator
 {
   static std::string Create(cmGeneratorTarget* target,
-                            cmGeneratorExpressionContext *context,
-                            const GeneratorExpressionContent *content);
+                            cmGeneratorExpressionContext* context,
+                            const GeneratorExpressionContent* content);
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultCreator<ArtifactSonameTag>
 {
   static std::string Create(cmGeneratorTarget* target,
-                            cmGeneratorExpressionContext *context,
-                            const GeneratorExpressionContent *content)
+                            cmGeneratorExpressionContext* context,
+                            const GeneratorExpressionContent* content)
   {
     // The target soname file (.so.1).
-    if(target->IsDLLPlatform())
-      {
+    if (target->IsDLLPlatform()) {
       ::reportError(context, content->GetOriginalExpression(),
                     "TARGET_SONAME_FILE is not allowed "
                     "for DLL target platforms.");
       return std::string();
-      }
-    if(target->GetType() != cmState::SHARED_LIBRARY)
-      {
+    }
+    if (target->GetType() != cmState::SHARED_LIBRARY) {
       ::reportError(context, content->GetOriginalExpression(),
                     "TARGET_SONAME_FILE is allowed only for "
                     "SHARED libraries.");
       return std::string();
-      }
+    }
     std::string result = target->GetDirectory(context->Config);
     result += "/";
     result += target->GetSOName(context->Config);
@@ -1562,42 +1424,39 @@ struct TargetFilesystemArtifactResultCreator<ArtifactSonameTag>
   }
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag>
 {
   static std::string Create(cmGeneratorTarget* target,
-                            cmGeneratorExpressionContext *context,
-                            const GeneratorExpressionContent *content)
+                            cmGeneratorExpressionContext* context,
+                            const GeneratorExpressionContent* content)
   {
-    if (target->IsImported())
-      {
+    if (target->IsImported()) {
       ::reportError(context, content->GetOriginalExpression(),
                     "TARGET_PDB_FILE not allowed for IMPORTED targets.");
       return std::string();
-      }
+    }
 
     std::string language = target->GetLinkerLanguage(context->Config);
 
     std::string pdbSupportVar = "CMAKE_" + language + "_LINKER_SUPPORTS_PDB";
 
-    if(!context->LG->GetMakefile()->IsOn(pdbSupportVar))
-      {
+    if (!context->LG->GetMakefile()->IsOn(pdbSupportVar)) {
       ::reportError(context, content->GetOriginalExpression(),
                     "TARGET_PDB_FILE is not supported by the target linker.");
       return std::string();
-      }
+    }
 
     cmState::TargetType targetType = target->GetType();
 
-    if(targetType != cmState::SHARED_LIBRARY &&
-       targetType != cmState::MODULE_LIBRARY &&
-       targetType != cmState::EXECUTABLE)
-      {
+    if (targetType != cmState::SHARED_LIBRARY &&
+        targetType != cmState::MODULE_LIBRARY &&
+        targetType != cmState::EXECUTABLE) {
       ::reportError(context, content->GetOriginalExpression(),
                     "TARGET_PDB_FILE is allowed only for "
                     "targets with linker created artifacts.");
       return std::string();
-      }
+    }
 
     std::string result = target->GetPDBDirectory(context->Config);
     result += "/";
@@ -1606,178 +1465,165 @@ struct TargetFilesystemArtifactResultCreator<ArtifactPdbTag>
   }
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultCreator<ArtifactLinkerTag>
 {
   static std::string Create(cmGeneratorTarget* target,
-                            cmGeneratorExpressionContext *context,
-                            const GeneratorExpressionContent *content)
+                            cmGeneratorExpressionContext* context,
+                            const GeneratorExpressionContent* content)
   {
     // The file used to link to the target (.so, .lib, .a).
-    if(!target->IsLinkable())
-      {
+    if (!target->IsLinkable()) {
       ::reportError(context, content->GetOriginalExpression(),
                     "TARGET_LINKER_FILE is allowed only for libraries and "
                     "executables with ENABLE_EXPORTS.");
       return std::string();
-      }
-    return target->GetFullPath(context->Config,
-                               target->HasImportLibrary());
+    }
+    return target->GetFullPath(context->Config, target->HasImportLibrary());
   }
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultCreator<ArtifactNameTag>
 {
   static std::string Create(cmGeneratorTarget* target,
-                            cmGeneratorExpressionContext *context,
-                            const GeneratorExpressionContent *)
+                            cmGeneratorExpressionContext* context,
+                            const GeneratorExpressionContent*)
   {
     return target->GetFullPath(context->Config, false, true);
   }
 };
 
-
-template<typename ArtifactT>
+template <typename ArtifactT>
 struct TargetFilesystemArtifactResultGetter
 {
-  static std::string Get(const std::string &result);
+  static std::string Get(const std::string& result);
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultGetter<ArtifactNameTag>
 {
-  static std::string Get(const std::string &result)
-  { return cmSystemTools::GetFilenameName(result); }
+  static std::string Get(const std::string& result)
+  {
+    return cmSystemTools::GetFilenameName(result);
+  }
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultGetter<ArtifactDirTag>
 {
-  static std::string Get(const std::string &result)
-  { return cmSystemTools::GetFilenamePath(result); }
+  static std::string Get(const std::string& result)
+  {
+    return cmSystemTools::GetFilenamePath(result);
+  }
 };
 
-template<>
+template <>
 struct TargetFilesystemArtifactResultGetter<ArtifactPathTag>
 {
-  static std::string Get(const std::string &result)
-  { return result; }
+  static std::string Get(const std::string& result) { return result; }
 };
 
-template<typename ArtifactT, typename ComponentT>
+template <typename ArtifactT, typename ComponentT>
 struct TargetFilesystemArtifact : public cmGeneratorExpressionNode
 {
   TargetFilesystemArtifact() {}
 
   virtual int NumExpectedParameters() const { return 1; }
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *dagChecker) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker* dagChecker) const
   {
     // Lookup the referenced target.
     std::string name = *parameters.begin();
 
-    if (!cmGeneratorExpression::IsValidTargetName(name))
-      {
+    if (!cmGeneratorExpression::IsValidTargetName(name)) {
       ::reportError(context, content->GetOriginalExpression(),
                     "Expression syntax not recognized.");
       return std::string();
-      }
-    cmGeneratorTarget* target =
-        context->LG->FindGeneratorTargetToUse(name);
-    if(!target)
-      {
+    }
+    cmGeneratorTarget* target = context->LG->FindGeneratorTargetToUse(name);
+    if (!target) {
       ::reportError(context, content->GetOriginalExpression(),
                     "No target \"" + name + "\"");
       return std::string();
-      }
-    if(target->GetType() >= cmState::OBJECT_LIBRARY &&
-      target->GetType() != cmState::UNKNOWN_LIBRARY)
-      {
-      ::reportError(context, content->GetOriginalExpression(),
-                  "Target \"" + name + "\" is not an executable or library.");
+    }
+    if (target->GetType() >= cmState::OBJECT_LIBRARY &&
+        target->GetType() != cmState::UNKNOWN_LIBRARY) {
+      ::reportError(context, content->GetOriginalExpression(), "Target \"" +
+                      name + "\" is not an executable or library.");
       return std::string();
-      }
-    if (dagChecker && (dagChecker->EvaluatingLinkLibraries(name.c_str())
-        || (dagChecker->EvaluatingSources()
-          && name == dagChecker->TopTarget())))
-      {
+    }
+    if (dagChecker && (dagChecker->EvaluatingLinkLibraries(name.c_str()) ||
+                       (dagChecker->EvaluatingSources() &&
+                        name == dagChecker->TopTarget()))) {
       ::reportError(context, content->GetOriginalExpression(),
                     "Expressions which require the linker language may not "
                     "be used while evaluating link libraries");
       return std::string();
-      }
+    }
     context->DependTargets.insert(target);
     context->AllTargets.insert(target);
 
     std::string result =
-                TargetFilesystemArtifactResultCreator<ArtifactT>::Create(
-                          target,
-                          context,
-                          content);
-    if (context->HadError)
-      {
+      TargetFilesystemArtifactResultCreator<ArtifactT>::Create(target, context,
+                                                               content);
+    if (context->HadError) {
       return std::string();
-      }
-    return
-        TargetFilesystemArtifactResultGetter<ComponentT>::Get(result);
+    }
+    return TargetFilesystemArtifactResultGetter<ComponentT>::Get(result);
   }
 };
 
-template<typename ArtifactT>
+template <typename ArtifactT>
 struct TargetFilesystemArtifactNodeGroup
 {
-  TargetFilesystemArtifactNodeGroup()
-    {
-    }
+  TargetFilesystemArtifactNodeGroup() {}
 
   TargetFilesystemArtifact<ArtifactT, ArtifactPathTag> File;
   TargetFilesystemArtifact<ArtifactT, ArtifactNameTag> FileName;
   TargetFilesystemArtifact<ArtifactT, ArtifactDirTag> FileDir;
 };
 
-static const
-TargetFilesystemArtifactNodeGroup<ArtifactNameTag> targetNodeGroup;
+static const TargetFilesystemArtifactNodeGroup<ArtifactNameTag>
+  targetNodeGroup;
 
-static const
-TargetFilesystemArtifactNodeGroup<ArtifactLinkerTag> targetLinkerNodeGroup;
+static const TargetFilesystemArtifactNodeGroup<ArtifactLinkerTag>
+  targetLinkerNodeGroup;
 
-static const
-TargetFilesystemArtifactNodeGroup<ArtifactSonameTag> targetSoNameNodeGroup;
+static const TargetFilesystemArtifactNodeGroup<ArtifactSonameTag>
+  targetSoNameNodeGroup;
 
-static const
-TargetFilesystemArtifactNodeGroup<ArtifactPdbTag> targetPdbNodeGroup;
+static const TargetFilesystemArtifactNodeGroup<ArtifactPdbTag>
+  targetPdbNodeGroup;
 
 static const struct ShellPathNode : public cmGeneratorExpressionNode
 {
   ShellPathNode() {}
 
-  std::string Evaluate(const std::vector<std::string> &parameters,
-                       cmGeneratorExpressionContext *context,
-                       const GeneratorExpressionContent *content,
-                       cmGeneratorExpressionDAGChecker *) const
+  std::string Evaluate(const std::vector<std::string>& parameters,
+                       cmGeneratorExpressionContext* context,
+                       const GeneratorExpressionContent* content,
+                       cmGeneratorExpressionDAGChecker*) const
   {
-    if (!cmSystemTools::FileIsFullPath(parameters.front()))
-      {
+    if (!cmSystemTools::FileIsFullPath(parameters.front())) {
       reportError(context, content->GetOriginalExpression(),
                   "\"" + parameters.front() + "\" is not an absolute path.");
       return std::string();
-      }
+    }
     cmOutputConverter converter(context->LG->GetStateSnapshot());
     return converter.ConvertDirectorySeparatorsForShell(parameters.front());
   }
 } shellPathNode;
 
-const cmGeneratorExpressionNode*
-cmGeneratorExpressionNode::GetNode(const std::string &identifier)
+const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode(
+  const std::string& identifier)
 {
   typedef std::map<std::string, const cmGeneratorExpressionNode*> NodeMap;
   static NodeMap nodeMap;
-  if (nodeMap.empty())
-    {
+  if (nodeMap.empty()) {
     nodeMap["0"] = &zeroNode;
     nodeMap["1"] = &oneNode;
     nodeMap["AND"] = &andNode;
@@ -1826,23 +1672,21 @@ cmGeneratorExpressionNode::GetNode(const std::string &identifier)
     nodeMap["LINK_ONLY"] = &linkOnlyNode;
     nodeMap["COMPILE_LANGUAGE"] = &languageNode;
     nodeMap["SHELL_PATH"] = &shellPathNode;
-    }
+  }
   NodeMap::const_iterator i = nodeMap.find(identifier);
-  if (i == nodeMap.end())
-    {
+  if (i == nodeMap.end()) {
     return 0;
-    }
+  }
   return i->second;
 }
 
-void reportError(cmGeneratorExpressionContext *context,
-                 const std::string &expr, const std::string &result)
+void reportError(cmGeneratorExpressionContext* context,
+                 const std::string& expr, const std::string& result)
 {
   context->HadError = true;
-  if (context->Quiet)
-    {
+  if (context->Quiet) {
     return;
-    }
+  }
 
   std::ostringstream e;
   /* clang-format off */
@@ -1850,7 +1694,6 @@ void reportError(cmGeneratorExpressionContext *context,
     << "  " << expr << "\n"
     << result;
   /* clang-format on */
-  context->LG->GetCMakeInstance()
-    ->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                    context->Backtrace);
+  context->LG->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, e.str(),
+                                                context->Backtrace);
 }
diff --git a/Source/cmGeneratorExpressionNode.h b/Source/cmGeneratorExpressionNode.h
index 725ff01..3ee57eb 100644
--- a/Source/cmGeneratorExpressionNode.h
+++ b/Source/cmGeneratorExpressionNode.h
@@ -29,7 +29,8 @@
 
 struct cmGeneratorExpressionNode
 {
-  enum {
+  enum
+  {
     DynamicParameters = 0,
     OneOrMoreParameters = -1,
     OneOrZeroParameters = -2
@@ -40,29 +41,27 @@ struct cmGeneratorExpressionNode
 
   virtual bool RequiresLiteralInput() const { return false; }
 
-  virtual bool AcceptsArbitraryContentParameter() const
-    { return false; }
+  virtual bool AcceptsArbitraryContentParameter() const { return false; }
 
   virtual int NumExpectedParameters() const { return 1; }
 
-  virtual std::string Evaluate(const std::vector<std::string> &parameters,
-                               cmGeneratorExpressionContext *context,
-                               const GeneratorExpressionContent *content,
-                               cmGeneratorExpressionDAGChecker *dagChecker
-                              ) const = 0;
+  virtual std::string Evaluate(
+    const std::vector<std::string>& parameters,
+    cmGeneratorExpressionContext* context,
+    const GeneratorExpressionContent* content,
+    cmGeneratorExpressionDAGChecker* dagChecker) const = 0;
 
   static std::string EvaluateDependentExpression(
-    std::string const& prop, cmLocalGenerator *lg,
-    cmGeneratorExpressionContext *context,
-    const cmGeneratorTarget* headTarget,
+    std::string const& prop, cmLocalGenerator* lg,
+    cmGeneratorExpressionContext* context, const cmGeneratorTarget* headTarget,
     const cmGeneratorTarget* currentTarget,
-    cmGeneratorExpressionDAGChecker *dagChecker);
+    cmGeneratorExpressionDAGChecker* dagChecker);
 
   static const cmGeneratorExpressionNode* GetNode(
-                                              const std::string &identifier);
+    const std::string& identifier);
 };
 
-void reportError(cmGeneratorExpressionContext *context,
-                 const std::string &expr, const std::string &result);
+void reportError(cmGeneratorExpressionContext* context,
+                 const std::string& expr, const std::string& result);
 
 #endif
diff --git a/Source/cmGeneratorExpressionParser.cxx b/Source/cmGeneratorExpressionParser.cxx
index f59405c..f853f8d 100644
--- a/Source/cmGeneratorExpressionParser.cxx
+++ b/Source/cmGeneratorExpressionParser.cxx
@@ -17,51 +17,48 @@
 #include "assert.h"
 
 cmGeneratorExpressionParser::cmGeneratorExpressionParser(
-                      const std::vector<cmGeneratorExpressionToken> &tokens)
-  : Tokens(tokens), NestingLevel(0)
+  const std::vector<cmGeneratorExpressionToken>& tokens)
+  : Tokens(tokens)
+  , NestingLevel(0)
 {
 }
 
 void cmGeneratorExpressionParser::Parse(
-                        std::vector<cmGeneratorExpressionEvaluator*> &result)
+  std::vector<cmGeneratorExpressionEvaluator*>& result)
 {
   it = this->Tokens.begin();
 
-  while (this->it != this->Tokens.end())
-    {
+  while (this->it != this->Tokens.end()) {
     this->ParseContent(result);
-    }
+  }
 }
 
-static void extendText(std::vector<cmGeneratorExpressionEvaluator*> &result,
-                  std::vector<cmGeneratorExpressionToken>::const_iterator it)
+static void extendText(
+  std::vector<cmGeneratorExpressionEvaluator*>& result,
+  std::vector<cmGeneratorExpressionToken>::const_iterator it)
 {
-  if (!result.empty()
-      && (*(result.end() - 1))->GetType()
-                                  == cmGeneratorExpressionEvaluator::Text)
-    {
-    TextContent *textContent = static_cast<TextContent*>(*(result.end() - 1));
+  if (!result.empty() &&
+      (*(result.end() - 1))->GetType() ==
+        cmGeneratorExpressionEvaluator::Text) {
+    TextContent* textContent = static_cast<TextContent*>(*(result.end() - 1));
     textContent->Extend(it->Length);
-    }
-  else
-    {
-    TextContent *textContent = new TextContent(it->Content, it->Length);
+  } else {
+    TextContent* textContent = new TextContent(it->Content, it->Length);
     result.push_back(textContent);
-    }
+  }
 }
 
-static void extendResult(std::vector<cmGeneratorExpressionEvaluator*> &result,
-                const std::vector<cmGeneratorExpressionEvaluator*> &contents)
+static void extendResult(
+  std::vector<cmGeneratorExpressionEvaluator*>& result,
+  const std::vector<cmGeneratorExpressionEvaluator*>& contents)
 {
-  if (!result.empty()
-      && (*(result.end() - 1))->GetType()
-                                  == cmGeneratorExpressionEvaluator::Text
-      && (*contents.begin())->GetType()
-                                  == cmGeneratorExpressionEvaluator::Text)
-  {
-    TextContent *textContent = static_cast<TextContent*>(*(result.end() - 1));
+  if (!result.empty() &&
+      (*(result.end() - 1))->GetType() ==
+        cmGeneratorExpressionEvaluator::Text &&
+      (*contents.begin())->GetType() == cmGeneratorExpressionEvaluator::Text) {
+    TextContent* textContent = static_cast<TextContent*>(*(result.end() - 1));
     textContent->Extend(
-                  static_cast<TextContent*>(*contents.begin())->GetLength());
+      static_cast<TextContent*>(*contents.begin())->GetLength());
     delete *contents.begin();
     result.insert(result.end(), contents.begin() + 1, contents.end());
   } else {
@@ -70,207 +67,178 @@ static void extendResult(std::vector<cmGeneratorExpressionEvaluator*> &result,
 }
 
 void cmGeneratorExpressionParser::ParseGeneratorExpression(
-                        std::vector<cmGeneratorExpressionEvaluator*> &result)
+  std::vector<cmGeneratorExpressionEvaluator*>& result)
 {
   assert(this->it != this->Tokens.end());
   unsigned int nestedLevel = this->NestingLevel;
   ++this->NestingLevel;
 
-  std::vector<cmGeneratorExpressionToken>::const_iterator startToken
-                                                              = this->it - 1;
+  std::vector<cmGeneratorExpressionToken>::const_iterator startToken =
+    this->it - 1;
 
   std::vector<cmGeneratorExpressionEvaluator*> identifier;
-  while(this->it->TokenType != cmGeneratorExpressionToken::EndExpression
-      && this->it->TokenType != cmGeneratorExpressionToken::ColonSeparator)
-    {
-    if (this->it->TokenType == cmGeneratorExpressionToken::CommaSeparator)
-      {
+  while (this->it->TokenType != cmGeneratorExpressionToken::EndExpression &&
+         this->it->TokenType != cmGeneratorExpressionToken::ColonSeparator) {
+    if (this->it->TokenType == cmGeneratorExpressionToken::CommaSeparator) {
       extendText(identifier, this->it);
       ++this->it;
-      }
-    else
-      {
+    } else {
       this->ParseContent(identifier);
-      }
-    if (this->it == this->Tokens.end())
-      {
+    }
+    if (this->it == this->Tokens.end()) {
       break;
-      }
     }
-  if (identifier.empty())
-    {
+  }
+  if (identifier.empty()) {
     // ERROR
-    }
+  }
 
   if (this->it != this->Tokens.end() &&
-      this->it->TokenType == cmGeneratorExpressionToken::EndExpression)
-    {
-    GeneratorExpressionContent *content = new GeneratorExpressionContent(
-                startToken->Content, this->it->Content
-                                    - startToken->Content
-                                    + this->it->Length);
+      this->it->TokenType == cmGeneratorExpressionToken::EndExpression) {
+    GeneratorExpressionContent* content =
+      new GeneratorExpressionContent(startToken->Content, this->it->Content -
+                                       startToken->Content + this->it->Length);
     assert(this->it != this->Tokens.end());
     ++this->it;
     --this->NestingLevel;
     content->SetIdentifier(identifier);
     result.push_back(content);
     return;
-    }
+  }
 
   std::vector<std::vector<cmGeneratorExpressionEvaluator*> > parameters;
   std::vector<std::vector<cmGeneratorExpressionToken>::const_iterator>
-                                                            commaTokens;
+    commaTokens;
   std::vector<cmGeneratorExpressionToken>::const_iterator colonToken;
 
   bool emptyParamTermination = false;
 
   if (this->it != this->Tokens.end() &&
-      this->it->TokenType == cmGeneratorExpressionToken::ColonSeparator)
-    {
+      this->it->TokenType == cmGeneratorExpressionToken::ColonSeparator) {
     colonToken = this->it;
     parameters.resize(parameters.size() + 1);
     assert(this->it != this->Tokens.end());
     ++this->it;
-    if(this->it == this->Tokens.end())
-      {
+    if (this->it == this->Tokens.end()) {
       emptyParamTermination = true;
-      }
+    }
 
     while (this->it != this->Tokens.end() &&
-           this->it->TokenType == cmGeneratorExpressionToken::CommaSeparator)
-      {
+           this->it->TokenType == cmGeneratorExpressionToken::CommaSeparator) {
       commaTokens.push_back(this->it);
       parameters.resize(parameters.size() + 1);
       assert(this->it != this->Tokens.end());
       ++this->it;
-      if(this->it == this->Tokens.end())
-        {
+      if (this->it == this->Tokens.end()) {
         emptyParamTermination = true;
-        }
       }
+    }
     while (this->it != this->Tokens.end() &&
-           this->it->TokenType == cmGeneratorExpressionToken::ColonSeparator)
-      {
+           this->it->TokenType == cmGeneratorExpressionToken::ColonSeparator) {
       extendText(*(parameters.end() - 1), this->it);
       assert(this->it != this->Tokens.end());
       ++this->it;
-      }
+    }
     while (this->it != this->Tokens.end() &&
-           this->it->TokenType != cmGeneratorExpressionToken::EndExpression)
-      {
+           this->it->TokenType != cmGeneratorExpressionToken::EndExpression) {
       this->ParseContent(*(parameters.end() - 1));
-      if (this->it == this->Tokens.end())
-        {
+      if (this->it == this->Tokens.end()) {
         break;
-        }
+      }
       while (this->it != this->Tokens.end() &&
-             this->it->TokenType == cmGeneratorExpressionToken::CommaSeparator)
-        {
+             this->it->TokenType ==
+               cmGeneratorExpressionToken::CommaSeparator) {
         commaTokens.push_back(this->it);
         parameters.resize(parameters.size() + 1);
         assert(this->it != this->Tokens.end());
         ++this->it;
-        if(this->it == this->Tokens.end())
-          {
+        if (this->it == this->Tokens.end()) {
           emptyParamTermination = true;
-          }
         }
+      }
       while (this->it != this->Tokens.end() &&
-             this->it->TokenType == cmGeneratorExpressionToken::ColonSeparator)
-        {
+             this->it->TokenType ==
+               cmGeneratorExpressionToken::ColonSeparator) {
         extendText(*(parameters.end() - 1), this->it);
         assert(this->it != this->Tokens.end());
         ++this->it;
-        }
       }
-      if(this->it != this->Tokens.end()
-          && this->it->TokenType == cmGeneratorExpressionToken::EndExpression)
-        {
-        --this->NestingLevel;
-        assert(this->it != this->Tokens.end());
-        ++this->it;
-        }
     }
+    if (this->it != this->Tokens.end() &&
+        this->it->TokenType == cmGeneratorExpressionToken::EndExpression) {
+      --this->NestingLevel;
+      assert(this->it != this->Tokens.end());
+      ++this->it;
+    }
+  }
 
-  if (nestedLevel != this->NestingLevel)
-  {
+  if (nestedLevel != this->NestingLevel) {
     // There was a '$<' in the text, but no corresponding '>'. Rebuild to
     // treat the '$<' as having been plain text, along with the
     // corresponding : and , tokens that might have been found.
     extendText(result, startToken);
     extendResult(result, identifier);
-    if (!parameters.empty())
-      {
+    if (!parameters.empty()) {
       extendText(result, colonToken);
 
       typedef std::vector<cmGeneratorExpressionEvaluator*> EvaluatorVector;
       typedef std::vector<cmGeneratorExpressionToken> TokenVector;
       std::vector<EvaluatorVector>::const_iterator pit = parameters.begin();
       const std::vector<EvaluatorVector>::const_iterator pend =
-                                                         parameters.end();
+        parameters.end();
       std::vector<TokenVector::const_iterator>::const_iterator commaIt =
-                                                         commaTokens.begin();
+        commaTokens.begin();
       assert(parameters.size() > commaTokens.size());
-      for ( ; pit != pend; ++pit, ++commaIt)
-        {
-        if (!pit->empty() && !emptyParamTermination)
-          {
+      for (; pit != pend; ++pit, ++commaIt) {
+        if (!pit->empty() && !emptyParamTermination) {
           extendResult(result, *pit);
-          }
-        if (commaIt != commaTokens.end())
-          {
+        }
+        if (commaIt != commaTokens.end()) {
           extendText(result, *commaIt);
-          }
-        else
-          {
+        } else {
           break;
-          }
         }
       }
+    }
     return;
   }
 
-  size_t contentLength = ((this->it - 1)->Content
-                    - startToken->Content)
-                    + (this->it - 1)->Length;
-  GeneratorExpressionContent *content = new GeneratorExpressionContent(
-                            startToken->Content, contentLength);
+  size_t contentLength =
+    ((this->it - 1)->Content - startToken->Content) + (this->it - 1)->Length;
+  GeneratorExpressionContent* content =
+    new GeneratorExpressionContent(startToken->Content, contentLength);
   content->SetIdentifier(identifier);
   content->SetParameters(parameters);
   result.push_back(content);
 }
 
 void cmGeneratorExpressionParser::ParseContent(
-                        std::vector<cmGeneratorExpressionEvaluator*> &result)
+  std::vector<cmGeneratorExpressionEvaluator*>& result)
 {
   assert(this->it != this->Tokens.end());
-  switch(this->it->TokenType)
-    {
-    case cmGeneratorExpressionToken::Text:
-    {
-      if (this->NestingLevel == 0)
-        {
-        if (!result.empty()
-            && (*(result.end() - 1))->GetType()
-                                      == cmGeneratorExpressionEvaluator::Text)
-          {
+  switch (this->it->TokenType) {
+    case cmGeneratorExpressionToken::Text: {
+      if (this->NestingLevel == 0) {
+        if (!result.empty() &&
+            (*(result.end() - 1))->GetType() ==
+              cmGeneratorExpressionEvaluator::Text) {
           // A comma in 'plain text' could have split text that should
           // otherwise be continuous. Extend the last text content instead of
           // creating a new one.
-          TextContent *textContent =
-                              static_cast<TextContent*>(*(result.end() - 1));
+          TextContent* textContent =
+            static_cast<TextContent*>(*(result.end() - 1));
           textContent->Extend(this->it->Length);
           assert(this->it != this->Tokens.end());
           ++this->it;
           return;
-          }
         }
-      cmGeneratorExpressionEvaluator* n = new TextContent(this->it->Content,
-                                                          this->it->Length);
+      }
+      cmGeneratorExpressionEvaluator* n =
+        new TextContent(this->it->Content, this->it->Length);
       result.push_back(n);
       assert(this->it != this->Tokens.end());
       ++this->it;
-      return ;
+      return;
     }
     case cmGeneratorExpressionToken::BeginExpression:
       assert(this->it != this->Tokens.end());
@@ -280,17 +248,14 @@ void cmGeneratorExpressionParser::ParseContent(
     case cmGeneratorExpressionToken::EndExpression:
     case cmGeneratorExpressionToken::ColonSeparator:
     case cmGeneratorExpressionToken::CommaSeparator:
-      if (this->NestingLevel == 0)
-        {
+      if (this->NestingLevel == 0) {
         extendText(result, this->it);
-        }
-      else
-        {
-          assert(0 && "Got unexpected syntax token.");
-        }
+      } else {
+        assert(0 && "Got unexpected syntax token.");
+      }
       assert(this->it != this->Tokens.end());
       ++this->it;
       return;
-    }
-    assert(0 && "Unhandled token in generator expression.");
+  }
+  assert(0 && "Unhandled token in generator expression.");
 }
diff --git a/Source/cmGeneratorExpressionParser.h b/Source/cmGeneratorExpressionParser.h
index 3df7fed..b0e9ea4 100644
--- a/Source/cmGeneratorExpressionParser.h
+++ b/Source/cmGeneratorExpressionParser.h
@@ -24,14 +24,13 @@ struct cmGeneratorExpressionEvaluator;
 struct cmGeneratorExpressionParser
 {
   cmGeneratorExpressionParser(
-                      const std::vector<cmGeneratorExpressionToken> &tokens);
+    const std::vector<cmGeneratorExpressionToken>& tokens);
 
-  void Parse(std::vector<cmGeneratorExpressionEvaluator*> &result);
+  void Parse(std::vector<cmGeneratorExpressionEvaluator*>& result);
 
 private:
-  void ParseContent(std::vector<cmGeneratorExpressionEvaluator*> &);
-  void ParseGeneratorExpression(
-                              std::vector<cmGeneratorExpressionEvaluator*> &);
+  void ParseContent(std::vector<cmGeneratorExpressionEvaluator*>&);
+  void ParseGeneratorExpression(std::vector<cmGeneratorExpressionEvaluator*>&);
 
 private:
   std::vector<cmGeneratorExpressionToken>::const_iterator it;
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index dffe4cc..31fff9f 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -34,81 +34,111 @@
 #define UNORDERED_SET std::set
 #endif
 
-class cmGeneratorTarget::TargetPropertyEntry {
+class cmGeneratorTarget::TargetPropertyEntry
+{
   static cmLinkImplItem NoLinkImplItem;
+
 public:
   TargetPropertyEntry(cmsys::auto_ptr<cmCompiledGeneratorExpression> cge,
                       cmLinkImplItem const& item = NoLinkImplItem)
-    : ge(cge), LinkImplItem(item)
-  {}
+    : ge(cge)
+    , LinkImplItem(item)
+  {
+  }
   const cmsys::auto_ptr<cmCompiledGeneratorExpression> ge;
   cmLinkImplItem const& LinkImplItem;
 };
 cmLinkImplItem cmGeneratorTarget::TargetPropertyEntry::NoLinkImplItem;
 
 void reportBadObjLib(std::vector<cmSourceFile*> const& badObjLib,
-                     cmGeneratorTarget const* target, cmake *cm)
+                     cmGeneratorTarget const* target, cmake* cm)
 {
-  if(!badObjLib.empty())
-    {
+  if (!badObjLib.empty()) {
     std::ostringstream e;
     e << "OBJECT library \"" << target->GetName() << "\" contains:\n";
-    for(std::vector<cmSourceFile*>::const_iterator i = badObjLib.begin();
-        i != badObjLib.end(); ++i)
-      {
+    for (std::vector<cmSourceFile*>::const_iterator i = badObjLib.begin();
+         i != badObjLib.end(); ++i) {
       e << "  " << (*i)->GetLocation().GetName() << "\n";
-      }
+    }
     e << "but may contain only sources that compile, header files, and "
          "other files that would not affect linking of a normal library.";
-    cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                     target->GetBacktrace());
-    }
+    cm->IssueMessage(cmake::FATAL_ERROR, e.str(), target->GetBacktrace());
+  }
 }
 
-struct ObjectSourcesTag {};
-struct CustomCommandsTag {};
-struct ExtraSourcesTag {};
-struct HeaderSourcesTag {};
-struct ExternalObjectsTag {};
-struct IDLSourcesTag {};
-struct ResxTag {};
-struct ModuleDefinitionFileTag {};
-struct AppManifestTag{};
-struct ManifestsTag{};
-struct CertificatesTag{};
-struct XamlTag{};
-
-template<typename Tag, typename OtherTag>
+struct ObjectSourcesTag
+{
+};
+struct CustomCommandsTag
+{
+};
+struct ExtraSourcesTag
+{
+};
+struct HeaderSourcesTag
+{
+};
+struct ExternalObjectsTag
+{
+};
+struct IDLSourcesTag
+{
+};
+struct ResxTag
+{
+};
+struct ModuleDefinitionFileTag
+{
+};
+struct AppManifestTag
+{
+};
+struct ManifestsTag
+{
+};
+struct CertificatesTag
+{
+};
+struct XamlTag
+{
+};
+
+template <typename Tag, typename OtherTag>
 struct IsSameTag
 {
-  enum {
+  enum
+  {
     Result = false
   };
 };
 
-template<typename Tag>
+template <typename Tag>
 struct IsSameTag<Tag, Tag>
 {
-  enum {
+  enum
+  {
     Result = true
   };
 };
 
-template<bool>
+template <bool>
 struct DoAccept
 {
-  template <typename T> static void Do(T&, cmSourceFile*) {}
+  template <typename T>
+  static void Do(T&, cmSourceFile*)
+  {
+  }
 };
 
-template<>
+template <>
 struct DoAccept<true>
 {
   static void Do(std::vector<cmSourceFile const*>& files, cmSourceFile* f)
-    {
+  {
     files.push_back(f);
-    }
+  }
   static void Do(cmGeneratorTarget::ResxData& data, cmSourceFile* f)
-    {
+  {
     // Build and save the name of the corresponding .h file
     // This relationship will be used later when building the project files.
     // Both names would have been auto generated from Visual Studio
@@ -118,9 +148,9 @@ struct DoAccept<true>
     std::string hFileName = resx.substr(0, resx.find_last_of(".")) + ".h";
     data.ExpectedResxHeaders.insert(hFileName);
     data.ResxSources.push_back(f);
-    }
+  }
   static void Do(cmGeneratorTarget::XamlData& data, cmSourceFile* f)
-    {
+  {
     // Build and save the name of the corresponding .h and .cpp file
     // This relationship will be used later when building the project files.
     // Both names would have been auto generated from Visual Studio
@@ -132,28 +162,29 @@ struct DoAccept<true>
     data.ExpectedXamlHeaders.insert(hFileName);
     data.ExpectedXamlSources.insert(cppFileName);
     data.XamlSources.push_back(f);
-    }
+  }
   static void Do(std::string& data, cmSourceFile* f)
-    {
+  {
     data = f->GetFullPath();
-    }
+  }
 };
 
-template<typename Tag, typename DataType = std::vector<cmSourceFile const*> >
+template <typename Tag, typename DataType = std::vector<cmSourceFile const*> >
 struct TagVisitor
 {
   DataType& Data;
   std::vector<cmSourceFile*> BadObjLibFiles;
   cmGeneratorTarget const* Target;
-  cmGlobalGenerator *GlobalGenerator;
+  cmGlobalGenerator* GlobalGenerator;
   cmsys::RegularExpression Header;
   bool IsObjLib;
 
   TagVisitor(cmGeneratorTarget const* target, DataType& data)
-    : Data(data), Target(target),
-    GlobalGenerator(target->GetLocalGenerator()->GetGlobalGenerator()),
-    Header(CM_HEADER_REGEX),
-    IsObjLib(target->GetType() == cmState::OBJECT_LIBRARY)
+    : Data(data)
+    , Target(target)
+    , GlobalGenerator(target->GetLocalGenerator()->GetGlobalGenerator())
+    , Header(CM_HEADER_REGEX)
+    , IsObjLib(target->GetType() == cmState::OBJECT_LIBRARY)
   {
   }
 
@@ -163,113 +194,79 @@ struct TagVisitor
                     this->GlobalGenerator->GetCMakeInstance());
   }
 
-  void Accept(cmSourceFile *sf)
+  void Accept(cmSourceFile* sf)
   {
     std::string ext = cmSystemTools::LowerCase(sf->GetExtension());
-    if(sf->GetCustomCommand())
-      {
+    if (sf->GetCustomCommand()) {
       DoAccept<IsSameTag<Tag, CustomCommandsTag>::Result>::Do(this->Data, sf);
-      }
-    else if(this->Target->GetType() == cmState::UTILITY)
-      {
+    } else if (this->Target->GetType() == cmState::UTILITY) {
       DoAccept<IsSameTag<Tag, ExtraSourcesTag>::Result>::Do(this->Data, sf);
-      }
-    else if(sf->GetPropertyAsBool("HEADER_FILE_ONLY"))
-      {
+    } else if (sf->GetPropertyAsBool("HEADER_FILE_ONLY")) {
       DoAccept<IsSameTag<Tag, HeaderSourcesTag>::Result>::Do(this->Data, sf);
-      }
-    else if(sf->GetPropertyAsBool("EXTERNAL_OBJECT"))
-      {
+    } else if (sf->GetPropertyAsBool("EXTERNAL_OBJECT")) {
       DoAccept<IsSameTag<Tag, ExternalObjectsTag>::Result>::Do(this->Data, sf);
-      if(this->IsObjLib)
-        {
+      if (this->IsObjLib) {
         this->BadObjLibFiles.push_back(sf);
-        }
       }
-    else if(!sf->GetLanguage().empty())
-      {
+    } else if (!sf->GetLanguage().empty()) {
       DoAccept<IsSameTag<Tag, ObjectSourcesTag>::Result>::Do(this->Data, sf);
-      }
-    else if(ext == "def")
-      {
+    } else if (ext == "def") {
       DoAccept<IsSameTag<Tag, ModuleDefinitionFileTag>::Result>::Do(this->Data,
                                                                     sf);
-      if(this->IsObjLib)
-        {
+      if (this->IsObjLib) {
         this->BadObjLibFiles.push_back(sf);
-        }
       }
-    else if(ext == "idl")
-      {
+    } else if (ext == "idl") {
       DoAccept<IsSameTag<Tag, IDLSourcesTag>::Result>::Do(this->Data, sf);
-      if(this->IsObjLib)
-        {
+      if (this->IsObjLib) {
         this->BadObjLibFiles.push_back(sf);
-        }
       }
-    else if(ext == "resx")
-      {
+    } else if (ext == "resx") {
       DoAccept<IsSameTag<Tag, ResxTag>::Result>::Do(this->Data, sf);
-      }
-    else if (ext == "appxmanifest")
-      {
+    } else if (ext == "appxmanifest") {
       DoAccept<IsSameTag<Tag, AppManifestTag>::Result>::Do(this->Data, sf);
-      }
-    else if (ext == "manifest")
-      {
+    } else if (ext == "manifest") {
       DoAccept<IsSameTag<Tag, ManifestsTag>::Result>::Do(this->Data, sf);
-      }
-    else if (ext == "pfx")
-      {
+    } else if (ext == "pfx") {
       DoAccept<IsSameTag<Tag, CertificatesTag>::Result>::Do(this->Data, sf);
-      }
-    else if (ext == "xaml")
-      {
+    } else if (ext == "xaml") {
       DoAccept<IsSameTag<Tag, XamlTag>::Result>::Do(this->Data, sf);
-      }
-    else if(this->Header.find(sf->GetFullPath().c_str()))
-      {
+    } else if (this->Header.find(sf->GetFullPath().c_str())) {
       DoAccept<IsSameTag<Tag, HeaderSourcesTag>::Result>::Do(this->Data, sf);
-      }
-    else if(this->GlobalGenerator->IgnoreFile(sf->GetExtension().c_str()))
-      {
+    } else if (this->GlobalGenerator->IgnoreFile(sf->GetExtension().c_str())) {
       DoAccept<IsSameTag<Tag, ExtraSourcesTag>::Result>::Do(this->Data, sf);
-      }
-    else
-      {
+    } else {
       DoAccept<IsSameTag<Tag, ExtraSourcesTag>::Result>::Do(this->Data, sf);
-      }
+    }
   }
 };
 
 void CreatePropertyGeneratorExpressions(
-    cmStringRange const& entries,
-    cmBacktraceRange const& backtraces,
-    std::vector<cmGeneratorTarget::TargetPropertyEntry*>& items,
-    bool evaluateForBuildsystem = false)
+  cmStringRange const& entries, cmBacktraceRange const& backtraces,
+  std::vector<cmGeneratorTarget::TargetPropertyEntry*>& items,
+  bool evaluateForBuildsystem = false)
 {
   std::vector<cmListFileBacktrace>::const_iterator btIt = backtraces.begin();
   for (std::vector<std::string>::const_iterator it = entries.begin();
-       it != entries.end(); ++it, ++btIt)
-    {
+       it != entries.end(); ++it, ++btIt) {
     cmGeneratorExpression ge(*btIt);
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*it);
     cge->SetEvaluateForBuildsystem(evaluateForBuildsystem);
     items.push_back(new cmGeneratorTarget::TargetPropertyEntry(cge));
-    }
+  }
 }
 
 cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg)
-  : Target(t),
-  SourceFileFlagsConstructed(false),
-  PolicyWarnedCMP0022(false),
-  DebugIncludesDone(false),
-  DebugCompileOptionsDone(false),
-  DebugCompileFeaturesDone(false),
-  DebugCompileDefinitionsDone(false),
-  DebugSourcesDone(false),
-  LinkImplementationLanguageIsContextDependent(true),
-  UtilityItemsDone(false)
+  : Target(t)
+  , SourceFileFlagsConstructed(false)
+  , PolicyWarnedCMP0022(false)
+  , DebugIncludesDone(false)
+  , DebugCompileOptionsDone(false)
+  , DebugCompileFeaturesDone(false)
+  , DebugCompileDefinitionsDone(false)
+  , DebugSourcesDone(false)
+  , LinkImplementationLanguageIsContextDependent(true)
+  , UtilityItemsDone(false)
 {
   this->Makefile = this->Target->GetMakefile();
   this->LocalGenerator = lg;
@@ -277,34 +274,29 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg)
 
   this->GlobalGenerator->ComputeTargetObjectDirectory(this);
 
-  CreatePropertyGeneratorExpressions(
-        t->GetIncludeDirectoriesEntries(),
-        t->GetIncludeDirectoriesBacktraces(),
-        this->IncludeDirectoriesEntries);
+  CreatePropertyGeneratorExpressions(t->GetIncludeDirectoriesEntries(),
+                                     t->GetIncludeDirectoriesBacktraces(),
+                                     this->IncludeDirectoriesEntries);
 
-  CreatePropertyGeneratorExpressions(
-        t->GetCompileOptionsEntries(),
-        t->GetCompileOptionsBacktraces(),
-        this->CompileOptionsEntries);
+  CreatePropertyGeneratorExpressions(t->GetCompileOptionsEntries(),
+                                     t->GetCompileOptionsBacktraces(),
+                                     this->CompileOptionsEntries);
 
-  CreatePropertyGeneratorExpressions(
-        t->GetCompileFeaturesEntries(),
-        t->GetCompileFeaturesBacktraces(),
-        this->CompileFeaturesEntries);
+  CreatePropertyGeneratorExpressions(t->GetCompileFeaturesEntries(),
+                                     t->GetCompileFeaturesBacktraces(),
+                                     this->CompileFeaturesEntries);
 
-  CreatePropertyGeneratorExpressions(
-        t->GetCompileDefinitionsEntries(),
-        t->GetCompileDefinitionsBacktraces(),
-        this->CompileDefinitionsEntries);
+  CreatePropertyGeneratorExpressions(t->GetCompileDefinitionsEntries(),
+                                     t->GetCompileDefinitionsBacktraces(),
+                                     this->CompileDefinitionsEntries);
 
-  CreatePropertyGeneratorExpressions(
-        t->GetSourceEntries(),
-        t->GetSourceBacktraces(),
-        this->SourceEntries, true);
+  CreatePropertyGeneratorExpressions(t->GetSourceEntries(),
+                                     t->GetSourceBacktraces(),
+                                     this->SourceEntries, true);
 
-  this->DLLPlatform = (this->Makefile->IsOn("WIN32") ||
-                       this->Makefile->IsOn("CYGWIN") ||
-                       this->Makefile->IsOn("MINGW"));
+  this->DLLPlatform =
+    (this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
+     this->Makefile->IsOn("MINGW"));
 
   this->PolicyMap = t->PolicyMap;
 }
@@ -337,80 +329,65 @@ const std::string& cmGeneratorTarget::GetName() const
 
 std::string cmGeneratorTarget::GetExportName() const
 {
-  const char *exportName = this->GetProperty("EXPORT_NAME");
+  const char* exportName = this->GetProperty("EXPORT_NAME");
 
-  if (exportName && *exportName)
-    {
-    if (!cmGeneratorExpression::IsValidTargetName(exportName))
-      {
+  if (exportName && *exportName) {
+    if (!cmGeneratorExpression::IsValidTargetName(exportName)) {
       std::ostringstream e;
       e << "EXPORT_NAME property \"" << exportName << "\" for \""
         << this->GetName() << "\": is not valid.";
       cmSystemTools::Error(e.str().c_str());
       return "";
-      }
-    return exportName;
     }
+    return exportName;
+  }
   return this->GetName();
 }
 
-const char *cmGeneratorTarget::GetProperty(const std::string& prop) const
+const char* cmGeneratorTarget::GetProperty(const std::string& prop) const
 {
   return this->Target->GetProperty(prop);
 }
 
 const char* cmGeneratorTarget::GetOutputTargetType(bool implib) const
 {
-  switch(this->GetType())
-    {
+  switch (this->GetType()) {
     case cmState::SHARED_LIBRARY:
-      if(this->IsDLLPlatform())
-        {
-        if(implib)
-          {
+      if (this->IsDLLPlatform()) {
+        if (implib) {
           // A DLL import library is treated as an archive target.
           return "ARCHIVE";
-          }
-        else
-          {
+        } else {
           // A DLL shared library is treated as a runtime target.
           return "RUNTIME";
-          }
         }
-      else
-        {
+      } else {
         // For non-DLL platforms shared libraries are treated as
         // library targets.
         return "LIBRARY";
-        }
+      }
     case cmState::STATIC_LIBRARY:
       // Static libraries are always treated as archive targets.
       return "ARCHIVE";
     case cmState::MODULE_LIBRARY:
-      if(implib)
-        {
+      if (implib) {
         // Module libraries are always treated as library targets.
         return "ARCHIVE";
-        }
-      else
-        {
+      } else {
         // Module import libraries are treated as archive targets.
         return "LIBRARY";
-        }
+      }
     case cmState::EXECUTABLE:
-      if(implib)
-        {
+      if (implib) {
         // Executable import libraries are treated as archive targets.
         return "ARCHIVE";
-        }
-      else
-        {
+      } else {
         // Executables are always treated as runtime targets.
         return "RUNTIME";
-        }
+      }
     default:
       break;
-    }
+  }
   return "";
 }
 
@@ -421,8 +398,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config,
   OutputNameKey key(config, implib);
   cmGeneratorTarget::OutputNameMapType::iterator i =
     this->OutputNameMap.find(key);
-  if(i == this->OutputNameMap.end())
-    {
+  if (i == this->OutputNameMap.end()) {
     // Add empty name in map to detect potential recursion.
     OutputNameMapType::value_type entry(key, "");
     i = this->OutputNameMap.insert(entry).first;
@@ -431,57 +407,48 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config,
     std::vector<std::string> props;
     std::string type = this->GetOutputTargetType(implib);
     std::string configUpper = cmSystemTools::UpperCase(config);
-    if(!type.empty() && !configUpper.empty())
-      {
+    if (!type.empty() && !configUpper.empty()) {
       // <ARCHIVE|LIBRARY|RUNTIME>_OUTPUT_NAME_<CONFIG>
       props.push_back(type + "_OUTPUT_NAME_" + configUpper);
-      }
-    if(!type.empty())
-      {
+    }
+    if (!type.empty()) {
       // <ARCHIVE|LIBRARY|RUNTIME>_OUTPUT_NAME
       props.push_back(type + "_OUTPUT_NAME");
-      }
-    if(!configUpper.empty())
-      {
+    }
+    if (!configUpper.empty()) {
       // OUTPUT_NAME_<CONFIG>
       props.push_back("OUTPUT_NAME_" + configUpper);
       // <CONFIG>_OUTPUT_NAME
       props.push_back(configUpper + "_OUTPUT_NAME");
-      }
+    }
     // OUTPUT_NAME
     props.push_back("OUTPUT_NAME");
 
     std::string outName;
-    for(std::vector<std::string>::const_iterator it = props.begin();
-        it != props.end(); ++it)
-      {
-      if (const char* outNameProp = this->GetProperty(*it))
-        {
+    for (std::vector<std::string>::const_iterator it = props.begin();
+         it != props.end(); ++it) {
+      if (const char* outNameProp = this->GetProperty(*it)) {
         outName = outNameProp;
         break;
-        }
       }
+    }
 
-    if(outName.empty())
-      {
+    if (outName.empty()) {
       outName = this->GetName();
-      }
+    }
 
     // Now evaluate genex and update the previously-prepared map entry.
     cmGeneratorExpression ge;
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName);
     i->second = cge->Evaluate(this->LocalGenerator, config);
-    }
-  else if(i->second.empty())
-    {
+  } else if (i->second.empty()) {
     // An empty map entry indicates we have been called recursively
     // from the above block.
-    this->LocalGenerator->GetCMakeInstance()
-          ->IssueMessage(
+    this->LocalGenerator->GetCMakeInstance()->IssueMessage(
       cmake::FATAL_ERROR,
       "Target '" + this->GetName() + "' OUTPUT_NAME depends on itself.",
       this->GetBacktrace());
-    }
+  }
   return i->second;
 }
 
@@ -492,8 +459,7 @@ void cmGeneratorTarget::AddSource(const std::string& src)
   cmGeneratorExpression ge(lfbt);
   cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src);
   cge->SetEvaluateForBuildsystem(true);
-  this->SourceEntries.push_back(
-                        new TargetPropertyEntry(cge));
+  this->SourceEntries.push_back(new TargetPropertyEntry(cge));
   this->SourceFilesMap.clear();
   this->LinkImplementationLanguageIsContextDependent = true;
 }
@@ -501,8 +467,7 @@ void cmGeneratorTarget::AddSource(const std::string& src)
 void cmGeneratorTarget::AddTracedSources(std::vector<std::string> const& srcs)
 {
   this->Target->AddTracedSources(srcs);
-  if (!srcs.empty())
-    {
+  if (!srcs.empty()) {
     std::string srcFiles = cmJoin(srcs, ";");
     this->SourceFilesMap.clear();
     this->LinkImplementationLanguageIsContextDependent = true;
@@ -511,52 +476,46 @@ void cmGeneratorTarget::AddTracedSources(std::vector<std::string> const& srcs)
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles);
     cge->SetEvaluateForBuildsystem(true);
     this->SourceEntries.push_back(
-          new cmGeneratorTarget::TargetPropertyEntry(cge));
-    }
+      new cmGeneratorTarget::TargetPropertyEntry(cge));
+  }
 }
 
-std::vector<cmSourceFile*> const*
-cmGeneratorTarget::GetSourceDepends(cmSourceFile const* sf) const
+std::vector<cmSourceFile*> const* cmGeneratorTarget::GetSourceDepends(
+  cmSourceFile const* sf) const
 {
   SourceEntriesType::const_iterator i = this->SourceDepends.find(sf);
-  if(i != this->SourceDepends.end())
-    {
+  if (i != this->SourceDepends.end()) {
     return &i->second.Depends;
-    }
+  }
   return 0;
 }
 
-static void handleSystemIncludesDep(cmLocalGenerator *lg,
-                                  cmGeneratorTarget const* depTgt,
-                                  const std::string& config,
-                                  cmGeneratorTarget const* headTarget,
-                                  cmGeneratorExpressionDAGChecker *dagChecker,
-                                  std::vector<std::string>& result,
-                                  bool excludeImported)
+static void handleSystemIncludesDep(
+  cmLocalGenerator* lg, cmGeneratorTarget const* depTgt,
+  const std::string& config, cmGeneratorTarget const* headTarget,
+  cmGeneratorExpressionDAGChecker* dagChecker,
+  std::vector<std::string>& result, bool excludeImported)
 {
   if (const char* dirs =
-          depTgt->GetProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES"))
-    {
+        depTgt->GetProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES")) {
     cmGeneratorExpression ge;
-    cmSystemTools::ExpandListArgument(ge.Parse(dirs)
-                                      ->Evaluate(lg,
-                                      config, false, headTarget,
-                                      depTgt, dagChecker), result);
-    }
-  if (!depTgt->IsImported() || excludeImported)
-    {
+    cmSystemTools::ExpandListArgument(
+      ge.Parse(dirs)->Evaluate(lg, config, false, headTarget, depTgt,
+                               dagChecker),
+      result);
+  }
+  if (!depTgt->IsImported() || excludeImported) {
     return;
-    }
+  }
 
   if (const char* dirs =
-                depTgt->GetProperty("INTERFACE_INCLUDE_DIRECTORIES"))
-    {
+        depTgt->GetProperty("INTERFACE_INCLUDE_DIRECTORIES")) {
     cmGeneratorExpression ge;
-    cmSystemTools::ExpandListArgument(ge.Parse(dirs)
-                                      ->Evaluate(lg,
-                                      config, false, headTarget,
-                                      depTgt, dagChecker), result);
-    }
+    cmSystemTools::ExpandListArgument(
+      ge.Parse(dirs)->Evaluate(lg, config, false, headTarget, depTgt,
+                               dagChecker),
+      result);
+  }
 }
 
 /* clang-format off */
@@ -572,71 +531,60 @@ static void handleSystemIncludesDep(cmLocalGenerator *lg,
   }
 /* clang-format on */
 
-#define IMPLEMENT_VISIT(DATA) \
-  IMPLEMENT_VISIT_IMPL(DATA, EMPTY) \
+#define IMPLEMENT_VISIT(DATA) IMPLEMENT_VISIT_IMPL(DATA, EMPTY)
 
 #define EMPTY
 #define COMMA ,
 
-void
-cmGeneratorTarget
-::GetObjectSources(std::vector<cmSourceFile const*> &data,
-                   const std::string& config) const
+void cmGeneratorTarget::GetObjectSources(
+  std::vector<cmSourceFile const*>& data, const std::string& config) const
 {
   IMPLEMENT_VISIT(ObjectSources);
 
-  if (!this->Objects.empty())
-    {
+  if (!this->Objects.empty()) {
     return;
-    }
+  }
 
-  for(std::vector<cmSourceFile const*>::const_iterator it = data.begin();
-      it != data.end(); ++it)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator it = data.begin();
+       it != data.end(); ++it) {
     this->Objects[*it];
-    }
+  }
 
   this->LocalGenerator->ComputeObjectFilenames(this->Objects, this);
 }
 
 void cmGeneratorTarget::ComputeObjectMapping()
 {
-  if(!this->Objects.empty())
-    {
+  if (!this->Objects.empty()) {
     return;
-    }
+  }
 
   std::vector<std::string> configs;
   this->Makefile->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) {
     std::vector<cmSourceFile const*> sourceFiles;
     this->GetObjectSources(sourceFiles, *ci);
-    }
+  }
 }
 
 const char* cmGeneratorTarget::GetFeature(const std::string& feature,
                                           const std::string& config) const
 {
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     std::string featureConfig = feature;
     featureConfig += "_";
     featureConfig += cmSystemTools::UpperCase(config);
-    if(const char* value = this->GetProperty(featureConfig))
-      {
+    if (const char* value = this->GetProperty(featureConfig)) {
       return value;
-      }
     }
-  if(const char* value = this->GetProperty(feature))
-    {
+  }
+  if (const char* value = this->GetProperty(feature)) {
     return value;
-    }
+  }
   return this->LocalGenerator->GetFeature(feature, config);
 }
 
@@ -660,129 +608,108 @@ void cmGeneratorTarget::AddExplicitObjectName(cmSourceFile const* sf)
 bool cmGeneratorTarget::HasExplicitObjectName(cmSourceFile const* file) const
 {
   const_cast<cmGeneratorTarget*>(this)->ComputeObjectMapping();
-  std::set<cmSourceFile const*>::const_iterator it
-                                        = this->ExplicitObjectName.find(file);
+  std::set<cmSourceFile const*>::const_iterator it =
+    this->ExplicitObjectName.find(file);
   return it != this->ExplicitObjectName.end();
 }
 
-void cmGeneratorTarget
-::GetIDLSources(std::vector<cmSourceFile const*>& data,
-                const std::string& config) const
+void cmGeneratorTarget::GetIDLSources(std::vector<cmSourceFile const*>& data,
+                                      const std::string& config) const
 {
   IMPLEMENT_VISIT(IDLSources);
 }
 
-void
-cmGeneratorTarget
-::GetHeaderSources(std::vector<cmSourceFile const*>& data,
-                   const std::string& config) const
+void cmGeneratorTarget::GetHeaderSources(
+  std::vector<cmSourceFile const*>& data, const std::string& config) const
 {
   IMPLEMENT_VISIT(HeaderSources);
 }
 
-void cmGeneratorTarget
-::GetExtraSources(std::vector<cmSourceFile const*>& data,
-                  const std::string& config) const
+void cmGeneratorTarget::GetExtraSources(std::vector<cmSourceFile const*>& data,
+                                        const std::string& config) const
 {
   IMPLEMENT_VISIT(ExtraSources);
 }
 
-void
-cmGeneratorTarget
-::GetCustomCommands(std::vector<cmSourceFile const*>& data,
-                    const std::string& config) const
+void cmGeneratorTarget::GetCustomCommands(
+  std::vector<cmSourceFile const*>& data, const std::string& config) const
 {
   IMPLEMENT_VISIT(CustomCommands);
 }
 
-void
-cmGeneratorTarget
-::GetExternalObjects(std::vector<cmSourceFile const*>& data,
-                     const std::string& config) const
+void cmGeneratorTarget::GetExternalObjects(
+  std::vector<cmSourceFile const*>& data, const std::string& config) const
 {
   IMPLEMENT_VISIT(ExternalObjects);
 }
 
-void
-cmGeneratorTarget::GetExpectedResxHeaders(std::set<std::string>& srcs,
-                                          const std::string& config) const
+void cmGeneratorTarget::GetExpectedResxHeaders(std::set<std::string>& srcs,
+                                               const std::string& config) const
 {
   ResxData data;
   IMPLEMENT_VISIT_IMPL(Resx, COMMA cmGeneratorTarget::ResxData)
   srcs = data.ExpectedResxHeaders;
 }
 
-void cmGeneratorTarget
-::GetResxSources(std::vector<cmSourceFile const*>& srcs,
-                 const std::string& config) const
+void cmGeneratorTarget::GetResxSources(std::vector<cmSourceFile const*>& srcs,
+                                       const std::string& config) const
 {
   ResxData data;
   IMPLEMENT_VISIT_IMPL(Resx, COMMA cmGeneratorTarget::ResxData)
   srcs = data.ResxSources;
 }
 
-void
-cmGeneratorTarget
-::GetAppManifest(std::vector<cmSourceFile const*>& data,
-                 const std::string& config) const
+void cmGeneratorTarget::GetAppManifest(std::vector<cmSourceFile const*>& data,
+                                       const std::string& config) const
 {
   IMPLEMENT_VISIT(AppManifest);
 }
 
-void
-cmGeneratorTarget
-::GetManifests(std::vector<cmSourceFile const*>& data,
-               const std::string& config) const
+void cmGeneratorTarget::GetManifests(std::vector<cmSourceFile const*>& data,
+                                     const std::string& config) const
 {
   IMPLEMENT_VISIT(Manifests);
 }
 
-void
-cmGeneratorTarget
-::GetCertificates(std::vector<cmSourceFile const*>& data,
-                  const std::string& config) const
+void cmGeneratorTarget::GetCertificates(std::vector<cmSourceFile const*>& data,
+                                        const std::string& config) const
 {
   IMPLEMENT_VISIT(Certificates);
 }
 
-void
-cmGeneratorTarget::GetExpectedXamlHeaders(std::set<std::string>& headers,
-                                          const std::string& config) const
+void cmGeneratorTarget::GetExpectedXamlHeaders(std::set<std::string>& headers,
+                                               const std::string& config) const
 {
   XamlData data;
   IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData)
   headers = data.ExpectedXamlHeaders;
 }
 
-void
-cmGeneratorTarget::GetExpectedXamlSources(std::set<std::string>& srcs,
-                                          const std::string& config) const
+void cmGeneratorTarget::GetExpectedXamlSources(std::set<std::string>& srcs,
+                                               const std::string& config) const
 {
   XamlData data;
   IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData)
-      srcs = data.ExpectedXamlSources;
+  srcs = data.ExpectedXamlSources;
 }
 
 std::set<cmLinkItem> const& cmGeneratorTarget::GetUtilityItems() const
 {
-  if(!this->UtilityItemsDone)
-    {
+  if (!this->UtilityItemsDone) {
     this->UtilityItemsDone = true;
     std::set<std::string> const& utilities = this->GetUtilities();
-    for(std::set<std::string>::const_iterator i = utilities.begin();
-        i != utilities.end(); ++i)
-      {
+    for (std::set<std::string>::const_iterator i = utilities.begin();
+         i != utilities.end(); ++i) {
       cmGeneratorTarget* gt =
-          this->LocalGenerator->FindGeneratorTargetToUse(*i);
+        this->LocalGenerator->FindGeneratorTargetToUse(*i);
       this->UtilityItems.insert(cmLinkItem(*i, gt));
-      }
     }
+  }
   return this->UtilityItems;
 }
 
-void cmGeneratorTarget
-::GetXamlSources(std::vector<cmSourceFile const*>& srcs,
-                 const std::string& config) const
+void cmGeneratorTarget::GetXamlSources(std::vector<cmSourceFile const*>& srcs,
+                                       const std::string& config) const
 {
   XamlData data;
   IMPLEMENT_VISIT_IMPL(Xaml, COMMA cmGeneratorTarget::XamlData)
@@ -792,31 +719,28 @@ void cmGeneratorTarget
 const char* cmGeneratorTarget::GetLocation(const std::string& config) const
 {
   static std::string location;
-  if (this->IsImported())
-    {
+  if (this->IsImported()) {
     location = this->Target->ImportedGetFullPath(config, false);
-    }
-  else
-    {
+  } else {
     location = this->GetFullPath(config, false);
-    }
+  }
   return location.c_str();
 }
 
-std::vector<cmCustomCommand> const&
-cmGeneratorTarget::GetPreBuildCommands() const
+std::vector<cmCustomCommand> const& cmGeneratorTarget::GetPreBuildCommands()
+  const
 {
   return this->Target->GetPreBuildCommands();
 }
 
-std::vector<cmCustomCommand> const&
-cmGeneratorTarget::GetPreLinkCommands() const
+std::vector<cmCustomCommand> const& cmGeneratorTarget::GetPreLinkCommands()
+  const
 {
   return this->Target->GetPreLinkCommands();
 }
 
-std::vector<cmCustomCommand> const&
-cmGeneratorTarget::GetPostBuildCommands() const
+std::vector<cmCustomCommand> const& cmGeneratorTarget::GetPostBuildCommands()
+  const
 {
   return this->Target->GetPostBuildCommands();
 }
@@ -834,94 +758,83 @@ bool cmGeneratorTarget::IsImportedGloballyVisible() const
 const char* cmGeneratorTarget::GetLocationForBuild() const
 {
   static std::string location;
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     location = this->Target->ImportedGetFullPath("", false);
     return location.c_str();
-    }
+  }
 
   // Now handle the deprecated build-time configuration location.
   location = this->GetDirectory();
   const char* cfgid = this->Makefile->GetDefinition("CMAKE_CFG_INTDIR");
-  if(cfgid && strcmp(cfgid, ".") != 0)
-    {
+  if (cfgid && strcmp(cfgid, ".") != 0) {
     location += "/";
     location += cfgid;
-    }
+  }
 
-  if(this->IsAppBundleOnApple())
-    {
-    std::string macdir = this->BuildMacContentDirectory("", "",
-                                                                false);
-    if(!macdir.empty())
-      {
+  if (this->IsAppBundleOnApple()) {
+    std::string macdir = this->BuildMacContentDirectory("", "", false);
+    if (!macdir.empty()) {
       location += "/";
       location += macdir;
-      }
     }
+  }
   location += "/";
   location += this->GetFullName("", false);
   return location.c_str();
 }
 
-
-bool cmGeneratorTarget::IsSystemIncludeDirectory(const std::string& dir,
-                                              const std::string& config) const
+bool cmGeneratorTarget::IsSystemIncludeDirectory(
+  const std::string& dir, const std::string& config) const
 {
   assert(this->GetType() != cmState::INTERFACE_LIBRARY);
   std::string config_upper;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     config_upper = cmSystemTools::UpperCase(config);
-    }
+  }
 
   typedef std::map<std::string, std::vector<std::string> > IncludeCacheType;
   IncludeCacheType::const_iterator iter =
-      this->SystemIncludesCache.find(config_upper);
+    this->SystemIncludesCache.find(config_upper);
 
-  if (iter == this->SystemIncludesCache.end())
-    {
+  if (iter == this->SystemIncludesCache.end()) {
     cmGeneratorExpressionDAGChecker dagChecker(
-                                        this->GetName(),
-                                        "SYSTEM_INCLUDE_DIRECTORIES", 0, 0);
+      this->GetName(), "SYSTEM_INCLUDE_DIRECTORIES", 0, 0);
 
-    bool excludeImported
-                = this->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED");
+    bool excludeImported = this->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED");
 
     std::vector<std::string> result;
-    for (std::set<std::string>::const_iterator
-        it = this->Target->GetSystemIncludeDirectories().begin();
-        it != this->Target->GetSystemIncludeDirectories().end(); ++it)
-      {
+    for (std::set<std::string>::const_iterator it =
+           this->Target->GetSystemIncludeDirectories().begin();
+         it != this->Target->GetSystemIncludeDirectories().end(); ++it) {
       cmGeneratorExpression ge;
-      cmSystemTools::ExpandListArgument(ge.Parse(*it)
-                                          ->Evaluate(this->LocalGenerator,
-                                          config, false, this,
-                                          &dagChecker), result);
-      }
+      cmSystemTools::ExpandListArgument(
+        ge.Parse(*it)->Evaluate(this->LocalGenerator, config, false, this,
+                                &dagChecker),
+        result);
+    }
 
     std::vector<cmGeneratorTarget const*> const& deps =
       this->GetLinkImplementationClosure(config);
-    for(std::vector<cmGeneratorTarget const*>::const_iterator
-          li = deps.begin(), le = deps.end(); li != le; ++li)
-      {
+    for (std::vector<cmGeneratorTarget const *>::const_iterator
+           li = deps.begin(),
+           le = deps.end();
+         li != le; ++li) {
       handleSystemIncludesDep(this->LocalGenerator, *li, config, this,
                               &dagChecker, result, excludeImported);
-      }
+    }
 
     std::set<std::string> unique;
-    for(std::vector<std::string>::iterator li = result.begin();
-        li != result.end(); ++li)
-      {
+    for (std::vector<std::string>::iterator li = result.begin();
+         li != result.end(); ++li) {
       cmSystemTools::ConvertToUnixSlashes(*li);
       unique.insert(*li);
-      }
+    }
     result.clear();
     result.insert(result.end(), unique.begin(), unique.end());
 
     IncludeCacheType::value_type entry(config_upper, result);
     iter = this->SystemIncludesCache.insert(entry).first;
-    }
+  }
 
   return std::binary_search(iter->second.begin(), iter->second.end(), dir);
 }
@@ -936,128 +849,111 @@ static void AddInterfaceEntries(
   std::string const& prop,
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries)
 {
-  if(cmLinkImplementationLibraries const* impl =
-     thisTarget->GetLinkImplementationLibraries(config))
-    {
+  if (cmLinkImplementationLibraries const* impl =
+        thisTarget->GetLinkImplementationLibraries(config)) {
     for (std::vector<cmLinkImplItem>::const_iterator
-           it = impl->Libraries.begin(), end = impl->Libraries.end();
-         it != end; ++it)
-      {
-      if(it->Target)
-        {
-        std::string genex =
-          "$<TARGET_PROPERTY:" + *it + "," + prop + ">";
+           it = impl->Libraries.begin(),
+           end = impl->Libraries.end();
+         it != end; ++it) {
+      if (it->Target) {
+        std::string genex = "$<TARGET_PROPERTY:" + *it + "," + prop + ">";
         cmGeneratorExpression ge(it->Backtrace);
         cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex);
         cge->SetEvaluateForBuildsystem(true);
         entries.push_back(
           new cmGeneratorTarget::TargetPropertyEntry(cge, *it));
-        }
       }
     }
+  }
 }
 
-static bool processSources(cmGeneratorTarget const* tgt,
-      const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries,
-      std::vector<std::string> &srcs,
-      UNORDERED_SET<std::string> &uniqueSrcs,
-      cmGeneratorExpressionDAGChecker *dagChecker,
-      std::string const& config, bool debugSources)
+static bool processSources(
+  cmGeneratorTarget const* tgt,
+  const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
+  std::vector<std::string>& srcs, UNORDERED_SET<std::string>& uniqueSrcs,
+  cmGeneratorExpressionDAGChecker* dagChecker, std::string const& config,
+  bool debugSources)
 {
-  cmMakefile *mf = tgt->Target->GetMakefile();
+  cmMakefile* mf = tgt->Target->GetMakefile();
 
   bool contextDependent = false;
 
-  for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator
-      it = entries.begin(), end = entries.end(); it != end; ++it)
-    {
+  for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
+         it = entries.begin(),
+         end = entries.end();
+       it != end; ++it) {
     cmLinkImplItem const& item = (*it)->LinkImplItem;
     std::string const& targetName = item;
     std::vector<std::string> entrySources;
-    cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(
-                                              tgt->GetLocalGenerator(),
-                                              config,
-                                              false,
-                                              tgt,
-                                              tgt,
-                                              dagChecker),
-                                    entrySources);
-
-    if ((*it)->ge->GetHadContextSensitiveCondition())
-      {
+    cmSystemTools::ExpandListArgument(
+      (*it)->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt, tgt,
+                          dagChecker),
+      entrySources);
+
+    if ((*it)->ge->GetHadContextSensitiveCondition()) {
       contextDependent = true;
-      }
+    }
 
-    for(std::vector<std::string>::iterator i = entrySources.begin();
-        i != entrySources.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = entrySources.begin();
+         i != entrySources.end(); ++i) {
       std::string& src = *i;
       cmSourceFile* sf = mf->GetOrCreateSource(src);
       std::string e;
       std::string fullPath = sf->GetFullPath(&e);
-      if(fullPath.empty())
-        {
-        if(!e.empty())
-          {
+      if (fullPath.empty()) {
+        if (!e.empty()) {
           cmake* cm = tgt->GetLocalGenerator()->GetCMakeInstance();
-          cm->IssueMessage(cmake::FATAL_ERROR, e,
-                          tgt->GetBacktrace());
-          }
-        return contextDependent;
+          cm->IssueMessage(cmake::FATAL_ERROR, e, tgt->GetBacktrace());
         }
+        return contextDependent;
+      }
 
-      if (!targetName.empty() && !cmSystemTools::FileIsFullPath(src.c_str()))
-        {
+      if (!targetName.empty() && !cmSystemTools::FileIsFullPath(src.c_str())) {
         std::ostringstream err;
-        if (!targetName.empty())
-          {
-          err << "Target \"" << targetName << "\" contains relative "
-            "path in its INTERFACE_SOURCES:\n"
-            "  \"" << src << "\"";
-          }
-        else
-          {
+        if (!targetName.empty()) {
+          err << "Target \"" << targetName
+              << "\" contains relative "
+                 "path in its INTERFACE_SOURCES:\n"
+                 "  \""
+              << src << "\"";
+        } else {
           err << "Found relative path while evaluating sources of "
-          "\"" << tgt->GetName() << "\":\n  \"" << src << "\"\n";
-          }
+                 "\""
+              << tgt->GetName() << "\":\n  \"" << src << "\"\n";
+        }
         tgt->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, err.str());
         return contextDependent;
-        }
-      src = fullPath;
       }
+      src = fullPath;
+    }
     std::string usedSources;
-    for(std::vector<std::string>::iterator
-          li = entrySources.begin(); li != entrySources.end(); ++li)
-      {
+    for (std::vector<std::string>::iterator li = entrySources.begin();
+         li != entrySources.end(); ++li) {
       std::string src = *li;
 
-      if(uniqueSrcs.insert(src).second)
-        {
+      if (uniqueSrcs.insert(src).second) {
         srcs.push_back(src);
-        if (debugSources)
-          {
+        if (debugSources) {
           usedSources += " * " + src + "\n";
-          }
         }
       }
-    if (!usedSources.empty())
-      {
-      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG,
-                            std::string("Used sources for target ")
-                            + tgt->GetName() + ":\n"
-                            + usedSources, (*it)->ge->GetBacktrace());
-      }
     }
+    if (!usedSources.empty()) {
+      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
+        cmake::LOG, std::string("Used sources for target ") + tgt->GetName() +
+          ":\n" + usedSources,
+        (*it)->ge->GetBacktrace());
+    }
+  }
   return contextDependent;
 }
 
-void cmGeneratorTarget::GetSourceFiles(std::vector<std::string> &files,
-                              const std::string& config) const
+void cmGeneratorTarget::GetSourceFiles(std::vector<std::string>& files,
+                                       const std::string& config) const
 {
   assert(this->GetType() != cmState::INTERFACE_LIBRARY);
 
-  if (!this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026())
-    {
+  if (!this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) {
     // At configure-time, this method can be called as part of getting the
     // LOCATION property or to export() a file to be include()d.  However
     // there is no cmGeneratorTarget at configure-time, so search the SOURCES
@@ -1065,125 +961,99 @@ void cmGeneratorTarget::GetSourceFiles(std::vector<std::string> &files,
     // behavior of CMP0024 and CMP0026 only.
 
     cmStringRange sourceEntries = this->Target->GetSourceEntries();
-    for(cmStringRange::const_iterator
-          i = sourceEntries.begin();
-        i != sourceEntries.end(); ++i)
-      {
+    for (cmStringRange::const_iterator i = sourceEntries.begin();
+         i != sourceEntries.end(); ++i) {
       std::string const& entry = *i;
 
       std::vector<std::string> items;
       cmSystemTools::ExpandListArgument(entry, items);
-      for (std::vector<std::string>::const_iterator
-          li = items.begin(); li != items.end(); ++li)
-        {
-        if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
-            (*li)[li->size() - 1] == '>')
-          {
+      for (std::vector<std::string>::const_iterator li = items.begin();
+           li != items.end(); ++li) {
+        if (cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
+            (*li)[li->size() - 1] == '>') {
           continue;
-          }
-        files.push_back(*li);
         }
+        files.push_back(*li);
       }
-    return;
     }
+    return;
+  }
 
   std::vector<std::string> debugProperties;
-  const char *debugProp =
-              this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
-  if (debugProp)
-    {
+  const char* debugProp =
+    this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
+  if (debugProp) {
     cmSystemTools::ExpandListArgument(debugProp, debugProperties);
-    }
+  }
 
-  bool debugSources = !this->DebugSourcesDone
-                    && std::find(debugProperties.begin(),
-                                 debugProperties.end(),
-                                 "SOURCES")
-                        != debugProperties.end();
+  bool debugSources = !this->DebugSourcesDone &&
+    std::find(debugProperties.begin(), debugProperties.end(), "SOURCES") !=
+      debugProperties.end();
 
-  if (this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026())
-    {
+  if (this->LocalGenerator->GetGlobalGenerator()->GetConfigureDoneCMP0026()) {
     this->DebugSourcesDone = true;
-    }
+  }
 
-  cmGeneratorExpressionDAGChecker dagChecker(this->GetName(),
-                                             "SOURCES", 0, 0);
+  cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), "SOURCES", 0, 0);
 
   UNORDERED_SET<std::string> uniqueSrcs;
-  bool contextDependentDirectSources = processSources(this,
-                 this->SourceEntries,
-                 files,
-                 uniqueSrcs,
-                 &dagChecker,
-                 config,
-                 debugSources);
+  bool contextDependentDirectSources =
+    processSources(this, this->SourceEntries, files, uniqueSrcs, &dagChecker,
+                   config, debugSources);
 
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>
     linkInterfaceSourcesEntries;
 
-  AddInterfaceEntries(
-    this, config, "INTERFACE_SOURCES",
-    linkInterfaceSourcesEntries);
+  AddInterfaceEntries(this, config, "INTERFACE_SOURCES",
+                      linkInterfaceSourcesEntries);
 
   std::vector<std::string>::size_type numFilesBefore = files.size();
-  bool contextDependentInterfaceSources = processSources(this,
-    linkInterfaceSourcesEntries,
-                            files,
-                            uniqueSrcs,
-                            &dagChecker,
-                            config,
-                            debugSources);
-
-  if (!contextDependentDirectSources
-      && !(contextDependentInterfaceSources && numFilesBefore < files.size()))
-    {
+  bool contextDependentInterfaceSources =
+    processSources(this, linkInterfaceSourcesEntries, files, uniqueSrcs,
+                   &dagChecker, config, debugSources);
+
+  if (!contextDependentDirectSources &&
+      !(contextDependentInterfaceSources && numFilesBefore < files.size())) {
     this->LinkImplementationLanguageIsContextDependent = false;
-    }
+  }
 
   cmDeleteAll(linkInterfaceSourcesEntries);
 }
 
-void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*> &files,
+void cmGeneratorTarget::GetSourceFiles(std::vector<cmSourceFile*>& files,
                                        const std::string& config) const
 {
 
   // Lookup any existing link implementation for this configuration.
   std::string key = cmSystemTools::UpperCase(config);
 
-  if(!this->LinkImplementationLanguageIsContextDependent)
-    {
+  if (!this->LinkImplementationLanguageIsContextDependent) {
     files = this->SourceFilesMap.begin()->second;
     return;
-    }
+  }
 
-  SourceFilesMapType::iterator
-    it = this->SourceFilesMap.find(key);
-  if(it != this->SourceFilesMap.end())
-    {
+  SourceFilesMapType::iterator it = this->SourceFilesMap.find(key);
+  if (it != this->SourceFilesMap.end()) {
     files = it->second;
-    }
-  else
-    {
+  } else {
     std::vector<std::string> srcs;
     this->GetSourceFiles(srcs, config);
 
     std::set<cmSourceFile*> emitted;
 
-    for(std::vector<std::string>::const_iterator i = srcs.begin();
-        i != srcs.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = srcs.begin();
+         i != srcs.end(); ++i) {
       cmSourceFile* sf = this->Makefile->GetOrCreateSource(*i);
-      if (emitted.insert(sf).second)
-        {
+      if (emitted.insert(sf).second) {
         files.push_back(sf);
-        }
       }
-    this->SourceFilesMap[key] = files;
     }
+    this->SourceFilesMap[key] = files;
+  }
 }
 
-std::string
-cmGeneratorTarget::GetCompilePDBName(const std::string& config) const
+std::string cmGeneratorTarget::GetCompilePDBName(
+  const std::string& config) const
 {
   std::string prefix;
   std::string base;
@@ -1195,33 +1065,29 @@ cmGeneratorTarget::GetCompilePDBName(const std::string& config) const
   std::string configProp = "COMPILE_PDB_NAME_";
   configProp += configUpper;
   const char* config_name = this->GetProperty(configProp);
-  if(config_name && *config_name)
-    {
+  if (config_name && *config_name) {
     return prefix + config_name + ".pdb";
-    }
+  }
 
   const char* name = this->GetProperty("COMPILE_PDB_NAME");
-  if(name && *name)
-    {
+  if (name && *name) {
     return prefix + name + ".pdb";
-    }
+  }
 
   return "";
 }
 
-std::string
-cmGeneratorTarget::GetCompilePDBPath(const std::string& config) const
+std::string cmGeneratorTarget::GetCompilePDBPath(
+  const std::string& config) const
 {
   std::string dir = this->GetCompilePDBDirectory(config);
   std::string name = this->GetCompilePDBName(config);
-  if(dir.empty() && !name.empty())
-    {
+  if (dir.empty() && !name.empty()) {
     dir = this->GetPDBDirectory(config);
-    }
-  if(!dir.empty())
-    {
+  }
+  if (!dir.empty()) {
     dir += "/";
-    }
+  }
   return dir + name;
 }
 
@@ -1234,230 +1100,189 @@ bool cmGeneratorTarget::HasSOName(const std::string& config) const
           this->Makefile->GetSONameFlag(this->GetLinkerLanguage(config)));
 }
 
-bool
-cmGeneratorTarget::NeedRelinkBeforeInstall(const std::string& config) const
+bool cmGeneratorTarget::NeedRelinkBeforeInstall(
+  const std::string& config) const
 {
   // Only executables and shared libraries can have an rpath and may
   // need relinking.
-  if(this->GetType() != cmState::EXECUTABLE &&
-     this->GetType() != cmState::SHARED_LIBRARY &&
-     this->GetType() != cmState::MODULE_LIBRARY)
-    {
+  if (this->GetType() != cmState::EXECUTABLE &&
+      this->GetType() != cmState::SHARED_LIBRARY &&
+      this->GetType() != cmState::MODULE_LIBRARY) {
     return false;
-    }
+  }
 
   // If there is no install location this target will not be installed
   // and therefore does not need relinking.
-  if(!this->Target->GetHaveInstallRule())
-    {
+  if (!this->Target->GetHaveInstallRule()) {
     return false;
-    }
+  }
 
   // If skipping all rpaths completely then no relinking is needed.
-  if(this->Makefile->IsOn("CMAKE_SKIP_RPATH"))
-    {
+  if (this->Makefile->IsOn("CMAKE_SKIP_RPATH")) {
     return false;
-    }
+  }
 
   // If building with the install-tree rpath no relinking is needed.
-  if(this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"))
-    {
+  if (this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")) {
     return false;
-    }
+  }
 
   // If chrpath is going to be used no relinking is needed.
-  if(this->IsChrpathUsed(config))
-    {
+  if (this->IsChrpathUsed(config)) {
     return false;
-    }
+  }
 
   // Check for rpath support on this platform.
   std::string ll = this->GetLinkerLanguage(config);
-  if(!ll.empty())
-    {
+  if (!ll.empty()) {
     std::string flagVar = "CMAKE_SHARED_LIBRARY_RUNTIME_";
     flagVar += ll;
     flagVar += "_FLAG";
-    if(!this->Makefile->IsSet(flagVar))
-      {
+    if (!this->Makefile->IsSet(flagVar)) {
       // There is no rpath support on this platform so nothing needs
       // relinking.
       return false;
-      }
     }
-  else
-    {
+  } else {
     // No linker language is known.  This error will be reported by
     // other code.
     return false;
-    }
+  }
 
   // If either a build or install tree rpath is set then the rpath
   // will likely change between the build tree and install tree and
   // this target must be relinked.
-  return this->HaveBuildTreeRPATH(config)
-      || this->HaveInstallTreeRPATH();
+  return this->HaveBuildTreeRPATH(config) || this->HaveInstallTreeRPATH();
 }
 
 bool cmGeneratorTarget::IsChrpathUsed(const std::string& config) const
 {
   // Only certain target types have an rpath.
-  if(!(this->GetType() == cmState::SHARED_LIBRARY ||
-       this->GetType() == cmState::MODULE_LIBRARY ||
-       this->GetType() == cmState::EXECUTABLE))
-    {
+  if (!(this->GetType() == cmState::SHARED_LIBRARY ||
+        this->GetType() == cmState::MODULE_LIBRARY ||
+        this->GetType() == cmState::EXECUTABLE)) {
     return false;
-    }
+  }
 
   // If the target will not be installed we do not need to change its
   // rpath.
-  if(!this->Target->GetHaveInstallRule())
-    {
+  if (!this->Target->GetHaveInstallRule()) {
     return false;
-    }
+  }
 
   // Skip chrpath if skipping rpath altogether.
-  if(this->Makefile->IsOn("CMAKE_SKIP_RPATH"))
-    {
+  if (this->Makefile->IsOn("CMAKE_SKIP_RPATH")) {
     return false;
-    }
+  }
 
   // Skip chrpath if it does not need to be changed at install time.
-  if(this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"))
-    {
+  if (this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")) {
     return false;
-    }
+  }
 
   // Allow the user to disable builtin chrpath explicitly.
-  if(this->Makefile->IsOn("CMAKE_NO_BUILTIN_CHRPATH"))
-    {
+  if (this->Makefile->IsOn("CMAKE_NO_BUILTIN_CHRPATH")) {
     return false;
-    }
+  }
 
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
     return true;
-    }
+  }
 
 #if defined(CMAKE_USE_ELF_PARSER)
   // Enable if the rpath flag uses a separator and the target uses ELF
   // binaries.
   std::string ll = this->GetLinkerLanguage(config);
-  if(!ll.empty())
-    {
+  if (!ll.empty()) {
     std::string sepVar = "CMAKE_SHARED_LIBRARY_RUNTIME_";
     sepVar += ll;
     sepVar += "_FLAG_SEP";
     const char* sep = this->Makefile->GetDefinition(sepVar);
-    if(sep && *sep)
-      {
+    if (sep && *sep) {
       // TODO: Add ELF check to ABI detection and get rid of
       // CMAKE_EXECUTABLE_FORMAT.
-      if(const char* fmt =
-         this->Makefile->GetDefinition("CMAKE_EXECUTABLE_FORMAT"))
-        {
+      if (const char* fmt =
+            this->Makefile->GetDefinition("CMAKE_EXECUTABLE_FORMAT")) {
         return strcmp(fmt, "ELF") == 0;
-        }
       }
     }
+  }
 #endif
   static_cast<void>(config);
   return false;
 }
 
 bool cmGeneratorTarget::IsImportedSharedLibWithoutSOName(
-                                          const std::string& config) const
+  const std::string& config) const
 {
-  if(this->IsImported() && this->GetType() == cmState::SHARED_LIBRARY)
-    {
-    if(cmGeneratorTarget::ImportInfo const* info =
-       this->GetImportInfo(config))
-      {
+  if (this->IsImported() && this->GetType() == cmState::SHARED_LIBRARY) {
+    if (cmGeneratorTarget::ImportInfo const* info =
+          this->GetImportInfo(config)) {
       return info->NoSOName;
-      }
     }
+  }
   return false;
 }
 
 bool cmGeneratorTarget::HasMacOSXRpathInstallNameDir(
-    const std::string& config) const
+  const std::string& config) const
 {
   bool install_name_is_rpath = false;
   bool macosx_rpath = false;
 
-  if(!this->IsImported())
-    {
-    if(this->GetType() != cmState::SHARED_LIBRARY)
-      {
+  if (!this->IsImported()) {
+    if (this->GetType() != cmState::SHARED_LIBRARY) {
       return false;
-      }
+    }
     const char* install_name = this->GetProperty("INSTALL_NAME_DIR");
     bool use_install_name =
       this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH");
-    if(install_name && use_install_name &&
-       std::string(install_name) == "@rpath")
-      {
+    if (install_name && use_install_name &&
+        std::string(install_name) == "@rpath") {
       install_name_is_rpath = true;
-      }
-    else if(install_name && use_install_name)
-      {
+    } else if (install_name && use_install_name) {
       return false;
-      }
-    if(!install_name_is_rpath)
-      {
+    }
+    if (!install_name_is_rpath) {
       macosx_rpath = this->MacOSXRpathInstallNameDirDefault();
-      }
     }
-  else
-    {
+  } else {
     // Lookup the imported soname.
-    if(cmGeneratorTarget::ImportInfo const* info =
-       this->GetImportInfo(config))
-      {
-      if(!info->NoSOName && !info->SOName.empty())
-        {
-        if(info->SOName.find("@rpath/") == 0)
-          {
+    if (cmGeneratorTarget::ImportInfo const* info =
+          this->GetImportInfo(config)) {
+      if (!info->NoSOName && !info->SOName.empty()) {
+        if (info->SOName.find("@rpath/") == 0) {
           install_name_is_rpath = true;
-          }
         }
-      else
-        {
+      } else {
         std::string install_name;
         cmSystemTools::GuessLibraryInstallName(info->Location, install_name);
-        if(install_name.find("@rpath") != std::string::npos)
-          {
+        if (install_name.find("@rpath") != std::string::npos) {
           install_name_is_rpath = true;
-          }
         }
       }
     }
+  }
 
-  if(!install_name_is_rpath && !macosx_rpath)
-    {
+  if (!install_name_is_rpath && !macosx_rpath) {
     return false;
-    }
+  }
 
-  if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG"))
-    {
+  if (!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) {
     std::ostringstream w;
     w << "Attempting to use";
-    if(macosx_rpath)
-      {
+    if (macosx_rpath) {
       w << " MACOSX_RPATH";
-      }
-    else
-      {
+    } else {
       w << " @rpath";
-      }
+    }
     w << " without CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG being set.";
     w << "  This could be because you are using a Mac OS X version";
     w << " less than 10.5 or because CMake's platform configuration is";
     w << " corrupt.";
     cmake* cm = this->LocalGenerator->GetCMakeInstance();
-    cm->IssueMessage(cmake::FATAL_ERROR, w.str(),
-                     this->GetBacktrace());
-    }
+    cm->IssueMessage(cmake::FATAL_ERROR, w.str(), this->GetBacktrace());
+  }
 
   return true;
 }
@@ -1465,97 +1290,78 @@ bool cmGeneratorTarget::HasMacOSXRpathInstallNameDir(
 bool cmGeneratorTarget::MacOSXRpathInstallNameDirDefault() const
 {
   // we can't do rpaths when unsupported
-  if(!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG"))
-    {
+  if (!this->Makefile->IsSet("CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG")) {
     return false;
-    }
+  }
 
   const char* macosx_rpath_str = this->GetProperty("MACOSX_RPATH");
-  if(macosx_rpath_str)
-    {
+  if (macosx_rpath_str) {
     return this->GetPropertyAsBool("MACOSX_RPATH");
-    }
+  }
 
   cmPolicies::PolicyStatus cmp0042 = this->GetPolicyStatusCMP0042();
 
-  if(cmp0042 == cmPolicies::WARN)
-    {
-    this->LocalGenerator->GetGlobalGenerator()->
-      AddCMP0042WarnTarget(this->GetName());
-    }
+  if (cmp0042 == cmPolicies::WARN) {
+    this->LocalGenerator->GetGlobalGenerator()->AddCMP0042WarnTarget(
+      this->GetName());
+  }
 
-  if(cmp0042 == cmPolicies::NEW)
-    {
+  if (cmp0042 == cmPolicies::NEW) {
     return true;
-    }
+  }
 
   return false;
 }
 
 std::string cmGeneratorTarget::GetSOName(const std::string& config) const
 {
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     // Lookup the imported soname.
-    if(cmGeneratorTarget::ImportInfo const* info =
-       this->GetImportInfo(config))
-      {
-      if(info->NoSOName)
-        {
+    if (cmGeneratorTarget::ImportInfo const* info =
+          this->GetImportInfo(config)) {
+      if (info->NoSOName) {
         // The imported library has no builtin soname so the name
         // searched at runtime will be just the filename.
         return cmSystemTools::GetFilenameName(info->Location);
-        }
-      else
-        {
+      } else {
         // Use the soname given if any.
-        if(info->SOName.find("@rpath/") == 0)
-          {
+        if (info->SOName.find("@rpath/") == 0) {
           return info->SOName.substr(6);
-          }
-        return info->SOName;
         }
+        return info->SOName;
       }
-    else
-      {
+    } else {
       return "";
-      }
     }
-  else
-    {
+  } else {
     // Compute the soname that will be built.
     std::string name;
     std::string soName;
     std::string realName;
     std::string impName;
     std::string pdbName;
-    this->GetLibraryNames(name, soName, realName,
-                          impName, pdbName, config);
+    this->GetLibraryNames(name, soName, realName, impName, pdbName, config);
     return soName;
-    }
+  }
 }
 
-
-std::string
-cmGeneratorTarget::GetAppBundleDirectory(const std::string& config,
-                                         bool contentOnly) const
+std::string cmGeneratorTarget::GetAppBundleDirectory(const std::string& config,
+                                                     bool contentOnly) const
 {
   std::string fpath = this->GetFullName(config, false);
   fpath += ".app";
-  if(!this->Makefile->PlatformIsAppleIos())
-    {
+  if (!this->Makefile->PlatformIsAppleIos()) {
     fpath += "/Contents";
-    if(!contentOnly)
+    if (!contentOnly)
       fpath += "/MacOS";
-    }
+  }
   return fpath;
 }
 
 bool cmGeneratorTarget::IsBundleOnApple() const
 {
-  return this->IsFrameworkOnApple()
-      || this->IsAppBundleOnApple()
-      || this->IsCFBundleOnApple();
+  return this->IsFrameworkOnApple() || this->IsAppBundleOnApple() ||
+    this->IsCFBundleOnApple();
 }
 
 std::string cmGeneratorTarget::GetCFBundleDirectory(const std::string& config,
@@ -1564,119 +1370,94 @@ std::string cmGeneratorTarget::GetCFBundleDirectory(const std::string& config,
   std::string fpath;
   fpath += this->GetOutputName(config, false);
   fpath += ".";
-  const char *ext = this->GetProperty("BUNDLE_EXTENSION");
-  if (!ext)
-    {
-    if (this->IsXCTestOnApple())
-      {
+  const char* ext = this->GetProperty("BUNDLE_EXTENSION");
+  if (!ext) {
+    if (this->IsXCTestOnApple()) {
       ext = "xctest";
-      }
-    else
-      {
+    } else {
       ext = "bundle";
-      }
     }
+  }
   fpath += ext;
-  if(!this->Makefile->PlatformIsAppleIos())
-  {
+  if (!this->Makefile->PlatformIsAppleIos()) {
     fpath += "/Contents";
-    if(!contentOnly)
+    if (!contentOnly)
       fpath += "/MacOS";
   }
   return fpath;
 }
 
-std::string
-cmGeneratorTarget::GetFrameworkDirectory(const std::string& config,
-                                         bool rootDir) const
+std::string cmGeneratorTarget::GetFrameworkDirectory(const std::string& config,
+                                                     bool rootDir) const
 {
   std::string fpath;
   fpath += this->GetOutputName(config, false);
   fpath += ".framework";
-  if(!rootDir && !this->Makefile->PlatformIsAppleIos())
-    {
+  if (!rootDir && !this->Makefile->PlatformIsAppleIos()) {
     fpath += "/Versions/";
     fpath += this->GetFrameworkVersion();
-    }
+  }
   return fpath;
 }
 
-std::string
-cmGeneratorTarget::GetFullName(const std::string& config, bool implib) const
+std::string cmGeneratorTarget::GetFullName(const std::string& config,
+                                           bool implib) const
 {
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return this->GetFullNameImported(config, implib);
-    }
-  else
-    {
+  } else {
     return this->GetFullNameInternal(config, implib);
-    }
+  }
 }
 
-std::string
-cmGeneratorTarget::GetInstallNameDirForBuildTree(
-                                            const std::string& config) const
+std::string cmGeneratorTarget::GetInstallNameDirForBuildTree(
+  const std::string& config) const
 {
   // If building directly for installation then the build tree install_name
   // is the same as the install tree.
-  if(this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH"))
-    {
+  if (this->GetPropertyAsBool("BUILD_WITH_INSTALL_RPATH")) {
     return this->GetInstallNameDirForInstallTree();
-    }
+  }
 
   // Use the build tree directory for the target.
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME") &&
-     !this->Makefile->IsOn("CMAKE_SKIP_RPATH") &&
-     !this->GetPropertyAsBool("SKIP_BUILD_RPATH"))
-    {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME") &&
+      !this->Makefile->IsOn("CMAKE_SKIP_RPATH") &&
+      !this->GetPropertyAsBool("SKIP_BUILD_RPATH")) {
     std::string dir;
-    if(this->MacOSXRpathInstallNameDirDefault())
-      {
+    if (this->MacOSXRpathInstallNameDirDefault()) {
       dir = "@rpath";
-      }
-    else
-      {
+    } else {
       dir = this->GetDirectory(config);
-      }
+    }
     dir += "/";
     return dir;
-    }
-  else
-    {
+  } else {
     return "";
-    }
+  }
 }
 
 std::string cmGeneratorTarget::GetInstallNameDirForInstallTree() const
 {
-  if(this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
+  if (this->Makefile->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
     std::string dir;
     const char* install_name_dir = this->GetProperty("INSTALL_NAME_DIR");
 
-    if(!this->Makefile->IsOn("CMAKE_SKIP_RPATH") &&
-       !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH"))
-      {
-      if(install_name_dir && *install_name_dir)
-        {
+    if (!this->Makefile->IsOn("CMAKE_SKIP_RPATH") &&
+        !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH")) {
+      if (install_name_dir && *install_name_dir) {
         dir = install_name_dir;
         dir += "/";
-        }
       }
-    if(!install_name_dir)
-      {
-      if(this->MacOSXRpathInstallNameDirDefault())
-        {
+    }
+    if (!install_name_dir) {
+      if (this->MacOSXRpathInstallNameDirDefault()) {
         dir = "@rpath/";
-        }
       }
-    return dir;
     }
-  else
-    {
+    return dir;
+  } else {
     return "";
-    }
+  }
 }
 
 cmListFileBacktrace cmGeneratorTarget::GetBacktrace() const
@@ -1684,7 +1465,7 @@ cmListFileBacktrace cmGeneratorTarget::GetBacktrace() const
   return this->Target->GetBacktrace();
 }
 
-const std::vector<std::string>&cmGeneratorTarget::GetLinkDirectories() const
+const std::vector<std::string>& cmGeneratorTarget::GetLinkDirectories() const
 {
   return this->Target->GetLinkDirectories();
 }
@@ -1694,16 +1475,15 @@ const std::set<std::string>& cmGeneratorTarget::GetUtilities() const
   return this->Target->GetUtilities();
 }
 
-const cmListFileBacktrace*
-cmGeneratorTarget::GetUtilityBacktrace(const std::string& u) const
+const cmListFileBacktrace* cmGeneratorTarget::GetUtilityBacktrace(
+  const std::string& u) const
 {
   return this->Target->GetUtilityBacktrace(u);
 }
 
 bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const
 {
-  return
-    this->GetType() == cmState::STATIC_LIBRARY ||
+  return this->GetType() == cmState::STATIC_LIBRARY ||
     this->GetType() == cmState::SHARED_LIBRARY ||
     this->GetType() == cmState::MODULE_LIBRARY ||
     this->GetType() == cmState::EXECUTABLE;
@@ -1712,26 +1492,20 @@ bool cmGeneratorTarget::HaveWellDefinedOutputFiles() const
 const char* cmGeneratorTarget::GetExportMacro() const
 {
   // Define the symbol for targets that export symbols.
-  if(this->GetType() == cmState::SHARED_LIBRARY ||
-     this->GetType() == cmState::MODULE_LIBRARY ||
-     this->IsExecutableWithExports())
-    {
-    if(const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL"))
-      {
+  if (this->GetType() == cmState::SHARED_LIBRARY ||
+      this->GetType() == cmState::MODULE_LIBRARY ||
+      this->IsExecutableWithExports()) {
+    if (const char* custom_export_name = this->GetProperty("DEFINE_SYMBOL")) {
       this->ExportMacro = custom_export_name;
-      }
-    else
-      {
+    } else {
       std::string in = this->GetName();
       in += "_EXPORTS";
       this->ExportMacro = cmSystemTools::MakeCidentifier(in);
-      }
-    return this->ExportMacro.c_str();
     }
-  else
-    {
+    return this->ExportMacro.c_str();
+  } else {
     return 0;
-    }
+  }
 }
 
 class cmTargetCollectLinkLanguages
@@ -1740,29 +1514,28 @@ public:
   cmTargetCollectLinkLanguages(cmGeneratorTarget const* target,
                                const std::string& config,
                                UNORDERED_SET<std::string>& languages,
-                               cmGeneratorTarget const* head):
-    Config(config), Languages(languages), HeadTarget(head),
-    Target(target)
-  { this->Visited.insert(target); }
+                               cmGeneratorTarget const* head)
+    : Config(config)
+    , Languages(languages)
+    , HeadTarget(head)
+    , Target(target)
+  {
+    this->Visited.insert(target);
+  }
 
   void Visit(cmLinkItem const& item)
-    {
-    if(!item.Target)
-      {
-      if(item.find("::") != std::string::npos)
-        {
+  {
+    if (!item.Target) {
+      if (item.find("::") != std::string::npos) {
         bool noMessage = false;
         cmake::MessageType messageType = cmake::FATAL_ERROR;
         std::stringstream e;
-        switch(this->Target->GetLocalGenerator()
-               ->GetPolicyStatus(cmPolicies::CMP0028))
-          {
-          case cmPolicies::WARN:
-            {
+        switch (this->Target->GetLocalGenerator()->GetPolicyStatus(
+          cmPolicies::CMP0028)) {
+          case cmPolicies::WARN: {
             e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0028) << "\n";
             messageType = cmake::AUTHOR_WARNING;
-            }
-            break;
+          } break;
           case cmPolicies::OLD:
             noMessage = true;
           case cmPolicies::REQUIRED_IF_USED:
@@ -1770,41 +1543,41 @@ public:
           case cmPolicies::NEW:
             // Issue the fatal message.
             break;
-          }
+        }
 
-        if(!noMessage)
-          {
+        if (!noMessage) {
           e << "Target \"" << this->Target->GetName()
             << "\" links to target \"" << item
             << "\" but the target was not found.  Perhaps a find_package() "
-            "call is missing for an IMPORTED target, or an ALIAS target is "
-            "missing?";
+               "call is missing for an IMPORTED target, or an ALIAS target is "
+               "missing?";
           this->Target->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
             messageType, e.str(), this->Target->GetBacktrace());
-          }
         }
-      return;
       }
-    if(!this->Visited.insert(item.Target).second)
-      {
       return;
-      }
+    }
+    if (!this->Visited.insert(item.Target).second) {
+      return;
+    }
     cmLinkInterface const* iface =
       item.Target->GetLinkInterface(this->Config, this->HeadTarget);
-    if(!iface) { return; }
+    if (!iface) {
+      return;
+    }
 
-    for(std::vector<std::string>::const_iterator
-          li = iface->Languages.begin(); li != iface->Languages.end(); ++li)
-      {
+    for (std::vector<std::string>::const_iterator li =
+           iface->Languages.begin();
+         li != iface->Languages.end(); ++li) {
       this->Languages.insert(*li);
-      }
+    }
 
-    for(std::vector<cmLinkItem>::const_iterator
-          li = iface->Libraries.begin(); li != iface->Libraries.end(); ++li)
-      {
+    for (std::vector<cmLinkItem>::const_iterator li = iface->Libraries.begin();
+         li != iface->Libraries.end(); ++li) {
       this->Visit(*li);
-      }
     }
+  }
+
 private:
   std::string Config;
   UNORDERED_SET<std::string>& Languages;
@@ -1813,19 +1586,17 @@ private:
   std::set<cmGeneratorTarget const*> Visited;
 };
 
-cmGeneratorTarget::LinkClosure const*
-cmGeneratorTarget::GetLinkClosure(const std::string& config) const
+cmGeneratorTarget::LinkClosure const* cmGeneratorTarget::GetLinkClosure(
+  const std::string& config) const
 {
   std::string key(cmSystemTools::UpperCase(config));
-  LinkClosureMapType::iterator
-    i = this->LinkClosureMap.find(key);
-  if(i == this->LinkClosureMap.end())
-    {
+  LinkClosureMapType::iterator i = this->LinkClosureMap.find(key);
+  if (i == this->LinkClosureMap.end()) {
     LinkClosure lc;
     this->ComputeLinkClosure(config, lc);
     LinkClosureMapType::value_type entry(key, lc);
     i = this->LinkClosureMap.insert(entry).first;
-    }
+  }
   return &i->second;
 }
 
@@ -1835,49 +1606,45 @@ class cmTargetSelectLinker
   cmGeneratorTarget const* Target;
   cmGlobalGenerator* GG;
   std::set<std::string> Preferred;
+
 public:
   cmTargetSelectLinker(cmGeneratorTarget const* target)
-      : Preference(0), Target(target)
-    {
+    : Preference(0)
+    , Target(target)
+  {
     this->GG = this->Target->GetLocalGenerator()->GetGlobalGenerator();
-    }
+  }
   void Consider(const char* lang)
-    {
+  {
     int preference = this->GG->GetLinkerPreference(lang);
-    if(preference > this->Preference)
-      {
+    if (preference > this->Preference) {
       this->Preference = preference;
       this->Preferred.clear();
-      }
-    if(preference == this->Preference)
-      {
+    }
+    if (preference == this->Preference) {
       this->Preferred.insert(lang);
-      }
     }
+  }
   std::string Choose()
-    {
-    if(this->Preferred.empty())
-      {
+  {
+    if (this->Preferred.empty()) {
       return "";
-      }
-    else if(this->Preferred.size() > 1)
-      {
+    } else if (this->Preferred.size() > 1) {
       std::stringstream e;
       e << "Target " << this->Target->GetName()
         << " contains multiple languages with the highest linker preference"
         << " (" << this->Preference << "):\n";
-      for(std::set<std::string>::const_iterator
-            li = this->Preferred.begin(); li != this->Preferred.end(); ++li)
-        {
+      for (std::set<std::string>::const_iterator li = this->Preferred.begin();
+           li != this->Preferred.end(); ++li) {
         e << "  " << *li << "\n";
-        }
+      }
       e << "Set the LINKER_LANGUAGE property for this target.";
       cmake* cm = this->Target->GetLocalGenerator()->GetCMakeInstance();
       cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
                        this->Target->GetBacktrace());
-      }
-    return *this->Preferred.begin();
     }
+    return *this->Preferred.begin();
+  }
 };
 
 void cmGeneratorTarget::ComputeLinkClosure(const std::string& config,
@@ -1885,64 +1652,54 @@ void cmGeneratorTarget::ComputeLinkClosure(const std::string& config,
 {
   // Get languages built in this target.
   UNORDERED_SET<std::string> languages;
-  cmLinkImplementation const* impl =
-                            this->GetLinkImplementation(config);
+  cmLinkImplementation const* impl = this->GetLinkImplementation(config);
   assert(impl);
-  for(std::vector<std::string>::const_iterator li = impl->Languages.begin();
-      li != impl->Languages.end(); ++li)
-    {
+  for (std::vector<std::string>::const_iterator li = impl->Languages.begin();
+       li != impl->Languages.end(); ++li) {
     languages.insert(*li);
-    }
+  }
 
   // Add interface languages from linked targets.
   cmTargetCollectLinkLanguages cll(this, config, languages, this);
-  for(std::vector<cmLinkImplItem>::const_iterator li = impl->Libraries.begin();
-      li != impl->Libraries.end(); ++li)
-    {
+  for (std::vector<cmLinkImplItem>::const_iterator li =
+         impl->Libraries.begin();
+       li != impl->Libraries.end(); ++li) {
     cll.Visit(*li);
-    }
+  }
 
   // Store the transitive closure of languages.
-  for(UNORDERED_SET<std::string>::const_iterator li = languages.begin();
-      li != languages.end(); ++li)
-    {
+  for (UNORDERED_SET<std::string>::const_iterator li = languages.begin();
+       li != languages.end(); ++li) {
     lc.Languages.push_back(*li);
-    }
+  }
 
   // Choose the language whose linker should be used.
-  if(this->GetProperty("HAS_CXX"))
-    {
+  if (this->GetProperty("HAS_CXX")) {
     lc.LinkerLanguage = "CXX";
-    }
-  else if(const char* linkerLang = this->GetProperty("LINKER_LANGUAGE"))
-    {
+  } else if (const char* linkerLang = this->GetProperty("LINKER_LANGUAGE")) {
     lc.LinkerLanguage = linkerLang;
-    }
-  else
-    {
+  } else {
     // Find the language with the highest preference value.
     cmTargetSelectLinker tsl(this);
 
     // First select from the languages compiled directly in this target.
-    for(std::vector<std::string>::const_iterator li = impl->Languages.begin();
-        li != impl->Languages.end(); ++li)
-      {
+    for (std::vector<std::string>::const_iterator li = impl->Languages.begin();
+         li != impl->Languages.end(); ++li) {
       tsl.Consider(li->c_str());
-      }
+    }
 
     // Now consider languages that propagate from linked targets.
-    for(UNORDERED_SET<std::string>::const_iterator sit = languages.begin();
-        sit != languages.end(); ++sit)
-      {
-      std::string propagates = "CMAKE_"+*sit+"_LINKER_PREFERENCE_PROPAGATES";
-      if(this->Makefile->IsOn(propagates))
-        {
+    for (UNORDERED_SET<std::string>::const_iterator sit = languages.begin();
+         sit != languages.end(); ++sit) {
+      std::string propagates =
+        "CMAKE_" + *sit + "_LINKER_PREFERENCE_PROPAGATES";
+      if (this->Makefile->IsOn(propagates)) {
         tsl.Consider(sit->c_str());
-        }
       }
+    }
 
     lc.LinkerLanguage = tsl.Choose();
-    }
+  }
 }
 
 void cmGeneratorTarget::GetFullNameComponents(std::string& prefix,
@@ -1954,93 +1711,80 @@ void cmGeneratorTarget::GetFullNameComponents(std::string& prefix,
   this->GetFullNameInternal(config, implib, prefix, base, suffix);
 }
 
-std::string
-cmGeneratorTarget::BuildMacContentDirectory(const std::string& base,
-                                            const std::string& config,
-                                            bool contentOnly) const
+std::string cmGeneratorTarget::BuildMacContentDirectory(
+  const std::string& base, const std::string& config, bool contentOnly) const
 {
   std::string fpath = base;
-  if(this->IsAppBundleOnApple())
-    {
+  if (this->IsAppBundleOnApple()) {
     fpath += this->GetAppBundleDirectory(config, contentOnly);
-    }
-  if(this->IsFrameworkOnApple())
-    {
+  }
+  if (this->IsFrameworkOnApple()) {
     fpath += this->GetFrameworkDirectory(config, contentOnly);
-    }
-  if(this->IsCFBundleOnApple())
-    {
+  }
+  if (this->IsCFBundleOnApple()) {
     fpath += this->GetCFBundleDirectory(config, contentOnly);
-    }
+  }
   return fpath;
 }
 
-std::string
-cmGeneratorTarget::GetMacContentDirectory(const std::string& config,
-                                          bool implib) const
+std::string cmGeneratorTarget::GetMacContentDirectory(
+  const std::string& config, bool implib) const
 {
   // Start with the output directory for the target.
   std::string fpath = this->GetDirectory(config, implib);
   fpath += "/";
   bool contentOnly = true;
-  if(this->IsFrameworkOnApple())
-    {
+  if (this->IsFrameworkOnApple()) {
     // additional files with a framework go into the version specific
     // directory
     contentOnly = false;
-    }
+  }
   fpath = this->BuildMacContentDirectory(fpath, config, contentOnly);
   return fpath;
 }
 
-
 cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo(
-                                            const std::string& config) const
+  const std::string& config) const
 {
   // There is no compile information for imported targets.
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return 0;
-    }
+  }
 
-  if(this->GetType() > cmState::OBJECT_LIBRARY)
-    {
+  if (this->GetType() > cmState::OBJECT_LIBRARY) {
     std::string msg = "cmTarget::GetCompileInfo called for ";
     msg += this->GetName();
     msg += " which has type ";
     msg += cmState::GetTargetTypeName(this->GetType());
     this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg);
     return 0;
-    }
+  }
 
   // Lookup/compute/cache the compile information for this configuration.
   std::string config_upper;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     config_upper = cmSystemTools::UpperCase(config);
-    }
+  }
   CompileInfoMapType::const_iterator i =
     this->CompileInfoMap.find(config_upper);
-  if(i == this->CompileInfoMap.end())
-    {
+  if (i == this->CompileInfoMap.end()) {
     CompileInfo info;
     this->ComputePDBOutputDir("COMPILE_PDB", config, info.CompilePdbDir);
     CompileInfoMapType::value_type entry(config_upper, info);
     i = this->CompileInfoMap.insert(entry).first;
-    }
+  }
   return &i->second;
 }
 
-cmSourceFile const*
-cmGeneratorTarget::GetModuleDefinitionFile(const std::string& config) const
+cmSourceFile const* cmGeneratorTarget::GetModuleDefinitionFile(
+  const std::string& config) const
 {
   std::vector<cmSourceFile const*> data;
   IMPLEMENT_VISIT_IMPL(ModuleDefinitionFile,
                        COMMA std::vector<cmSourceFile const*>)
-  if(!data.empty())
-    {
+  if (!data.empty()) {
     return data.front();
-    }
+  }
 
   return 0;
 }
@@ -2050,115 +1794,97 @@ bool cmGeneratorTarget::IsDLLPlatform() const
   return this->DLLPlatform;
 }
 
-void
-cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs,
-                                      const std::string &config) const
+void cmGeneratorTarget::UseObjectLibraries(std::vector<std::string>& objs,
+                                           const std::string& config) const
 {
   std::vector<cmSourceFile const*> objectFiles;
   this->GetExternalObjects(objectFiles, config);
   std::vector<cmGeneratorTarget*> objectLibraries;
-  for(std::vector<cmSourceFile const*>::const_iterator
-      it = objectFiles.begin(); it != objectFiles.end(); ++it)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator it =
+         objectFiles.begin();
+       it != objectFiles.end(); ++it) {
     std::string objLib = (*it)->GetObjectLibrary();
     if (cmGeneratorTarget* tgt =
-        this->LocalGenerator->FindGeneratorTargetToUse(objLib))
-      {
+          this->LocalGenerator->FindGeneratorTargetToUse(objLib)) {
       objectLibraries.push_back(tgt);
-      }
     }
+  }
 
-  std::vector<cmGeneratorTarget*>::const_iterator end
-      = cmRemoveDuplicates(objectLibraries);
+  std::vector<cmGeneratorTarget*>::const_iterator end =
+    cmRemoveDuplicates(objectLibraries);
 
-  for(std::vector<cmGeneratorTarget*>::const_iterator
-        ti = objectLibraries.begin();
-      ti != end; ++ti)
-    {
+  for (std::vector<cmGeneratorTarget*>::const_iterator ti =
+         objectLibraries.begin();
+       ti != end; ++ti) {
     cmGeneratorTarget* ogt = *ti;
     std::vector<cmSourceFile const*> objectSources;
     ogt->GetObjectSources(objectSources, config);
-    for(std::vector<cmSourceFile const*>::const_iterator
-          si = objectSources.begin();
-        si != objectSources.end(); ++si)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator si =
+           objectSources.begin();
+         si != objectSources.end(); ++si) {
       std::string obj = ogt->ObjectDirectory;
       obj += ogt->Objects[*si];
       objs.push_back(obj);
-      }
     }
+  }
 }
 
-void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string> &result,
-                                 const std::string& config) const
+void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string>& result,
+                                          const std::string& config) const
 {
-  const char *prop
-            = this->GetLinkInterfaceDependentStringProperty("AUTOUIC_OPTIONS",
-                                                            config);
-  if (!prop)
-    {
+  const char* prop =
+    this->GetLinkInterfaceDependentStringProperty("AUTOUIC_OPTIONS", config);
+  if (!prop) {
     return;
-    }
+  }
   cmGeneratorExpression ge;
 
-  cmGeneratorExpressionDAGChecker dagChecker(
-                                      this->GetName(),
-                                      "AUTOUIC_OPTIONS", 0, 0);
-  cmSystemTools::ExpandListArgument(ge.Parse(prop)
-                                      ->Evaluate(this->LocalGenerator,
-                                                config,
-                                                false,
-                                                this,
-                                                &dagChecker),
-                                  result);
+  cmGeneratorExpressionDAGChecker dagChecker(this->GetName(),
+                                             "AUTOUIC_OPTIONS", 0, 0);
+  cmSystemTools::ExpandListArgument(
+    ge.Parse(prop)->Evaluate(this->LocalGenerator, config, false, this,
+                             &dagChecker),
+    result);
 }
 
 void processILibs(const std::string& config,
-                  cmGeneratorTarget const* headTarget,
-                  cmLinkItem const& item,
+                  cmGeneratorTarget const* headTarget, cmLinkItem const& item,
                   cmGlobalGenerator* gg,
                   std::vector<cmGeneratorTarget const*>& tgts,
                   std::set<cmGeneratorTarget const*>& emitted)
 {
-  if (item.Target && emitted.insert(item.Target).second)
-    {
+  if (item.Target && emitted.insert(item.Target).second) {
     tgts.push_back(item.Target);
-    if(cmLinkInterfaceLibraries const* iface =
-       item.Target->GetLinkInterfaceLibraries(config, headTarget, true))
-      {
-      for(std::vector<cmLinkItem>::const_iterator
-            it = iface->Libraries.begin();
-          it != iface->Libraries.end(); ++it)
-        {
+    if (cmLinkInterfaceLibraries const* iface =
+          item.Target->GetLinkInterfaceLibraries(config, headTarget, true)) {
+      for (std::vector<cmLinkItem>::const_iterator it =
+             iface->Libraries.begin();
+           it != iface->Libraries.end(); ++it) {
         processILibs(config, headTarget, *it, gg, tgts, emitted);
-        }
       }
     }
+  }
 }
 
 const std::vector<const cmGeneratorTarget*>&
 cmGeneratorTarget::GetLinkImplementationClosure(
-    const std::string& config) const
+  const std::string& config) const
 {
-  LinkImplClosure& tgts =
-    this->LinkImplClosureMap[config];
-  if(!tgts.Done)
-    {
+  LinkImplClosure& tgts = this->LinkImplClosureMap[config];
+  if (!tgts.Done) {
     tgts.Done = true;
     std::set<cmGeneratorTarget const*> emitted;
 
-    cmLinkImplementationLibraries const* impl
-      = this->GetLinkImplementationLibraries(config);
+    cmLinkImplementationLibraries const* impl =
+      this->GetLinkImplementationLibraries(config);
 
-    for(std::vector<cmLinkImplItem>::const_iterator
-          it = impl->Libraries.begin();
-        it != impl->Libraries.end(); ++it)
-      {
+    for (std::vector<cmLinkImplItem>::const_iterator it =
+           impl->Libraries.begin();
+         it != impl->Libraries.end(); ++it) {
       processILibs(config, this, *it,
-                   this->LocalGenerator->GetGlobalGenerator(),
-                   tgts , emitted);
-      }
+                   this->LocalGenerator->GetGlobalGenerator(), tgts, emitted);
     }
+  }
   return tgts;
 }
 
@@ -2167,6 +1893,7 @@ class cmTargetTraceDependencies
 public:
   cmTargetTraceDependencies(cmGeneratorTarget* target);
   void Trace();
+
 private:
   cmGeneratorTarget* GeneratorTarget;
   cmMakefile* Makefile;
@@ -2191,9 +1918,8 @@ private:
                             std::set<std::string>& emitted);
 };
 
-cmTargetTraceDependencies
-::cmTargetTraceDependencies(cmGeneratorTarget* target):
-  GeneratorTarget(target)
+cmTargetTraceDependencies::cmTargetTraceDependencies(cmGeneratorTarget* target)
+  : GeneratorTarget(target)
 {
   // Convenience.
   this->Makefile = target->Target->GetMakefile();
@@ -2202,78 +1928,66 @@ cmTargetTraceDependencies
   this->CurrentEntry = 0;
 
   // Queue all the source files already specified for the target.
-  if (target->GetType() != cmState::INTERFACE_LIBRARY)
-    {
+  if (target->GetType() != cmState::INTERFACE_LIBRARY) {
     std::vector<std::string> configs;
     this->Makefile->GetConfigurations(configs);
-    if (configs.empty())
-      {
+    if (configs.empty()) {
       configs.push_back("");
-      }
+    }
     std::set<cmSourceFile*> emitted;
-    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::vector<cmSourceFile*> sources;
       this->GeneratorTarget->GetSourceFiles(sources, *ci);
-      for(std::vector<cmSourceFile*>::const_iterator si = sources.begin();
-          si != sources.end(); ++si)
-        {
+      for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
+           si != sources.end(); ++si) {
         cmSourceFile* sf = *si;
         const std::set<cmGeneratorTarget const*> tgts =
-                          this->GlobalGenerator->GetFilenameTargetDepends(sf);
-        if (tgts.find(this->GeneratorTarget) != tgts.end())
-          {
+          this->GlobalGenerator->GetFilenameTargetDepends(sf);
+        if (tgts.find(this->GeneratorTarget) != tgts.end()) {
           std::ostringstream e;
           e << "Evaluation output file\n  \"" << sf->GetFullPath()
             << "\"\ndepends on the sources of a target it is used in.  This "
-              "is a dependency loop and is not allowed.";
-          this->GeneratorTarget
-              ->LocalGenerator->IssueMessage(cmake::FATAL_ERROR, e.str());
+               "is a dependency loop and is not allowed.";
+          this->GeneratorTarget->LocalGenerator->IssueMessage(
+            cmake::FATAL_ERROR, e.str());
           return;
-          }
-        if(emitted.insert(sf).second && this->SourcesQueued.insert(sf).second)
-          {
+        }
+        if (emitted.insert(sf).second &&
+            this->SourcesQueued.insert(sf).second) {
           this->SourceQueue.push(sf);
-          }
         }
       }
     }
+  }
 
   // Queue pre-build, pre-link, and post-build rule dependencies.
-  this->CheckCustomCommands(
-        this->GeneratorTarget->GetPreBuildCommands());
-  this->CheckCustomCommands(
-        this->GeneratorTarget->GetPreLinkCommands());
-  this->CheckCustomCommands(
-        this->GeneratorTarget->GetPostBuildCommands());
+  this->CheckCustomCommands(this->GeneratorTarget->GetPreBuildCommands());
+  this->CheckCustomCommands(this->GeneratorTarget->GetPreLinkCommands());
+  this->CheckCustomCommands(this->GeneratorTarget->GetPostBuildCommands());
 }
 
 void cmTargetTraceDependencies::Trace()
 {
   // Process one dependency at a time until the queue is empty.
-  while(!this->SourceQueue.empty())
-    {
+  while (!this->SourceQueue.empty()) {
     // Get the next source from the queue.
     cmSourceFile* sf = this->SourceQueue.front();
     this->SourceQueue.pop();
     this->CurrentEntry = &this->GeneratorTarget->SourceDepends[sf];
 
     // Queue dependencies added explicitly by the user.
-    if(const char* additionalDeps = sf->GetProperty("OBJECT_DEPENDS"))
-      {
+    if (const char* additionalDeps = sf->GetProperty("OBJECT_DEPENDS")) {
       std::vector<std::string> objDeps;
       cmSystemTools::ExpandListArgument(additionalDeps, objDeps);
-      for(std::vector<std::string>::iterator odi = objDeps.begin();
-          odi != objDeps.end(); ++odi)
-        {
-        if (cmSystemTools::FileIsFullPath(*odi))
-          {
+      for (std::vector<std::string>::iterator odi = objDeps.begin();
+           odi != objDeps.end(); ++odi) {
+        if (cmSystemTools::FileIsFullPath(*odi)) {
           *odi = cmSystemTools::CollapseFullPath(*odi);
-          }
         }
-      this->FollowNames(objDeps);
       }
+      this->FollowNames(objDeps);
+    }
 
     // Queue the source needed to generate this file, if any.
     this->FollowName(sf->GetFullPath());
@@ -2282,11 +1996,10 @@ void cmTargetTraceDependencies::Trace()
     this->FollowNames(sf->GetDepends());
 
     // Queue custom command dependencies.
-    if(cmCustomCommand const* cc = sf->GetCustomCommand())
-      {
+    if (cmCustomCommand const* cc = sf->GetCustomCommand()) {
       this->CheckCustomCommand(*cc);
-      }
     }
+  }
   this->CurrentEntry = 0;
 
   this->GeneratorTarget->AddTracedSources(this->NewSources);
@@ -2294,44 +2007,39 @@ void cmTargetTraceDependencies::Trace()
 
 void cmTargetTraceDependencies::QueueSource(cmSourceFile* sf)
 {
-  if(this->SourcesQueued.insert(sf).second)
-    {
+  if (this->SourcesQueued.insert(sf).second) {
     this->SourceQueue.push(sf);
 
     // Make sure this file is in the target at the end.
     this->NewSources.push_back(sf->GetFullPath());
-    }
+  }
 }
 
 void cmTargetTraceDependencies::FollowName(std::string const& name)
 {
   NameMapType::iterator i = this->NameMap.find(name);
-  if(i == this->NameMap.end())
-    {
+  if (i == this->NameMap.end()) {
     // Check if we know how to generate this file.
     cmSourceFile* sf = this->Makefile->GetSourceFileWithOutput(name);
     NameMapType::value_type entry(name, sf);
     i = this->NameMap.insert(entry).first;
-    }
-  if(cmSourceFile* sf = i->second)
-    {
+  }
+  if (cmSourceFile* sf = i->second) {
     // Record the dependency we just followed.
-    if(this->CurrentEntry)
-      {
+    if (this->CurrentEntry) {
       this->CurrentEntry->Depends.push_back(sf);
-      }
-    this->QueueSource(sf);
     }
+    this->QueueSource(sf);
+  }
 }
 
-void
-cmTargetTraceDependencies::FollowNames(std::vector<std::string> const& names)
+void cmTargetTraceDependencies::FollowNames(
+  std::vector<std::string> const& names)
 {
-  for(std::vector<std::string>::const_iterator i = names.begin();
-      i != names.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = names.begin();
+       i != names.end(); ++i) {
     this->FollowName(*i);
-    }
+  }
 }
 
 bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
@@ -2343,24 +2051,20 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
   // that case the target name will be the file basename of the
   // dependency.
   std::string util = cmSystemTools::GetFilenameName(dep);
-  if(cmSystemTools::GetFilenameLastExtension(util) == ".exe")
-    {
+  if (cmSystemTools::GetFilenameLastExtension(util) == ".exe") {
     util = cmSystemTools::GetFilenameWithoutLastExtension(util);
-    }
+  }
 
   // Check for a target with this name.
-  if(cmGeneratorTarget* t
-                    = this->GeneratorTarget->
-                    GetLocalGenerator()->FindGeneratorTargetToUse(util))
-    {
+  if (cmGeneratorTarget* t =
+        this->GeneratorTarget->GetLocalGenerator()->FindGeneratorTargetToUse(
+          util)) {
     // If we find the target and the dep was given as a full path,
     // then make sure it was not a full path to something else, and
     // the fact that the name matched a target was just a coincidence.
-    if(cmSystemTools::FileIsFullPath(dep.c_str()))
-      {
-      if(t->GetType() >= cmState::EXECUTABLE &&
-         t->GetType() <= cmState::MODULE_LIBRARY)
-        {
+    if (cmSystemTools::FileIsFullPath(dep.c_str())) {
+      if (t->GetType() >= cmState::EXECUTABLE &&
+          t->GetType() <= cmState::MODULE_LIBRARY) {
         // This is really only for compatibility so we do not need to
         // worry about configuration names and output names.
         std::string tLocation = t->GetLocationForBuild();
@@ -2368,29 +2072,24 @@ bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
         std::string depLocation = cmSystemTools::GetFilenamePath(dep);
         depLocation = cmSystemTools::CollapseFullPath(depLocation);
         tLocation = cmSystemTools::CollapseFullPath(tLocation);
-        if(depLocation == tLocation)
-          {
+        if (depLocation == tLocation) {
           this->GeneratorTarget->Target->AddUtility(util);
           return true;
-          }
         }
       }
-    else
-      {
+    } else {
       // The original name of the dependency was not a full path.  It
       // must name a target, so add the target-level dependency.
       this->GeneratorTarget->Target->AddUtility(util);
       return true;
-      }
     }
+  }
 
   // The dependency does not name a target built in this project.
   return false;
 }
 
-void
-cmTargetTraceDependencies
-::CheckCustomCommand(cmCustomCommand const& cc)
+void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
 {
   // Transform command names that reference targets built in this
   // project to corresponding target-level dependencies.
@@ -2399,91 +2098,79 @@ cmTargetTraceDependencies
   // Add target-level dependencies referenced by generator expressions.
   std::set<cmGeneratorTarget*> targets;
 
-  for(cmCustomCommandLines::const_iterator cit = cc.GetCommandLines().begin();
-      cit != cc.GetCommandLines().end(); ++cit)
-    {
+  for (cmCustomCommandLines::const_iterator cit = cc.GetCommandLines().begin();
+       cit != cc.GetCommandLines().end(); ++cit) {
     std::string const& command = *cit->begin();
     // Check for a target with this name.
-    if(cmGeneratorTarget* t =
-       this->LocalGenerator->FindGeneratorTargetToUse(command))
-      {
-      if(t->GetType() == cmState::EXECUTABLE)
-        {
+    if (cmGeneratorTarget* t =
+          this->LocalGenerator->FindGeneratorTargetToUse(command)) {
+      if (t->GetType() == cmState::EXECUTABLE) {
         // The command refers to an executable target built in
         // this project.  Add the target-level dependency to make
         // sure the executable is up to date before this custom
         // command possibly runs.
         this->GeneratorTarget->Target->AddUtility(command);
-        }
       }
+    }
 
     // Check for target references in generator expressions.
-    for(cmCustomCommandLine::const_iterator cli = cit->begin();
-        cli != cit->end(); ++cli)
-      {
-      const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge
-                                                              = ge.Parse(*cli);
+    for (cmCustomCommandLine::const_iterator cli = cit->begin();
+         cli != cit->end(); ++cli) {
+      const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
+        ge.Parse(*cli);
       cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true);
       std::set<cmGeneratorTarget*> geTargets = cge->GetTargets();
       targets.insert(geTargets.begin(), geTargets.end());
-      }
     }
+  }
 
-  for(std::set<cmGeneratorTarget*>::iterator ti = targets.begin();
-      ti != targets.end(); ++ti)
-    {
+  for (std::set<cmGeneratorTarget*>::iterator ti = targets.begin();
+       ti != targets.end(); ++ti) {
     this->GeneratorTarget->Target->AddUtility((*ti)->GetName());
-    }
+  }
 
   // Queue the custom command dependencies.
   std::vector<std::string> configs;
   std::set<std::string> emitted;
   this->Makefile->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) {
     this->FollowCommandDepends(cc, *ci, emitted);
-    }
+  }
 }
 
-void cmTargetTraceDependencies::FollowCommandDepends(cmCustomCommand const& cc,
-                                              const std::string& config,
-                                              std::set<std::string>& emitted)
+void cmTargetTraceDependencies::FollowCommandDepends(
+  cmCustomCommand const& cc, const std::string& config,
+  std::set<std::string>& emitted)
 {
   cmCustomCommandGenerator ccg(cc, config,
                                this->GeneratorTarget->LocalGenerator);
 
   const std::vector<std::string>& depends = ccg.GetDepends();
 
-  for(std::vector<std::string>::const_iterator di = depends.begin();
-      di != depends.end(); ++di)
-    {
+  for (std::vector<std::string>::const_iterator di = depends.begin();
+       di != depends.end(); ++di) {
     std::string const& dep = *di;
-    if(emitted.insert(dep).second)
-      {
-      if(!this->IsUtility(dep))
-        {
+    if (emitted.insert(dep).second) {
+      if (!this->IsUtility(dep)) {
         // The dependency does not name a target and may be a file we
         // know how to generate.  Queue it.
         this->FollowName(dep);
-        }
       }
     }
+  }
 }
 
-void
-cmTargetTraceDependencies
-::CheckCustomCommands(const std::vector<cmCustomCommand>& commands)
+void cmTargetTraceDependencies::CheckCustomCommands(
+  const std::vector<cmCustomCommand>& commands)
 {
-  for(std::vector<cmCustomCommand>::const_iterator cli = commands.begin();
-      cli != commands.end(); ++cli)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator cli = commands.begin();
+       cli != commands.end(); ++cli) {
     this->CheckCustomCommand(*cli);
-    }
+  }
 }
 
 void cmGeneratorTarget::TraceDependencies()
@@ -2492,66 +2179,55 @@ void cmGeneratorTarget::TraceDependencies()
   // would find nothing anyway, but when building CMake itself the "install"
   // target command ends up referencing the "cmake" target but we do not
   // really want the dependency because "install" depend on "all" anyway.
-  if(this->GetType() == cmState::GLOBAL_TARGET)
-    {
+  if (this->GetType() == cmState::GLOBAL_TARGET) {
     return;
-    }
+  }
 
   // Use a helper object to trace the dependencies.
   cmTargetTraceDependencies tracer(this);
   tracer.Trace();
 }
 
-std::string
-cmGeneratorTarget::GetCompilePDBDirectory(const std::string& config) const
+std::string cmGeneratorTarget::GetCompilePDBDirectory(
+  const std::string& config) const
 {
-  if(CompileInfo const* info = this->GetCompileInfo(config))
-    {
+  if (CompileInfo const* info = this->GetCompileInfo(config)) {
     return info->CompilePdbDir;
-    }
+  }
   return "";
 }
 
 void cmGeneratorTarget::GetAppleArchs(const std::string& config,
-                             std::vector<std::string>& archVec) const
+                                      std::vector<std::string>& archVec) const
 {
   const char* archs = 0;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     std::string defVarName = "OSX_ARCHITECTURES_";
     defVarName += cmSystemTools::UpperCase(config);
     archs = this->GetProperty(defVarName);
-    }
-  if(!archs)
-    {
+  }
+  if (!archs) {
     archs = this->GetProperty("OSX_ARCHITECTURES");
-    }
-  if(archs)
-    {
+  }
+  if (archs) {
     cmSystemTools::ExpandListArgument(std::string(archs), archVec);
-    }
+  }
 }
 
-std::string
-cmGeneratorTarget::GetCreateRuleVariable(std::string const& lang,
-                                         std::string const& config) const
+std::string cmGeneratorTarget::GetCreateRuleVariable(
+  std::string const& lang, std::string const& config) const
 {
-  switch(this->GetType())
-    {
-    case cmState::STATIC_LIBRARY:
-      {
+  switch (this->GetType()) {
+    case cmState::STATIC_LIBRARY: {
       std::string var = "CMAKE_" + lang + "_CREATE_STATIC_LIBRARY";
-      if(this->GetFeatureAsBool(
-           "INTERPROCEDURAL_OPTIMIZATION", config))
-        {
+      if (this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION", config)) {
         std::string varIPO = var + "_IPO";
-        if(this->Makefile->GetDefinition(varIPO))
-          {
+        if (this->Makefile->GetDefinition(varIPO)) {
           return varIPO;
-          }
         }
-      return var;
       }
+      return var;
+    }
     case cmState::SHARED_LIBRARY:
       return "CMAKE_" + lang + "_CREATE_SHARED_LIBRARY";
     case cmState::MODULE_LIBRARY:
@@ -2560,46 +2236,39 @@ cmGeneratorTarget::GetCreateRuleVariable(std::string const& lang,
       return "CMAKE_" + lang + "_LINK_EXECUTABLE";
     default:
       break;
-    }
+  }
   return "";
 }
-static void processIncludeDirectories(cmGeneratorTarget const* tgt,
-      const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries,
-      std::vector<std::string> &includes,
-      UNORDERED_SET<std::string> &uniqueIncludes,
-      cmGeneratorExpressionDAGChecker *dagChecker,
-      const std::string& config, bool debugIncludes,
-      const std::string& language)
-{
-  for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator
-      it = entries.begin(), end = entries.end(); it != end; ++it)
-    {
+static void processIncludeDirectories(
+  cmGeneratorTarget const* tgt,
+  const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
+  std::vector<std::string>& includes,
+  UNORDERED_SET<std::string>& uniqueIncludes,
+  cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
+  bool debugIncludes, const std::string& language)
+{
+  for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
+         it = entries.begin(),
+         end = entries.end();
+       it != end; ++it) {
     cmLinkImplItem const& item = (*it)->LinkImplItem;
     std::string const& targetName = item;
     bool const fromImported = item.Target && item.Target->IsImported();
     bool const checkCMP0027 = item.FromGenex;
     std::vector<std::string> entryIncludes;
-    cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(
-                                        tgt->GetLocalGenerator(),
-                                              config,
-                                              false,
-                                              tgt,
-                                              dagChecker, language),
-                                    entryIncludes);
+    cmSystemTools::ExpandListArgument(
+      (*it)->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt,
+                          dagChecker, language),
+      entryIncludes);
 
     std::string usedIncludes;
-    for(std::vector<std::string>::iterator
-          li = entryIncludes.begin(); li != entryIncludes.end(); ++li)
-      {
-      if (fromImported
-          && !cmSystemTools::FileExists(li->c_str()))
-        {
+    for (std::vector<std::string>::iterator li = entryIncludes.begin();
+         li != entryIncludes.end(); ++li) {
+      if (fromImported && !cmSystemTools::FileExists(li->c_str())) {
         std::ostringstream e;
         cmake::MessageType messageType = cmake::FATAL_ERROR;
-        if (checkCMP0027)
-          {
-          switch(tgt->GetPolicyStatusCMP0027())
-            {
+        if (checkCMP0027) {
+          switch (tgt->GetPolicyStatusCMP0027()) {
             case cmPolicies::WARN:
               e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0027) << "\n";
             case cmPolicies::OLD:
@@ -2609,8 +2278,8 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
             case cmPolicies::REQUIRED_IF_USED:
             case cmPolicies::NEW:
               break;
-            }
           }
+        }
         /* clang-format off */
         e << "Imported target \"" << targetName << "\" includes "
              "non-existent path\n  \"" << *li << "\"\nin its "
@@ -2624,31 +2293,24 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
         /* clang-format on */
         tgt->GetLocalGenerator()->IssueMessage(messageType, e.str());
         return;
-        }
+      }
 
-      if (!cmSystemTools::FileIsFullPath(li->c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(li->c_str())) {
         std::ostringstream e;
         bool noMessage = false;
         cmake::MessageType messageType = cmake::FATAL_ERROR;
-        if (!targetName.empty())
-          {
+        if (!targetName.empty()) {
           /* clang-format off */
           e << "Target \"" << targetName << "\" contains relative "
             "path in its INTERFACE_INCLUDE_DIRECTORIES:\n"
             "  \"" << *li << "\"";
           /* clang-format on */
-          }
-        else
-          {
-          switch(tgt->GetPolicyStatusCMP0021())
-            {
-            case cmPolicies::WARN:
-              {
+        } else {
+          switch (tgt->GetPolicyStatusCMP0021()) {
+            case cmPolicies::WARN: {
               e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0021) << "\n";
               messageType = cmake::AUTHOR_WARNING;
-              }
-              break;
+            } break;
             case cmPolicies::OLD:
               noMessage = true;
             case cmPolicies::REQUIRED_IF_USED:
@@ -2656,48 +2318,42 @@ static void processIncludeDirectories(cmGeneratorTarget const* tgt,
             case cmPolicies::NEW:
               // Issue the fatal message.
               break;
-            }
-          e << "Found relative path while evaluating include directories of "
-          "\"" << tgt->GetName() << "\":\n  \"" << *li << "\"\n";
           }
-        if (!noMessage)
-          {
+          e << "Found relative path while evaluating include directories of "
+               "\""
+            << tgt->GetName() << "\":\n  \"" << *li << "\"\n";
+        }
+        if (!noMessage) {
           tgt->GetLocalGenerator()->IssueMessage(messageType, e.str());
-          if (messageType == cmake::FATAL_ERROR)
-            {
+          if (messageType == cmake::FATAL_ERROR) {
             return;
-            }
           }
         }
+      }
 
-      if (!cmSystemTools::IsOff(li->c_str()))
-        {
+      if (!cmSystemTools::IsOff(li->c_str())) {
         cmSystemTools::ConvertToUnixSlashes(*li);
-        }
+      }
       std::string inc = *li;
 
-      if(uniqueIncludes.insert(inc).second)
-        {
+      if (uniqueIncludes.insert(inc).second) {
         includes.push_back(inc);
-        if (debugIncludes)
-          {
+        if (debugIncludes) {
           usedIncludes += " * " + inc + "\n";
-          }
         }
       }
-    if (!usedIncludes.empty())
-      {
-      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG,
-                            std::string("Used includes for target ")
-                            + tgt->GetName() + ":\n"
-                            + usedIncludes, (*it)->ge->GetBacktrace());
-      }
     }
+    if (!usedIncludes.empty()) {
+      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
+        cmake::LOG, std::string("Used includes for target ") + tgt->GetName() +
+          ":\n" + usedIncludes,
+        (*it)->ge->GetBacktrace());
+    }
+  }
 }
 
-std::vector<std::string>
-cmGeneratorTarget::GetIncludeDirectories(const std::string& config,
-                                         const std::string& lang) const
+std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories(
+  const std::string& config, const std::string& lang) const
 {
   std::vector<std::string> includes;
   UNORDERED_SET<std::string> uniqueIncludes;
@@ -2706,142 +2362,114 @@ cmGeneratorTarget::GetIncludeDirectories(const std::string& config,
                                              "INCLUDE_DIRECTORIES", 0, 0);
 
   std::vector<std::string> debugProperties;
-  const char *debugProp =
-              this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
-  if (debugProp)
-    {
+  const char* debugProp =
+    this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
+  if (debugProp) {
     cmSystemTools::ExpandListArgument(debugProp, debugProperties);
-    }
+  }
 
-  bool debugIncludes = !this->DebugIncludesDone
-                    && std::find(debugProperties.begin(),
-                                 debugProperties.end(),
-                                 "INCLUDE_DIRECTORIES")
-                        != debugProperties.end();
+  bool debugIncludes = !this->DebugIncludesDone &&
+    std::find(debugProperties.begin(), debugProperties.end(),
+              "INCLUDE_DIRECTORIES") != debugProperties.end();
 
-  if (this->GlobalGenerator->GetConfigureDoneCMP0026())
-    {
+  if (this->GlobalGenerator->GetConfigureDoneCMP0026()) {
     this->DebugIncludesDone = true;
-    }
+  }
 
-  processIncludeDirectories(this,
-                            this->IncludeDirectoriesEntries,
-                            includes,
-                            uniqueIncludes,
-                            &dagChecker,
-                            config,
-                            debugIncludes,
+  processIncludeDirectories(this, this->IncludeDirectoriesEntries, includes,
+                            uniqueIncludes, &dagChecker, config, debugIncludes,
                             lang);
 
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>
     linkInterfaceIncludeDirectoriesEntries;
-  AddInterfaceEntries(
-    this, config, "INTERFACE_INCLUDE_DIRECTORIES",
-    linkInterfaceIncludeDirectoriesEntries);
+  AddInterfaceEntries(this, config, "INTERFACE_INCLUDE_DIRECTORIES",
+                      linkInterfaceIncludeDirectoriesEntries);
 
-  if(this->Makefile->IsOn("APPLE"))
-    {
+  if (this->Makefile->IsOn("APPLE")) {
     cmLinkImplementationLibraries const* impl =
-        this->GetLinkImplementationLibraries(config);
-    for(std::vector<cmLinkImplItem>::const_iterator
-        it = impl->Libraries.begin();
-        it != impl->Libraries.end(); ++it)
-      {
+      this->GetLinkImplementationLibraries(config);
+    for (std::vector<cmLinkImplItem>::const_iterator it =
+           impl->Libraries.begin();
+         it != impl->Libraries.end(); ++it) {
       std::string libDir = cmSystemTools::CollapseFullPath(*it);
 
-      static cmsys::RegularExpression
-        frameworkCheck("(.*\\.framework)(/Versions/[^/]+)?/[^/]+$");
-      if(!frameworkCheck.find(libDir))
-        {
+      static cmsys::RegularExpression frameworkCheck(
+        "(.*\\.framework)(/Versions/[^/]+)?/[^/]+$");
+      if (!frameworkCheck.find(libDir)) {
         continue;
-        }
+      }
 
       libDir = frameworkCheck.match(1);
 
       cmGeneratorExpression ge;
       cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
-                ge.Parse(libDir.c_str());
-      linkInterfaceIncludeDirectoriesEntries
-              .push_back(new cmGeneratorTarget::TargetPropertyEntry(cge));
-      }
+        ge.Parse(libDir.c_str());
+      linkInterfaceIncludeDirectoriesEntries.push_back(
+        new cmGeneratorTarget::TargetPropertyEntry(cge));
     }
+  }
 
-  processIncludeDirectories(this,
-                            linkInterfaceIncludeDirectoriesEntries,
-                            includes,
-                            uniqueIncludes,
-                            &dagChecker,
-                            config,
-                            debugIncludes,
-                            lang);
+  processIncludeDirectories(this, linkInterfaceIncludeDirectoriesEntries,
+                            includes, uniqueIncludes, &dagChecker, config,
+                            debugIncludes, lang);
 
   cmDeleteAll(linkInterfaceIncludeDirectoriesEntries);
 
   return includes;
 }
 
-static void processCompileOptionsInternal(cmGeneratorTarget const* tgt,
-      const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries,
-      std::vector<std::string> &options,
-      UNORDERED_SET<std::string> &uniqueOptions,
-      cmGeneratorExpressionDAGChecker *dagChecker,
-      const std::string& config, bool debugOptions, const char *logName,
-      std::string const& language)
+static void processCompileOptionsInternal(
+  cmGeneratorTarget const* tgt,
+  const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
+  std::vector<std::string>& options, UNORDERED_SET<std::string>& uniqueOptions,
+  cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
+  bool debugOptions, const char* logName, std::string const& language)
 {
-  for (std::vector<cmGeneratorTarget::TargetPropertyEntry*>::const_iterator
-      it = entries.begin(), end = entries.end(); it != end; ++it)
-    {
+  for (std::vector<cmGeneratorTarget::TargetPropertyEntry *>::const_iterator
+         it = entries.begin(),
+         end = entries.end();
+       it != end; ++it) {
     std::vector<std::string> entryOptions;
-    cmSystemTools::ExpandListArgument((*it)->ge->Evaluate(
-                                        tgt->GetLocalGenerator(),
-                                              config,
-                                              false,
-                                              tgt,
-                                              dagChecker,
-                                              language),
-                                    entryOptions);
+    cmSystemTools::ExpandListArgument(
+      (*it)->ge->Evaluate(tgt->GetLocalGenerator(), config, false, tgt,
+                          dagChecker, language),
+      entryOptions);
     std::string usedOptions;
-    for(std::vector<std::string>::iterator
-          li = entryOptions.begin(); li != entryOptions.end(); ++li)
-      {
+    for (std::vector<std::string>::iterator li = entryOptions.begin();
+         li != entryOptions.end(); ++li) {
       std::string const& opt = *li;
 
-      if(uniqueOptions.insert(opt).second)
-        {
+      if (uniqueOptions.insert(opt).second) {
         options.push_back(opt);
-        if (debugOptions)
-          {
+        if (debugOptions) {
           usedOptions += " * " + opt + "\n";
-          }
         }
       }
-    if (!usedOptions.empty())
-      {
-      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(cmake::LOG,
-                            std::string("Used compile ") + logName
-                            + std::string(" for target ")
-                            + tgt->GetName() + ":\n"
-                            + usedOptions, (*it)->ge->GetBacktrace());
-      }
     }
+    if (!usedOptions.empty()) {
+      tgt->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
+        cmake::LOG, std::string("Used compile ") + logName +
+          std::string(" for target ") + tgt->GetName() + ":\n" + usedOptions,
+        (*it)->ge->GetBacktrace());
+    }
+  }
 }
 
-static void processCompileOptions(cmGeneratorTarget const* tgt,
-      const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries,
-      std::vector<std::string> &options,
-      UNORDERED_SET<std::string> &uniqueOptions,
-      cmGeneratorExpressionDAGChecker *dagChecker,
-      const std::string& config, bool debugOptions,
-      std::string const& language)
+static void processCompileOptions(
+  cmGeneratorTarget const* tgt,
+  const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
+  std::vector<std::string>& options, UNORDERED_SET<std::string>& uniqueOptions,
+  cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
+  bool debugOptions, std::string const& language)
 {
   processCompileOptionsInternal(tgt, entries, options, uniqueOptions,
                                 dagChecker, config, debugOptions, "options",
                                 language);
 }
 
-void cmGeneratorTarget::GetCompileOptions(std::vector<std::string> &result,
-                                 const std::string& config,
-                                 const std::string& language) const
+void cmGeneratorTarget::GetCompileOptions(std::vector<std::string>& result,
+                                          const std::string& config,
+                                          const std::string& language) const
 {
   UNORDERED_SET<std::string> uniqueOptions;
 
@@ -2849,133 +2477,101 @@ void cmGeneratorTarget::GetCompileOptions(std::vector<std::string> &result,
                                              "COMPILE_OPTIONS", 0, 0);
 
   std::vector<std::string> debugProperties;
-  const char *debugProp =
-              this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
-  if (debugProp)
-    {
+  const char* debugProp =
+    this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
+  if (debugProp) {
     cmSystemTools::ExpandListArgument(debugProp, debugProperties);
-    }
+  }
 
-  bool debugOptions = !this->DebugCompileOptionsDone
-                    && std::find(debugProperties.begin(),
-                                 debugProperties.end(),
-                                 "COMPILE_OPTIONS")
-                        != debugProperties.end();
+  bool debugOptions = !this->DebugCompileOptionsDone &&
+    std::find(debugProperties.begin(), debugProperties.end(),
+              "COMPILE_OPTIONS") != debugProperties.end();
 
-  if (this->GlobalGenerator->GetConfigureDoneCMP0026())
-    {
+  if (this->GlobalGenerator->GetConfigureDoneCMP0026()) {
     this->DebugCompileOptionsDone = true;
-    }
+  }
 
-  processCompileOptions(this,
-                            this->CompileOptionsEntries,
-                            result,
-                            uniqueOptions,
-                            &dagChecker,
-                            config,
-                            debugOptions,
-                            language);
+  processCompileOptions(this, this->CompileOptionsEntries, result,
+                        uniqueOptions, &dagChecker, config, debugOptions,
+                        language);
 
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>
     linkInterfaceCompileOptionsEntries;
 
-  AddInterfaceEntries(
-    this, config, "INTERFACE_COMPILE_OPTIONS",
-    linkInterfaceCompileOptionsEntries);
-
-  processCompileOptions(this,
-                        linkInterfaceCompileOptionsEntries,
-                            result,
-                            uniqueOptions,
-                            &dagChecker,
-                            config,
-                            debugOptions,
-                            language);
+  AddInterfaceEntries(this, config, "INTERFACE_COMPILE_OPTIONS",
+                      linkInterfaceCompileOptionsEntries);
+
+  processCompileOptions(this, linkInterfaceCompileOptionsEntries, result,
+                        uniqueOptions, &dagChecker, config, debugOptions,
+                        language);
 
   cmDeleteAll(linkInterfaceCompileOptionsEntries);
 }
 
-static void processCompileFeatures(cmGeneratorTarget const* tgt,
-      const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries,
-      std::vector<std::string> &options,
-      UNORDERED_SET<std::string> &uniqueOptions,
-      cmGeneratorExpressionDAGChecker *dagChecker,
-      const std::string& config, bool debugOptions)
+static void processCompileFeatures(
+  cmGeneratorTarget const* tgt,
+  const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
+  std::vector<std::string>& options, UNORDERED_SET<std::string>& uniqueOptions,
+  cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
+  bool debugOptions)
 {
   processCompileOptionsInternal(tgt, entries, options, uniqueOptions,
                                 dagChecker, config, debugOptions, "features",
                                 std::string());
 }
 
-void cmGeneratorTarget::GetCompileFeatures(std::vector<std::string> &result,
-                                  const std::string& config) const
+void cmGeneratorTarget::GetCompileFeatures(std::vector<std::string>& result,
+                                           const std::string& config) const
 {
   UNORDERED_SET<std::string> uniqueFeatures;
 
   cmGeneratorExpressionDAGChecker dagChecker(this->GetName(),
-                                             "COMPILE_FEATURES",
-                                             0, 0);
+                                             "COMPILE_FEATURES", 0, 0);
 
   std::vector<std::string> debugProperties;
-  const char *debugProp =
-              this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
-  if (debugProp)
-    {
+  const char* debugProp =
+    this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
+  if (debugProp) {
     cmSystemTools::ExpandListArgument(debugProp, debugProperties);
-    }
+  }
 
-  bool debugFeatures = !this->DebugCompileFeaturesDone
-                    && std::find(debugProperties.begin(),
-                                 debugProperties.end(),
-                                 "COMPILE_FEATURES")
-                        != debugProperties.end();
+  bool debugFeatures = !this->DebugCompileFeaturesDone &&
+    std::find(debugProperties.begin(), debugProperties.end(),
+              "COMPILE_FEATURES") != debugProperties.end();
 
-  if (this->GlobalGenerator->GetConfigureDoneCMP0026())
-    {
+  if (this->GlobalGenerator->GetConfigureDoneCMP0026()) {
     this->DebugCompileFeaturesDone = true;
-    }
+  }
 
-  processCompileFeatures(this,
-                            this->CompileFeaturesEntries,
-                            result,
-                            uniqueFeatures,
-                            &dagChecker,
-                            config,
-                            debugFeatures);
+  processCompileFeatures(this, this->CompileFeaturesEntries, result,
+                         uniqueFeatures, &dagChecker, config, debugFeatures);
 
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>
     linkInterfaceCompileFeaturesEntries;
-  AddInterfaceEntries(
-    this, config, "INTERFACE_COMPILE_FEATURES",
-    linkInterfaceCompileFeaturesEntries);
-
-  processCompileFeatures(this,
-                         linkInterfaceCompileFeaturesEntries,
-                            result,
-                            uniqueFeatures,
-                            &dagChecker,
-                            config,
-                            debugFeatures);
+  AddInterfaceEntries(this, config, "INTERFACE_COMPILE_FEATURES",
+                      linkInterfaceCompileFeaturesEntries);
+
+  processCompileFeatures(this, linkInterfaceCompileFeaturesEntries, result,
+                         uniqueFeatures, &dagChecker, config, debugFeatures);
 
   cmDeleteAll(linkInterfaceCompileFeaturesEntries);
 }
 
-static void processCompileDefinitions(cmGeneratorTarget const* tgt,
-      const std::vector<cmGeneratorTarget::TargetPropertyEntry*> &entries,
-      std::vector<std::string> &options,
-      UNORDERED_SET<std::string> &uniqueOptions,
-      cmGeneratorExpressionDAGChecker *dagChecker,
-      const std::string& config, bool debugOptions,
-      std::string const& language)
+static void processCompileDefinitions(
+  cmGeneratorTarget const* tgt,
+  const std::vector<cmGeneratorTarget::TargetPropertyEntry*>& entries,
+  std::vector<std::string>& options, UNORDERED_SET<std::string>& uniqueOptions,
+  cmGeneratorExpressionDAGChecker* dagChecker, const std::string& config,
+  bool debugOptions, std::string const& language)
 {
   processCompileOptionsInternal(tgt, entries, options, uniqueOptions,
                                 dagChecker, config, debugOptions,
                                 "definitions", language);
 }
 
-void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list,
-                                            const std::string& config,
-                                            const std::string& language) const
+void cmGeneratorTarget::GetCompileDefinitions(
+  std::vector<std::string>& list, const std::string& config,
+  const std::string& language) const
 {
   UNORDERED_SET<std::string> uniqueOptions;
 
@@ -2983,90 +2579,66 @@ void cmGeneratorTarget::GetCompileDefinitions(std::vector<std::string> &list,
                                              "COMPILE_DEFINITIONS", 0, 0);
 
   std::vector<std::string> debugProperties;
-  const char *debugProp =
-              this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
-  if (debugProp)
-    {
+  const char* debugProp =
+    this->Makefile->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
+  if (debugProp) {
     cmSystemTools::ExpandListArgument(debugProp, debugProperties);
-    }
+  }
 
-  bool debugDefines = !this->DebugCompileDefinitionsDone
-                          && std::find(debugProperties.begin(),
-                                debugProperties.end(),
-                                "COMPILE_DEFINITIONS")
-                        != debugProperties.end();
+  bool debugDefines = !this->DebugCompileDefinitionsDone &&
+    std::find(debugProperties.begin(), debugProperties.end(),
+              "COMPILE_DEFINITIONS") != debugProperties.end();
 
-  if (this->GlobalGenerator->GetConfigureDoneCMP0026())
-    {
+  if (this->GlobalGenerator->GetConfigureDoneCMP0026()) {
     this->DebugCompileDefinitionsDone = true;
-    }
+  }
 
-  processCompileDefinitions(this,
-                            this->CompileDefinitionsEntries,
-                            list,
-                            uniqueOptions,
-                            &dagChecker,
-                            config,
-                            debugDefines,
+  processCompileDefinitions(this, this->CompileDefinitionsEntries, list,
+                            uniqueOptions, &dagChecker, config, debugDefines,
                             language);
 
   std::vector<cmGeneratorTarget::TargetPropertyEntry*>
     linkInterfaceCompileDefinitionsEntries;
-  AddInterfaceEntries(
-    this, config, "INTERFACE_COMPILE_DEFINITIONS",
-    linkInterfaceCompileDefinitionsEntries);
-  if (!config.empty())
-    {
-    std::string configPropName = "COMPILE_DEFINITIONS_"
-                                        + cmSystemTools::UpperCase(config);
-    const char *configProp = this->GetProperty(configPropName);
-    if (configProp)
-      {
-      switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0043))
-        {
-        case cmPolicies::WARN:
-          {
+  AddInterfaceEntries(this, config, "INTERFACE_COMPILE_DEFINITIONS",
+                      linkInterfaceCompileDefinitionsEntries);
+  if (!config.empty()) {
+    std::string configPropName =
+      "COMPILE_DEFINITIONS_" + cmSystemTools::UpperCase(config);
+    const char* configProp = this->GetProperty(configPropName);
+    if (configProp) {
+      switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0043)) {
+        case cmPolicies::WARN: {
           std::ostringstream e;
           e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0043);
-          this->LocalGenerator->IssueMessage(cmake::AUTHOR_WARNING,
-                                       e.str());
-          }
-        case cmPolicies::OLD:
-          {
+          this->LocalGenerator->IssueMessage(cmake::AUTHOR_WARNING, e.str());
+        }
+        case cmPolicies::OLD: {
           cmGeneratorExpression ge;
           cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
-                                                      ge.Parse(configProp);
-          linkInterfaceCompileDefinitionsEntries
-                .push_back(new cmGeneratorTarget::TargetPropertyEntry(cge));
-          }
-          break;
+            ge.Parse(configProp);
+          linkInterfaceCompileDefinitionsEntries.push_back(
+            new cmGeneratorTarget::TargetPropertyEntry(cge));
+        } break;
         case cmPolicies::NEW:
         case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::REQUIRED_IF_USED:
           break;
-        }
       }
     }
+  }
 
-  processCompileDefinitions(this,
-                            linkInterfaceCompileDefinitionsEntries,
-                            list,
-                            uniqueOptions,
-                            &dagChecker,
-                            config,
-                            debugDefines,
+  processCompileDefinitions(this, linkInterfaceCompileDefinitionsEntries, list,
+                            uniqueOptions, &dagChecker, config, debugDefines,
                             language);
 
   cmDeleteAll(linkInterfaceCompileDefinitionsEntries);
 }
 
-void cmGeneratorTarget::ComputeTargetManifest(
-                                              const std::string& config) const
+void cmGeneratorTarget::ComputeTargetManifest(const std::string& config) const
 {
-  if (this->IsImported())
-    {
+  if (this->IsImported()) {
     return;
-    }
+  }
   cmGlobalGenerator* gg = this->LocalGenerator->GetGlobalGenerator();
 
   // Get the names.
@@ -3075,75 +2647,61 @@ void cmGeneratorTarget::ComputeTargetManifest(
   std::string realName;
   std::string impName;
   std::string pdbName;
-  if(this->GetType() == cmState::EXECUTABLE)
-    {
+  if (this->GetType() == cmState::EXECUTABLE) {
     this->GetExecutableNames(name, realName, impName, pdbName, config);
-    }
-  else if(this->GetType() == cmState::STATIC_LIBRARY ||
-          this->GetType() == cmState::SHARED_LIBRARY ||
-          this->GetType() == cmState::MODULE_LIBRARY)
-    {
-    this->GetLibraryNames(name, soName, realName, impName, pdbName,
-                                  config);
-    }
-  else
-    {
+  } else if (this->GetType() == cmState::STATIC_LIBRARY ||
+             this->GetType() == cmState::SHARED_LIBRARY ||
+             this->GetType() == cmState::MODULE_LIBRARY) {
+    this->GetLibraryNames(name, soName, realName, impName, pdbName, config);
+  } else {
     return;
-    }
+  }
 
   // Get the directory.
   std::string dir = this->GetDirectory(config, false);
 
   // Add each name.
   std::string f;
-  if(!name.empty())
-    {
+  if (!name.empty()) {
     f = dir;
     f += "/";
     f += name;
     gg->AddToManifest(f);
-    }
-  if(!soName.empty())
-    {
+  }
+  if (!soName.empty()) {
     f = dir;
     f += "/";
     f += soName;
     gg->AddToManifest(f);
-    }
-  if(!realName.empty())
-    {
+  }
+  if (!realName.empty()) {
     f = dir;
     f += "/";
     f += realName;
     gg->AddToManifest(f);
-    }
-  if(!pdbName.empty())
-    {
+  }
+  if (!pdbName.empty()) {
     f = dir;
     f += "/";
     f += pdbName;
     gg->AddToManifest(f);
-    }
-  if(!impName.empty())
-    {
+  }
+  if (!impName.empty()) {
     f = this->GetDirectory(config, true);
     f += "/";
     f += impName;
     gg->AddToManifest(f);
-    }
+  }
 }
 
 std::string cmGeneratorTarget::GetFullPath(const std::string& config,
                                            bool implib, bool realname) const
 {
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return this->Target->ImportedGetFullPath(config, implib);
-    }
-  else
-    {
+  } else {
     return this->NormalGetFullPath(config, implib, realname);
-    }
+  }
 }
 
 std::string cmGeneratorTarget::NormalGetFullPath(const std::string& config,
@@ -3152,43 +2710,35 @@ std::string cmGeneratorTarget::NormalGetFullPath(const std::string& config,
 {
   std::string fpath = this->GetDirectory(config, implib);
   fpath += "/";
-  if(this->IsAppBundleOnApple())
-    {
+  if (this->IsAppBundleOnApple()) {
     fpath = this->BuildMacContentDirectory(fpath, config, false);
     fpath += "/";
-    }
+  }
 
   // Add the full name of the target.
-  if(implib)
-    {
+  if (implib) {
     fpath += this->GetFullName(config, true);
-    }
-  else if(realname)
-    {
+  } else if (realname) {
     fpath += this->NormalGetRealName(config);
-    }
-  else
-    {
+  } else {
     fpath += this->GetFullName(config, false);
-    }
+  }
   return fpath;
 }
 
-std::string
-cmGeneratorTarget::NormalGetRealName(const std::string& config) const
+std::string cmGeneratorTarget::NormalGetRealName(
+  const std::string& config) const
 {
   // This should not be called for imported targets.
   // TODO: Split cmTarget into a class hierarchy to get compile-time
   // enforcement of the limited imported target API.
-  if(this->IsImported())
-    {
-    std::string msg =  "NormalGetRealName called on imported target: ";
+  if (this->IsImported()) {
+    std::string msg = "NormalGetRealName called on imported target: ";
     msg += this->GetName();
     this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg);
-    }
+  }
 
-  if(this->GetType() == cmState::EXECUTABLE)
-    {
+  if (this->GetType() == cmState::EXECUTABLE) {
     // Compute the real name that will be built.
     std::string name;
     std::string realName;
@@ -3196,63 +2746,54 @@ cmGeneratorTarget::NormalGetRealName(const std::string& config) const
     std::string pdbName;
     this->GetExecutableNames(name, realName, impName, pdbName, config);
     return realName;
-    }
-  else
-    {
+  } else {
     // Compute the real name that will be built.
     std::string name;
     std::string soName;
     std::string realName;
     std::string impName;
     std::string pdbName;
-    this->GetLibraryNames(name, soName, realName,
-                          impName, pdbName, config);
+    this->GetLibraryNames(name, soName, realName, impName, pdbName, config);
     return realName;
-    }
+  }
 }
 
-void cmGeneratorTarget::GetLibraryNames(std::string& name,
-                               std::string& soName,
-                               std::string& realName,
-                               std::string& impName,
-                               std::string& pdbName,
-                               const std::string& config) const
+void cmGeneratorTarget::GetLibraryNames(std::string& name, std::string& soName,
+                                        std::string& realName,
+                                        std::string& impName,
+                                        std::string& pdbName,
+                                        const std::string& config) const
 {
   // This should not be called for imported targets.
   // TODO: Split cmTarget into a class hierarchy to get compile-time
   // enforcement of the limited imported target API.
-  if(this->IsImported())
-    {
-    std::string msg =  "GetLibraryNames called on imported target: ";
+  if (this->IsImported()) {
+    std::string msg = "GetLibraryNames called on imported target: ";
     msg += this->GetName();
-    this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR,
-                                 msg);
+    this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg);
     return;
-    }
+  }
 
   // Check for library version properties.
   const char* version = this->GetProperty("VERSION");
   const char* soversion = this->GetProperty("SOVERSION");
-  if(!this->HasSOName(config) ||
-     this->Makefile->IsOn("CMAKE_PLATFORM_NO_VERSIONED_SONAME") ||
-     this->IsFrameworkOnApple())
-    {
+  if (!this->HasSOName(config) ||
+      this->Makefile->IsOn("CMAKE_PLATFORM_NO_VERSIONED_SONAME") ||
+      this->IsFrameworkOnApple()) {
     // Versioning is supported only for shared libraries and modules,
     // and then only when the platform supports an soname flag.
     version = 0;
     soversion = 0;
-    }
-  if(version && !soversion)
-    {
+  }
+  if (version && !soversion) {
     // The soversion must be set if the library version is set.  Use
     // the library version as the soversion.
     soversion = version;
-    }
-  if(!version && soversion)
-    {
+  }
+  if (!version && soversion) {
     // Use the soversion as the library version.
     version = soversion;
-    }
+  }
 
   // Get the components of the library name.
   std::string prefix;
@@ -3261,74 +2802,63 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name,
   this->GetFullNameInternal(config, false, prefix, base, suffix);
 
   // The library name.
-  name = prefix+base+suffix;
+  name = prefix + base + suffix;
 
-  if(this->IsFrameworkOnApple())
-    {
+  if (this->IsFrameworkOnApple()) {
     realName = prefix;
-    if(!this->Makefile->PlatformIsAppleIos())
-      {
+    if (!this->Makefile->PlatformIsAppleIos()) {
       realName += "Versions/";
       realName += this->GetFrameworkVersion();
       realName += "/";
-      }
+    }
     realName += base;
     soName = realName;
-    }
-  else
-  {
+  } else {
     // The library's soname.
-    this->ComputeVersionedName(soName, prefix, base, suffix,
-                              name, soversion);
+    this->ComputeVersionedName(soName, prefix, base, suffix, name, soversion);
 
     // The library's real name on disk.
-    this->ComputeVersionedName(realName, prefix, base, suffix,
-                              name, version);
+    this->ComputeVersionedName(realName, prefix, base, suffix, name, version);
   }
 
   // The import library name.
-  if(this->GetType() == cmState::SHARED_LIBRARY ||
-     this->GetType() == cmState::MODULE_LIBRARY)
-    {
+  if (this->GetType() == cmState::SHARED_LIBRARY ||
+      this->GetType() == cmState::MODULE_LIBRARY) {
     impName = this->GetFullNameInternal(config, true);
-    }
-  else
-    {
+  } else {
     impName = "";
-    }
+  }
 
   // The program database file name.
   pdbName = this->GetPDBName(config);
 }
 
 void cmGeneratorTarget::GetExecutableNames(std::string& name,
-                                  std::string& realName,
-                                  std::string& impName,
-                                  std::string& pdbName,
-                                  const std::string& config) const
+                                           std::string& realName,
+                                           std::string& impName,
+                                           std::string& pdbName,
+                                           const std::string& config) const
 {
   // This should not be called for imported targets.
   // TODO: Split cmTarget into a class hierarchy to get compile-time
   // enforcement of the limited imported target API.
-  if(this->IsImported())
-    {
-    std::string msg =
-      "GetExecutableNames called on imported target: ";
+  if (this->IsImported()) {
+    std::string msg = "GetExecutableNames called on imported target: ";
     msg += this->GetName();
     this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg);
-    }
+  }
 
-  // This versioning is supported only for executables and then only
-  // when the platform supports symbolic links.
+// This versioning is supported only for executables and then only
+// when the platform supports symbolic links.
 #if defined(_WIN32) && !defined(__CYGWIN__)
   const char* version = 0;
 #else
   // Check for executable version properties.
   const char* version = this->GetProperty("VERSION");
-  if(this->GetType() != cmState::EXECUTABLE || this->Makefile->IsOn("XCODE"))
-    {
+  if (this->GetType() != cmState::EXECUTABLE ||
+      this->Makefile->IsOn("XCODE")) {
     version = 0;
-    }
+  }
 #endif
 
   // Get the components of the executable name.
@@ -3338,19 +2868,18 @@ void cmGeneratorTarget::GetExecutableNames(std::string& name,
   this->GetFullNameInternal(config, false, prefix, base, suffix);
 
   // The executable name.
-  name = prefix+base+suffix;
+  name = prefix + base + suffix;
 
-  // The executable's real name on disk.
+// The executable's real name on disk.
 #if defined(__CYGWIN__)
-  realName = prefix+base;
+  realName = prefix + base;
 #else
   realName = name;
 #endif
-  if(version)
-    {
+  if (version) {
     realName += "-";
     realName += version;
-    }
+  }
 #if defined(__CYGWIN__)
   realName += suffix;
 #endif
@@ -3369,11 +2898,11 @@ std::string cmGeneratorTarget::GetFullNameInternal(const std::string& config,
   std::string base;
   std::string suffix;
   this->GetFullNameInternal(config, implib, prefix, base, suffix);
-  return prefix+base+suffix;
+  return prefix + base + suffix;
 }
 
-const char*
-cmGeneratorTarget::ImportedGetLocation(const std::string& config) const
+const char* cmGeneratorTarget::ImportedGetLocation(
+  const std::string& config) const
 {
   static std::string location;
   assert(this->IsImported());
@@ -3395,132 +2924,115 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config,
                                             std::string& outSuffix) const
 {
   // Use just the target name for non-main target types.
-  if(this->GetType() != cmState::STATIC_LIBRARY &&
-     this->GetType() != cmState::SHARED_LIBRARY &&
-     this->GetType() != cmState::MODULE_LIBRARY &&
-     this->GetType() != cmState::EXECUTABLE)
-    {
+  if (this->GetType() != cmState::STATIC_LIBRARY &&
+      this->GetType() != cmState::SHARED_LIBRARY &&
+      this->GetType() != cmState::MODULE_LIBRARY &&
+      this->GetType() != cmState::EXECUTABLE) {
     outPrefix = "";
     outBase = this->GetName();
     outSuffix = "";
     return;
-    }
+  }
 
   // Return an empty name for the import library if this platform
   // does not support import libraries.
-  if(implib &&
-     !this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX"))
-    {
+  if (implib &&
+      !this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
     outPrefix = "";
     outBase = "";
     outSuffix = "";
     return;
-    }
+  }
 
   // The implib option is only allowed for shared libraries, module
   // libraries, and executables.
-  if(this->GetType() != cmState::SHARED_LIBRARY &&
-     this->GetType() != cmState::MODULE_LIBRARY &&
-     this->GetType() != cmState::EXECUTABLE)
-    {
+  if (this->GetType() != cmState::SHARED_LIBRARY &&
+      this->GetType() != cmState::MODULE_LIBRARY &&
+      this->GetType() != cmState::EXECUTABLE) {
     implib = false;
-    }
+  }
 
   // Compute the full name for main target types.
-  const char* targetPrefix = (implib
-                              ? this->GetProperty("IMPORT_PREFIX")
-                              : this->GetProperty("PREFIX"));
-  const char* targetSuffix = (implib
-                              ? this->GetProperty("IMPORT_SUFFIX")
-                              : this->GetProperty("SUFFIX"));
+  const char* targetPrefix = (implib ? this->GetProperty("IMPORT_PREFIX")
+                                     : this->GetProperty("PREFIX"));
+  const char* targetSuffix = (implib ? this->GetProperty("IMPORT_SUFFIX")
+                                     : this->GetProperty("SUFFIX"));
   const char* configPostfix = 0;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     std::string configProp = cmSystemTools::UpperCase(config);
     configProp += "_POSTFIX";
     configPostfix = this->GetProperty(configProp);
     // Mac application bundles and frameworks have no postfix.
-    if(configPostfix &&
-       (this->IsAppBundleOnApple() || this->IsFrameworkOnApple()))
-      {
+    if (configPostfix &&
+        (this->IsAppBundleOnApple() || this->IsFrameworkOnApple())) {
       configPostfix = 0;
-      }
     }
+  }
   const char* prefixVar = this->Target->GetPrefixVariableInternal(implib);
   const char* suffixVar = this->Target->GetSuffixVariableInternal(implib);
 
   // Check for language-specific default prefix and suffix.
   std::string ll = this->GetLinkerLanguage(config);
-  if(!ll.empty())
-    {
-    if(!targetSuffix && suffixVar && *suffixVar)
-      {
+  if (!ll.empty()) {
+    if (!targetSuffix && suffixVar && *suffixVar) {
       std::string langSuff = suffixVar + std::string("_") + ll;
       targetSuffix = this->Makefile->GetDefinition(langSuff);
-      }
-    if(!targetPrefix && prefixVar && *prefixVar)
-      {
+    }
+    if (!targetPrefix && prefixVar && *prefixVar) {
       std::string langPrefix = prefixVar + std::string("_") + ll;
       targetPrefix = this->Makefile->GetDefinition(langPrefix);
-      }
     }
+  }
 
   // if there is no prefix on the target use the cmake definition
-  if(!targetPrefix && prefixVar)
-    {
+  if (!targetPrefix && prefixVar) {
     targetPrefix = this->Makefile->GetSafeDefinition(prefixVar);
-    }
+  }
   // if there is no suffix on the target use the cmake definition
-  if(!targetSuffix && suffixVar)
-    {
+  if (!targetSuffix && suffixVar) {
     targetSuffix = this->Makefile->GetSafeDefinition(suffixVar);
-    }
+  }
 
   // frameworks have directory prefix but no suffix
   std::string fw_prefix;
-  if(this->IsFrameworkOnApple())
-    {
+  if (this->IsFrameworkOnApple()) {
     fw_prefix = this->GetOutputName(config, false);
     fw_prefix += ".framework/";
     targetPrefix = fw_prefix.c_str();
     targetSuffix = 0;
-    }
+  }
 
-  if(this->IsCFBundleOnApple())
-    {
+  if (this->IsCFBundleOnApple()) {
     fw_prefix = this->GetCFBundleDirectory(config, false);
     fw_prefix += "/";
     targetPrefix = fw_prefix.c_str();
     targetSuffix = 0;
-    }
+  }
 
   // Begin the final name with the prefix.
-  outPrefix = targetPrefix?targetPrefix:"";
+  outPrefix = targetPrefix ? targetPrefix : "";
 
   // Append the target name or property-specified name.
   outBase += this->GetOutputName(config, implib);
 
   // Append the per-configuration postfix.
-  outBase += configPostfix?configPostfix:"";
+  outBase += configPostfix ? configPostfix : "";
 
   // Name shared libraries with their version number on some platforms.
-  if(const char* soversion = this->GetProperty("SOVERSION"))
-    {
-    if(this->GetType() == cmState::SHARED_LIBRARY && !implib &&
-       this->Makefile->IsOn("CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION"))
-      {
+  if (const char* soversion = this->GetProperty("SOVERSION")) {
+    if (this->GetType() == cmState::SHARED_LIBRARY && !implib &&
+        this->Makefile->IsOn("CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION")) {
       outBase += "-";
       outBase += soversion;
-      }
     }
+  }
 
   // Append the suffix.
-  outSuffix = targetSuffix?targetSuffix:"";
+  outSuffix = targetSuffix ? targetSuffix : "";
 }
 
-
-std::string
-cmGeneratorTarget::GetLinkerLanguage(const std::string& config) const
+std::string cmGeneratorTarget::GetLinkerLanguage(
+  const std::string& config) const
 {
   return this->GetLinkClosure(config)->LinkerLanguage;
 }
@@ -3533,38 +3045,33 @@ std::string cmGeneratorTarget::GetPDBName(const std::string& config) const
   this->GetFullNameInternal(config, false, prefix, base, suffix);
 
   std::vector<std::string> props;
-  std::string configUpper =
-    cmSystemTools::UpperCase(config);
-  if(!configUpper.empty())
-    {
+  std::string configUpper = cmSystemTools::UpperCase(config);
+  if (!configUpper.empty()) {
     // PDB_NAME_<CONFIG>
     props.push_back("PDB_NAME_" + configUpper);
-    }
+  }
 
   // PDB_NAME
   props.push_back("PDB_NAME");
 
-  for(std::vector<std::string>::const_iterator i = props.begin();
-      i != props.end(); ++i)
-    {
-    if(const char* outName = this->GetProperty(*i))
-      {
+  for (std::vector<std::string>::const_iterator i = props.begin();
+       i != props.end(); ++i) {
+    if (const char* outName = this->GetProperty(*i)) {
       base = outName;
       break;
-      }
     }
-  return prefix+base+".pdb";
+  }
+  return prefix + base + ".pdb";
 }
 
 bool cmGeneratorTarget::StrictTargetComparison::operator()(
-    cmGeneratorTarget const* t1, cmGeneratorTarget const* t2) const
+  cmGeneratorTarget const* t1, cmGeneratorTarget const* t2) const
 {
   int nameResult = strcmp(t1->GetName().c_str(), t2->GetName().c_str());
-  if (nameResult == 0)
-    {
+  if (nameResult == 0) {
     return strcmp(t1->GetLocalGenerator()->GetCurrentBinaryDirectory(),
                   t2->GetLocalGenerator()->GetCurrentBinaryDirectory()) < 0;
-    }
+  }
   return nameResult < 0;
 }
 
@@ -3575,93 +3082,75 @@ cmGeneratorTarget::GetTargetSourceFileFlags(const cmSourceFile* sf) const
   this->ConstructSourceFileFlags();
   std::map<cmSourceFile const*, SourceFileFlags>::iterator si =
     this->SourceFlagsMap.find(sf);
-  if(si != this->SourceFlagsMap.end())
-    {
+  if (si != this->SourceFlagsMap.end()) {
     flags = si->second;
-    }
-  else
-    {
+  } else {
     // Handle the MACOSX_PACKAGE_LOCATION property on source files that
     // were not listed in one of the other lists.
-    if(const char* location = sf->GetProperty("MACOSX_PACKAGE_LOCATION"))
-      {
+    if (const char* location = sf->GetProperty("MACOSX_PACKAGE_LOCATION")) {
       flags.MacFolder = location;
-      if(strcmp(location, "Resources") == 0)
-        {
+      if (strcmp(location, "Resources") == 0) {
         flags.Type = cmGeneratorTarget::SourceFileTypeResource;
-        }
-      else
-        {
+      } else {
         flags.Type = cmGeneratorTarget::SourceFileTypeMacContent;
-        }
       }
     }
+  }
   return flags;
 }
 
 void cmGeneratorTarget::ConstructSourceFileFlags() const
 {
-  if(this->SourceFileFlagsConstructed)
-    {
+  if (this->SourceFileFlagsConstructed) {
     return;
-    }
+  }
   this->SourceFileFlagsConstructed = true;
 
   // Process public headers to mark the source files.
-  if(const char* files = this->GetProperty("PUBLIC_HEADER"))
-    {
+  if (const char* files = this->GetProperty("PUBLIC_HEADER")) {
     std::vector<std::string> relFiles;
     cmSystemTools::ExpandListArgument(files, relFiles);
-    for(std::vector<std::string>::iterator it = relFiles.begin();
-        it != relFiles.end(); ++it)
-      {
-      if(cmSourceFile* sf = this->Makefile->GetSource(*it))
-        {
+    for (std::vector<std::string>::iterator it = relFiles.begin();
+         it != relFiles.end(); ++it) {
+      if (cmSourceFile* sf = this->Makefile->GetSource(*it)) {
         SourceFileFlags& flags = this->SourceFlagsMap[sf];
         flags.MacFolder = "Headers";
         flags.Type = cmGeneratorTarget::SourceFileTypePublicHeader;
-        }
       }
     }
+  }
 
   // Process private headers after public headers so that they take
   // precedence if a file is listed in both.
-  if(const char* files = this->GetProperty("PRIVATE_HEADER"))
-    {
+  if (const char* files = this->GetProperty("PRIVATE_HEADER")) {
     std::vector<std::string> relFiles;
     cmSystemTools::ExpandListArgument(files, relFiles);
-    for(std::vector<std::string>::iterator it = relFiles.begin();
-        it != relFiles.end(); ++it)
-      {
-      if(cmSourceFile* sf = this->Makefile->GetSource(*it))
-        {
+    for (std::vector<std::string>::iterator it = relFiles.begin();
+         it != relFiles.end(); ++it) {
+      if (cmSourceFile* sf = this->Makefile->GetSource(*it)) {
         SourceFileFlags& flags = this->SourceFlagsMap[sf];
         flags.MacFolder = "PrivateHeaders";
         flags.Type = cmGeneratorTarget::SourceFileTypePrivateHeader;
-        }
       }
     }
+  }
 
   // Mark sources listed as resources.
-  if(const char* files = this->GetProperty("RESOURCE"))
-    {
+  if (const char* files = this->GetProperty("RESOURCE")) {
     std::vector<std::string> relFiles;
     cmSystemTools::ExpandListArgument(files, relFiles);
-    for(std::vector<std::string>::iterator it = relFiles.begin();
-        it != relFiles.end(); ++it)
-      {
-      if(cmSourceFile* sf = this->Makefile->GetSource(*it))
-        {
+    for (std::vector<std::string>::iterator it = relFiles.begin();
+         it != relFiles.end(); ++it) {
+      if (cmSourceFile* sf = this->Makefile->GetSource(*it)) {
         SourceFileFlags& flags = this->SourceFlagsMap[sf];
         flags.MacFolder = "";
-        if(!this->Makefile->PlatformIsAppleIos())
-          {
+        if (!this->Makefile->PlatformIsAppleIos()) {
           flags.MacFolder = "Resources";
-          }
-        flags.Type = cmGeneratorTarget::SourceFileTypeResource;
         }
+        flags.Type = cmGeneratorTarget::SourceFileTypeResource;
       }
     }
+  }
 }
 
 const cmGeneratorTarget::CompatibleInterfacesBase&
@@ -3669,74 +3158,68 @@ cmGeneratorTarget::GetCompatibleInterfaces(std::string const& config) const
 {
   cmGeneratorTarget::CompatibleInterfaces& compat =
     this->CompatibleInterfacesMap[config];
-  if(!compat.Done)
-    {
+  if (!compat.Done) {
     compat.Done = true;
     compat.PropsBool.insert("POSITION_INDEPENDENT_CODE");
     compat.PropsString.insert("AUTOUIC_OPTIONS");
     std::vector<cmGeneratorTarget const*> const& deps =
       this->GetLinkImplementationClosure(config);
-    for(std::vector<cmGeneratorTarget const*>::const_iterator li =
-        deps.begin(); li != deps.end(); ++li)
-      {
-#define CM_READ_COMPATIBLE_INTERFACE(X, x) \
-      if(const char* prop = (*li)->GetProperty("COMPATIBLE_INTERFACE_" #X)) \
-        { \
-        std::vector<std::string> props; \
-        cmSystemTools::ExpandListArgument(prop, props); \
-        compat.Props##x.insert(props.begin(), props.end()); \
-        }
+    for (std::vector<cmGeneratorTarget const*>::const_iterator li =
+           deps.begin();
+         li != deps.end(); ++li) {
+#define CM_READ_COMPATIBLE_INTERFACE(X, x)                                    \
+  if (const char* prop = (*li)->GetProperty("COMPATIBLE_INTERFACE_" #X)) {    \
+    std::vector<std::string> props;                                           \
+    cmSystemTools::ExpandListArgument(prop, props);                           \
+    compat.Props##x.insert(props.begin(), props.end());                       \
+  }
       CM_READ_COMPATIBLE_INTERFACE(BOOL, Bool)
       CM_READ_COMPATIBLE_INTERFACE(STRING, String)
       CM_READ_COMPATIBLE_INTERFACE(NUMBER_MIN, NumberMin)
       CM_READ_COMPATIBLE_INTERFACE(NUMBER_MAX, NumberMax)
 #undef CM_READ_COMPATIBLE_INTERFACE
-      }
     }
+  }
   return compat;
 }
 
 bool cmGeneratorTarget::IsLinkInterfaceDependentBoolProperty(
-    const std::string &p, const std::string& config) const
+  const std::string& p, const std::string& config) const
 {
-  if (this->GetType() == cmState::OBJECT_LIBRARY
-      || this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::OBJECT_LIBRARY ||
+      this->GetType() == cmState::INTERFACE_LIBRARY) {
     return false;
-    }
+  }
   return this->GetCompatibleInterfaces(config).PropsBool.count(p) > 0;
 }
 
 bool cmGeneratorTarget::IsLinkInterfaceDependentStringProperty(
-    const std::string &p, const std::string& config) const
+  const std::string& p, const std::string& config) const
 {
-  if (this->GetType() == cmState::OBJECT_LIBRARY
-      || this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::OBJECT_LIBRARY ||
+      this->GetType() == cmState::INTERFACE_LIBRARY) {
     return false;
-    }
+  }
   return this->GetCompatibleInterfaces(config).PropsString.count(p) > 0;
 }
 
 bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMinProperty(
-    const std::string &p, const std::string& config) const
+  const std::string& p, const std::string& config) const
 {
-  if (this->GetType() == cmState::OBJECT_LIBRARY
-      || this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::OBJECT_LIBRARY ||
+      this->GetType() == cmState::INTERFACE_LIBRARY) {
     return false;
-    }
+  }
   return this->GetCompatibleInterfaces(config).PropsNumberMin.count(p) > 0;
 }
 
 bool cmGeneratorTarget::IsLinkInterfaceDependentNumberMaxProperty(
-    const std::string &p, const std::string& config) const
+  const std::string& p, const std::string& config) const
 {
-  if (this->GetType() == cmState::OBJECT_LIBRARY
-      || this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::OBJECT_LIBRARY ||
+      this->GetType() == cmState::INTERFACE_LIBRARY) {
     return false;
-    }
+  }
   return this->GetCompatibleInterfaces(config).PropsNumberMax.count(p) > 0;
 }
 
@@ -3748,109 +3231,100 @@ enum CompatibleType
   NumberMaxType
 };
 
-template<typename PropertyType>
+template <typename PropertyType>
 PropertyType getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt,
                                                const std::string& prop,
                                                const std::string& config,
-                                               CompatibleType,
-                                               PropertyType *);
+                                               CompatibleType, PropertyType*);
 
-template<>
+template <>
 bool getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt,
                                        const std::string& prop,
                                        const std::string& config,
-                                       CompatibleType, bool *)
+                                       CompatibleType, bool*)
 {
   return tgt->GetLinkInterfaceDependentBoolProperty(prop, config);
 }
 
-template<>
-const char * getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt,
-                                               const std::string& prop,
-                                               const std::string& config,
-                                               CompatibleType t,
-                                               const char **)
+template <>
+const char* getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt,
+                                              const std::string& prop,
+                                              const std::string& config,
+                                              CompatibleType t, const char**)
 {
-  switch(t)
-  {
-  case BoolType:
-    assert(0 && "String compatibility check function called for boolean");
-    return 0;
-  case StringType:
-    return tgt->GetLinkInterfaceDependentStringProperty(prop, config);
-  case NumberMinType:
-    return tgt->GetLinkInterfaceDependentNumberMinProperty(prop, config);
-  case NumberMaxType:
-    return tgt->GetLinkInterfaceDependentNumberMaxProperty(prop, config);
+  switch (t) {
+    case BoolType:
+      assert(0 && "String compatibility check function called for boolean");
+      return 0;
+    case StringType:
+      return tgt->GetLinkInterfaceDependentStringProperty(prop, config);
+    case NumberMinType:
+      return tgt->GetLinkInterfaceDependentNumberMinProperty(prop, config);
+    case NumberMaxType:
+      return tgt->GetLinkInterfaceDependentNumberMaxProperty(prop, config);
   }
   assert(0 && "Unreachable!");
   return 0;
 }
 
-template<typename PropertyType>
+template <typename PropertyType>
 void checkPropertyConsistency(cmGeneratorTarget const* depender,
                               cmGeneratorTarget const* dependee,
                               const std::string& propName,
-                              std::set<std::string> &emitted,
-                              const std::string& config,
-                              CompatibleType t,
-                              PropertyType *)
-{
-  const char *prop = dependee->GetProperty(propName);
-  if (!prop)
-    {
+                              std::set<std::string>& emitted,
+                              const std::string& config, CompatibleType t,
+                              PropertyType*)
+{
+  const char* prop = dependee->GetProperty(propName);
+  if (!prop) {
     return;
-    }
+  }
 
   std::vector<std::string> props;
   cmSystemTools::ExpandListArgument(prop, props);
   std::string pdir = cmSystemTools::GetCMakeRoot();
   pdir += "/Help/prop_tgt/";
 
-  for(std::vector<std::string>::iterator pi = props.begin();
-      pi != props.end(); ++pi)
-    {
+  for (std::vector<std::string>::iterator pi = props.begin();
+       pi != props.end(); ++pi) {
     std::string pname = cmSystemTools::HelpFileName(*pi);
     std::string pfile = pdir + pname + ".rst";
-    if(cmSystemTools::FileExists(pfile.c_str(), true))
-      {
+    if (cmSystemTools::FileExists(pfile.c_str(), true)) {
       std::ostringstream e;
-      e << "Target \"" << dependee->GetName() << "\" has property \""
-        << *pi << "\" listed in its " << propName << " property.  "
-          "This is not allowed.  Only user-defined properties may appear "
-          "listed in the " << propName << " property.";
+      e << "Target \"" << dependee->GetName() << "\" has property \"" << *pi
+        << "\" listed in its " << propName
+        << " property.  "
+           "This is not allowed.  Only user-defined properties may appear "
+           "listed in the "
+        << propName << " property.";
       depender->GetLocalGenerator()->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
-    if(emitted.insert(*pi).second)
-      {
-      getLinkInterfaceDependentProperty<PropertyType>(depender, *pi, config,
-                                                      t, 0);
-      if (cmSystemTools::GetErrorOccuredFlag())
-        {
+    }
+    if (emitted.insert(*pi).second) {
+      getLinkInterfaceDependentProperty<PropertyType>(depender, *pi, config, t,
+                                                      0);
+      if (cmSystemTools::GetErrorOccuredFlag()) {
         return;
-        }
       }
     }
+  }
 }
 
-static std::string intersect(const std::set<std::string> &s1,
-                             const std::set<std::string> &s2)
+static std::string intersect(const std::set<std::string>& s1,
+                             const std::set<std::string>& s2)
 {
   std::set<std::string> intersect;
-  std::set_intersection(s1.begin(),s1.end(),
-                        s2.begin(),s2.end(),
-                      std::inserter(intersect,intersect.begin()));
-  if (!intersect.empty())
-    {
+  std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(),
+                        std::inserter(intersect, intersect.begin()));
+  if (!intersect.empty()) {
     return *intersect.begin();
-    }
+  }
   return "";
 }
 
-static std::string intersect(const std::set<std::string> &s1,
-                       const std::set<std::string> &s2,
-                       const std::set<std::string> &s3)
+static std::string intersect(const std::set<std::string>& s1,
+                             const std::set<std::string>& s2,
+                             const std::set<std::string>& s3)
 {
   std::string result;
   result = intersect(s1, s2);
@@ -3862,10 +3336,10 @@ static std::string intersect(const std::set<std::string> &s1,
   return intersect(s2, s3);
 }
 
-static std::string intersect(const std::set<std::string> &s1,
-                       const std::set<std::string> &s2,
-                       const std::set<std::string> &s3,
-                       const std::set<std::string> &s4)
+static std::string intersect(const std::set<std::string>& s1,
+                             const std::set<std::string>& s2,
+                             const std::set<std::string>& s3,
+                             const std::set<std::string>& s4)
 {
   std::string result;
   result = intersect(s1, s2);
@@ -3881,9 +3355,9 @@ static std::string intersect(const std::set<std::string> &s1,
 }
 
 void cmGeneratorTarget::CheckPropertyCompatibility(
-    cmComputeLinkInformation *info, const std::string& config) const
+  cmComputeLinkInformation* info, const std::string& config) const
 {
-  const cmComputeLinkInformation::ItemVector &deps = info->GetItems();
+  const cmComputeLinkInformation::ItemVector& deps = info->GetItems();
 
   std::set<std::string> emittedBools;
   static std::string strBool = "COMPATIBLE_INTERFACE_BOOL";
@@ -3894,96 +3368,77 @@ void cmGeneratorTarget::CheckPropertyCompatibility(
   std::set<std::string> emittedMaxNumbers;
   static std::string strNumMax = "COMPATIBLE_INTERFACE_NUMBER_MAX";
 
-  for(cmComputeLinkInformation::ItemVector::const_iterator li =
-      deps.begin(); li != deps.end(); ++li)
-    {
-    if (!li->Target)
-      {
+  for (cmComputeLinkInformation::ItemVector::const_iterator li = deps.begin();
+       li != deps.end(); ++li) {
+    if (!li->Target) {
       continue;
-      }
+    }
 
-    checkPropertyConsistency<bool>(this, li->Target,
-                                strBool,
-                                emittedBools, config, BoolType, 0);
-    if (cmSystemTools::GetErrorOccuredFlag())
-      {
+    checkPropertyConsistency<bool>(this, li->Target, strBool, emittedBools,
+                                   config, BoolType, 0);
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       return;
-      }
-    checkPropertyConsistency<const char *>(this, li->Target,
-                                strString,
-                                emittedStrings, config,
-                                StringType, 0);
-    if (cmSystemTools::GetErrorOccuredFlag())
-      {
+    }
+    checkPropertyConsistency<const char*>(
+      this, li->Target, strString, emittedStrings, config, StringType, 0);
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       return;
-      }
-    checkPropertyConsistency<const char *>(this, li->Target,
-                                strNumMin,
-                                emittedMinNumbers, config,
-                                NumberMinType, 0);
-    if (cmSystemTools::GetErrorOccuredFlag())
-      {
+    }
+    checkPropertyConsistency<const char*>(this, li->Target, strNumMin,
+                                          emittedMinNumbers, config,
+                                          NumberMinType, 0);
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       return;
-      }
-    checkPropertyConsistency<const char *>(this, li->Target,
-                                strNumMax,
-                                emittedMaxNumbers, config,
-                                NumberMaxType, 0);
-    if (cmSystemTools::GetErrorOccuredFlag())
-      {
+    }
+    checkPropertyConsistency<const char*>(this, li->Target, strNumMax,
+                                          emittedMaxNumbers, config,
+                                          NumberMaxType, 0);
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       return;
-      }
     }
+  }
 
-  std::string prop = intersect(emittedBools,
-                               emittedStrings,
-                               emittedMinNumbers,
+  std::string prop = intersect(emittedBools, emittedStrings, emittedMinNumbers,
                                emittedMaxNumbers);
 
-  if (!prop.empty())
-    {
+  if (!prop.empty()) {
     // Use a sorted std::vector to keep the error message sorted.
     std::vector<std::string> props;
     std::set<std::string>::const_iterator i = emittedBools.find(prop);
-    if (i != emittedBools.end())
-      {
+    if (i != emittedBools.end()) {
       props.push_back(strBool);
-      }
+    }
     i = emittedStrings.find(prop);
-    if (i != emittedStrings.end())
-      {
+    if (i != emittedStrings.end()) {
       props.push_back(strString);
-      }
+    }
     i = emittedMinNumbers.find(prop);
-    if (i != emittedMinNumbers.end())
-      {
+    if (i != emittedMinNumbers.end()) {
       props.push_back(strNumMin);
-      }
+    }
     i = emittedMaxNumbers.find(prop);
-    if (i != emittedMaxNumbers.end())
-      {
+    if (i != emittedMaxNumbers.end()) {
       props.push_back(strNumMax);
-      }
+    }
     std::sort(props.begin(), props.end());
 
     std::string propsString = cmJoin(cmMakeRange(props).retreat(1), ", ");
     propsString += " and the " + props.back();
 
     std::ostringstream e;
-    e << "Property \"" << prop << "\" appears in both the "
-      << propsString <<
-    " property in the dependencies of target \"" << this->GetName() <<
-    "\".  This is not allowed. A property may only require compatibility "
-    "in a boolean interpretation, a numeric minimum, a numeric maximum or a "
-    "string interpretation, but not a mixture.";
+    e << "Property \"" << prop << "\" appears in both the " << propsString
+      << " property in the dependencies of target \"" << this->GetName()
+      << "\".  This is not allowed. A property may only require compatibility "
+         "in a boolean interpretation, a numeric minimum, a numeric maximum "
+         "or a "
+         "string interpretation, but not a mixture.";
     this->LocalGenerator->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
+  }
 }
 
 std::string compatibilityType(CompatibleType t)
 {
-  switch(t)
-    {
+  switch (t) {
     case BoolType:
       return "Boolean compatibility";
     case StringType:
@@ -3992,204 +3447,183 @@ std::string compatibilityType(CompatibleType t)
       return "Numeric maximum compatibility";
     case NumberMinType:
       return "Numeric minimum compatibility";
-    }
+  }
   assert(0 && "Unreachable!");
   return "";
 }
 
 std::string compatibilityAgree(CompatibleType t, bool dominant)
 {
-  switch(t)
-    {
+  switch (t) {
     case BoolType:
     case StringType:
       return dominant ? "(Disagree)\n" : "(Agree)\n";
     case NumberMaxType:
     case NumberMinType:
       return dominant ? "(Dominant)\n" : "(Ignored)\n";
-    }
+  }
   assert(0 && "Unreachable!");
   return "";
 }
 
-template<typename PropertyType>
+template <typename PropertyType>
 PropertyType getTypedProperty(cmGeneratorTarget const* tgt,
                               const std::string& prop);
 
-template<>
+template <>
 bool getTypedProperty<bool>(cmGeneratorTarget const* tgt,
                             const std::string& prop)
 {
   return tgt->GetPropertyAsBool(prop);
 }
 
-template<>
-const char *getTypedProperty<const char *>(cmGeneratorTarget const* tgt,
-                                           const std::string& prop)
+template <>
+const char* getTypedProperty<const char*>(cmGeneratorTarget const* tgt,
+                                          const std::string& prop)
 {
   return tgt->GetProperty(prop);
 }
 
-template<typename PropertyType>
+template <typename PropertyType>
 std::string valueAsString(PropertyType);
-template<>
+template <>
 std::string valueAsString<bool>(bool value)
 {
   return value ? "TRUE" : "FALSE";
 }
-template<>
+template <>
 std::string valueAsString<const char*>(const char* value)
 {
   return value ? value : "(unset)";
 }
 
-template<typename PropertyType>
+template <typename PropertyType>
 PropertyType impliedValue(PropertyType);
-template<>
+template <>
 bool impliedValue<bool>(bool)
 {
   return false;
 }
-template<>
+template <>
 const char* impliedValue<const char*>(const char*)
 {
   return "";
 }
 
-template<typename PropertyType>
+template <typename PropertyType>
 std::pair<bool, PropertyType> consistentProperty(PropertyType lhs,
                                                  PropertyType rhs,
                                                  CompatibleType t);
 
-template<>
-std::pair<bool, bool> consistentProperty(bool lhs, bool rhs,
-                                         CompatibleType)
+template <>
+std::pair<bool, bool> consistentProperty(bool lhs, bool rhs, CompatibleType)
 {
   return std::make_pair(lhs == rhs, lhs);
 }
 
-std::pair<bool, const char*> consistentStringProperty(const char *lhs,
-                                                      const char *rhs)
+std::pair<bool, const char*> consistentStringProperty(const char* lhs,
+                                                      const char* rhs)
 {
   const bool b = strcmp(lhs, rhs) == 0;
   return std::make_pair(b, b ? lhs : 0);
 }
 
-std::pair<bool, const char*> consistentNumberProperty(const char *lhs,
-                                                   const char *rhs,
-                                                   CompatibleType t)
+std::pair<bool, const char*> consistentNumberProperty(const char* lhs,
+                                                      const char* rhs,
+                                                      CompatibleType t)
 {
-  char *pEnd;
+  char* pEnd;
 
   const char* const null_ptr = 0;
 
   long lnum = strtol(lhs, &pEnd, 0);
-  if (pEnd == lhs || *pEnd != '\0' || errno == ERANGE)
-    {
+  if (pEnd == lhs || *pEnd != '\0' || errno == ERANGE) {
     return std::pair<bool, const char*>(false, null_ptr);
-    }
+  }
 
   long rnum = strtol(rhs, &pEnd, 0);
-  if (pEnd == rhs || *pEnd != '\0' || errno == ERANGE)
-    {
+  if (pEnd == rhs || *pEnd != '\0' || errno == ERANGE) {
     return std::pair<bool, const char*>(false, null_ptr);
-    }
+  }
 
-  if (t == NumberMaxType)
-    {
+  if (t == NumberMaxType) {
     return std::make_pair(true, std::max(lnum, rnum) == lnum ? lhs : rhs);
-    }
-  else
-    {
+  } else {
     return std::make_pair(true, std::min(lnum, rnum) == lnum ? lhs : rhs);
-    }
+  }
 }
 
-template<>
-std::pair<bool, const char*> consistentProperty(const char *lhs,
-                                                const char *rhs,
+template <>
+std::pair<bool, const char*> consistentProperty(const char* lhs,
+                                                const char* rhs,
                                                 CompatibleType t)
 {
-  if (!lhs && !rhs)
-    {
+  if (!lhs && !rhs) {
     return std::make_pair(true, lhs);
-    }
-  if (!lhs)
-    {
+  }
+  if (!lhs) {
     return std::make_pair(true, rhs);
-    }
-  if (!rhs)
-    {
+  }
+  if (!rhs) {
     return std::make_pair(true, lhs);
-    }
+  }
 
   const char* const null_ptr = 0;
 
-  switch(t)
-  {
-  case BoolType:
-    assert(0 && "consistentProperty for strings called with BoolType");
-    return std::pair<bool, const char*>(false, null_ptr);
-  case StringType:
-    return consistentStringProperty(lhs, rhs);
-  case NumberMinType:
-  case NumberMaxType:
-    return consistentNumberProperty(lhs, rhs, t);
+  switch (t) {
+    case BoolType:
+      assert(0 && "consistentProperty for strings called with BoolType");
+      return std::pair<bool, const char*>(false, null_ptr);
+    case StringType:
+      return consistentStringProperty(lhs, rhs);
+    case NumberMinType:
+    case NumberMaxType:
+      return consistentNumberProperty(lhs, rhs, t);
   }
   assert(0 && "Unreachable!");
   return std::pair<bool, const char*>(false, null_ptr);
 }
 
-template<typename PropertyType>
+template <typename PropertyType>
 PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
-                                          const std::string &p,
-                                          const std::string& config,
-                                          const char *defaultValue,
-                                          CompatibleType t,
-                                          PropertyType *)
+                                                 const std::string& p,
+                                                 const std::string& config,
+                                                 const char* defaultValue,
+                                                 CompatibleType t,
+                                                 PropertyType*)
 {
   PropertyType propContent = getTypedProperty<PropertyType>(tgt, p);
   std::vector<std::string> headPropKeys = tgt->GetPropertyKeys();
   const bool explicitlySet =
-      std::find(headPropKeys.begin(), headPropKeys.end(),
-                p) != headPropKeys.end();
+    std::find(headPropKeys.begin(), headPropKeys.end(), p) !=
+    headPropKeys.end();
 
-  const bool impliedByUse =
-          tgt->IsNullImpliedByLinkLibraries(p);
-  assert((impliedByUse ^ explicitlySet)
-      || (!impliedByUse && !explicitlySet));
+  const bool impliedByUse = tgt->IsNullImpliedByLinkLibraries(p);
+  assert((impliedByUse ^ explicitlySet) || (!impliedByUse && !explicitlySet));
 
   std::vector<cmGeneratorTarget const*> const& deps =
     tgt->GetLinkImplementationClosure(config);
 
-  if(deps.empty())
-    {
+  if (deps.empty()) {
     return propContent;
-    }
+  }
   bool propInitialized = explicitlySet;
 
   std::string report = " * Target \"";
   report += tgt->GetName();
-  if (explicitlySet)
-    {
+  if (explicitlySet) {
     report += "\" has property content \"";
     report += valueAsString<PropertyType>(propContent);
     report += "\"\n";
-    }
-  else if (impliedByUse)
-    {
+  } else if (impliedByUse) {
     report += "\" property is implied by use.\n";
-    }
-  else
-    {
+  } else {
     report += "\" property not set.\n";
-    }
+  }
 
   std::string interfaceProperty = "INTERFACE_" + p;
-  for(std::vector<cmGeneratorTarget const*>::const_iterator li =
-      deps.begin();
-      li != deps.end(); ++li)
-    {
+  for (std::vector<cmGeneratorTarget const*>::const_iterator li = deps.begin();
+       li != deps.end(); ++li) {
     // An error should be reported if one dependency
     // has INTERFACE_POSITION_INDEPENDENT_CODE ON and the other
     // has INTERFACE_POSITION_INDEPENDENT_CODE OFF, or if the
@@ -4200,129 +3634,101 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
 
     std::vector<std::string> propKeys = theTarget->GetPropertyKeys();
 
-    const bool ifaceIsSet =
-        std::find(propKeys.begin(), propKeys.end(),
-                  interfaceProperty) != propKeys.end();
+    const bool ifaceIsSet = std::find(propKeys.begin(), propKeys.end(),
+                                      interfaceProperty) != propKeys.end();
     PropertyType ifacePropContent =
-                    getTypedProperty<PropertyType>(theTarget,
-                              interfaceProperty);
+      getTypedProperty<PropertyType>(theTarget, interfaceProperty);
 
     std::string reportEntry;
-    if (ifaceIsSet)
-      {
+    if (ifaceIsSet) {
       reportEntry += " * Target \"";
       reportEntry += theTarget->GetName();
       reportEntry += "\" property value \"";
       reportEntry += valueAsString<PropertyType>(ifacePropContent);
       reportEntry += "\" ";
-      }
+    }
 
-    if (explicitlySet)
-      {
-      if (ifaceIsSet)
-        {
+    if (explicitlySet) {
+      if (ifaceIsSet) {
         std::pair<bool, PropertyType> consistent =
-                                  consistentProperty(propContent,
-                                                     ifacePropContent, t);
+          consistentProperty(propContent, ifacePropContent, t);
         report += reportEntry;
         report += compatibilityAgree(t, propContent != consistent.second);
-        if (!consistent.first)
-          {
+        if (!consistent.first) {
           std::ostringstream e;
-          e << "Property " << p << " on target \""
-            << tgt->GetName() << "\" does\nnot match the "
-            "INTERFACE_" << p << " property requirement\nof "
-            "dependency \"" << theTarget->GetName() << "\".\n";
+          e << "Property " << p << " on target \"" << tgt->GetName()
+            << "\" does\nnot match the "
+               "INTERFACE_"
+            << p << " property requirement\nof "
+                    "dependency \""
+            << theTarget->GetName() << "\".\n";
           cmSystemTools::Error(e.str().c_str());
           break;
-          }
-        else
-          {
+        } else {
           propContent = consistent.second;
           continue;
-          }
         }
-      else
-        {
+      } else {
         // Explicitly set on target and not set in iface. Can't disagree.
         continue;
-        }
       }
-    else if (impliedByUse)
-      {
+    } else if (impliedByUse) {
       propContent = impliedValue<PropertyType>(propContent);
 
-      if (ifaceIsSet)
-        {
+      if (ifaceIsSet) {
         std::pair<bool, PropertyType> consistent =
-                                  consistentProperty(propContent,
-                                                     ifacePropContent, t);
+          consistentProperty(propContent, ifacePropContent, t);
         report += reportEntry;
         report += compatibilityAgree(t, propContent != consistent.second);
-        if (!consistent.first)
-          {
+        if (!consistent.first) {
           std::ostringstream e;
-          e << "Property " << p << " on target \""
-            << tgt->GetName() << "\" is\nimplied to be " << defaultValue
+          e << "Property " << p << " on target \"" << tgt->GetName()
+            << "\" is\nimplied to be " << defaultValue
             << " because it was used to determine the link libraries\n"
-               "already. The INTERFACE_" << p << " property on\ndependency \""
-            << theTarget->GetName() << "\" is in conflict.\n";
+               "already. The INTERFACE_"
+            << p << " property on\ndependency \"" << theTarget->GetName()
+            << "\" is in conflict.\n";
           cmSystemTools::Error(e.str().c_str());
           break;
-          }
-        else
-          {
+        } else {
           propContent = consistent.second;
           continue;
-          }
         }
-      else
-        {
+      } else {
         // Implicitly set on target and not set in iface. Can't disagree.
         continue;
-        }
       }
-    else
-      {
-      if (ifaceIsSet)
-        {
-        if (propInitialized)
-          {
+    } else {
+      if (ifaceIsSet) {
+        if (propInitialized) {
           std::pair<bool, PropertyType> consistent =
-                                    consistentProperty(propContent,
-                                                       ifacePropContent, t);
+            consistentProperty(propContent, ifacePropContent, t);
           report += reportEntry;
           report += compatibilityAgree(t, propContent != consistent.second);
-          if (!consistent.first)
-            {
+          if (!consistent.first) {
             std::ostringstream e;
             e << "The INTERFACE_" << p << " property of \""
               << theTarget->GetName() << "\" does\nnot agree with the value "
-                "of " << p << " already determined\nfor \""
-              << tgt->GetName() << "\".\n";
+                                         "of "
+              << p << " already determined\nfor \"" << tgt->GetName()
+              << "\".\n";
             cmSystemTools::Error(e.str().c_str());
             break;
-            }
-          else
-            {
+          } else {
             propContent = consistent.second;
             continue;
-            }
           }
-        else
-          {
+        } else {
           report += reportEntry + "(Interface set)\n";
           propContent = ifacePropContent;
           propInitialized = true;
-          }
         }
-      else
-        {
+      } else {
         // Not set. Nothing to agree on.
         continue;
-        }
       }
     }
+  }
 
   tgt->ReportPropertyOrigin(p, valueAsString<PropertyType>(propContent),
                             report, compatibilityType(t));
@@ -4330,73 +3736,56 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
 }
 
 bool cmGeneratorTarget::GetLinkInterfaceDependentBoolProperty(
-    const std::string &p, const std::string& config) const
+  const std::string& p, const std::string& config) const
 {
-  return checkInterfacePropertyCompatibility<bool>(this, p, config,
-                                                   "FALSE",
+  return checkInterfacePropertyCompatibility<bool>(this, p, config, "FALSE",
                                                    BoolType, 0);
 }
 
 const char* cmGeneratorTarget::GetLinkInterfaceDependentStringProperty(
-                                              const std::string &p,
-                                              const std::string& config) const
+  const std::string& p, const std::string& config) const
 {
-  return checkInterfacePropertyCompatibility<const char *>(this,
-                                                           p,
-                                                           config,
-                                                           "empty",
-                                                     StringType, 0);
+  return checkInterfacePropertyCompatibility<const char*>(
+    this, p, config, "empty", StringType, 0);
 }
 
-const char * cmGeneratorTarget::GetLinkInterfaceDependentNumberMinProperty(
-                                              const std::string &p,
-                                              const std::string& config) const
+const char* cmGeneratorTarget::GetLinkInterfaceDependentNumberMinProperty(
+  const std::string& p, const std::string& config) const
 {
-  return checkInterfacePropertyCompatibility<const char *>(this,
-                                                           p,
-                                                           config,
-                                                           "empty",
-                                                   NumberMinType, 0);
+  return checkInterfacePropertyCompatibility<const char*>(
+    this, p, config, "empty", NumberMinType, 0);
 }
 
-const char * cmGeneratorTarget::GetLinkInterfaceDependentNumberMaxProperty(
-                                              const std::string &p,
-                                              const std::string& config) const
+const char* cmGeneratorTarget::GetLinkInterfaceDependentNumberMaxProperty(
+  const std::string& p, const std::string& config) const
 {
-  return checkInterfacePropertyCompatibility<const char *>(this,
-                                                           p,
-                                                           config,
-                                                           "empty",
-                                                   NumberMaxType, 0);
+  return checkInterfacePropertyCompatibility<const char*>(
+    this, p, config, "empty", NumberMaxType, 0);
 }
 
-cmComputeLinkInformation*
-cmGeneratorTarget::GetLinkInformation(const std::string& config) const
+cmComputeLinkInformation* cmGeneratorTarget::GetLinkInformation(
+  const std::string& config) const
 {
   // Lookup any existing information for this configuration.
   std::string key(cmSystemTools::UpperCase(config));
-  cmTargetLinkInformationMap::iterator
-    i = this->LinkInformation.find(key);
-  if(i == this->LinkInformation.end())
-    {
+  cmTargetLinkInformationMap::iterator i = this->LinkInformation.find(key);
+  if (i == this->LinkInformation.end()) {
     // Compute information for this configuration.
     cmComputeLinkInformation* info =
       new cmComputeLinkInformation(this, config);
-    if(!info || !info->Compute())
-      {
+    if (!info || !info->Compute()) {
       delete info;
       info = 0;
-      }
+    }
 
     // Store the information for this configuration.
     cmTargetLinkInformationMap::value_type entry(key, info);
     i = this->LinkInformation.insert(entry).first;
 
-    if (info)
-      {
+    if (info) {
       this->CheckPropertyCompatibility(info, config);
-      }
     }
+  }
   return i->second;
 }
 
@@ -4406,8 +3795,8 @@ void cmGeneratorTarget::GetTargetVersion(int& major, int& minor) const
   this->GetTargetVersion(false, major, minor, patch);
 }
 
-void cmGeneratorTarget::GetTargetVersion(bool soversion,
-                                int& major, int& minor, int& patch) const
+void cmGeneratorTarget::GetTargetVersion(bool soversion, int& major,
+                                         int& minor, int& patch) const
 {
   // Set the default values.
   major = 0;
@@ -4417,56 +3806,52 @@ void cmGeneratorTarget::GetTargetVersion(bool soversion,
   assert(this->GetType() != cmState::INTERFACE_LIBRARY);
 
   // Look for a VERSION or SOVERSION property.
-  const char* prop = soversion? "SOVERSION" : "VERSION";
-  if(const char* version = this->GetProperty(prop))
-    {
+  const char* prop = soversion ? "SOVERSION" : "VERSION";
+  if (const char* version = this->GetProperty(prop)) {
     // Try to parse the version number and store the results that were
     // successfully parsed.
     int parsed_major;
     int parsed_minor;
     int parsed_patch;
-    switch(sscanf(version, "%d.%d.%d",
-                  &parsed_major, &parsed_minor, &parsed_patch))
-      {
-      case 3: patch = parsed_patch; // no break!
-      case 2: minor = parsed_minor; // no break!
-      case 1: major = parsed_major; // no break!
-      default: break;
-      }
+    switch (sscanf(version, "%d.%d.%d", &parsed_major, &parsed_minor,
+                   &parsed_patch)) {
+      case 3:
+        patch = parsed_patch; // no break!
+      case 2:
+        minor = parsed_minor; // no break!
+      case 1:
+        major = parsed_major; // no break!
+      default:
+        break;
     }
+  }
 }
 
 std::string cmGeneratorTarget::GetFrameworkVersion() const
 {
   assert(this->GetType() != cmState::INTERFACE_LIBRARY);
 
-  if(const char* fversion = this->GetProperty("FRAMEWORK_VERSION"))
-    {
+  if (const char* fversion = this->GetProperty("FRAMEWORK_VERSION")) {
     return fversion;
-    }
-  else if(const char* tversion = this->GetProperty("VERSION"))
-    {
+  } else if (const char* tversion = this->GetProperty("VERSION")) {
     return tversion;
-    }
-  else
-    {
+  } else {
     return "A";
-    }
+  }
 }
 
 void cmGeneratorTarget::ComputeVersionedName(std::string& vName,
-                                    std::string const& prefix,
-                                    std::string const& base,
-                                    std::string const& suffix,
-                                    std::string const& name,
-                                    const char* version) const
-{
-  vName = this->Makefile->IsOn("APPLE") ? (prefix+base) : name;
-  if(version)
-    {
+                                             std::string const& prefix,
+                                             std::string const& base,
+                                             std::string const& suffix,
+                                             std::string const& name,
+                                             const char* version) const
+{
+  vName = this->Makefile->IsOn("APPLE") ? (prefix + base) : name;
+  if (version) {
     vName += ".";
     vName += version;
-    }
+  }
   vName += this->Makefile->IsOn("APPLE") ? suffix : std::string();
 }
 
@@ -4476,41 +3861,33 @@ std::vector<std::string> cmGeneratorTarget::GetPropertyKeys() const
   std::vector<std::string> props;
   props.reserve(propsObject.size());
   for (cmPropertyMap::const_iterator it = propsObject.begin();
-       it != propsObject.end(); ++it)
-    {
+       it != propsObject.end(); ++it) {
     props.push_back(it->first);
-    }
+  }
   return props;
 }
 
-void
-cmGeneratorTarget::ReportPropertyOrigin(const std::string &p,
-                               const std::string &result,
-                               const std::string &report,
-                               const std::string &compatibilityType) const
+void cmGeneratorTarget::ReportPropertyOrigin(
+  const std::string& p, const std::string& result, const std::string& report,
+  const std::string& compatibilityType) const
 {
   std::vector<std::string> debugProperties;
-  const char *debugProp = this->Target->GetMakefile()
-      ->GetDefinition("CMAKE_DEBUG_TARGET_PROPERTIES");
-  if (debugProp)
-    {
+  const char* debugProp = this->Target->GetMakefile()->GetDefinition(
+    "CMAKE_DEBUG_TARGET_PROPERTIES");
+  if (debugProp) {
     cmSystemTools::ExpandListArgument(debugProp, debugProperties);
-    }
+  }
 
-  bool debugOrigin = !this->DebugCompatiblePropertiesDone[p]
-                    && std::find(debugProperties.begin(),
-                                 debugProperties.end(),
-                                 p)
-                        != debugProperties.end();
+  bool debugOrigin = !this->DebugCompatiblePropertiesDone[p] &&
+    std::find(debugProperties.begin(), debugProperties.end(), p) !=
+      debugProperties.end();
 
-  if (this->GlobalGenerator->GetConfigureDoneCMP0026())
-    {
+  if (this->GlobalGenerator->GetConfigureDoneCMP0026()) {
     this->DebugCompatiblePropertiesDone[p] = true;
-    }
-  if (!debugOrigin)
-    {
+  }
+  if (!debugOrigin) {
     return;
-    }
+  }
 
   std::string areport = compatibilityType;
   areport += std::string(" of property \"") + p + "\" for target \"";
@@ -4523,293 +3900,240 @@ cmGeneratorTarget::ReportPropertyOrigin(const std::string &p,
 }
 
 void cmGeneratorTarget::LookupLinkItems(std::vector<std::string> const& names,
-                               std::vector<cmLinkItem>& items) const
+                                        std::vector<cmLinkItem>& items) const
 {
-  for(std::vector<std::string>::const_iterator i = names.begin();
-      i != names.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = names.begin();
+       i != names.end(); ++i) {
     std::string name = this->CheckCMP0004(*i);
-    if(name == this->GetName() || name.empty())
-      {
+    if (name == this->GetName() || name.empty()) {
       continue;
-      }
-    items.push_back(cmLinkItem(name, this->FindTargetToLink(name)));
     }
+    items.push_back(cmLinkItem(name, this->FindTargetToLink(name)));
+  }
 }
 
-void cmGeneratorTarget::ExpandLinkItems(std::string const& prop,
-                               std::string const& value,
-                               std::string const& config,
-                               cmGeneratorTarget const* headTarget,
-                               bool usage_requirements_only,
-                               std::vector<cmLinkItem>& items,
-                               bool& hadHeadSensitiveCondition) const
+void cmGeneratorTarget::ExpandLinkItems(
+  std::string const& prop, std::string const& value, std::string const& config,
+  cmGeneratorTarget const* headTarget, bool usage_requirements_only,
+  std::vector<cmLinkItem>& items, bool& hadHeadSensitiveCondition) const
 {
   cmGeneratorExpression ge;
   cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), prop, 0, 0);
   // The $<LINK_ONLY> expression may be in a link interface to specify private
   // link dependencies that are otherwise excluded from usage requirements.
-  if(usage_requirements_only)
-    {
+  if (usage_requirements_only) {
     dagChecker.SetTransitivePropertiesOnly();
-    }
+  }
   std::vector<std::string> libs;
   cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value);
-  cmSystemTools::ExpandListArgument(cge->Evaluate(
-                                      this->LocalGenerator,
-                                      config,
-                                      false,
-                                      headTarget,
-                                      this, &dagChecker), libs);
+  cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator, config,
+                                                  false, headTarget, this,
+                                                  &dagChecker),
+                                    libs);
   this->LookupLinkItems(libs, items);
   hadHeadSensitiveCondition = cge->GetHadHeadSensitiveCondition();
 }
 
-cmLinkInterface const*
-cmGeneratorTarget::GetLinkInterface(const std::string& config,
-                                    cmGeneratorTarget const* head) const
+cmLinkInterface const* cmGeneratorTarget::GetLinkInterface(
+  const std::string& config, cmGeneratorTarget const* head) const
 {
   // Imported targets have their own link interface.
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return this->GetImportLinkInterface(config, head, false);
-    }
+  }
 
   // Link interfaces are not supported for executables that do not
   // export symbols.
-  if(this->GetType() == cmState::EXECUTABLE &&
-     !this->IsExecutableWithExports())
-    {
+  if (this->GetType() == cmState::EXECUTABLE &&
+      !this->IsExecutableWithExports()) {
     return 0;
-    }
+  }
 
   // Lookup any existing link interface for this configuration.
-  cmHeadToLinkInterfaceMap& hm =
-      this->GetHeadToLinkInterfaceMap(config);
+  cmHeadToLinkInterfaceMap& hm = this->GetHeadToLinkInterfaceMap(config);
 
   // If the link interface does not depend on the head target
   // then return the one we computed first.
-  if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition)
-    {
+  if (!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) {
     return &hm.begin()->second;
-    }
+  }
 
   cmOptionalLinkInterface& iface = hm[head];
-  if(!iface.LibrariesDone)
-    {
+  if (!iface.LibrariesDone) {
     iface.LibrariesDone = true;
-    this->ComputeLinkInterfaceLibraries(
-      config, iface, head, false);
-    }
-  if(!iface.AllDone)
-    {
+    this->ComputeLinkInterfaceLibraries(config, iface, head, false);
+  }
+  if (!iface.AllDone) {
     iface.AllDone = true;
-    if(iface.Exists)
-      {
+    if (iface.Exists) {
       this->ComputeLinkInterface(config, iface, head);
-      }
     }
+  }
 
-  return iface.Exists? &iface : 0;
+  return iface.Exists ? &iface : 0;
 }
 
-void cmGeneratorTarget::ComputeLinkInterface(const std::string& config,
-                                    cmOptionalLinkInterface &iface,
-                                    cmGeneratorTarget const* headTarget) const
+void cmGeneratorTarget::ComputeLinkInterface(
+  const std::string& config, cmOptionalLinkInterface& iface,
+  cmGeneratorTarget const* headTarget) const
 {
-  if(iface.ExplicitLibraries)
-    {
-    if(this->GetType() == cmState::SHARED_LIBRARY
-        || this->GetType() == cmState::STATIC_LIBRARY
-        || this->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  if (iface.ExplicitLibraries) {
+    if (this->GetType() == cmState::SHARED_LIBRARY ||
+        this->GetType() == cmState::STATIC_LIBRARY ||
+        this->GetType() == cmState::INTERFACE_LIBRARY) {
       // Shared libraries may have runtime implementation dependencies
       // on other shared libraries that are not in the interface.
       UNORDERED_SET<std::string> emitted;
-      for(std::vector<cmLinkItem>::const_iterator
-          li = iface.Libraries.begin(); li != iface.Libraries.end(); ++li)
-        {
+      for (std::vector<cmLinkItem>::const_iterator li =
+             iface.Libraries.begin();
+           li != iface.Libraries.end(); ++li) {
         emitted.insert(*li);
-        }
-      if (this->GetType() != cmState::INTERFACE_LIBRARY)
-        {
-        cmLinkImplementation const* impl =
-            this->GetLinkImplementation(config);
-        for(std::vector<cmLinkImplItem>::const_iterator
-              li = impl->Libraries.begin(); li != impl->Libraries.end(); ++li)
-          {
-          if(emitted.insert(*li).second)
-            {
-            if(li->Target)
-              {
+      }
+      if (this->GetType() != cmState::INTERFACE_LIBRARY) {
+        cmLinkImplementation const* impl = this->GetLinkImplementation(config);
+        for (std::vector<cmLinkImplItem>::const_iterator li =
+               impl->Libraries.begin();
+             li != impl->Libraries.end(); ++li) {
+          if (emitted.insert(*li).second) {
+            if (li->Target) {
               // This is a runtime dependency on another shared library.
-              if(li->Target->GetType() == cmState::SHARED_LIBRARY)
-                {
+              if (li->Target->GetType() == cmState::SHARED_LIBRARY) {
                 iface.SharedDeps.push_back(*li);
-                }
               }
-            else
-              {
+            } else {
               // TODO: Recognize shared library file names.  Perhaps this
               // should be moved to cmComputeLinkInformation, but that creates
               // a chicken-and-egg problem since this list is needed for its
               // construction.
-              }
             }
           }
         }
       }
     }
-  else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN
-        || this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
-    {
+  } else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN ||
+             this->GetPolicyStatusCMP0022() == cmPolicies::OLD) {
     // The link implementation is the default link interface.
-    cmLinkImplementationLibraries const*
-      impl = this->GetLinkImplementationLibrariesInternal(config,
-                                                          headTarget);
+    cmLinkImplementationLibraries const* impl =
+      this->GetLinkImplementationLibrariesInternal(config, headTarget);
     iface.ImplementationIsInterface = true;
     iface.WrongConfigLibraries = impl->WrongConfigLibraries;
-    }
+  }
 
-  if(this->LinkLanguagePropagatesToDependents())
-    {
+  if (this->LinkLanguagePropagatesToDependents()) {
     // Targets using this archive need its language runtime libraries.
-    if(cmLinkImplementation const* impl =
-       this->GetLinkImplementation(config))
-      {
+    if (cmLinkImplementation const* impl =
+          this->GetLinkImplementation(config)) {
       iface.Languages = impl->Languages;
-      }
     }
+  }
 
-  if(this->GetType() == cmState::STATIC_LIBRARY)
-    {
+  if (this->GetType() == cmState::STATIC_LIBRARY) {
     // Construct the property name suffix for this configuration.
     std::string suffix = "_";
-    if(!config.empty())
-      {
+    if (!config.empty()) {
       suffix += cmSystemTools::UpperCase(config);
-      }
-    else
-      {
+    } else {
       suffix += "NOCONFIG";
-      }
+    }
 
     // How many repetitions are needed if this library has cyclic
     // dependencies?
     std::string propName = "LINK_INTERFACE_MULTIPLICITY";
     propName += suffix;
-    if(const char* config_reps = this->GetProperty(propName))
-      {
+    if (const char* config_reps = this->GetProperty(propName)) {
       sscanf(config_reps, "%u", &iface.Multiplicity);
-      }
-    else if(const char* reps =
-            this->GetProperty("LINK_INTERFACE_MULTIPLICITY"))
-      {
+    } else if (const char* reps =
+                 this->GetProperty("LINK_INTERFACE_MULTIPLICITY")) {
       sscanf(reps, "%u", &iface.Multiplicity);
-      }
     }
+  }
 }
 
-const cmLinkInterfaceLibraries *
-cmGeneratorTarget::GetLinkInterfaceLibraries(const std::string& config,
-                                    cmGeneratorTarget const* head,
-                                    bool usage_requirements_only) const
+const cmLinkInterfaceLibraries* cmGeneratorTarget::GetLinkInterfaceLibraries(
+  const std::string& config, cmGeneratorTarget const* head,
+  bool usage_requirements_only) const
 {
   // Imported targets have their own link interface.
-  if(this->IsImported())
-    {
-    return this->GetImportLinkInterface(config, head,
-                                                usage_requirements_only);
-    }
+  if (this->IsImported()) {
+    return this->GetImportLinkInterface(config, head, usage_requirements_only);
+  }
 
   // Link interfaces are not supported for executables that do not
   // export symbols.
-  if(this->GetType() == cmState::EXECUTABLE &&
-     !this->IsExecutableWithExports())
-    {
+  if (this->GetType() == cmState::EXECUTABLE &&
+      !this->IsExecutableWithExports()) {
     return 0;
-    }
+  }
 
   // Lookup any existing link interface for this configuration.
   std::string CONFIG = cmSystemTools::UpperCase(config);
   cmHeadToLinkInterfaceMap& hm =
-    (usage_requirements_only ?
-     this->GetHeadToLinkInterfaceUsageRequirementsMap(config) :
-     this->GetHeadToLinkInterfaceMap(config));
+    (usage_requirements_only
+       ? this->GetHeadToLinkInterfaceUsageRequirementsMap(config)
+       : this->GetHeadToLinkInterfaceMap(config));
 
   // If the link interface does not depend on the head target
   // then return the one we computed first.
-  if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition)
-    {
+  if (!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) {
     return &hm.begin()->second;
-    }
+  }
 
   cmOptionalLinkInterface& iface = hm[head];
-  if(!iface.LibrariesDone)
-    {
+  if (!iface.LibrariesDone) {
     iface.LibrariesDone = true;
-    this->ComputeLinkInterfaceLibraries(
-      config, iface, head, usage_requirements_only);
-    }
+    this->ComputeLinkInterfaceLibraries(config, iface, head,
+                                        usage_requirements_only);
+  }
 
-  return iface.Exists? &iface : 0;
+  return iface.Exists ? &iface : 0;
 }
 
 std::string cmGeneratorTarget::GetDirectory(const std::string& config,
-                                   bool implib) const
+                                            bool implib) const
 {
-  if (this->IsImported())
-    {
+  if (this->IsImported()) {
     // Return the directory from which the target is imported.
-    return
-      cmSystemTools::GetFilenamePath(
+    return cmSystemTools::GetFilenamePath(
       this->Target->ImportedGetFullPath(config, implib));
-    }
-  else if(OutputInfo const* info = this->GetOutputInfo(config))
-    {
+  } else if (OutputInfo const* info = this->GetOutputInfo(config)) {
     // Return the directory in which the target will be built.
-    return implib? info->ImpDir : info->OutDir;
-    }
+    return implib ? info->ImpDir : info->OutDir;
+  }
   return "";
 }
 
 bool cmGeneratorTarget::UsesDefaultOutputDir(const std::string& config,
-                                    bool implib) const
+                                             bool implib) const
 {
   std::string dir;
   return this->ComputeOutputDir(config, implib, dir);
 }
 
 cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo(
-    const std::string& config) const
+  const std::string& config) const
 {
   // There is no output information for imported targets.
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return 0;
-    }
+  }
 
   // Only libraries and executables have well-defined output files.
-  if(!this->HaveWellDefinedOutputFiles())
-    {
+  if (!this->HaveWellDefinedOutputFiles()) {
     std::string msg = "cmGeneratorTarget::GetOutputInfo called for ";
     msg += this->GetName();
     msg += " which has type ";
     msg += cmState::GetTargetTypeName(this->GetType());
     this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg);
     return 0;
-    }
+  }
 
   // Lookup/compute/cache the output information for this configuration.
   std::string config_upper;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     config_upper = cmSystemTools::UpperCase(config);
-    }
-  OutputInfoMapType::iterator i =
-    this->OutputInfoMap.find(config_upper);
-  if(i == this->OutputInfoMap.end())
-    {
+  }
+  OutputInfoMapType::iterator i = this->OutputInfoMap.find(config_upper);
+  if (i == this->OutputInfoMap.end()) {
     // Add empty info in map to detect potential recursion.
     OutputInfo info;
     OutputInfoMapType::value_type entry(config_upper, info);
@@ -4818,16 +4142,13 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo(
     // Compute output directories.
     this->ComputeOutputDir(config, false, info.OutDir);
     this->ComputeOutputDir(config, true, info.ImpDir);
-    if(!this->ComputePDBOutputDir("PDB", config, info.PdbDir))
-      {
+    if (!this->ComputePDBOutputDir("PDB", config, info.PdbDir)) {
       info.PdbDir = info.OutDir;
-      }
+    }
 
     // Now update the previously-prepared map entry.
     i->second = info;
-    }
-  else if(i->second.empty())
-    {
+  } else if (i->second.empty()) {
     // An empty map entry indicates we have been called recursively
     // from the above block.
     this->LocalGenerator->GetCMakeInstance()->IssueMessage(
@@ -4835,12 +4156,12 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo(
       "Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.",
       this->GetBacktrace());
     return 0;
-    }
+  }
   return &i->second;
 }
 
 bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
-                                bool implib, std::string& out) const
+                                         bool implib, std::string& out) const
 {
   bool usesDefaultOutputDir = false;
   std::string conf = config;
@@ -4850,26 +4171,23 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
   std::string targetTypeName = this->GetOutputTargetType(implib);
   const char* propertyName = 0;
   std::string propertyNameStr = targetTypeName;
-  if(!propertyNameStr.empty())
-    {
+  if (!propertyNameStr.empty()) {
     propertyNameStr += "_OUTPUT_DIRECTORY";
     propertyName = propertyNameStr.c_str();
-    }
+  }
 
   // Check for a per-configuration output directory target property.
   std::string configUpper = cmSystemTools::UpperCase(conf);
   const char* configProp = 0;
   std::string configPropStr = targetTypeName;
-  if(!configPropStr.empty())
-    {
+  if (!configPropStr.empty()) {
     configPropStr += "_OUTPUT_DIRECTORY_";
     configPropStr += configUpper;
     configProp = configPropStr.c_str();
-    }
+  }
 
   // Select an output directory.
-  if(const char* config_outdir = this->GetProperty(configProp))
-    {
+  if (const char* config_outdir = this->GetProperty(configProp)) {
     // Use the user-specified per-configuration output directory.
     cmGeneratorExpression ge;
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
@@ -4878,117 +4196,100 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
 
     // Skip per-configuration subdirectory.
     conf = "";
-    }
-  else if(const char* outdir = this->GetProperty(propertyName))
-    {
+  } else if (const char* outdir = this->GetProperty(propertyName)) {
     // Use the user-specified output directory.
     cmGeneratorExpression ge;
-    cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
-      ge.Parse(outdir);
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
     out = cge->Evaluate(this->LocalGenerator, config);
 
     // Skip per-configuration subdirectory if the value contained a
     // generator expression.
-    if (out != outdir)
-      {
+    if (out != outdir) {
       conf = "";
-      }
     }
-  else if(this->GetType() == cmState::EXECUTABLE)
-    {
+  } else if (this->GetType() == cmState::EXECUTABLE) {
     // Lookup the output path for executables.
     out = this->Makefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
-    }
-  else if(this->GetType() == cmState::STATIC_LIBRARY ||
-          this->GetType() == cmState::SHARED_LIBRARY ||
-          this->GetType() == cmState::MODULE_LIBRARY)
-    {
+  } else if (this->GetType() == cmState::STATIC_LIBRARY ||
+             this->GetType() == cmState::SHARED_LIBRARY ||
+             this->GetType() == cmState::MODULE_LIBRARY) {
     // Lookup the output path for libraries.
     out = this->Makefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
-    }
-  if(out.empty())
-    {
+  }
+  if (out.empty()) {
     // Default to the current output directory.
     usesDefaultOutputDir = true;
     out = ".";
-    }
+  }
 
   // Convert the output path to a full path in case it is
   // specified as a relative path.  Treat a relative path as
   // relative to the current output directory for this makefile.
-  out = (cmSystemTools::CollapseFullPath
-         (out, this->LocalGenerator->GetCurrentBinaryDirectory()));
+  out = (cmSystemTools::CollapseFullPath(
+    out, this->LocalGenerator->GetCurrentBinaryDirectory()));
 
   // The generator may add the configuration's subdirectory.
-  if(!conf.empty())
-    {
+  if (!conf.empty()) {
     bool iosPlatform = this->Makefile->PlatformIsAppleIos();
     std::string suffix =
       usesDefaultOutputDir && iosPlatform ? "${EFFECTIVE_PLATFORM_NAME}" : "";
-    this->LocalGenerator->GetGlobalGenerator()->
-      AppendDirectoryForConfig("/", conf, suffix, out);
-    }
+    this->LocalGenerator->GetGlobalGenerator()->AppendDirectoryForConfig(
+      "/", conf, suffix, out);
+  }
 
   return usesDefaultOutputDir;
 }
 
 bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind,
-                                   const std::string& config,
-                                   std::string& out) const
+                                            const std::string& config,
+                                            std::string& out) const
 {
   // Look for a target property defining the target output directory
   // based on the target type.
   const char* propertyName = 0;
   std::string propertyNameStr = kind;
-  if(!propertyNameStr.empty())
-    {
+  if (!propertyNameStr.empty()) {
     propertyNameStr += "_OUTPUT_DIRECTORY";
     propertyName = propertyNameStr.c_str();
-    }
+  }
   std::string conf = config;
 
   // Check for a per-configuration output directory target property.
   std::string configUpper = cmSystemTools::UpperCase(conf);
   const char* configProp = 0;
   std::string configPropStr = kind;
-  if(!configPropStr.empty())
-    {
+  if (!configPropStr.empty()) {
     configPropStr += "_OUTPUT_DIRECTORY_";
     configPropStr += configUpper;
     configProp = configPropStr.c_str();
-    }
+  }
 
   // Select an output directory.
-  if(const char* config_outdir = this->GetProperty(configProp))
-    {
+  if (const char* config_outdir = this->GetProperty(configProp)) {
     // Use the user-specified per-configuration output directory.
     out = config_outdir;
 
     // Skip per-configuration subdirectory.
     conf = "";
-    }
-  else if(const char* outdir = this->GetProperty(propertyName))
-    {
+  } else if (const char* outdir = this->GetProperty(propertyName)) {
     // Use the user-specified output directory.
     out = outdir;
-    }
-  if(out.empty())
-    {
+  }
+  if (out.empty()) {
     return false;
-    }
+  }
 
   // Convert the output path to a full path in case it is
   // specified as a relative path.  Treat a relative path as
   // relative to the current output directory for this makefile.
-  out = (cmSystemTools::CollapseFullPath
-         (out, this->LocalGenerator->GetCurrentBinaryDirectory()));
+  out = (cmSystemTools::CollapseFullPath(
+    out, this->LocalGenerator->GetCurrentBinaryDirectory()));
 
   // The generator may add the configuration's subdirectory.
-  if(!conf.empty())
-    {
-    this->LocalGenerator->GetGlobalGenerator()->
-      AppendDirectoryForConfig("/", conf, "", out);
-    }
+  if (!conf.empty()) {
+    this->LocalGenerator->GetGlobalGenerator()->AppendDirectoryForConfig(
+      "/", conf, "", out);
+  }
   return true;
 }
 
@@ -4996,41 +4297,32 @@ bool cmGeneratorTarget::HaveInstallTreeRPATH() const
 {
   const char* install_rpath = this->GetProperty("INSTALL_RPATH");
   return (install_rpath && *install_rpath) &&
-          !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH");
+    !this->Makefile->IsOn("CMAKE_SKIP_INSTALL_RPATH");
 }
 
-void
-cmGeneratorTarget::ComputeLinkInterfaceLibraries(
-  const std::string& config,
-  cmOptionalLinkInterface& iface,
-  cmGeneratorTarget const* headTarget,
-  bool usage_requirements_only) const
+void cmGeneratorTarget::ComputeLinkInterfaceLibraries(
+  const std::string& config, cmOptionalLinkInterface& iface,
+  cmGeneratorTarget const* headTarget, bool usage_requirements_only) const
 {
   // Construct the property name suffix for this configuration.
   std::string suffix = "_";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     suffix += cmSystemTools::UpperCase(config);
-    }
-  else
-    {
+  } else {
     suffix += "NOCONFIG";
-    }
+  }
 
   // An explicit list of interface libraries may be set for shared
   // libraries and executables that export symbols.
   const char* explicitLibraries = 0;
   std::string linkIfaceProp;
-  if(this->GetPolicyStatusCMP0022() != cmPolicies::OLD &&
-     this->GetPolicyStatusCMP0022() != cmPolicies::WARN)
-    {
+  if (this->GetPolicyStatusCMP0022() != cmPolicies::OLD &&
+      this->GetPolicyStatusCMP0022() != cmPolicies::WARN) {
     // CMP0022 NEW behavior is to use INTERFACE_LINK_LIBRARIES.
     linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
     explicitLibraries = this->GetProperty(linkIfaceProp);
-    }
-  else if(this->GetType() == cmState::SHARED_LIBRARY ||
-          this->IsExecutableWithExports())
-    {
+  } else if (this->GetType() == cmState::SHARED_LIBRARY ||
+             this->IsExecutableWithExports()) {
     // CMP0022 OLD behavior is to use LINK_INTERFACE_LIBRARIES if set on a
     // shared lib or executable.
 
@@ -5040,24 +4332,21 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
     explicitLibraries = this->GetProperty(linkIfaceProp);
 
     // If not set, try the generic property.
-    if(!explicitLibraries)
-      {
+    if (!explicitLibraries) {
       linkIfaceProp = "LINK_INTERFACE_LIBRARIES";
       explicitLibraries = this->GetProperty(linkIfaceProp);
-      }
     }
+  }
 
-  if(explicitLibraries &&
-     this->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
-     !this->PolicyWarnedCMP0022)
-    {
+  if (explicitLibraries &&
+      this->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
+      !this->PolicyWarnedCMP0022) {
     // Compare the explicitly set old link interface properties to the
     // preferred new link interface property one and warn if different.
     const char* newExplicitLibraries =
       this->GetProperty("INTERFACE_LINK_LIBRARIES");
-    if (newExplicitLibraries
-        && strcmp(newExplicitLibraries, explicitLibraries) != 0)
-      {
+    if (newExplicitLibraries &&
+        strcmp(newExplicitLibraries, explicitLibraries) != 0) {
       std::ostringstream w;
       /* clang-format off */
       w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0022) << "\n"
@@ -5072,64 +4361,56 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
       /* clang-format on */
       this->LocalGenerator->IssueMessage(cmake::AUTHOR_WARNING, w.str());
       this->PolicyWarnedCMP0022 = true;
-      }
     }
+  }
 
   // There is no implicit link interface for executables or modules
   // so if none was explicitly set then there is no link interface.
-  if(!explicitLibraries &&
-     (this->GetType() == cmState::EXECUTABLE ||
-      (this->GetType() == cmState::MODULE_LIBRARY)))
-    {
+  if (!explicitLibraries && (this->GetType() == cmState::EXECUTABLE ||
+                             (this->GetType() == cmState::MODULE_LIBRARY))) {
     return;
-    }
+  }
   iface.Exists = true;
   iface.ExplicitLibraries = explicitLibraries;
 
-  if(explicitLibraries)
-    {
+  if (explicitLibraries) {
     // The interface libraries have been explicitly set.
-    this->ExpandLinkItems(linkIfaceProp, explicitLibraries,
-                                  config,
-                                headTarget, usage_requirements_only,
-                                iface.Libraries,
-                                iface.HadHeadSensitiveCondition);
-    }
-  else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN
-        || this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
-    // If CMP0022 is NEW then the plain tll signature sets the
-    // INTERFACE_LINK_LIBRARIES, so if we get here then the project
-    // cleared the property explicitly and we should not fall back
-    // to the link implementation.
-    {
+    this->ExpandLinkItems(linkIfaceProp, explicitLibraries, config, headTarget,
+                          usage_requirements_only, iface.Libraries,
+                          iface.HadHeadSensitiveCondition);
+  } else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN ||
+             this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
+  // If CMP0022 is NEW then the plain tll signature sets the
+  // INTERFACE_LINK_LIBRARIES, so if we get here then the project
+  // cleared the property explicitly and we should not fall back
+  // to the link implementation.
+  {
     // The link implementation is the default link interface.
     cmLinkImplementationLibraries const* impl =
       this->GetLinkImplementationLibrariesInternal(config, headTarget);
-    iface.Libraries.insert(iface.Libraries.end(),
-                           impl->Libraries.begin(), impl->Libraries.end());
-    if(this->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
-       !this->PolicyWarnedCMP0022 && !usage_requirements_only)
-      {
+    iface.Libraries.insert(iface.Libraries.end(), impl->Libraries.begin(),
+                           impl->Libraries.end());
+    if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN &&
+        !this->PolicyWarnedCMP0022 && !usage_requirements_only) {
       // Compare the link implementation fallback link interface to the
       // preferred new link interface property and warn if different.
       std::vector<cmLinkItem> ifaceLibs;
       static const std::string newProp = "INTERFACE_LINK_LIBRARIES";
-      if(const char* newExplicitLibraries = this->GetProperty(newProp))
-        {
+      if (const char* newExplicitLibraries = this->GetProperty(newProp)) {
         bool hadHeadSensitiveConditionDummy = false;
         this->ExpandLinkItems(newProp, newExplicitLibraries, config,
-                              headTarget,
-                              usage_requirements_only,
-                              ifaceLibs, hadHeadSensitiveConditionDummy);
-        }
-      if (ifaceLibs != iface.Libraries)
-        {
+                              headTarget, usage_requirements_only, ifaceLibs,
+                              hadHeadSensitiveConditionDummy);
+      }
+      if (ifaceLibs != iface.Libraries) {
         std::string oldLibraries = cmJoin(impl->Libraries, ";");
         std::string newLibraries = cmJoin(ifaceLibs, ";");
-        if(oldLibraries.empty())
-          { oldLibraries = "(empty)"; }
-        if(newLibraries.empty())
-          { newLibraries = "(empty)"; }
+        if (oldLibraries.empty()) {
+          oldLibraries = "(empty)";
+        }
+        if (newLibraries.empty()) {
+          newLibraries = "(empty)";
+        }
 
         std::ostringstream w;
         /* clang-format off */
@@ -5148,102 +4429,88 @@ cmGeneratorTarget::ComputeLinkInterfaceLibraries(
         /* clang-format on */
         this->LocalGenerator->IssueMessage(cmake::AUTHOR_WARNING, w.str());
         this->PolicyWarnedCMP0022 = true;
-        }
       }
     }
+  }
 }
 
-const cmLinkInterface *
-cmGeneratorTarget::GetImportLinkInterface(const std::string& config,
-                                 cmGeneratorTarget const* headTarget,
-                                 bool usage_requirements_only) const
+const cmLinkInterface* cmGeneratorTarget::GetImportLinkInterface(
+  const std::string& config, cmGeneratorTarget const* headTarget,
+  bool usage_requirements_only) const
 {
   cmGeneratorTarget::ImportInfo const* info = this->GetImportInfo(config);
-  if(!info)
-    {
+  if (!info) {
     return 0;
-    }
+  }
 
   std::string CONFIG = cmSystemTools::UpperCase(config);
   cmHeadToLinkInterfaceMap& hm =
-    (usage_requirements_only ?
-     this->GetHeadToLinkInterfaceUsageRequirementsMap(config) :
-     this->GetHeadToLinkInterfaceMap(config));
+    (usage_requirements_only
+       ? this->GetHeadToLinkInterfaceUsageRequirementsMap(config)
+       : this->GetHeadToLinkInterfaceMap(config));
 
   // If the link interface does not depend on the head target
   // then return the one we computed first.
-  if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition)
-    {
+  if (!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) {
     return &hm.begin()->second;
-    }
+  }
 
   cmOptionalLinkInterface& iface = hm[headTarget];
-  if(!iface.AllDone)
-    {
+  if (!iface.AllDone) {
     iface.AllDone = true;
     iface.Multiplicity = info->Multiplicity;
     cmSystemTools::ExpandListArgument(info->Languages, iface.Languages);
-    this->ExpandLinkItems(info->LibrariesProp, info->Libraries,
-                                  config,
-                          headTarget, usage_requirements_only,
-                          iface.Libraries,
+    this->ExpandLinkItems(info->LibrariesProp, info->Libraries, config,
+                          headTarget, usage_requirements_only, iface.Libraries,
                           iface.HadHeadSensitiveCondition);
     std::vector<std::string> deps;
     cmSystemTools::ExpandListArgument(info->SharedDeps, deps);
     this->LookupLinkItems(deps, iface.SharedDeps);
-    }
+  }
 
   return &iface;
 }
 
-cmGeneratorTarget::ImportInfo const*
-cmGeneratorTarget::GetImportInfo(const std::string& config) const
+cmGeneratorTarget::ImportInfo const* cmGeneratorTarget::GetImportInfo(
+  const std::string& config) const
 {
   // There is no imported information for non-imported targets.
-  if(!this->IsImported())
-    {
+  if (!this->IsImported()) {
     return 0;
-    }
+  }
 
   // Lookup/compute/cache the import information for this
   // configuration.
   std::string config_upper;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     config_upper = cmSystemTools::UpperCase(config);
-    }
-  else
-    {
+  } else {
     config_upper = "NOCONFIG";
-    }
+  }
 
-  ImportInfoMapType::const_iterator i =
-    this->ImportInfoMap.find(config_upper);
-  if(i == this->ImportInfoMap.end())
-    {
+  ImportInfoMapType::const_iterator i = this->ImportInfoMap.find(config_upper);
+  if (i == this->ImportInfoMap.end()) {
     ImportInfo info;
     this->ComputeImportInfo(config_upper, info);
     ImportInfoMapType::value_type entry(config_upper, info);
     i = this->ImportInfoMap.insert(entry).first;
-    }
+  }
 
-  if(this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::INTERFACE_LIBRARY) {
     return &i->second;
-    }
+  }
   // If the location is empty then the target is not available for
   // this configuration.
-  if(i->second.Location.empty() && i->second.ImportLibrary.empty())
-    {
+  if (i->second.Location.empty() && i->second.ImportLibrary.empty()) {
     return 0;
-    }
+  }
 
   // Return the import information.
   return &i->second;
 }
 
 void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config,
-                                 ImportInfo& info) const
+                                          ImportInfo& info) const
 {
   // This method finds information about an imported target from its
   // properties.  The "IMPORTED_" namespace is reserved for properties
@@ -5255,164 +4522,128 @@ void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config,
   const char* loc = 0;
   const char* imp = 0;
   std::string suffix;
-  if (!this->Target->GetMappedConfig(desired_config, &loc, &imp, suffix))
-    {
+  if (!this->Target->GetMappedConfig(desired_config, &loc, &imp, suffix)) {
     return;
-    }
+  }
 
   // Get the link interface.
   {
-  std::string linkProp = "INTERFACE_LINK_LIBRARIES";
-  const char *propertyLibs = this->GetProperty(linkProp);
-
-  if (this->GetType() != cmState::INTERFACE_LIBRARY)
-    {
-    if(!propertyLibs)
-      {
-      linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES";
-      linkProp += suffix;
-      propertyLibs = this->GetProperty(linkProp);
+    std::string linkProp = "INTERFACE_LINK_LIBRARIES";
+    const char* propertyLibs = this->GetProperty(linkProp);
+
+    if (this->GetType() != cmState::INTERFACE_LIBRARY) {
+      if (!propertyLibs) {
+        linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES";
+        linkProp += suffix;
+        propertyLibs = this->GetProperty(linkProp);
       }
 
-    if(!propertyLibs)
-      {
-      linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES";
-      propertyLibs = this->GetProperty(linkProp);
+      if (!propertyLibs) {
+        linkProp = "IMPORTED_LINK_INTERFACE_LIBRARIES";
+        propertyLibs = this->GetProperty(linkProp);
       }
     }
-  if(propertyLibs)
-    {
-    info.LibrariesProp = linkProp;
-    info.Libraries = propertyLibs;
+    if (propertyLibs) {
+      info.LibrariesProp = linkProp;
+      info.Libraries = propertyLibs;
     }
   }
-  if(this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
+  }
 
   // A provided configuration has been chosen.  Load the
   // configuration's properties.
 
   // Get the location.
-  if(loc)
-    {
+  if (loc) {
     info.Location = loc;
-    }
-  else
-    {
+  } else {
     std::string impProp = "IMPORTED_LOCATION";
     impProp += suffix;
-    if(const char* config_location = this->GetProperty(impProp))
-      {
+    if (const char* config_location = this->GetProperty(impProp)) {
       info.Location = config_location;
-      }
-    else if(const char* location = this->GetProperty("IMPORTED_LOCATION"))
-      {
+    } else if (const char* location = this->GetProperty("IMPORTED_LOCATION")) {
       info.Location = location;
-      }
     }
+  }
 
   // Get the soname.
-  if(this->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (this->GetType() == cmState::SHARED_LIBRARY) {
     std::string soProp = "IMPORTED_SONAME";
     soProp += suffix;
-    if(const char* config_soname = this->GetProperty(soProp))
-      {
+    if (const char* config_soname = this->GetProperty(soProp)) {
       info.SOName = config_soname;
-      }
-    else if(const char* soname = this->GetProperty("IMPORTED_SONAME"))
-      {
+    } else if (const char* soname = this->GetProperty("IMPORTED_SONAME")) {
       info.SOName = soname;
-      }
     }
+  }
 
   // Get the "no-soname" mark.
-  if(this->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (this->GetType() == cmState::SHARED_LIBRARY) {
     std::string soProp = "IMPORTED_NO_SONAME";
     soProp += suffix;
-    if(const char* config_no_soname = this->GetProperty(soProp))
-      {
+    if (const char* config_no_soname = this->GetProperty(soProp)) {
       info.NoSOName = cmSystemTools::IsOn(config_no_soname);
-      }
-    else if(const char* no_soname = this->GetProperty("IMPORTED_NO_SONAME"))
-      {
+    } else if (const char* no_soname =
+                 this->GetProperty("IMPORTED_NO_SONAME")) {
       info.NoSOName = cmSystemTools::IsOn(no_soname);
-      }
     }
+  }
 
   // Get the import library.
-  if(imp)
-    {
+  if (imp) {
     info.ImportLibrary = imp;
-    }
-  else if(this->GetType() == cmState::SHARED_LIBRARY ||
-          this->IsExecutableWithExports())
-    {
+  } else if (this->GetType() == cmState::SHARED_LIBRARY ||
+             this->IsExecutableWithExports()) {
     std::string impProp = "IMPORTED_IMPLIB";
     impProp += suffix;
-    if(const char* config_implib = this->GetProperty(impProp))
-      {
+    if (const char* config_implib = this->GetProperty(impProp)) {
       info.ImportLibrary = config_implib;
-      }
-    else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB"))
-      {
+    } else if (const char* implib = this->GetProperty("IMPORTED_IMPLIB")) {
       info.ImportLibrary = implib;
-      }
     }
+  }
 
   // Get the link dependencies.
   {
-  std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES";
-  linkProp += suffix;
-  if(const char* config_libs = this->GetProperty(linkProp))
-    {
-    info.SharedDeps = config_libs;
-    }
-  else if(const char* libs =
-          this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES"))
-    {
-    info.SharedDeps = libs;
+    std::string linkProp = "IMPORTED_LINK_DEPENDENT_LIBRARIES";
+    linkProp += suffix;
+    if (const char* config_libs = this->GetProperty(linkProp)) {
+      info.SharedDeps = config_libs;
+    } else if (const char* libs =
+                 this->GetProperty("IMPORTED_LINK_DEPENDENT_LIBRARIES")) {
+      info.SharedDeps = libs;
     }
   }
 
   // Get the link languages.
-  if(this->LinkLanguagePropagatesToDependents())
-    {
+  if (this->LinkLanguagePropagatesToDependents()) {
     std::string linkProp = "IMPORTED_LINK_INTERFACE_LANGUAGES";
     linkProp += suffix;
-    if(const char* config_libs = this->GetProperty(linkProp))
-      {
+    if (const char* config_libs = this->GetProperty(linkProp)) {
       info.Languages = config_libs;
-      }
-    else if(const char* libs =
-            this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES"))
-      {
+    } else if (const char* libs =
+                 this->GetProperty("IMPORTED_LINK_INTERFACE_LANGUAGES")) {
       info.Languages = libs;
-      }
     }
+  }
 
   // Get the cyclic repetition count.
-  if(this->GetType() == cmState::STATIC_LIBRARY)
-    {
+  if (this->GetType() == cmState::STATIC_LIBRARY) {
     std::string linkProp = "IMPORTED_LINK_INTERFACE_MULTIPLICITY";
     linkProp += suffix;
-    if(const char* config_reps = this->GetProperty(linkProp))
-      {
+    if (const char* config_reps = this->GetProperty(linkProp)) {
       sscanf(config_reps, "%u", &info.Multiplicity);
-      }
-    else if(const char* reps =
-            this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY"))
-      {
+    } else if (const char* reps =
+                 this->GetProperty("IMPORTED_LINK_INTERFACE_MULTIPLICITY")) {
       sscanf(reps, "%u", &info.Multiplicity);
-      }
     }
+  }
 }
 
-cmHeadToLinkInterfaceMap&
-cmGeneratorTarget::GetHeadToLinkInterfaceMap(const std::string &config) const
+cmHeadToLinkInterfaceMap& cmGeneratorTarget::GetHeadToLinkInterfaceMap(
+  const std::string& config) const
 {
   std::string CONFIG = cmSystemTools::UpperCase(config);
   return this->LinkInterfaceMap[CONFIG];
@@ -5420,75 +4651,67 @@ cmGeneratorTarget::GetHeadToLinkInterfaceMap(const std::string &config) const
 
 cmHeadToLinkInterfaceMap&
 cmGeneratorTarget::GetHeadToLinkInterfaceUsageRequirementsMap(
-    const std::string &config) const
+  const std::string& config) const
 {
   std::string CONFIG = cmSystemTools::UpperCase(config);
   return this->LinkInterfaceUsageRequirementsOnlyMap[CONFIG];
 }
 
-const cmLinkImplementation *
-cmGeneratorTarget::GetLinkImplementation(const std::string& config) const
+const cmLinkImplementation* cmGeneratorTarget::GetLinkImplementation(
+  const std::string& config) const
 {
   // There is no link implementation for imported targets.
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return 0;
-    }
+  }
 
   std::string CONFIG = cmSystemTools::UpperCase(config);
   cmOptionalLinkImplementation& impl = this->LinkImplMap[CONFIG][this];
-  if(!impl.LibrariesDone)
-    {
+  if (!impl.LibrariesDone) {
     impl.LibrariesDone = true;
     this->ComputeLinkImplementationLibraries(config, impl, this);
-    }
-  if(!impl.LanguagesDone)
-    {
+  }
+  if (!impl.LanguagesDone) {
     impl.LanguagesDone = true;
     this->ComputeLinkImplementationLanguages(config, impl);
-    }
+  }
   return &impl;
 }
 
 bool cmGeneratorTarget::GetConfigCommonSourceFiles(
-    std::vector<cmSourceFile*>& files) const
+  std::vector<cmSourceFile*>& files) const
 {
   std::vector<std::string> configs;
   this->Makefile->GetConfigurations(configs);
-  if (configs.empty())
-    {
+  if (configs.empty()) {
     configs.push_back("");
-    }
+  }
 
   std::vector<std::string>::const_iterator it = configs.begin();
   const std::string& firstConfig = *it;
   this->GetSourceFiles(files, firstConfig);
 
-  for ( ; it != configs.end(); ++it)
-    {
+  for (; it != configs.end(); ++it) {
     std::vector<cmSourceFile*> configFiles;
     this->GetSourceFiles(configFiles, *it);
-    if (configFiles != files)
-      {
+    if (configFiles != files) {
       std::string firstConfigFiles;
       const char* sep = "";
       for (std::vector<cmSourceFile*>::const_iterator fi = files.begin();
-           fi != files.end(); ++fi)
-        {
+           fi != files.end(); ++fi) {
         firstConfigFiles += sep;
         firstConfigFiles += (*fi)->GetFullPath();
         sep = "\n  ";
-        }
+      }
 
       std::string thisConfigFiles;
       sep = "";
       for (std::vector<cmSourceFile*>::const_iterator fi = configFiles.begin();
-           fi != configFiles.end(); ++fi)
-        {
+           fi != configFiles.end(); ++fi) {
         thisConfigFiles += sep;
         thisConfigFiles += (*fi)->GetFullPath();
         sep = "\n  ";
-        }
+      }
       std::ostringstream e;
       /* clang-format off */
       e << "Target \"" << this->GetName()
@@ -5503,13 +4726,13 @@ bool cmGeneratorTarget::GetConfigCommonSourceFiles(
       /* clang-format on */
       this->LocalGenerator->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
     }
+  }
   return true;
 }
 
 void cmGeneratorTarget::GetObjectLibrariesCMP0026(
-    std::vector<cmGeneratorTarget*>& objlibs) const
+  std::vector<cmGeneratorTarget*>& objlibs) const
 {
   // At configure-time, this method can be called as part of getting the
   // LOCATION property or to export() a file to be include()d.  However
@@ -5517,34 +4740,29 @@ void cmGeneratorTarget::GetObjectLibrariesCMP0026(
   // for TARGET_OBJECTS instead for backwards compatibility with OLD
   // behavior of CMP0024 and CMP0026 only.
   cmStringRange rng = this->Target->GetSourceEntries();
-  for(std::vector<std::string>::const_iterator
-        i = rng.begin(); i != rng.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = rng.begin();
+       i != rng.end(); ++i) {
     std::string const& entry = *i;
 
     std::vector<std::string> files;
     cmSystemTools::ExpandListArgument(entry, files);
-    for (std::vector<std::string>::const_iterator
-        li = files.begin(); li != files.end(); ++li)
-      {
-      if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
-          (*li)[li->size() - 1] == '>')
-        {
-        std::string objLibName = li->substr(17, li->size()-18);
-
-        if (cmGeneratorExpression::Find(objLibName) != std::string::npos)
-          {
+    for (std::vector<std::string>::const_iterator li = files.begin();
+         li != files.end(); ++li) {
+      if (cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
+          (*li)[li->size() - 1] == '>') {
+        std::string objLibName = li->substr(17, li->size() - 18);
+
+        if (cmGeneratorExpression::Find(objLibName) != std::string::npos) {
           continue;
-          }
-        cmGeneratorTarget *objLib =
-            this->LocalGenerator->FindGeneratorTargetToUse(objLibName);
-        if(objLib)
-          {
+        }
+        cmGeneratorTarget* objLib =
+          this->LocalGenerator->FindGeneratorTargetToUse(objLibName);
+        if (objLib) {
           objlibs.push_back(objLib);
-          }
         }
       }
     }
+  }
 }
 
 std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
@@ -5554,227 +4772,190 @@ std::string cmGeneratorTarget::CheckCMP0004(std::string const& item) const
   // do the expansion but users link to libraries like " ${VAR} ".
   std::string lib = item;
   std::string::size_type pos = lib.find_first_not_of(" \t\r\n");
-  if(pos != lib.npos)
-    {
+  if (pos != lib.npos) {
     lib = lib.substr(pos, lib.npos);
-    }
+  }
   pos = lib.find_last_not_of(" \t\r\n");
-  if(pos != lib.npos)
-    {
-    lib = lib.substr(0, pos+1);
-    }
-  if(lib != item)
-    {
+  if (pos != lib.npos) {
+    lib = lib.substr(0, pos + 1);
+  }
+  if (lib != item) {
     cmake* cm = this->LocalGenerator->GetCMakeInstance();
-    switch(this->GetPolicyStatusCMP0004())
-      {
-      case cmPolicies::WARN:
-        {
+    switch (this->GetPolicyStatusCMP0004()) {
+      case cmPolicies::WARN: {
         std::ostringstream w;
         w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n"
-          << "Target \"" << this->GetName() << "\" links to item \""
-          << item << "\" which has leading or trailing whitespace.";
-        cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
-                         this->GetBacktrace());
-        }
+          << "Target \"" << this->GetName() << "\" links to item \"" << item
+          << "\" which has leading or trailing whitespace.";
+        cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(), this->GetBacktrace());
+      }
       case cmPolicies::OLD:
         break;
-      case cmPolicies::NEW:
-        {
+      case cmPolicies::NEW: {
         std::ostringstream e;
-        e << "Target \"" << this->GetName() << "\" links to item \""
-          << item << "\" which has leading or trailing whitespace.  "
+        e << "Target \"" << this->GetName() << "\" links to item \"" << item
+          << "\" which has leading or trailing whitespace.  "
           << "This is now an error according to policy CMP0004.";
-        cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                         this->GetBacktrace());
-        }
-        break;
+        cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());
+      } break;
       case cmPolicies::REQUIRED_IF_USED:
-      case cmPolicies::REQUIRED_ALWAYS:
-        {
+      case cmPolicies::REQUIRED_ALWAYS: {
         std::ostringstream e;
         e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n"
-          << "Target \"" << this->GetName() << "\" links to item \""
-          << item << "\" which has leading or trailing whitespace.";
-        cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                         this->GetBacktrace());
-        }
-        break;
-      }
+          << "Target \"" << this->GetName() << "\" links to item \"" << item
+          << "\" which has leading or trailing whitespace.";
+        cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());
+      } break;
     }
+  }
   return lib;
 }
 
 void cmGeneratorTarget::GetLanguages(std::set<std::string>& languages,
-                            const std::string& config) const
+                                     const std::string& config) const
 {
   std::vector<cmSourceFile*> sourceFiles;
   this->GetSourceFiles(sourceFiles, config);
-  for(std::vector<cmSourceFile*>::const_iterator
-        i = sourceFiles.begin(); i != sourceFiles.end(); ++i)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator i = sourceFiles.begin();
+       i != sourceFiles.end(); ++i) {
     const std::string& lang = (*i)->GetLanguage();
-    if(!lang.empty())
-      {
+    if (!lang.empty()) {
       languages.insert(lang);
-      }
     }
+  }
 
   std::vector<cmGeneratorTarget*> objectLibraries;
   std::vector<cmSourceFile const*> externalObjects;
-  if (!this->GlobalGenerator->GetConfigureDoneCMP0026())
-    {
+  if (!this->GlobalGenerator->GetConfigureDoneCMP0026()) {
     std::vector<cmGeneratorTarget*> objectTargets;
     this->GetObjectLibrariesCMP0026(objectTargets);
     objectLibraries.reserve(objectTargets.size());
     for (std::vector<cmGeneratorTarget*>::const_iterator it =
-         objectTargets.begin(); it != objectTargets.end(); ++it)
-      {
+           objectTargets.begin();
+         it != objectTargets.end(); ++it) {
       objectLibraries.push_back(*it);
-      }
     }
-  else
-    {
+  } else {
     this->GetExternalObjects(externalObjects, config);
-    for(std::vector<cmSourceFile const*>::const_iterator
-          i = externalObjects.begin(); i != externalObjects.end(); ++i)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator i =
+           externalObjects.begin();
+         i != externalObjects.end(); ++i) {
       std::string objLib = (*i)->GetObjectLibrary();
       if (cmGeneratorTarget* tgt =
-          this->LocalGenerator->FindGeneratorTargetToUse(objLib))
-        {
+            this->LocalGenerator->FindGeneratorTargetToUse(objLib)) {
         objectLibraries.push_back(tgt);
-        }
       }
     }
-  for(std::vector<cmGeneratorTarget*>::const_iterator
-      i = objectLibraries.begin(); i != objectLibraries.end(); ++i)
-    {
+  }
+  for (std::vector<cmGeneratorTarget*>::const_iterator i =
+         objectLibraries.begin();
+       i != objectLibraries.end(); ++i) {
     (*i)->GetLanguages(languages, config);
-    }
+  }
 }
 
 void cmGeneratorTarget::ComputeLinkImplementationLanguages(
-  const std::string& config,
-  cmOptionalLinkImplementation& impl) const
+  const std::string& config, cmOptionalLinkImplementation& impl) const
 {
   // This target needs runtime libraries for its source languages.
   std::set<std::string> languages;
   // Get languages used in our source files.
   this->GetLanguages(languages, config);
   // Copy the set of langauges to the link implementation.
-  impl.Languages.insert(impl.Languages.begin(),
-                        languages.begin(), languages.end());
+  impl.Languages.insert(impl.Languages.begin(), languages.begin(),
+                        languages.end());
 }
 
 bool cmGeneratorTarget::HaveBuildTreeRPATH(const std::string& config) const
 {
-  if (this->GetPropertyAsBool("SKIP_BUILD_RPATH"))
-    {
+  if (this->GetPropertyAsBool("SKIP_BUILD_RPATH")) {
     return false;
-    }
-  if(cmLinkImplementationLibraries const* impl =
-     this->GetLinkImplementationLibraries(config))
-    {
+  }
+  if (cmLinkImplementationLibraries const* impl =
+        this->GetLinkImplementationLibraries(config)) {
     return !impl->Libraries.empty();
-    }
+  }
   return false;
 }
 
 cmLinkImplementationLibraries const*
 cmGeneratorTarget::GetLinkImplementationLibraries(
-    const std::string& config) const
+  const std::string& config) const
 {
   return this->GetLinkImplementationLibrariesInternal(config, this);
 }
 
 cmLinkImplementationLibraries const*
 cmGeneratorTarget::GetLinkImplementationLibrariesInternal(
-    const std::string& config, cmGeneratorTarget const* head) const
+  const std::string& config, cmGeneratorTarget const* head) const
 {
   // There is no link implementation for imported targets.
-  if(this->IsImported())
-    {
+  if (this->IsImported()) {
     return 0;
-    }
+  }
 
   // Populate the link implementation libraries for this configuration.
   std::string CONFIG = cmSystemTools::UpperCase(config);
-  HeadToLinkImplementationMap& hm =
-    this->LinkImplMap[CONFIG];
+  HeadToLinkImplementationMap& hm = this->LinkImplMap[CONFIG];
 
   // If the link implementation does not depend on the head target
   // then return the one we computed first.
-  if(!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition)
-    {
+  if (!hm.empty() && !hm.begin()->second.HadHeadSensitiveCondition) {
     return &hm.begin()->second;
-    }
+  }
 
   cmOptionalLinkImplementation& impl = hm[head];
-  if(!impl.LibrariesDone)
-    {
+  if (!impl.LibrariesDone) {
     impl.LibrariesDone = true;
     this->ComputeLinkImplementationLibraries(config, impl, head);
-    }
+  }
   return &impl;
 }
 
-bool
-cmGeneratorTarget::IsNullImpliedByLinkLibraries(const std::string &p) const
+bool cmGeneratorTarget::IsNullImpliedByLinkLibraries(
+  const std::string& p) const
 {
-  return this->LinkImplicitNullProperties.find(p)
-      != this->LinkImplicitNullProperties.end();
+  return this->LinkImplicitNullProperties.find(p) !=
+    this->LinkImplicitNullProperties.end();
 }
 
 void cmGeneratorTarget::ComputeLinkImplementationLibraries(
-  const std::string& config,
-  cmOptionalLinkImplementation& impl,
+  const std::string& config, cmOptionalLinkImplementation& impl,
   cmGeneratorTarget const* head) const
 {
-  cmStringRange entryRange =
-      this->Target->GetLinkImplementationEntries();
-  cmBacktraceRange btRange =
-      this->Target->GetLinkImplementationBacktraces();
+  cmStringRange entryRange = this->Target->GetLinkImplementationEntries();
+  cmBacktraceRange btRange = this->Target->GetLinkImplementationBacktraces();
   cmBacktraceRange::const_iterator btIt = btRange.begin();
   // Collect libraries directly linked in this configuration.
   for (cmStringRange::const_iterator le = entryRange.begin(),
-      end = entryRange.end(); le != end; ++le, ++btIt)
-    {
+                                     end = entryRange.end();
+       le != end; ++le, ++btIt) {
     std::vector<std::string> llibs;
-    cmGeneratorExpressionDAGChecker dagChecker(
-                                        this->GetName(),
-                                        "LINK_LIBRARIES", 0, 0);
+    cmGeneratorExpressionDAGChecker dagChecker(this->GetName(),
+                                               "LINK_LIBRARIES", 0, 0);
     cmGeneratorExpression ge(*btIt);
-    cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge =
-      ge.Parse(*le);
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = ge.Parse(*le);
     std::string const evaluated =
       cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker);
     cmSystemTools::ExpandListArgument(evaluated, llibs);
-    if(cge->GetHadHeadSensitiveCondition())
-      {
+    if (cge->GetHadHeadSensitiveCondition()) {
       impl.HadHeadSensitiveCondition = true;
-      }
+    }
 
-    for(std::vector<std::string>::const_iterator li = llibs.begin();
-        li != llibs.end(); ++li)
-      {
+    for (std::vector<std::string>::const_iterator li = llibs.begin();
+         li != llibs.end(); ++li) {
       // Skip entries that resolve to the target itself or are empty.
       std::string name = this->CheckCMP0004(*li);
-      if(name == this->GetName() || name.empty())
-        {
-        if(name == this->GetName())
-          {
+      if (name == this->GetName() || name.empty()) {
+        if (name == this->GetName()) {
           bool noMessage = false;
           cmake::MessageType messageType = cmake::FATAL_ERROR;
           std::ostringstream e;
-          switch(this->GetPolicyStatusCMP0038())
-            {
-            case cmPolicies::WARN:
-              {
+          switch (this->GetPolicyStatusCMP0038()) {
+            case cmPolicies::WARN: {
               e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0038) << "\n";
               messageType = cmake::AUTHOR_WARNING;
-              }
-              break;
+            } break;
             case cmPolicies::OLD:
               noMessage = true;
             case cmPolicies::REQUIRED_IF_USED:
@@ -5782,125 +4963,112 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
             case cmPolicies::NEW:
               // Issue the fatal message.
               break;
-            }
+          }
 
-          if(!noMessage)
-            {
+          if (!noMessage) {
             e << "Target \"" << this->GetName() << "\" links to itself.";
             this->LocalGenerator->GetCMakeInstance()->IssueMessage(
               messageType, e.str(), this->GetBacktrace());
-            if (messageType == cmake::FATAL_ERROR)
-              {
+            if (messageType == cmake::FATAL_ERROR) {
               return;
-              }
             }
           }
-        continue;
         }
+        continue;
+      }
 
       // The entry is meant for this configuration.
-      impl.Libraries.push_back(
-        cmLinkImplItem(name, this->FindTargetToLink(name),
-                       *btIt, evaluated != *le));
-      }
+      impl.Libraries.push_back(cmLinkImplItem(
+        name, this->FindTargetToLink(name), *btIt, evaluated != *le));
+    }
 
     std::set<std::string> const& seenProps = cge->GetSeenTargetProperties();
     for (std::set<std::string>::const_iterator it = seenProps.begin();
-        it != seenProps.end(); ++it)
-      {
-      if (!this->GetProperty(*it))
-        {
+         it != seenProps.end(); ++it) {
+      if (!this->GetProperty(*it)) {
         this->LinkImplicitNullProperties.insert(*it);
-        }
       }
-    cge->GetMaxLanguageStandard(this,
-                                this->MaxLanguageStandards);
     }
+    cge->GetMaxLanguageStandard(this, this->MaxLanguageStandards);
+  }
 
   // Get the list of configurations considered to be DEBUG.
   std::vector<std::string> debugConfigs =
     this->Makefile->GetCMakeInstance()->GetDebugConfigs();
 
   cmTargetLinkLibraryType linkType =
-      CMP0003_ComputeLinkType(config, debugConfigs);
+    CMP0003_ComputeLinkType(config, debugConfigs);
   cmTarget::LinkLibraryVectorType const& oldllibs =
     this->Target->GetOriginalLinkLibraries();
-  for(cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin();
-      li != oldllibs.end(); ++li)
-    {
-    if(li->second != GENERAL_LibraryType && li->second != linkType)
-      {
+  for (cmTarget::LinkLibraryVectorType::const_iterator li = oldllibs.begin();
+       li != oldllibs.end(); ++li) {
+    if (li->second != GENERAL_LibraryType && li->second != linkType) {
       std::string name = this->CheckCMP0004(li->first);
-      if(name == this->GetName() || name.empty())
-        {
+      if (name == this->GetName() || name.empty()) {
         continue;
-        }
+      }
       // Support OLD behavior for CMP0003.
       impl.WrongConfigLibraries.push_back(
         cmLinkItem(name, this->FindTargetToLink(name)));
-      }
     }
+  }
 }
 
-cmGeneratorTarget*
-cmGeneratorTarget::FindTargetToLink(std::string const& name) const
+cmGeneratorTarget* cmGeneratorTarget::FindTargetToLink(
+  std::string const& name) const
 {
   cmGeneratorTarget* tgt =
-      this->LocalGenerator->FindGeneratorTargetToUse(name);
+    this->LocalGenerator->FindGeneratorTargetToUse(name);
 
   // Skip targets that will not really be linked.  This is probably a
   // name conflict between an external library and an executable
   // within the project.
-  if(tgt && tgt->GetType() == cmState::EXECUTABLE &&
-     !tgt->IsExecutableWithExports())
-    {
+  if (tgt && tgt->GetType() == cmState::EXECUTABLE &&
+      !tgt->IsExecutableWithExports()) {
     tgt = 0;
-    }
+  }
 
-  if(tgt && tgt->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  if (tgt && tgt->GetType() == cmState::OBJECT_LIBRARY) {
     std::ostringstream e;
     e << "Target \"" << this->GetName() << "\" links to "
-      "OBJECT library \"" << tgt->GetName() << "\" but this is not "
-      "allowed.  "
-      "One may link only to STATIC or SHARED libraries, or to executables "
-      "with the ENABLE_EXPORTS property set.";
+                                           "OBJECT library \""
+      << tgt->GetName()
+      << "\" but this is not "
+         "allowed.  "
+         "One may link only to STATIC or SHARED libraries, or to executables "
+         "with the ENABLE_EXPORTS property set.";
     cmake* cm = this->LocalGenerator->GetCMakeInstance();
-    cm->IssueMessage(cmake::FATAL_ERROR, e.str(),
-                     this->GetBacktrace());
+    cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());
     tgt = 0;
-    }
+  }
 
   return tgt;
 }
 
-std::string
-cmGeneratorTarget::GetPDBDirectory(const std::string& config) const
+std::string cmGeneratorTarget::GetPDBDirectory(const std::string& config) const
 {
-  if(OutputInfo const* info = this->GetOutputInfo(config))
-    {
+  if (OutputInfo const* info = this->GetOutputInfo(config)) {
     // Return the directory in which the target will be built.
     return info->PdbDir;
-    }
+  }
   return "";
 }
 
 bool cmGeneratorTarget::HasImplibGNUtoMS() const
 {
-  return this->HasImportLibrary()
-      && this->GetPropertyAsBool("GNUtoMS");
+  return this->HasImportLibrary() && this->GetPropertyAsBool("GNUtoMS");
 }
 
 bool cmGeneratorTarget::GetImplibGNUtoMS(std::string const& gnuName,
-                                std::string& out, const char* newExt) const
+                                         std::string& out,
+                                         const char* newExt) const
 {
-  if(this->HasImplibGNUtoMS() &&
-     gnuName.size() > 6 && gnuName.substr(gnuName.size()-6) == ".dll.a")
-    {
-    out = gnuName.substr(0, gnuName.size()-6);
-    out += newExt? newExt : ".lib";
+  if (this->HasImplibGNUtoMS() && gnuName.size() > 6 &&
+      gnuName.substr(gnuName.size() - 6) == ".dll.a") {
+    out = gnuName.substr(0, gnuName.size() - 6);
+    out += newExt ? newExt : ".lib";
     return true;
-    }
+  }
   return false;
 }
 
@@ -5957,13 +5125,11 @@ bool cmGeneratorTarget::IsAppBundleOnApple() const
 
 bool cmGeneratorTarget::IsXCTestOnApple() const
 {
-  return (this->IsCFBundleOnApple() &&
-          this->GetPropertyAsBool("XCTEST"));
+  return (this->IsCFBundleOnApple() && this->GetPropertyAsBool("XCTEST"));
 }
 
 bool cmGeneratorTarget::IsCFBundleOnApple() const
 {
   return (this->GetType() == cmState::MODULE_LIBRARY &&
-          this->Makefile->IsOn("APPLE") &&
-          this->GetPropertyAsBool("BUNDLE"));
+          this->Makefile->IsOn("APPLE") && this->GetPropertyAsBool("BUNDLE"));
 }
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 65c29f5..63208bc 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -32,15 +32,17 @@ public:
 
   bool IsImported() const;
   bool IsImportedGloballyVisible() const;
-  const char *GetLocation(const std::string& config) const;
+  const char* GetLocation(const std::string& config) const;
 
-  std::vector<cmCustomCommand> const &GetPreBuildCommands() const;
-  std::vector<cmCustomCommand> const &GetPreLinkCommands() const;
-  std::vector<cmCustomCommand> const &GetPostBuildCommands() const;
+  std::vector<cmCustomCommand> const& GetPreBuildCommands() const;
+  std::vector<cmCustomCommand> const& GetPreLinkCommands() const;
+  std::vector<cmCustomCommand> const& GetPostBuildCommands() const;
 
-#define DECLARE_TARGET_POLICY(POLICY) \
-  cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \
-    { return this->PolicyMap.Get(cmPolicies::POLICY); }
+#define DECLARE_TARGET_POLICY(POLICY)                                         \
+  cmPolicies::PolicyStatus GetPolicyStatus##POLICY() const                    \
+  {                                                                           \
+    return this->PolicyMap.Get(cmPolicies::POLICY);                           \
+  }
 
   CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY)
 
@@ -51,20 +53,20 @@ public:
       location is suitable for use as the LOCATION target property.  */
   const char* GetLocationForBuild() const;
 
-  cmComputeLinkInformation*
-    GetLinkInformation(const std::string& config) const;
+  cmComputeLinkInformation* GetLinkInformation(
+    const std::string& config) const;
 
   cmState::TargetType GetType() const;
   const std::string& GetName() const;
   std::string GetExportName() const;
 
   std::vector<std::string> GetPropertyKeys() const;
-  const char *GetProperty(const std::string& prop) const;
+  const char* GetProperty(const std::string& prop) const;
   bool GetPropertyAsBool(const std::string& prop) const;
   void GetSourceFiles(std::vector<cmSourceFile*>& files,
                       const std::string& config) const;
 
-  void GetObjectSources(std::vector<cmSourceFile const*> &,
+  void GetObjectSources(std::vector<cmSourceFile const*>&,
                         const std::string& config) const;
   const std::string& GetObjectName(cmSourceFile const* file);
 
@@ -98,7 +100,7 @@ public:
   void GetExpectedXamlSources(std::set<std::string>&,
                               const std::string& config) const;
 
-  std::set<cmLinkItem>const& GetUtilityItems() const;
+  std::set<cmLinkItem> const& GetUtilityItems() const;
 
   void ComputeObjectMapping();
 
@@ -107,44 +109,43 @@ public:
   bool GetFeatureAsBool(const std::string& feature,
                         const std::string& config) const;
 
-  bool IsLinkInterfaceDependentBoolProperty(const std::string &p,
-                         const std::string& config) const;
-  bool IsLinkInterfaceDependentStringProperty(const std::string &p,
-                         const std::string& config) const;
-  bool IsLinkInterfaceDependentNumberMinProperty(const std::string &p,
-                         const std::string& config) const;
-  bool IsLinkInterfaceDependentNumberMaxProperty(const std::string &p,
-                         const std::string& config) const;
+  bool IsLinkInterfaceDependentBoolProperty(const std::string& p,
+                                            const std::string& config) const;
+  bool IsLinkInterfaceDependentStringProperty(const std::string& p,
+                                              const std::string& config) const;
+  bool IsLinkInterfaceDependentNumberMinProperty(
+    const std::string& p, const std::string& config) const;
+  bool IsLinkInterfaceDependentNumberMaxProperty(
+    const std::string& p, const std::string& config) const;
 
-  bool GetLinkInterfaceDependentBoolProperty(const std::string &p,
+  bool GetLinkInterfaceDependentBoolProperty(const std::string& p,
                                              const std::string& config) const;
 
-  const char *GetLinkInterfaceDependentStringProperty(const std::string &p,
-                         const std::string& config) const;
-  const char *GetLinkInterfaceDependentNumberMinProperty(const std::string &p,
-                         const std::string& config) const;
-  const char *GetLinkInterfaceDependentNumberMaxProperty(const std::string &p,
-                         const std::string& config) const;
+  const char* GetLinkInterfaceDependentStringProperty(
+    const std::string& p, const std::string& config) const;
+  const char* GetLinkInterfaceDependentNumberMinProperty(
+    const std::string& p, const std::string& config) const;
+  const char* GetLinkInterfaceDependentNumberMaxProperty(
+    const std::string& p, const std::string& config) const;
 
-  cmLinkInterface const* GetLinkInterface(const std::string& config,
-                                    const cmGeneratorTarget* headTarget) const;
+  cmLinkInterface const* GetLinkInterface(
+    const std::string& config, const cmGeneratorTarget* headTarget) const;
   void ComputeLinkInterface(const std::string& config,
                             cmOptionalLinkInterface& iface,
                             const cmGeneratorTarget* head) const;
 
-  cmLinkInterfaceLibraries const*
-    GetLinkInterfaceLibraries(const std::string& config,
-                              const cmGeneratorTarget* headTarget,
-                              bool usage_requirements_only) const;
+  cmLinkInterfaceLibraries const* GetLinkInterfaceLibraries(
+    const std::string& config, const cmGeneratorTarget* headTarget,
+    bool usage_requirements_only) const;
 
   void ComputeLinkInterfaceLibraries(const std::string& config,
-                                     cmOptionalLinkInterface &iface,
+                                     cmOptionalLinkInterface& iface,
                                      const cmGeneratorTarget* head,
                                      bool usage_requirements_only) const;
 
   /** Get the full path to the target according to the settings in its
       makefile and the configuration type.  */
-  std::string GetFullPath(const std::string& config="", bool implib = false,
+  std::string GetFullPath(const std::string& config = "", bool implib = false,
                           bool realname = false) const;
   std::string NormalGetFullPath(const std::string& config, bool implib,
                                 bool realname) const;
@@ -160,7 +161,7 @@ public:
 
   /** Get the full name of the target according to the settings in its
       makefile.  */
-  std::string GetFullName(const std::string& config="",
+  std::string GetFullName(const std::string& config = "",
                           bool implib = false) const;
 
   /** @return the Mac framework directory without the base. */
@@ -188,11 +189,13 @@ public:
 
   const std::vector<std::string>& GetLinkDirectories() const;
 
-  std::set<std::string>const& GetUtilities() const;
+  std::set<std::string> const& GetUtilities() const;
   cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
 
   bool LinkLanguagePropagatesToDependents() const
-  { return this->GetType() == cmState::STATIC_LIBRARY; }
+  {
+    return this->GetType() == cmState::STATIC_LIBRARY;
+  }
 
   /** Get the macro to define when building sources in this target.
       If no macro should be defined null is returned.  */
@@ -201,9 +204,9 @@ public:
   /** Get the soname of the target.  Allowed only for a shared library.  */
   std::string GetSOName(const std::string& config) const;
 
-  void GetFullNameComponents(std::string& prefix,
-                             std::string& base, std::string& suffix,
-                             const std::string& config="",
+  void GetFullNameComponents(std::string& prefix, std::string& base,
+                             std::string& suffix,
+                             const std::string& config = "",
                              bool implib = false) const;
 
   /** Append to @a base the mac content directory and return it. */
@@ -242,15 +245,14 @@ public:
   LinkClosure const* GetLinkClosure(const std::string& config) const;
   void ComputeLinkClosure(const std::string& config, LinkClosure& lc) const;
 
-  cmLinkImplementation const*
-    GetLinkImplementation(const std::string& config) const;
+  cmLinkImplementation const* GetLinkImplementation(
+    const std::string& config) const;
 
-  void ComputeLinkImplementationLanguages(const std::string& config,
-                                          cmOptionalLinkImplementation& impl
-                                          ) const;
+  void ComputeLinkImplementationLanguages(
+    const std::string& config, cmOptionalLinkImplementation& impl) const;
 
-  cmLinkImplementationLibraries const*
-    GetLinkImplementationLibraries(const std::string& config) const;
+  cmLinkImplementationLibraries const* GetLinkImplementationLibraries(
+    const std::string& config) const;
 
   void ComputeLinkImplementationLibraries(const std::string& config,
                                           cmOptionalLinkImplementation& impl,
@@ -266,8 +268,8 @@ public:
   void GetLanguages(std::set<std::string>& languages,
                     std::string const& config) const;
 
-  void
-  GetObjectLibrariesCMP0026(std::vector<cmGeneratorTarget*>& objlibs) const;
+  void GetObjectLibrariesCMP0026(
+    std::vector<cmGeneratorTarget*>& objlibs) const;
 
   std::string GetFullNameImported(const std::string& config,
                                   bool implib) const;
@@ -293,16 +295,16 @@ public:
 
   /** Get the include directories for this target.  */
   std::vector<std::string> GetIncludeDirectories(
-      const std::string& config, const std::string& lang) const;
+    const std::string& config, const std::string& lang) const;
 
-  void GetCompileOptions(std::vector<std::string> &result,
+  void GetCompileOptions(std::vector<std::string>& result,
                          const std::string& config,
                          const std::string& language) const;
 
-  void GetCompileFeatures(std::vector<std::string> &features,
+  void GetCompileFeatures(std::vector<std::string>& features,
                           const std::string& config) const;
 
-  void GetCompileDefinitions(std::vector<std::string> &result,
+  void GetCompileDefinitions(std::vector<std::string>& result,
                              const std::string& config,
                              const std::string& language) const;
 
@@ -332,8 +334,8 @@ public:
   std::string GetCompilePDBDirectory(const std::string& config = "") const;
 
   /** Get sources that must be built before the given source.  */
-  std::vector<cmSourceFile*> const*
-  GetSourceDepends(cmSourceFile const* sf) const;
+  std::vector<cmSourceFile*> const* GetSourceDepends(
+    cmSourceFile const* sf) const;
 
   /** Return whether this target uses the default value for its output
       directory.  */
@@ -346,13 +348,15 @@ public:
     std::string ImpDir;
     std::string PdbDir;
     bool empty() const
-      { return OutDir.empty() && ImpDir.empty() && PdbDir.empty(); }
+    {
+      return OutDir.empty() && ImpDir.empty() && PdbDir.empty();
+    }
   };
 
   OutputInfo const* GetOutputInfo(const std::string& config) const;
 
   /** Get the name of the pdb file for the target.  */
-  std::string GetPDBName(const std::string& config="") const;
+  std::string GetPDBName(const std::string& config = "") const;
 
   /** Whether this library has soname enabled and platform supports it.  */
   bool HasSOName(const std::string& config) const;
@@ -367,13 +371,13 @@ public:
   typedef std::map<std::string, CompileInfo> CompileInfoMapType;
   mutable CompileInfoMapType CompileInfoMap;
 
-  bool IsNullImpliedByLinkLibraries(const std::string &p) const;
+  bool IsNullImpliedByLinkLibraries(const std::string& p) const;
 
   /** Get the name of the compiler pdb file for the target.  */
-  std::string GetCompilePDBName(const std::string& config="") const;
+  std::string GetCompilePDBName(const std::string& config = "") const;
 
   /** Get the path for the MSVC /Fd option for this target.  */
-  std::string GetCompilePDBPath(const std::string& config="") const;
+  std::string GetCompilePDBPath(const std::string& config = "") const;
 
   // Get the target base name.
   std::string GetOutputName(const std::string& config, bool implib) const;
@@ -396,13 +400,20 @@ public:
   };
   struct SourceFileFlags
   {
-    SourceFileFlags(): Type(SourceFileTypeNormal), MacFolder(0) {}
-    SourceFileFlags(SourceFileFlags const& r):
-      Type(r.Type), MacFolder(r.MacFolder) {}
+    SourceFileFlags()
+      : Type(SourceFileTypeNormal)
+      , MacFolder(0)
+    {
+    }
+    SourceFileFlags(SourceFileFlags const& r)
+      : Type(r.Type)
+      , MacFolder(r.MacFolder)
+    {
+    }
     SourceFileType Type;
     const char* MacFolder; // location inside Mac content folders
   };
-  void GetAutoUicOptions(std::vector<std::string> &result,
+  void GetAutoUicOptions(std::vector<std::string>& result,
                          const std::string& config) const;
 
   /** Get the names of the executable needed to generate a build rule
@@ -468,24 +479,25 @@ public:
   /** Return whether this target is a CFBundle (plugin) on Apple.  */
   bool IsCFBundleOnApple() const;
 
-  struct SourceFileFlags
-  GetTargetSourceFileFlags(const cmSourceFile* sf) const;
+  struct SourceFileFlags GetTargetSourceFileFlags(
+    const cmSourceFile* sf) const;
 
-  struct ResxData {
+  struct ResxData
+  {
     mutable std::set<std::string> ExpectedResxHeaders;
     mutable std::vector<cmSourceFile const*> ResxSources;
   };
 
-  struct XamlData {
+  struct XamlData
+  {
     std::set<std::string> ExpectedXamlHeaders;
     std::set<std::string> ExpectedXamlSources;
     std::vector<cmSourceFile const*> XamlSources;
   };
 
-  void ReportPropertyOrigin(const std::string &p,
-                            const std::string &result,
-                            const std::string &report,
-                            const std::string &compatibilityType) const;
+  void ReportPropertyOrigin(const std::string& p, const std::string& result,
+                            const std::string& report,
+                            const std::string& compatibilityType) const;
 
   class TargetPropertyEntry;
 
@@ -511,12 +523,15 @@ public:
   /** Get the target major, minor, and patch version numbers
       interpreted from the VERSION or SOVERSION property.  Version 0
       is returned if the property is not set or cannot be parsed.  */
-  void
-  GetTargetVersion(bool soversion, int& major, int& minor, int& patch) const;
+  void GetTargetVersion(bool soversion, int& major, int& minor,
+                        int& patch) const;
 
 private:
   friend class cmTargetTraceDependencies;
-  struct SourceEntry { std::vector<cmSourceFile*> Depends; };
+  struct SourceEntry
+  {
+    std::vector<cmSourceFile*> Depends;
+  };
   typedef std::map<cmSourceFile const*, SourceEntry> SourceEntriesType;
   SourceEntriesType SourceDepends;
   mutable std::map<cmSourceFile const*, std::string> Objects;
@@ -543,10 +558,8 @@ private:
   // Returns ARCHIVE, LIBRARY, or RUNTIME based on platform and type.
   const char* GetOutputTargetType(bool implib) const;
 
-  void ComputeVersionedName(std::string& vName,
-                            std::string const& prefix,
-                            std::string const& base,
-                            std::string const& suffix,
+  void ComputeVersionedName(std::string& vName, std::string const& prefix,
+                            std::string const& base, std::string const& suffix,
                             std::string const& name,
                             const char* version) const;
 
@@ -557,47 +570,56 @@ private:
     std::set<std::string> PropsNumberMax;
     std::set<std::string> PropsNumberMin;
   };
-  CompatibleInterfacesBase const&
-    GetCompatibleInterfaces(std::string const& config) const;
+  CompatibleInterfacesBase const& GetCompatibleInterfaces(
+    std::string const& config) const;
 
-  struct CompatibleInterfaces: public CompatibleInterfacesBase
+  struct CompatibleInterfaces : public CompatibleInterfacesBase
   {
-    CompatibleInterfaces(): Done(false) {}
+    CompatibleInterfaces()
+      : Done(false)
+    {
+    }
     bool Done;
   };
   mutable std::map<std::string, CompatibleInterfaces> CompatibleInterfacesMap;
 
   typedef std::map<std::string, cmComputeLinkInformation*>
-                                                   cmTargetLinkInformationMap;
+    cmTargetLinkInformationMap;
   mutable cmTargetLinkInformationMap LinkInformation;
 
-  void CheckPropertyCompatibility(cmComputeLinkInformation *info,
+  void CheckPropertyCompatibility(cmComputeLinkInformation* info,
                                   const std::string& config) const;
 
   cmGeneratorTarget(cmGeneratorTarget const&);
   void operator=(cmGeneratorTarget const&);
 
-  struct LinkImplClosure: public std::vector<cmGeneratorTarget const*>
+  struct LinkImplClosure : public std::vector<cmGeneratorTarget const*>
   {
-    LinkImplClosure(): Done(false) {}
+    LinkImplClosure()
+      : Done(false)
+    {
+    }
     bool Done;
   };
   mutable std::map<std::string, LinkImplClosure> LinkImplClosureMap;
 
-  typedef std::map<std::string, cmHeadToLinkInterfaceMap>
-                                                          LinkInterfaceMapType;
+  typedef std::map<std::string, cmHeadToLinkInterfaceMap> LinkInterfaceMapType;
   mutable LinkInterfaceMapType LinkInterfaceMap;
   mutable LinkInterfaceMapType LinkInterfaceUsageRequirementsOnlyMap;
 
-  cmHeadToLinkInterfaceMap&
-  GetHeadToLinkInterfaceMap(std::string const& config) const;
+  cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceMap(
+    std::string const& config) const;
   cmHeadToLinkInterfaceMap& GetHeadToLinkInterfaceUsageRequirementsMap(
-      std::string const& config) const;
+    std::string const& config) const;
 
   // Cache import information from properties for each configuration.
   struct ImportInfo
   {
-    ImportInfo(): NoSOName(false), Multiplicity(0) {}
+    ImportInfo()
+      : NoSOName(false)
+      , Multiplicity(0)
+    {
+    }
     bool NoSOName;
     unsigned int Multiplicity;
     std::string Location;
@@ -619,13 +641,12 @@ private:
       the link dependencies of this target.  */
   std::string CheckCMP0004(std::string const& item) const;
 
-  cmLinkInterface const*
-    GetImportLinkInterface(const std::string& config,
-                           const cmGeneratorTarget* head,
-                           bool usage_requirements_only) const;
+  cmLinkInterface const* GetImportLinkInterface(
+    const std::string& config, const cmGeneratorTarget* head,
+    bool usage_requirements_only) const;
 
   typedef std::map<std::string, std::vector<cmSourceFile*> >
-                                                       SourceFilesMapType;
+    SourceFilesMapType;
   mutable SourceFilesMapType SourceFilesMap;
 
   std::vector<TargetPropertyEntry*> IncludeDirectoriesEntries;
@@ -647,18 +668,17 @@ private:
   void GetSourceFiles(std::vector<std::string>& files,
                       const std::string& config) const;
 
-  struct HeadToLinkImplementationMap:
-    public std::map<cmGeneratorTarget const*, cmOptionalLinkImplementation> {};
-  typedef std::map<std::string,
-                   HeadToLinkImplementationMap> LinkImplMapType;
+  struct HeadToLinkImplementationMap
+    : public std::map<cmGeneratorTarget const*, cmOptionalLinkImplementation>
+  {
+  };
+  typedef std::map<std::string, HeadToLinkImplementationMap> LinkImplMapType;
   mutable LinkImplMapType LinkImplMap;
 
-  cmLinkImplementationLibraries const*
-    GetLinkImplementationLibrariesInternal(const std::string& config,
-                                          const cmGeneratorTarget* head) const;
-  bool
-  ComputeOutputDir(const std::string& config,
-                   bool implib, std::string& out) const;
+  cmLinkImplementationLibraries const* GetLinkImplementationLibrariesInternal(
+    const std::string& config, const cmGeneratorTarget* head) const;
+  bool ComputeOutputDir(const std::string& config, bool implib,
+                        std::string& out) const;
 
   typedef std::map<std::string, OutputInfo> OutputInfoMapType;
   mutable OutputInfoMapType OutputInfoMap;
@@ -682,17 +702,17 @@ private:
                            std::string& out) const;
 
 public:
-  const std::vector<const cmGeneratorTarget*>&
-  GetLinkImplementationClosure(const std::string& config) const;
+  const std::vector<const cmGeneratorTarget*>& GetLinkImplementationClosure(
+    const std::string& config) const;
 
   mutable std::map<std::string, std::string> MaxLanguageStandards;
-  std::map<std::string, std::string> const&
-  GetMaxLanguageStandards() const
+  std::map<std::string, std::string> const& GetMaxLanguageStandards() const
   {
     return this->MaxLanguageStandards;
   }
 
-  struct StrictTargetComparison {
+  struct StrictTargetComparison
+  {
     bool operator()(cmGeneratorTarget const* t1,
                     cmGeneratorTarget const* t2) const;
   };
diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx
index 2be4dec..331aab9 100644
--- a/Source/cmGetCMakePropertyCommand.cxx
+++ b/Source/cmGetCMakePropertyCommand.cxx
@@ -17,51 +17,39 @@
 #include "cmake.h"
 
 // cmGetCMakePropertyCommand
-bool cmGetCMakePropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetCMakePropertyCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string variable = args[0];
   std::string output = "NOTFOUND";
 
-  if ( args[1] == "VARIABLES" )
-    {
-    if (const char* varsProp = this->Makefile->GetProperty("VARIABLES"))
-      {
+  if (args[1] == "VARIABLES") {
+    if (const char* varsProp = this->Makefile->GetProperty("VARIABLES")) {
       output = varsProp;
-      }
     }
-  else if ( args[1] == "MACROS" )
-    {
+  } else if (args[1] == "MACROS") {
     output.clear();
-    if (const char* macrosProp = this->Makefile->GetProperty("MACROS"))
-      {
+    if (const char* macrosProp = this->Makefile->GetProperty("MACROS")) {
       output = macrosProp;
-      }
     }
-  else if ( args[1] == "COMPONENTS" )
-    {
-    const std::set<std::string>* components
-      = this->Makefile->GetGlobalGenerator()->GetInstallComponents();
+  } else if (args[1] == "COMPONENTS") {
+    const std::set<std::string>* components =
+      this->Makefile->GetGlobalGenerator()->GetInstallComponents();
     output = cmJoin(*components, ";");
-    }
-  else
-    {
-    const char *prop = 0;
-    if (!args[1].empty())
-      {
+  } else {
+    const char* prop = 0;
+    if (!args[1].empty()) {
       prop = this->Makefile->GetState()->GetGlobalProperty(args[1]);
-      }
-    if (prop)
-      {
+    }
+    if (prop) {
       output = prop;
-      }
     }
+  }
 
   this->Makefile->AddDefinition(variable, output.c_str());
 
diff --git a/Source/cmGetCMakePropertyCommand.h b/Source/cmGetCMakePropertyCommand.h
index 1511406..fd247e8 100644
--- a/Source/cmGetCMakePropertyCommand.h
+++ b/Source/cmGetCMakePropertyCommand.h
@@ -17,17 +17,14 @@
 class cmGetCMakePropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmGetCMakePropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetCMakePropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -37,11 +34,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_cmake_property";}
+  virtual std::string GetName() const { return "get_cmake_property"; }
 
   cmTypeMacro(cmGetCMakePropertyCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmGetDirectoryPropertyCommand.cxx b/Source/cmGetDirectoryPropertyCommand.cxx
index 2558876..1b5bcc9 100644
--- a/Source/cmGetDirectoryPropertyCommand.cxx
+++ b/Source/cmGetDirectoryPropertyCommand.cxx
@@ -14,94 +14,84 @@
 #include "cmake.h"
 
 // cmGetDirectoryPropertyCommand
-bool cmGetDirectoryPropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetDirectoryPropertyCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::vector<std::string>::const_iterator i = args.begin();
   std::string variable = *i;
   ++i;
 
   // get the directory argument if there is one
-  cmMakefile *dir = this->Makefile;
-  if (*i == "DIRECTORY")
-    {
+  cmMakefile* dir = this->Makefile;
+  if (*i == "DIRECTORY") {
     ++i;
-    if (i == args.end())
-      {
-      this->SetError
-        ("DIRECTORY argument provided without subsequent arguments");
+    if (i == args.end()) {
+      this->SetError(
+        "DIRECTORY argument provided without subsequent arguments");
       return false;
-      }
+    }
     std::string sd = *i;
     // make sure the start dir is a full path
-    if (!cmSystemTools::FileIsFullPath(sd.c_str()))
-      {
+    if (!cmSystemTools::FileIsFullPath(sd.c_str())) {
       sd = this->Makefile->GetCurrentSourceDirectory();
       sd += "/";
       sd += *i;
-      }
+    }
 
     // The local generators are associated with collapsed paths.
     sd = cmSystemTools::CollapseFullPath(sd);
 
     // lookup the makefile from the directory name
     dir = this->Makefile->GetGlobalGenerator()->FindMakefile(sd);
-    if (!dir)
-      {
-      this->SetError
-        ("DIRECTORY argument provided but requested directory not found. "
-         "This could be because the directory argument was invalid or, "
-         "it is valid but has not been processed yet.");
+    if (!dir) {
+      this->SetError(
+        "DIRECTORY argument provided but requested directory not found. "
+        "This could be because the directory argument was invalid or, "
+        "it is valid but has not been processed yet.");
       return false;
-      }
-    ++i;
     }
+    ++i;
+  }
 
   // OK, now we have the directory to process, we just get the requested
   // information out of it
 
-  if ( *i == "DEFINITION" )
-    {
+  if (*i == "DEFINITION") {
     ++i;
-    if (i == args.end())
-      {
+    if (i == args.end()) {
       this->SetError("A request for a variable definition was made without "
                      "providing the name of the variable to get.");
       return false;
-      }
+    }
     std::string output = dir->GetSafeDefinition(*i);
     this->Makefile->AddDefinition(variable, output.c_str());
     return true;
-    }
+  }
 
-  const char *prop = 0;
-  if (!i->empty())
-    {
-    if (*i == "DEFINITIONS")
-      {
-      switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0059))
-        {
+  const char* prop = 0;
+  if (!i->empty()) {
+    if (*i == "DEFINITIONS") {
+      switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0059)) {
         case cmPolicies::WARN:
-          this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
-                           cmPolicies::GetPolicyWarning(cmPolicies::CMP0059));
+          this->Makefile->IssueMessage(
+            cmake::AUTHOR_WARNING,
+            cmPolicies::GetPolicyWarning(cmPolicies::CMP0059));
         case cmPolicies::OLD:
-          this->StoreResult(variable,
-                                   this->Makefile->GetDefineFlagsCMP0059());
-        return true;
+          this->StoreResult(variable, this->Makefile->GetDefineFlagsCMP0059());
+          return true;
         case cmPolicies::NEW:
         case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::REQUIRED_IF_USED:
           break;
-        }
       }
-    prop = dir->GetProperty(*i);
     }
+    prop = dir->GetProperty(*i);
+  }
   this->StoreResult(variable, prop);
   return true;
 }
@@ -109,11 +99,9 @@ bool cmGetDirectoryPropertyCommand
 void cmGetDirectoryPropertyCommand::StoreResult(std::string const& variable,
                                                 const char* prop)
 {
-  if (prop)
-    {
+  if (prop) {
     this->Makefile->AddDefinition(variable, prop);
     return;
-    }
+  }
   this->Makefile->AddDefinition(variable, "");
 }
-
diff --git a/Source/cmGetDirectoryPropertyCommand.h b/Source/cmGetDirectoryPropertyCommand.h
index f418886..97394ec 100644
--- a/Source/cmGetDirectoryPropertyCommand.h
+++ b/Source/cmGetDirectoryPropertyCommand.h
@@ -17,17 +17,14 @@
 class cmGetDirectoryPropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmGetDirectoryPropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetDirectoryPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -37,7 +34,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_directory_property";}
+  virtual std::string GetName() const { return "get_directory_property"; }
 
   cmTypeMacro(cmGetDirectoryPropertyCommand, cmCommand);
 
diff --git a/Source/cmGetFilenameComponentCommand.cxx b/Source/cmGetFilenameComponentCommand.cxx
index 2026a45..1830b0c 100644
--- a/Source/cmGetFilenameComponentCommand.cxx
+++ b/Source/cmGetFilenameComponentCommand.cxx
@@ -14,139 +14,102 @@
 #include "cmSystemTools.h"
 
 // cmGetFilenameComponentCommand
-bool cmGetFilenameComponentCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetFilenameComponentCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Check and see if the value has been stored in the cache
   // already, if so use that value
-  if(args.size() >= 4 && args[args.size() - 1] == "CACHE")
-    {
+  if (args.size() >= 4 && args[args.size() - 1] == "CACHE") {
     const char* cacheValue = this->Makefile->GetDefinition(args[0]);
-    if(cacheValue && !cmSystemTools::IsNOTFOUND(cacheValue))
-      {
+    if (cacheValue && !cmSystemTools::IsNOTFOUND(cacheValue)) {
       return true;
-      }
     }
+  }
 
   std::string result;
   std::string filename = args[1];
-  if(filename.find("[HKEY") != filename.npos)
-    {
+  if (filename.find("[HKEY") != filename.npos) {
     // Check the registry as the target application would view it.
     cmSystemTools::KeyWOW64 view = cmSystemTools::KeyWOW64_32;
     cmSystemTools::KeyWOW64 other_view = cmSystemTools::KeyWOW64_64;
-    if(this->Makefile->PlatformIs64Bit())
-      {
+    if (this->Makefile->PlatformIs64Bit()) {
       view = cmSystemTools::KeyWOW64_64;
       other_view = cmSystemTools::KeyWOW64_32;
-      }
+    }
     cmSystemTools::ExpandRegistryValues(filename, view);
-    if(filename.find("/registry") != filename.npos)
-      {
+    if (filename.find("/registry") != filename.npos) {
       std::string other = args[1];
       cmSystemTools::ExpandRegistryValues(other, other_view);
-      if(other.find("/registry") == other.npos)
-        {
+      if (other.find("/registry") == other.npos) {
         filename = other;
-        }
       }
     }
+  }
   std::string storeArgs;
   std::string programArgs;
-  if (args[2] == "DIRECTORY" || args[2] == "PATH")
-    {
+  if (args[2] == "DIRECTORY" || args[2] == "PATH") {
     result = cmSystemTools::GetFilenamePath(filename);
-    }
-  else if (args[2] == "NAME")
-    {
+  } else if (args[2] == "NAME") {
     result = cmSystemTools::GetFilenameName(filename);
-    }
-  else if (args[2] == "PROGRAM")
-    {
-    for(unsigned int i=2; i < args.size(); ++i)
-      {
-      if(args[i] == "PROGRAM_ARGS")
-        {
+  } else if (args[2] == "PROGRAM") {
+    for (unsigned int i = 2; i < args.size(); ++i) {
+      if (args[i] == "PROGRAM_ARGS") {
         i++;
-        if(i < args.size())
-          {
+        if (i < args.size()) {
           storeArgs = args[i];
-          }
         }
       }
-    cmSystemTools::SplitProgramFromArgs(filename,
-                                        result, programArgs);
     }
-  else if (args[2] == "EXT")
-    {
+    cmSystemTools::SplitProgramFromArgs(filename, result, programArgs);
+  } else if (args[2] == "EXT") {
     result = cmSystemTools::GetFilenameExtension(filename);
-    }
-  else if (args[2] == "NAME_WE")
-    {
+  } else if (args[2] == "NAME_WE") {
     result = cmSystemTools::GetFilenameWithoutExtension(filename);
-    }
-  else if (args[2] == "ABSOLUTE" ||
-           args[2] == "REALPATH")
-    {
+  } else if (args[2] == "ABSOLUTE" || args[2] == "REALPATH") {
     // If the path given is relative, evaluate it relative to the
     // current source directory unless the user passes a different
     // base directory.
     std::string baseDir = this->Makefile->GetCurrentSourceDirectory();
-    for(unsigned int i=3; i < args.size(); ++i)
-      {
-      if(args[i] == "BASE_DIR")
-        {
+    for (unsigned int i = 3; i < args.size(); ++i) {
+      if (args[i] == "BASE_DIR") {
         ++i;
-        if(i < args.size())
-          {
+        if (i < args.size()) {
           baseDir = args[i];
-          }
         }
       }
+    }
     // Collapse the path to its simplest form.
     result = cmSystemTools::CollapseFullPath(filename, baseDir);
-    if(args[2] == "REALPATH")
-      {
+    if (args[2] == "REALPATH") {
       // Resolve symlinks if possible
       result = cmSystemTools::GetRealPath(result);
-      }
     }
-  else
-    {
+  } else {
     std::string err = "unknown component " + args[2];
     this->SetError(err);
     return false;
-    }
+  }
 
-  if(args.size() >= 4 && args[args.size() - 1] == "CACHE")
-    {
-    if(!programArgs.empty() && !storeArgs.empty())
-      {
-      this->Makefile->AddCacheDefinition
-        (storeArgs, programArgs.c_str(),
-         "", args[2] == "PATH" ? cmState::FILEPATH
-         : cmState::STRING);
-      }
-    this->Makefile->AddCacheDefinition
-      (args[0], result.c_str(), "",
-       args[2] == "PATH" ? cmState::FILEPATH
-       : cmState::STRING);
+  if (args.size() >= 4 && args[args.size() - 1] == "CACHE") {
+    if (!programArgs.empty() && !storeArgs.empty()) {
+      this->Makefile->AddCacheDefinition(storeArgs, programArgs.c_str(), "",
+                                         args[2] == "PATH" ? cmState::FILEPATH
+                                                           : cmState::STRING);
     }
-  else
-    {
-    if(!programArgs.empty() && !storeArgs.empty())
-      {
+    this->Makefile->AddCacheDefinition(args[0], result.c_str(), "",
+                                       args[2] == "PATH" ? cmState::FILEPATH
+                                                         : cmState::STRING);
+  } else {
+    if (!programArgs.empty() && !storeArgs.empty()) {
       this->Makefile->AddDefinition(storeArgs, programArgs.c_str());
-      }
-    this->Makefile->AddDefinition(args[0], result.c_str());
     }
+    this->Makefile->AddDefinition(args[0], result.c_str());
+  }
 
   return true;
 }
-
diff --git a/Source/cmGetFilenameComponentCommand.h b/Source/cmGetFilenameComponentCommand.h
index 534de53..a114b3d 100644
--- a/Source/cmGetFilenameComponentCommand.h
+++ b/Source/cmGetFilenameComponentCommand.h
@@ -26,17 +26,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmGetFilenameComponentCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetFilenameComponentCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -46,11 +43,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_filename_component";}
+  virtual std::string GetName() const { return "get_filename_component"; }
 
   cmTypeMacro(cmGetFilenameComponentCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index 6bcc131..06f7504 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/Source/cmGetPropertyCommand.cxx
@@ -23,215 +23,173 @@ cmGetPropertyCommand::cmGetPropertyCommand()
   this->InfoType = OutValue;
 }
 
-bool cmGetPropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetPropertyCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // The cmake variable in which to store the result.
   this->Variable = args[0];
 
   // Get the scope from which to get the property.
   cmProperty::ScopeType scope;
-  if(args[1] == "GLOBAL")
-    {
+  if (args[1] == "GLOBAL") {
     scope = cmProperty::GLOBAL;
-    }
-  else if(args[1] == "DIRECTORY")
-    {
+  } else if (args[1] == "DIRECTORY") {
     scope = cmProperty::DIRECTORY;
-    }
-  else if(args[1] == "TARGET")
-    {
+  } else if (args[1] == "TARGET") {
     scope = cmProperty::TARGET;
-    }
-  else if(args[1] == "SOURCE")
-    {
+  } else if (args[1] == "SOURCE") {
     scope = cmProperty::SOURCE_FILE;
-    }
-  else if(args[1] == "TEST")
-    {
+  } else if (args[1] == "TEST") {
     scope = cmProperty::TEST;
-    }
-  else if(args[1] == "VARIABLE")
-    {
+  } else if (args[1] == "VARIABLE") {
     scope = cmProperty::VARIABLE;
-    }
-  else if(args[1] == "CACHE")
-    {
+  } else if (args[1] == "CACHE") {
     scope = cmProperty::CACHE;
-    }
-  else if(args[1] == "INSTALL")
-    {
+  } else if (args[1] == "INSTALL") {
     scope = cmProperty::INSTALL;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "given invalid scope " << args[1] << ".  "
       << "Valid scopes are "
       << "GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, VARIABLE, CACHE, INSTALL.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Parse remaining arguments.
-  enum Doing { DoingNone, DoingName, DoingProperty, DoingType };
+  enum Doing
+  {
+    DoingNone,
+    DoingName,
+    DoingProperty,
+    DoingType
+  };
   Doing doing = DoingName;
-  for(unsigned int i=2; i < args.size(); ++i)
-    {
-    if(args[i] == "PROPERTY")
-      {
+  for (unsigned int i = 2; i < args.size(); ++i) {
+    if (args[i] == "PROPERTY") {
       doing = DoingProperty;
-      }
-    else if(args[i] == "BRIEF_DOCS")
-      {
+    } else if (args[i] == "BRIEF_DOCS") {
       doing = DoingNone;
       this->InfoType = OutBriefDoc;
-      }
-    else if(args[i] == "FULL_DOCS")
-      {
+    } else if (args[i] == "FULL_DOCS") {
       doing = DoingNone;
       this->InfoType = OutFullDoc;
-      }
-    else if(args[i] == "SET")
-      {
+    } else if (args[i] == "SET") {
       doing = DoingNone;
       this->InfoType = OutSet;
-      }
-    else if(args[i] == "DEFINED")
-      {
+    } else if (args[i] == "DEFINED") {
       doing = DoingNone;
       this->InfoType = OutDefined;
-      }
-    else if(doing == DoingName)
-      {
+    } else if (doing == DoingName) {
       doing = DoingNone;
       this->Name = args[i];
-      }
-    else if(doing == DoingProperty)
-      {
+    } else if (doing == DoingProperty) {
       doing = DoingNone;
       this->PropertyName = args[i];
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "given invalid argument \"" << args[i] << "\".";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Make sure a property name was found.
-  if(this->PropertyName.empty())
-    {
+  if (this->PropertyName.empty()) {
     this->SetError("not given a PROPERTY <name> argument.");
     return false;
-    }
+  }
 
   // Compute requested output.
-  if(this->InfoType == OutBriefDoc)
-    {
+  if (this->InfoType == OutBriefDoc) {
     // Lookup brief documentation.
     std::string output;
-    if(cmPropertyDefinition const* def = this->Makefile->GetState()->
-       GetPropertyDefinition(this->PropertyName, scope))
-      {
+    if (cmPropertyDefinition const* def =
+          this->Makefile->GetState()->GetPropertyDefinition(this->PropertyName,
+                                                            scope)) {
       output = def->GetShortDescription();
-      }
-    else
-      {
+    } else {
       output = "NOTFOUND";
-      }
-    this->Makefile->AddDefinition(this->Variable, output.c_str());
     }
-  else if(this->InfoType == OutFullDoc)
-    {
+    this->Makefile->AddDefinition(this->Variable, output.c_str());
+  } else if (this->InfoType == OutFullDoc) {
     // Lookup full documentation.
     std::string output;
-    if(cmPropertyDefinition const* def = this->Makefile->GetState()->
-       GetPropertyDefinition(this->PropertyName, scope))
-      {
+    if (cmPropertyDefinition const* def =
+          this->Makefile->GetState()->GetPropertyDefinition(this->PropertyName,
+                                                            scope)) {
       output = def->GetFullDescription();
-      }
-    else
-      {
+    } else {
       output = "NOTFOUND";
-      }
-    this->Makefile->AddDefinition(this->Variable, output.c_str());
     }
-  else if(this->InfoType == OutDefined)
-    {
+    this->Makefile->AddDefinition(this->Variable, output.c_str());
+  } else if (this->InfoType == OutDefined) {
     // Lookup if the property is defined
-    if(this->Makefile->GetState()->
-       GetPropertyDefinition(this->PropertyName, scope))
-      {
+    if (this->Makefile->GetState()->GetPropertyDefinition(this->PropertyName,
+                                                          scope)) {
       this->Makefile->AddDefinition(this->Variable, "1");
-      }
-    else
-      {
+    } else {
       this->Makefile->AddDefinition(this->Variable, "0");
-      }
     }
-  else
-    {
+  } else {
     // Dispatch property getting.
-    switch(scope)
-      {
-      case cmProperty::GLOBAL:      return this->HandleGlobalMode();
-      case cmProperty::DIRECTORY:   return this->HandleDirectoryMode();
-      case cmProperty::TARGET:      return this->HandleTargetMode();
-      case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
-      case cmProperty::TEST:        return this->HandleTestMode();
-      case cmProperty::VARIABLE:    return this->HandleVariableMode();
-      case cmProperty::CACHE:       return this->HandleCacheMode();
-      case cmProperty::INSTALL:       return this->HandleInstallMode();
+    switch (scope) {
+      case cmProperty::GLOBAL:
+        return this->HandleGlobalMode();
+      case cmProperty::DIRECTORY:
+        return this->HandleDirectoryMode();
+      case cmProperty::TARGET:
+        return this->HandleTargetMode();
+      case cmProperty::SOURCE_FILE:
+        return this->HandleSourceMode();
+      case cmProperty::TEST:
+        return this->HandleTestMode();
+      case cmProperty::VARIABLE:
+        return this->HandleVariableMode();
+      case cmProperty::CACHE:
+        return this->HandleCacheMode();
+      case cmProperty::INSTALL:
+        return this->HandleInstallMode();
 
       case cmProperty::CACHED_VARIABLE:
         break; // should never happen
-      }
     }
+  }
 
   return true;
 }
 
 bool cmGetPropertyCommand::StoreResult(const char* value)
 {
-  if(this->InfoType == OutSet)
-    {
-    this->Makefile->AddDefinition(this->Variable, value? "1":"0");
-    }
-  else // if(this->InfoType == OutValue)
-    {
-    if(value)
-      {
+  if (this->InfoType == OutSet) {
+    this->Makefile->AddDefinition(this->Variable, value ? "1" : "0");
+  } else // if(this->InfoType == OutValue)
+  {
+    if (value) {
       this->Makefile->AddDefinition(this->Variable, value);
-      }
-    else
-      {
+    } else {
       this->Makefile->RemoveDefinition(this->Variable);
-      }
     }
+  }
   return true;
 }
 
 bool cmGetPropertyCommand::HandleGlobalMode()
 {
-  if(!this->Name.empty())
-    {
+  if (!this->Name.empty()) {
     this->SetError("given name for GLOBAL scope.");
     return false;
-    }
+  }
 
   // Get the property.
   cmake* cm = this->Makefile->GetCMakeInstance();
-  return this->StoreResult(cm->GetState()
-             ->GetGlobalProperty(this->PropertyName));
+  return this->StoreResult(
+    cm->GetState()->GetGlobalProperty(this->PropertyName));
 }
 
 bool cmGetPropertyCommand::HandleDirectoryMode()
@@ -240,38 +198,33 @@ bool cmGetPropertyCommand::HandleDirectoryMode()
   cmMakefile* mf = this->Makefile;
 
   // Lookup the directory if given.
-  if(!this->Name.empty())
-    {
+  if (!this->Name.empty()) {
     // Construct the directory name.  Interpret relative paths with
     // respect to the current directory.
     std::string dir = this->Name;
-    if(!cmSystemTools::FileIsFullPath(dir.c_str()))
-      {
+    if (!cmSystemTools::FileIsFullPath(dir.c_str())) {
       dir = this->Makefile->GetCurrentSourceDirectory();
       dir += "/";
       dir += this->Name;
-      }
+    }
 
     // The local generators are associated with collapsed paths.
     dir = cmSystemTools::CollapseFullPath(dir);
 
     // Lookup the generator.
     mf = this->Makefile->GetGlobalGenerator()->FindMakefile(dir);
-    if (!mf)
-      {
+    if (!mf) {
       // Could not find the directory.
-      this->SetError
-        ("DIRECTORY scope provided but requested directory was not found. "
-         "This could be because the directory argument was invalid or, "
-         "it is valid but has not been processed yet.");
+      this->SetError(
+        "DIRECTORY scope provided but requested directory was not found. "
+        "This could be because the directory argument was invalid or, "
+        "it is valid but has not been processed yet.");
       return false;
-      }
     }
+  }
 
-  if (this->PropertyName == "DEFINITIONS")
-    {
-    switch(mf->GetPolicyStatus(cmPolicies::CMP0059))
-      {
+  if (this->PropertyName == "DEFINITIONS") {
+    switch (mf->GetPolicyStatus(cmPolicies::CMP0059)) {
       case cmPolicies::WARN:
         mf->IssueMessage(cmake::AUTHOR_WARNING,
                          cmPolicies::GetPolicyWarning(cmPolicies::CMP0059));
@@ -281,8 +234,8 @@ bool cmGetPropertyCommand::HandleDirectoryMode()
       case cmPolicies::REQUIRED_ALWAYS:
       case cmPolicies::REQUIRED_IF_USED:
         break;
-      }
     }
+  }
 
   // Get the property.
   return this->StoreResult(mf->GetProperty(this->PropertyName));
@@ -290,77 +243,61 @@ bool cmGetPropertyCommand::HandleDirectoryMode()
 
 bool cmGetPropertyCommand::HandleTargetMode()
 {
-  if(this->Name.empty())
-    {
+  if (this->Name.empty()) {
     this->SetError("not given name for TARGET scope.");
     return false;
-    }
+  }
 
-  if(this->PropertyName == "ALIASED_TARGET")
-    {
-    if(this->Makefile->IsAlias(this->Name))
-      {
-      if(cmTarget* target =
-                          this->Makefile->FindTargetToUse(this->Name))
-        {
+  if (this->PropertyName == "ALIASED_TARGET") {
+    if (this->Makefile->IsAlias(this->Name)) {
+      if (cmTarget* target = this->Makefile->FindTargetToUse(this->Name)) {
         return this->StoreResult(target->GetName().c_str());
-        }
       }
-    return this->StoreResult((this->Variable + "-NOTFOUND").c_str());
-    }
-  if(cmTarget* target = this->Makefile->FindTargetToUse(this->Name))
-    {
-    return this->StoreResult(target->GetProperty(this->PropertyName,
-                                                 this->Makefile));
     }
-  else
-    {
+    return this->StoreResult((this->Variable + "-NOTFOUND").c_str());
+  }
+  if (cmTarget* target = this->Makefile->FindTargetToUse(this->Name)) {
+    return this->StoreResult(
+      target->GetProperty(this->PropertyName, this->Makefile));
+  } else {
     std::ostringstream e;
     e << "could not find TARGET " << this->Name
       << ".  Perhaps it has not yet been created.";
     this->SetError(e.str());
     return false;
-    }
+  }
 }
 
 bool cmGetPropertyCommand::HandleSourceMode()
 {
-  if(this->Name.empty())
-    {
+  if (this->Name.empty()) {
     this->SetError("not given name for SOURCE scope.");
     return false;
-    }
+  }
 
   // Get the source file.
-  if(cmSourceFile* sf =
-     this->Makefile->GetOrCreateSource(this->Name))
-    {
-    return
-      this->StoreResult(sf->GetPropertyForUser(this->PropertyName));
-    }
-  else
-    {
+  if (cmSourceFile* sf = this->Makefile->GetOrCreateSource(this->Name)) {
+    return this->StoreResult(sf->GetPropertyForUser(this->PropertyName));
+  } else {
     std::ostringstream e;
     e << "given SOURCE name that could not be found or created: "
       << this->Name;
     this->SetError(e.str());
     return false;
-    }
+  }
 }
 
 bool cmGetPropertyCommand::HandleTestMode()
 {
-  if(this->Name.empty())
-    {
+  if (this->Name.empty()) {
     this->SetError("not given name for TEST scope.");
     return false;
-    }
+  }
 
   // Loop over all tests looking for matching names.
-  if(cmTest* test = this->Makefile->GetTest(this->Name))
-    {
+  if (cmTest* test = this->Makefile->GetTest(this->Name)) {
     return this->StoreResult(test->GetProperty(this->PropertyName));
-    }
+  }
 
   // If not found it is an error.
   std::ostringstream e;
@@ -371,59 +308,51 @@ bool cmGetPropertyCommand::HandleTestMode()
 
 bool cmGetPropertyCommand::HandleVariableMode()
 {
-  if(!this->Name.empty())
-    {
+  if (!this->Name.empty()) {
     this->SetError("given name for VARIABLE scope.");
     return false;
-    }
+  }
 
-  return this->StoreResult
-    (this->Makefile->GetDefinition(this->PropertyName));
+  return this->StoreResult(this->Makefile->GetDefinition(this->PropertyName));
 }
 
 bool cmGetPropertyCommand::HandleCacheMode()
 {
-  if(this->Name.empty())
-    {
+  if (this->Name.empty()) {
     this->SetError("not given name for CACHE scope.");
     return false;
-    }
+  }
 
   const char* value = 0;
-  if(this->Makefile->GetState()->GetCacheEntryValue(this->Name))
-    {
-    value = this->Makefile->GetState()
-                ->GetCacheEntryProperty(this->Name, this->PropertyName);
-    }
+  if (this->Makefile->GetState()->GetCacheEntryValue(this->Name)) {
+    value = this->Makefile->GetState()->GetCacheEntryProperty(
+      this->Name, this->PropertyName);
+  }
   this->StoreResult(value);
   return true;
 }
 
 bool cmGetPropertyCommand::HandleInstallMode()
 {
-  if(this->Name.empty())
-    {
+  if (this->Name.empty()) {
     this->SetError("not given name for INSTALL scope.");
     return false;
-    }
+  }
 
   // Get the installed file.
   cmake* cm = this->Makefile->GetCMakeInstance();
 
-  if(cmInstalledFile* file = cm->GetOrCreateInstalledFile(
-    this->Makefile, this->Name))
-    {
+  if (cmInstalledFile* file =
+        cm->GetOrCreateInstalledFile(this->Makefile, this->Name)) {
     std::string value;
     bool isSet = file->GetProperty(this->PropertyName, value);
 
     return this->StoreResult(isSet ? value.c_str() : 0);
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "given INSTALL name that could not be found or created: "
       << this->Name;
     this->SetError(e.str());
     return false;
-    }
+  }
 }
diff --git a/Source/cmGetPropertyCommand.h b/Source/cmGetPropertyCommand.h
index 40b7dbc..aeed01d 100644
--- a/Source/cmGetPropertyCommand.h
+++ b/Source/cmGetPropertyCommand.h
@@ -19,17 +19,14 @@ class cmGetPropertyCommand : public cmCommand
 public:
   cmGetPropertyCommand();
 
-  virtual cmCommand* Clone()
-    {
-      return new cmGetPropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -39,11 +36,19 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_property";}
+  virtual std::string GetName() const { return "get_property"; }
 
   cmTypeMacro(cmGetPropertyCommand, cmCommand);
+
 private:
-  enum OutType { OutValue, OutDefined, OutBriefDoc, OutFullDoc, OutSet };
+  enum OutType
+  {
+    OutValue,
+    OutDefined,
+    OutBriefDoc,
+    OutFullDoc,
+    OutSet
+  };
   std::string Variable;
   std::string Name;
   std::string PropertyName;
diff --git a/Source/cmGetSourceFilePropertyCommand.cxx b/Source/cmGetSourceFilePropertyCommand.cxx
index 46daa34..e64befe 100644
--- a/Source/cmGetSourceFilePropertyCommand.cxx
+++ b/Source/cmGetSourceFilePropertyCommand.cxx
@@ -14,43 +14,36 @@
 #include "cmSourceFile.h"
 
 // cmSetSourceFilePropertyCommand
-bool cmGetSourceFilePropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetSourceFilePropertyCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() != 3 )
-    {
+  if (args.size() != 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   const char* var = args[0].c_str();
   const char* file = args[1].c_str();
   cmSourceFile* sf = this->Makefile->GetSource(file);
 
   // for the location we must create a source file first
-  if (!sf && args[2] == "LOCATION")
-    {
+  if (!sf && args[2] == "LOCATION") {
     sf = this->Makefile->CreateSource(file);
-    }
-  if(sf)
-    {
-    if(args[2] == "LANGUAGE")
-      {
+  }
+  if (sf) {
+    if (args[2] == "LANGUAGE") {
       this->Makefile->AddDefinition(var, sf->GetLanguage().c_str());
       return true;
-      }
-    const char *prop = 0;
-    if (!args[2].empty())
-      {
+    }
+    const char* prop = 0;
+    if (!args[2].empty()) {
       prop = sf->GetPropertyForUser(args[2]);
-      }
-    if (prop)
-      {
+    }
+    if (prop) {
       this->Makefile->AddDefinition(var, prop);
       return true;
-      }
     }
+  }
 
   this->Makefile->AddDefinition(var, "NOTFOUND");
   return true;
 }
-
diff --git a/Source/cmGetSourceFilePropertyCommand.h b/Source/cmGetSourceFilePropertyCommand.h
index ab8ce36..06f582f 100644
--- a/Source/cmGetSourceFilePropertyCommand.h
+++ b/Source/cmGetSourceFilePropertyCommand.h
@@ -17,26 +17,21 @@
 class cmGetSourceFilePropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmGetSourceFilePropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetSourceFilePropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_source_file_property";}
+  virtual std::string GetName() const { return "get_source_file_property"; }
 
   cmTypeMacro(cmGetSourceFilePropertyCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmGetTargetPropertyCommand.cxx b/Source/cmGetTargetPropertyCommand.cxx
index ca40bd0..dded9f7 100644
--- a/Source/cmGetTargetPropertyCommand.cxx
+++ b/Source/cmGetTargetPropertyCommand.cxx
@@ -12,52 +12,40 @@
 #include "cmGetTargetPropertyCommand.h"
 
 // cmSetTargetPropertyCommand
-bool cmGetTargetPropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetTargetPropertyCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() != 3 )
-    {
+  if (args.size() != 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::string var = args[0];
   const std::string& targetName = args[1];
   std::string prop;
   bool prop_exists = false;
 
-  if(args[2] == "ALIASED_TARGET")
-    {
-    if(this->Makefile->IsAlias(targetName))
-      {
-      if(cmTarget* target =
-                          this->Makefile->FindTargetToUse(targetName))
-        {
+  if (args[2] == "ALIASED_TARGET") {
+    if (this->Makefile->IsAlias(targetName)) {
+      if (cmTarget* target = this->Makefile->FindTargetToUse(targetName)) {
         prop = target->GetName();
         prop_exists = true;
-        }
       }
     }
-  else if(cmTarget* tgt = this->Makefile->FindTargetToUse(targetName))
-    {
+  } else if (cmTarget* tgt = this->Makefile->FindTargetToUse(targetName)) {
     cmTarget& target = *tgt;
     const char* prop_cstr = 0;
-    if (!args[2].empty())
-      {
+    if (!args[2].empty()) {
       prop_cstr = target.GetProperty(args[2], this->Makefile);
-      }
-    if(prop_cstr)
-      {
+    }
+    if (prop_cstr) {
       prop = prop_cstr;
       prop_exists = true;
-      }
     }
-  else
-    {
+  } else {
     bool issueMessage = false;
     std::ostringstream e;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0045))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0045)) {
       case cmPolicies::WARN:
         issueMessage = true;
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0045) << "\n";
@@ -68,24 +56,20 @@ bool cmGetTargetPropertyCommand
       case cmPolicies::NEW:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
-    if (issueMessage)
-      {
+    }
+    if (issueMessage) {
       e << "get_target_property() called with non-existent target \""
-        << targetName <<  "\".";
+        << targetName << "\".";
       this->Makefile->IssueMessage(messageType, e.str());
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
-  if (prop_exists)
-    {
+  }
+  if (prop_exists) {
     this->Makefile->AddDefinition(var, prop.c_str());
     return true;
-    }
-  this->Makefile->AddDefinition(var, (var+"-NOTFOUND").c_str());
+  }
+  this->Makefile->AddDefinition(var, (var + "-NOTFOUND").c_str());
   return true;
 }
-
diff --git a/Source/cmGetTargetPropertyCommand.h b/Source/cmGetTargetPropertyCommand.h
index a35c6fe..9a1e18e 100644
--- a/Source/cmGetTargetPropertyCommand.h
+++ b/Source/cmGetTargetPropertyCommand.h
@@ -17,26 +17,21 @@
 class cmGetTargetPropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmGetTargetPropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetTargetPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_target_property";}
+  virtual std::string GetName() const { return "get_target_property"; }
 
   cmTypeMacro(cmGetTargetPropertyCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmGetTestPropertyCommand.cxx b/Source/cmGetTestPropertyCommand.cxx
index 3d7a013..6599021 100644
--- a/Source/cmGetTestPropertyCommand.cxx
+++ b/Source/cmGetTestPropertyCommand.cxx
@@ -15,32 +15,27 @@
 #include "cmake.h"
 
 // cmGetTestPropertyCommand
-bool cmGetTestPropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmGetTestPropertyCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string testName = args[0];
   std::string var = args[2];
-  cmTest *test = this->Makefile->GetTest(testName);
-  if (test)
-    {
-    const char *prop = 0;
-    if (!args[1].empty())
-      {
+  cmTest* test = this->Makefile->GetTest(testName);
+  if (test) {
+    const char* prop = 0;
+    if (!args[1].empty()) {
       prop = test->GetProperty(args[1]);
-      }
-    if (prop)
-      {
+    }
+    if (prop) {
       this->Makefile->AddDefinition(var, prop);
       return true;
-      }
     }
+  }
   this->Makefile->AddDefinition(var, "NOTFOUND");
   return true;
 }
-
diff --git a/Source/cmGetTestPropertyCommand.h b/Source/cmGetTestPropertyCommand.h
index 2819492..fc281c4 100644
--- a/Source/cmGetTestPropertyCommand.h
+++ b/Source/cmGetTestPropertyCommand.h
@@ -17,26 +17,21 @@
 class cmGetTestPropertyCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-    return new cmGetTestPropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmGetTestPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "get_test_property";}
+  virtual std::string GetName() const { return "get_test_property"; }
 
   cmTypeMacro(cmGetTestPropertyCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmGhsMultiGpj.cxx b/Source/cmGhsMultiGpj.cxx
index e1dce52..ca88578 100644
--- a/Source/cmGhsMultiGpj.cxx
+++ b/Source/cmGhsMultiGpj.cxx
@@ -14,11 +14,10 @@
 #include "cmGeneratedFileStream.h"
 
 void GhsMultiGpj::WriteGpjTag(Types const gpjType,
-                              cmGeneratedFileStream *const filestream)
+                              cmGeneratedFileStream* const filestream)
 {
-  char const *tag;
-  switch (gpjType)
-    {
+  char const* tag;
+  switch (gpjType) {
     case INTERGRITY_APPLICATION:
       tag = "INTEGRITY Application";
       break;
@@ -39,6 +38,6 @@ void GhsMultiGpj::WriteGpjTag(Types const gpjType,
       break;
     default:
       tag = "";
-    }
+  }
   *filestream << "[" << tag << "]" << std::endl;
 }
diff --git a/Source/cmGhsMultiGpj.h b/Source/cmGhsMultiGpj.h
index 862b63c..b388455 100644
--- a/Source/cmGhsMultiGpj.h
+++ b/Source/cmGhsMultiGpj.h
@@ -30,7 +30,7 @@ public:
   };
 
   static void WriteGpjTag(Types const gpjType,
-                          cmGeneratedFileStream *filestream);
+                          cmGeneratedFileStream* filestream);
 };
 
 #endif // ! cmGhsMultiGpjType_h
diff --git a/Source/cmGhsMultiTargetGenerator.cxx b/Source/cmGhsMultiTargetGenerator.cxx
index 4ca59cb..325a86e 100644
--- a/Source/cmGhsMultiTargetGenerator.cxx
+++ b/Source/cmGhsMultiTargetGenerator.cxx
@@ -22,18 +22,17 @@
 
 std::string const cmGhsMultiTargetGenerator::DDOption("-dynamic");
 
-cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget *target)
+cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget* target)
   : GeneratorTarget(target)
-  , LocalGenerator(static_cast<cmLocalGhsMultiGenerator *>(
-                     target->GetLocalGenerator()))
+  , LocalGenerator(
+      static_cast<cmLocalGhsMultiGenerator*>(target->GetLocalGenerator()))
   , Makefile(target->Target->GetMakefile())
   , TargetGroup(DetermineIfTargetGroup(target))
   , DynamicDownload(false)
 {
   this->RelBuildFilePath = this->GetRelBuildFilePath(target);
 
-  this->RelOutputFileName =
-    this->RelBuildFilePath + target->GetName() + ".a";
+  this->RelOutputFileName = this->RelBuildFilePath + target->GetName() + ".a";
 
   this->RelBuildFileName = this->RelBuildFilePath;
   this->RelBuildFileName += this->GetBuildFileName(target);
@@ -50,50 +49,48 @@ cmGhsMultiTargetGenerator::~cmGhsMultiTargetGenerator()
   cmDeleteAll(this->FolderBuildStreams);
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetRelBuildFilePath(
-        const cmGeneratorTarget *target)
+std::string cmGhsMultiTargetGenerator::GetRelBuildFilePath(
+  const cmGeneratorTarget* target)
 {
   std::string output;
-  char const *folderProp = target->GetProperty("FOLDER");
+  char const* folderProp = target->GetProperty("FOLDER");
   output = NULL == folderProp ? "" : folderProp;
   cmSystemTools::ConvertToUnixSlashes(output);
-  if (!output.empty())
-  {
+  if (!output.empty()) {
     output += "/";
   }
   output += target->GetName() + "/";
   return output;
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetAbsPathToRoot(const cmGeneratorTarget *target)
+std::string cmGhsMultiTargetGenerator::GetAbsPathToRoot(
+  const cmGeneratorTarget* target)
 {
   return target->GetLocalGenerator()->GetBinaryDirectory();
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetAbsBuildFilePath(const cmGeneratorTarget *target)
+std::string cmGhsMultiTargetGenerator::GetAbsBuildFilePath(
+  const cmGeneratorTarget* target)
 {
   std::string output;
   output = cmGhsMultiTargetGenerator::GetAbsPathToRoot(target);
   output = cmGhsMultiTargetGenerator::AddSlashIfNeededToPath(output);
   output += cmGhsMultiTargetGenerator::GetRelBuildFilePath(target);
-  return  output;
+  return output;
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetRelBuildFileName(const cmGeneratorTarget *target)
+std::string cmGhsMultiTargetGenerator::GetRelBuildFileName(
+  const cmGeneratorTarget* target)
 {
   std::string output;
   output = cmGhsMultiTargetGenerator::GetRelBuildFilePath(target);
   output = cmGhsMultiTargetGenerator::AddSlashIfNeededToPath(output);
   output += cmGhsMultiTargetGenerator::GetBuildFileName(target);
-  return  output;
+  return output;
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetBuildFileName(const cmGeneratorTarget *target)
+std::string cmGhsMultiTargetGenerator::GetBuildFileName(
+  const cmGeneratorTarget* target)
 {
   std::string output;
   output = target->GetName();
@@ -101,44 +98,39 @@ cmGhsMultiTargetGenerator::GetBuildFileName(const cmGeneratorTarget *target)
   return output;
 }
 
-std::string
-cmGhsMultiTargetGenerator::AddSlashIfNeededToPath(std::string const &input)
+std::string cmGhsMultiTargetGenerator::AddSlashIfNeededToPath(
+  std::string const& input)
 {
   std::string output(input);
-  if (!cmHasLiteralSuffix(output, "/"))
-    {
+  if (!cmHasLiteralSuffix(output, "/")) {
     output += "/";
-    }
+  }
   return output;
 }
 
 void cmGhsMultiTargetGenerator::Generate()
 {
-  std::vector<cmSourceFile *> objectSources = this->GetSources();
-  if (!objectSources.empty() && this->IncludeThisTarget())
-    {
-    if (!cmSystemTools::FileExists(this->AbsBuildFilePath.c_str()))
-      {
+  std::vector<cmSourceFile*> objectSources = this->GetSources();
+  if (!objectSources.empty() && this->IncludeThisTarget()) {
+    if (!cmSystemTools::FileExists(this->AbsBuildFilePath.c_str())) {
       cmSystemTools::MakeDirectory(this->AbsBuildFilePath.c_str());
-      }
+    }
     cmGlobalGhsMultiGenerator::Open(std::string(""), this->AbsBuildFileName,
                                     &this->FolderBuildStreams);
     cmGlobalGhsMultiGenerator::OpenBuildFileStream(
       this->GetFolderBuildStreams());
     std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
-    if (0 == config.length())
-      {
+    if (0 == config.length()) {
       config = "RELEASE";
-      }
+    }
     const std::string language(
-          this->GeneratorTarget->GetLinkerLanguage(config));
+      this->GeneratorTarget->GetLinkerLanguage(config));
     config = cmSystemTools::UpperCase(config);
     this->DynamicDownload = this->DetermineIfDynamicDownload(config, language);
-    if (this->DynamicDownload)
-      {
+    if (this->DynamicDownload) {
       *this->GetFolderBuildStreams() << "#component integrity_dynamic_download"
                                      << std::endl;
-      }
+    }
     GhsMultiGpj::WriteGpjTag(this->GetGpjTag(), this->GetFolderBuildStreams());
     cmGlobalGhsMultiGenerator::WriteDisclaimer(this->GetFolderBuildStreams());
 
@@ -148,36 +140,34 @@ void cmGhsMultiTargetGenerator::Generate()
     this->WriteCompilerFlags(config, language);
     this->WriteCompilerDefinitions(config, language);
     this->WriteIncludes(config, language);
-    if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-      {
+    if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
       this->WriteTargetLinkLibraries(config, language);
-      }
+    }
     this->WriteCustomCommands();
 
-    std::map<const cmSourceFile *, std::string> objectNames =
-        cmGhsMultiTargetGenerator::GetObjectNames(
-            &objectSources, this->LocalGenerator, this->GeneratorTarget);
+    std::map<const cmSourceFile*, std::string> objectNames =
+      cmGhsMultiTargetGenerator::GetObjectNames(
+        &objectSources, this->LocalGenerator, this->GeneratorTarget);
 
     this->WriteSources(objectSources, objectNames);
-    }
+  }
 }
 
 bool cmGhsMultiTargetGenerator::IncludeThisTarget()
 {
   bool output = true;
-  char const *excludeFromAll =
-      this->GeneratorTarget->GetProperty("EXCLUDE_FROM_ALL");
+  char const* excludeFromAll =
+    this->GeneratorTarget->GetProperty("EXCLUDE_FROM_ALL");
   if (NULL != excludeFromAll && '1' == excludeFromAll[0] &&
-      '\0' == excludeFromAll[1])
-    {
+      '\0' == excludeFromAll[1]) {
     output = false;
-    }
+  }
   return output;
 }
 
-std::vector<cmSourceFile *> cmGhsMultiTargetGenerator::GetSources() const
+std::vector<cmSourceFile*> cmGhsMultiTargetGenerator::GetSources() const
 {
-  std::vector<cmSourceFile *> output;
+  std::vector<cmSourceFile*> output;
   std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
   this->GeneratorTarget->GetSourceFiles(output, config);
   return output;
@@ -189,185 +179,157 @@ GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag() const
 }
 
 GhsMultiGpj::Types cmGhsMultiTargetGenerator::GetGpjTag(
-    const cmGeneratorTarget *target)
+  const cmGeneratorTarget* target)
 {
   GhsMultiGpj::Types output;
-  if (cmGhsMultiTargetGenerator::DetermineIfTargetGroup(target))
-    {
+  if (cmGhsMultiTargetGenerator::DetermineIfTargetGroup(target)) {
     output = GhsMultiGpj::INTERGRITY_APPLICATION;
-    }
-  else if (target->GetType() == cmState::STATIC_LIBRARY)
-    {
+  } else if (target->GetType() == cmState::STATIC_LIBRARY) {
     output = GhsMultiGpj::LIBRARY;
-    }
-  else
-    {
+  } else {
     output = GhsMultiGpj::PROGRAM;
-    }
+  }
   return output;
 }
 
-cmGlobalGhsMultiGenerator*
-cmGhsMultiTargetGenerator::GetGlobalGenerator() const
+cmGlobalGhsMultiGenerator* cmGhsMultiTargetGenerator::GetGlobalGenerator()
+  const
 {
-  return static_cast<cmGlobalGhsMultiGenerator *>(
+  return static_cast<cmGlobalGhsMultiGenerator*>(
     this->LocalGenerator->GetGlobalGenerator());
 }
 
-void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string &config,
+void cmGhsMultiTargetGenerator::WriteTypeSpecifics(const std::string& config,
                                                    bool const notKernel)
 {
   std::string outputDir(this->GetOutputDirectory(config));
   std::string outputFilename(this->GetOutputFilename(config));
 
-  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) {
     std::string const static_library_suffix =
       this->Makefile->GetSafeDefinition("CMAKE_STATIC_LIBRARY_SUFFIX");
-    *this->GetFolderBuildStreams() << "    -o \""
-                                   << outputDir << outputFilename
-                                   << static_library_suffix << "\""
-                                   << std::endl;
-    }
-  else if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-    {
-    if (notKernel && !this->IsTargetGroup())
-      {
+    *this->GetFolderBuildStreams() << "    -o \"" << outputDir
+                                   << outputFilename << static_library_suffix
+                                   << "\"" << std::endl;
+  } else if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
+    if (notKernel && !this->IsTargetGroup()) {
       *this->GetFolderBuildStreams() << "    -relprog" << std::endl;
-      }
-    if (this->IsTargetGroup())
-      {
+    }
+    if (this->IsTargetGroup()) {
       *this->GetFolderBuildStreams()
-          << "    -o \"" << outputDir
-          << outputFilename << ".elf\"" << std::endl;
+        << "    -o \"" << outputDir << outputFilename << ".elf\"" << std::endl;
       *this->GetFolderBuildStreams() << "    :extraOutputFile=\"" << outputDir
                                      << outputFilename << ".elf.ael\""
                                      << std::endl;
-      }
-    else
-      {
+    } else {
       std::string const executable_suffix =
         this->Makefile->GetSafeDefinition("CMAKE_EXECUTABLE_SUFFIX");
-      *this->GetFolderBuildStreams() << "    -o \""
-                                     << outputDir << outputFilename
-                                     << executable_suffix << "\""
-                                     << std::endl;
-      }
+      *this->GetFolderBuildStreams() << "    -o \"" << outputDir
+                                     << outputFilename << executable_suffix
+                                     << "\"" << std::endl;
     }
+  }
 }
 
-void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const &config,
-                                                 const std::string &language,
+void cmGhsMultiTargetGenerator::SetCompilerFlags(std::string const& config,
+                                                 const std::string& language,
                                                  bool const notKernel)
 {
   std::map<std::string, std::string>::iterator i =
     this->FlagsByLanguage.find(language);
-  if (i == this->FlagsByLanguage.end())
-    {
+  if (i == this->FlagsByLanguage.end()) {
     std::string flags;
-    const char *lang = language.c_str();
+    const char* lang = language.c_str();
 
-    if (notKernel)
-      {
+    if (notKernel) {
       this->LocalGenerator->AddLanguageFlags(flags, lang, config);
-      }
-    else
-      {
-        this->LocalGenerator->AddLanguageFlags(
-            flags, lang + std::string("_GHS_KERNEL"), config);
-      }
-    this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget,
-                                          lang, config);
-    this->LocalGenerator->AddVisibilityPresetFlags(flags,
-                                                   this->GeneratorTarget,
-                                                   lang);
+    } else {
+      this->LocalGenerator->AddLanguageFlags(
+        flags, lang + std::string("_GHS_KERNEL"), config);
+    }
+    this->LocalGenerator->AddCMP0018Flags(flags, this->GeneratorTarget, lang,
+                                          config);
+    this->LocalGenerator->AddVisibilityPresetFlags(
+      flags, this->GeneratorTarget, lang);
 
     // Append old-style preprocessor definition flags.
-    if (std::string(" ") != std::string(this->Makefile->GetDefineFlags()))
-      {
+    if (std::string(" ") != std::string(this->Makefile->GetDefineFlags())) {
       this->LocalGenerator->AppendFlags(flags,
-                                      this->Makefile->GetDefineFlags());
-      }
+                                        this->Makefile->GetDefineFlags());
+    }
 
     // Add target-specific flags.
-    this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
-                                            lang, config);
+    this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget, lang,
+                                            config);
 
     std::map<std::string, std::string>::value_type entry(language, flags);
     i = this->FlagsByLanguage.insert(entry).first;
-    }
+  }
 }
 
-std::string cmGhsMultiTargetGenerator::GetDefines(const std::string &language,
-                                                  std::string const &config)
+std::string cmGhsMultiTargetGenerator::GetDefines(const std::string& language,
+                                                  std::string const& config)
 {
   std::map<std::string, std::string>::iterator i =
     this->DefinesByLanguage.find(language);
-  if (i == this->DefinesByLanguage.end())
-    {
+  if (i == this->DefinesByLanguage.end()) {
     std::set<std::string> defines;
-    const char *lang = language.c_str();
+    const char* lang = language.c_str();
     // Add the export symbol definition for shared library objects.
-    if (const char *exportMacro = this->GeneratorTarget->GetExportMacro())
-      {
+    if (const char* exportMacro = this->GeneratorTarget->GetExportMacro()) {
       this->LocalGenerator->AppendDefines(defines, exportMacro);
-      }
+    }
 
     // Add preprocessor definitions for this target and configuration.
-    this->LocalGenerator->AddCompileDefinitions(defines,
-                                                this->GeneratorTarget, config,
-                                                language);
+    this->LocalGenerator->AddCompileDefinitions(defines, this->GeneratorTarget,
+                                                config, language);
 
     std::string definesString;
     this->LocalGenerator->JoinDefines(defines, definesString, lang);
 
     std::map<std::string, std::string>::value_type entry(language,
-                                                          definesString);
+                                                         definesString);
     i = this->DefinesByLanguage.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
-void cmGhsMultiTargetGenerator::WriteCompilerFlags(std::string const &,
-                                                   const std::string &language)
+void cmGhsMultiTargetGenerator::WriteCompilerFlags(std::string const&,
+                                                   const std::string& language)
 {
   std::map<std::string, std::string>::iterator flagsByLangI =
-      this->FlagsByLanguage.find(language);
-  if (flagsByLangI != this->FlagsByLanguage.end())
-    {
-    if (!flagsByLangI->second.empty())
-      {
+    this->FlagsByLanguage.find(language);
+  if (flagsByLangI != this->FlagsByLanguage.end()) {
+    if (!flagsByLangI->second.empty()) {
       *this->GetFolderBuildStreams() << "    " << flagsByLangI->second
-        << std::endl;
-      }
+                                     << std::endl;
     }
+  }
 }
 
 void cmGhsMultiTargetGenerator::WriteCompilerDefinitions(
-  const std::string &config, const std::string &language)
+  const std::string& config, const std::string& language)
 {
   std::vector<std::string> compileDefinitions;
-  this->GeneratorTarget->GetCompileDefinitions(compileDefinitions,
-                                               config, language);
+  this->GeneratorTarget->GetCompileDefinitions(compileDefinitions, config,
+                                               language);
   for (std::vector<std::string>::const_iterator cdI =
          compileDefinitions.begin();
-       cdI != compileDefinitions.end(); ++cdI)
-    {
+       cdI != compileDefinitions.end(); ++cdI) {
     *this->GetFolderBuildStreams() << "    -D" << (*cdI) << std::endl;
-    }
+  }
 }
 
-void cmGhsMultiTargetGenerator::WriteIncludes(const std::string &config,
-                                              const std::string &language)
+void cmGhsMultiTargetGenerator::WriteIncludes(const std::string& config,
+                                              const std::string& language)
 {
   std::vector<std::string> includes =
     this->GeneratorTarget->GetIncludeDirectories(config, language);
   for (std::vector<std::string>::const_iterator includes_i = includes.begin();
-       includes_i != includes.end(); ++includes_i)
-    {
+       includes_i != includes.end(); ++includes_i) {
     *this->GetFolderBuildStreams() << "    -I\"" << *includes_i << "\""
                                    << std::endl;
-    }
+  }
 }
 
 void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries(
@@ -377,83 +339,71 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLibraries(
   cmTargetDependSet tds =
     this->GetGlobalGenerator()->GetTargetDirectDepends(this->GeneratorTarget);
   for (cmTargetDependSet::iterator tdsI = tds.begin(); tdsI != tds.end();
-       ++tdsI)
-    {
-    const cmGeneratorTarget *tg = *tdsI;
+       ++tdsI) {
+    const cmGeneratorTarget* tg = *tdsI;
     *this->GetFolderBuildStreams() << "    -L\"" << GetAbsBuildFilePath(tg)
                                    << "\"" << std::endl;
-    }
+  }
   // library targets
   cmTarget::LinkLibraryVectorType llv =
     this->GeneratorTarget->Target->GetOriginalLinkLibraries();
   for (cmTarget::LinkLibraryVectorType::const_iterator llvI = llv.begin();
-       llvI != llv.end(); ++llvI)
-    {
+       llvI != llv.end(); ++llvI) {
     std::string libName = llvI->first;
     // if it is a user defined target get the full path to the lib
-    cmTarget *tg(GetGlobalGenerator()->FindTarget(libName));
-    if (NULL != tg)
-      {
+    cmTarget* tg(GetGlobalGenerator()->FindTarget(libName));
+    if (NULL != tg) {
       libName = tg->GetName() + ".a";
-      }
+    }
     *this->GetFolderBuildStreams() << "    -l\"" << libName << "\""
                                    << std::endl;
-    }
+  }
 
-  if (!this->TargetGroup)
-    {
+  if (!this->TargetGroup) {
     std::string linkLibraries;
     std::string flags;
     std::string linkFlags;
     std::string frameworkPath;
     std::string linkPath;
     std::string createRule =
-        this->GeneratorTarget->GetCreateRuleVariable(language, config);
+      this->GeneratorTarget->GetCreateRuleVariable(language, config);
     bool useWatcomQuote =
-        this->Makefile->IsOn(createRule + "_USE_WATCOM_QUOTE");
+      this->Makefile->IsOn(createRule + "_USE_WATCOM_QUOTE");
     this->LocalGenerator->GetTargetFlags(
-      linkLibraries, flags, linkFlags,
-      frameworkPath, linkPath,
+      linkLibraries, flags, linkFlags, frameworkPath, linkPath,
       this->GeneratorTarget, useWatcomQuote);
     linkFlags = cmSystemTools::TrimWhitespace(linkFlags);
 
-    if (!linkPath.empty())
-      {
+    if (!linkPath.empty()) {
       linkPath = " " + linkPath.substr(0U, linkPath.size() - 1U);
       *this->GetFolderBuildStreams() << linkPath;
-      }
+    }
 
-    if (!linkFlags.empty())
-      {
+    if (!linkFlags.empty()) {
       *this->GetFolderBuildStreams() << "    " << linkFlags << std::endl;
-      }
     }
+  }
 }
 
 void cmGhsMultiTargetGenerator::WriteCustomCommands()
 {
-  WriteCustomCommandsHelper(
-        this->GeneratorTarget->GetPreBuildCommands(),
-        cmTarget::PRE_BUILD);
-  WriteCustomCommandsHelper(
-        this->GeneratorTarget->GetPostBuildCommands(),
-        cmTarget::POST_BUILD);
+  WriteCustomCommandsHelper(this->GeneratorTarget->GetPreBuildCommands(),
+                            cmTarget::PRE_BUILD);
+  WriteCustomCommandsHelper(this->GeneratorTarget->GetPostBuildCommands(),
+                            cmTarget::POST_BUILD);
 }
 
 void cmGhsMultiTargetGenerator::WriteCustomCommandsHelper(
-  std::vector<cmCustomCommand> const &commandsSet,
+  std::vector<cmCustomCommand> const& commandsSet,
   cmTarget::CustomCommandType const commandType)
 {
   for (std::vector<cmCustomCommand>::const_iterator commandsSetI =
          commandsSet.begin();
-       commandsSetI != commandsSet.end(); ++commandsSetI)
-    {
-    cmCustomCommandLines const &commands = commandsSetI->GetCommandLines();
+       commandsSetI != commandsSet.end(); ++commandsSetI) {
+    cmCustomCommandLines const& commands = commandsSetI->GetCommandLines();
     for (cmCustomCommandLines::const_iterator commandI = commands.begin();
-         commandI != commands.end(); ++commandI)
-      {
-      switch (commandType)
-        {
+         commandI != commands.end(); ++commandI) {
+      switch (commandType) {
         case cmTarget::PRE_BUILD:
           *this->GetFolderBuildStreams() << "    :preexecShellSafe=";
           break;
@@ -462,97 +412,88 @@ void cmGhsMultiTargetGenerator::WriteCustomCommandsHelper(
           break;
         default:
           assert("Only pre and post are supported");
-        }
-      cmCustomCommandLine const &command = *commandI;
+      }
+      cmCustomCommandLine const& command = *commandI;
       for (cmCustomCommandLine::const_iterator commandLineI = command.begin();
-           commandLineI != command.end(); ++commandLineI)
-        {
+           commandLineI != command.end(); ++commandLineI) {
         std::string subCommandE =
-            this->LocalGenerator->EscapeForShell(*commandLineI, true);
-        if (!command.empty())
-          {
+          this->LocalGenerator->EscapeForShell(*commandLineI, true);
+        if (!command.empty()) {
           *this->GetFolderBuildStreams()
             << (command.begin() == commandLineI ? "'" : " ");
-          //Need to double escape backslashes
+          // Need to double escape backslashes
           cmSystemTools::ReplaceString(subCommandE, "\\", "\\\\");
-          }
-        *this->GetFolderBuildStreams() << subCommandE;
         }
-      if (!command.empty())
-        {
+        *this->GetFolderBuildStreams() << subCommandE;
+      }
+      if (!command.empty()) {
         *this->GetFolderBuildStreams() << "'" << std::endl;
-        }
       }
     }
+  }
 }
 
-std::map<const cmSourceFile *, std::string>
+std::map<const cmSourceFile*, std::string>
 cmGhsMultiTargetGenerator::GetObjectNames(
-    std::vector<cmSourceFile *> *const objectSources,
-    cmLocalGhsMultiGenerator *const localGhsMultiGenerator,
-    cmGeneratorTarget *const generatorTarget)
-{
-  std::map<std::string, std::vector<cmSourceFile *> > filenameToSource;
-  std::map<cmSourceFile *, std::string> sourceToFilename;
-  for(std::vector<cmSourceFile *>::const_iterator
-      sf = objectSources->begin(); sf != objectSources->end(); ++sf)
-    {
+  std::vector<cmSourceFile*>* const objectSources,
+  cmLocalGhsMultiGenerator* const localGhsMultiGenerator,
+  cmGeneratorTarget* const generatorTarget)
+{
+  std::map<std::string, std::vector<cmSourceFile*> > filenameToSource;
+  std::map<cmSourceFile*, std::string> sourceToFilename;
+  for (std::vector<cmSourceFile*>::const_iterator sf = objectSources->begin();
+       sf != objectSources->end(); ++sf) {
     const std::string filename =
-        cmSystemTools::GetFilenameName((*sf)->GetFullPath());
+      cmSystemTools::GetFilenameName((*sf)->GetFullPath());
     const std::string lower_filename = cmSystemTools::LowerCase(filename);
     filenameToSource[lower_filename].push_back(*sf);
     sourceToFilename[*sf] = lower_filename;
-    }
+  }
 
-  std::vector<cmSourceFile *> duplicateSources;
-  for (std::map<std::string, std::vector<cmSourceFile *> >::const_iterator
-       msvSourceI = filenameToSource.begin();
-       msvSourceI != filenameToSource.end(); ++msvSourceI)
-    {
-    if (msvSourceI->second.size() > 1)
-      {
+  std::vector<cmSourceFile*> duplicateSources;
+  for (std::map<std::string, std::vector<cmSourceFile*> >::const_iterator
+         msvSourceI = filenameToSource.begin();
+       msvSourceI != filenameToSource.end(); ++msvSourceI) {
+    if (msvSourceI->second.size() > 1) {
       duplicateSources.insert(duplicateSources.end(),
                               msvSourceI->second.begin(),
                               msvSourceI->second.end());
-      }
     }
+  }
 
-  std::map<const cmSourceFile *, std::string> objectNamesCorrected;
+  std::map<const cmSourceFile*, std::string> objectNamesCorrected;
 
-  for (std::vector<cmSourceFile *>::const_iterator sf =
-           duplicateSources.begin();
-       sf != duplicateSources.end(); ++sf)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator sf =
+         duplicateSources.begin();
+       sf != duplicateSources.end(); ++sf) {
     static std::string::size_type const MAX_FULL_PATH_LENGTH = 247;
     std::string const longestObjectDirectory(
-        cmGhsMultiTargetGenerator::ComputeLongestObjectDirectory(
-    localGhsMultiGenerator, generatorTarget, *sf));
+      cmGhsMultiTargetGenerator::ComputeLongestObjectDirectory(
+        localGhsMultiGenerator, generatorTarget, *sf));
     std::string fullFilename = (*sf)->GetFullPath();
     bool const ObjPathFound = cmLocalGeneratorCheckObjectName(
-        fullFilename, longestObjectDirectory.size(), MAX_FULL_PATH_LENGTH);
-    if (!ObjPathFound)
-      {
+      fullFilename, longestObjectDirectory.size(), MAX_FULL_PATH_LENGTH);
+    if (!ObjPathFound) {
       cmSystemTools::Error("Object path \"", fullFilename.c_str(),
                            "\" too long", "");
-      }
+    }
     cmsys::SystemTools::ReplaceString(fullFilename, ":/", "_");
     cmsys::SystemTools::ReplaceString(fullFilename, "/", "_");
     objectNamesCorrected[*sf] = fullFilename;
-    }
+  }
 
   return objectNamesCorrected;
 }
 
 void cmGhsMultiTargetGenerator::WriteSources(
-    std::vector<cmSourceFile *> const &objectSources,
-    std::map<const cmSourceFile *, std::string> const &objectNames)
+  std::vector<cmSourceFile*> const& objectSources,
+  std::map<const cmSourceFile*, std::string> const& objectNames)
 {
-  for (std::vector<cmSourceFile *>::const_iterator si = objectSources.begin();
-       si != objectSources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator si = objectSources.begin();
+       si != objectSources.end(); ++si) {
     std::vector<cmSourceGroup> sourceGroups(this->Makefile->GetSourceGroups());
-    char const *sourceFullPath = (*si)->GetFullPath().c_str();
-    cmSourceGroup *sourceGroup =
+    char const* sourceFullPath = (*si)->GetFullPath().c_str();
+    cmSourceGroup* sourceGroup =
       this->Makefile->FindSourceGroup(sourceFullPath, sourceGroups);
     std::string sgPath(sourceGroup->GetFullName());
     cmSystemTools::ConvertToUnixSlashes(sgPath);
@@ -562,131 +503,118 @@ void cmGhsMultiTargetGenerator::WriteSources(
       GhsMultiGpj::SUBPROJECT, this->RelBuildFilePath);
 
     std::string fullSourcePath((*si)->GetFullPath());
-    if ((*si)->GetExtension() == "int" || (*si)->GetExtension() == "bsp")
-      {
+    if ((*si)->GetExtension() == "int" || (*si)->GetExtension() == "bsp") {
       *this->FolderBuildStreams[sgPath] << fullSourcePath << std::endl;
-      }
-    else
-      {
-      //WORKAROUND: GHS MULTI needs the path to use backslashes without quotes
+    } else {
+      // WORKAROUND: GHS MULTI needs the path to use backslashes without quotes
       //  to open files in search as of version 6.1.6
       cmsys::SystemTools::ReplaceString(fullSourcePath, "/", "\\");
       *this->FolderBuildStreams[sgPath] << fullSourcePath << std::endl;
-      }
+    }
 
     if ("ld" != (*si)->GetExtension() && "int" != (*si)->GetExtension() &&
-        "bsp" != (*si)->GetExtension())
-      {
+        "bsp" != (*si)->GetExtension()) {
       this->WriteObjectLangOverride(this->FolderBuildStreams[sgPath], (*si));
-      if (objectNames.end() != objectNames.find(*si))
-        {
-        *this->FolderBuildStreams[sgPath] << "    -o \"" <<
-          objectNames.find(*si)->second << ".o\"" << std::endl;
-        }
+      if (objectNames.end() != objectNames.find(*si)) {
+        *this->FolderBuildStreams[sgPath]
+          << "    -o \"" << objectNames.find(*si)->second << ".o\""
+          << std::endl;
+      }
 
       this->WriteObjectDir(this->FolderBuildStreams[sgPath],
                            this->AbsBuildFilePath + sgPath);
-      }
     }
+  }
 }
 
 void cmGhsMultiTargetGenerator::WriteObjectLangOverride(
-  cmGeneratedFileStream *fileStream, cmSourceFile *sourceFile)
+  cmGeneratedFileStream* fileStream, cmSourceFile* sourceFile)
 {
-  const char *rawLangProp = sourceFile->GetProperty("LANGUAGE");
-  if (NULL != rawLangProp)
-    {
+  const char* rawLangProp = sourceFile->GetProperty("LANGUAGE");
+  if (NULL != rawLangProp) {
     std::string sourceLangProp(rawLangProp);
     std::string extension(sourceFile->GetExtension());
-    if ("CXX" == sourceLangProp && ("c" == extension || "C" == extension))
-      {
+    if ("CXX" == sourceLangProp && ("c" == extension || "C" == extension)) {
       *fileStream << "    -dotciscxx" << std::endl;
-      }
     }
+  }
 }
 
 void cmGhsMultiTargetGenerator::WriteObjectDir(
-  cmGeneratedFileStream *fileStream, std::string const &dir)
+  cmGeneratedFileStream* fileStream, std::string const& dir)
 {
   std::string workingDir(dir);
   cmSystemTools::ConvertToUnixSlashes(workingDir);
-  if (!workingDir.empty())
-    {
+  if (!workingDir.empty()) {
     workingDir += "/";
-    }
+  }
   workingDir += "Objs";
   *fileStream << "    -object_dir=\"" << workingDir << "\"" << std::endl;
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetOutputDirectory(const std::string &config) const
+std::string cmGhsMultiTargetGenerator::GetOutputDirectory(
+  const std::string& config) const
 {
   std::string outputDir(AbsBuildFilePath);
 
-  const char *runtimeOutputProp =
+  const char* runtimeOutputProp =
     this->GeneratorTarget->GetProperty("RUNTIME_OUTPUT_DIRECTORY");
-  if (NULL != runtimeOutputProp)
-    {
+  if (NULL != runtimeOutputProp) {
     outputDir = runtimeOutputProp;
-    }
+  }
 
   std::string configCapped(cmSystemTools::UpperCase(config));
-  const char *runtimeOutputSProp =
-    this->GeneratorTarget
-      ->GetProperty("RUNTIME_OUTPUT_DIRECTORY_" + configCapped);
-  if (NULL != runtimeOutputSProp)
-    {
+  const char* runtimeOutputSProp = this->GeneratorTarget->GetProperty(
+    "RUNTIME_OUTPUT_DIRECTORY_" + configCapped);
+  if (NULL != runtimeOutputSProp) {
     outputDir = runtimeOutputSProp;
-    }
+  }
   cmSystemTools::ConvertToUnixSlashes(outputDir);
 
-  if (!outputDir.empty())
-    {
+  if (!outputDir.empty()) {
     outputDir += "/";
-    }
+  }
 
   return outputDir;
 }
 
-std::string
-cmGhsMultiTargetGenerator::GetOutputFilename(const std::string &config) const
+std::string cmGhsMultiTargetGenerator::GetOutputFilename(
+  const std::string& config) const
 {
   std::string outputFilename(this->GeneratorTarget->GetName());
 
-  const char *outputNameProp =
-      this->GeneratorTarget->GetProperty("OUTPUT_NAME");
-  if (NULL != outputNameProp)
-    {
+  const char* outputNameProp =
+    this->GeneratorTarget->GetProperty("OUTPUT_NAME");
+  if (NULL != outputNameProp) {
     outputFilename = outputNameProp;
-    }
+  }
 
   std::string configCapped(cmSystemTools::UpperCase(config));
-  const char *outputNameSProp =
+  const char* outputNameSProp =
     this->GeneratorTarget->GetProperty(configCapped + "_OUTPUT_NAME");
-  if (NULL != outputNameSProp)
-    {
+  if (NULL != outputNameSProp) {
     outputFilename = outputNameSProp;
-    }
+  }
 
   return outputFilename;
 }
 
 std::string cmGhsMultiTargetGenerator::ComputeLongestObjectDirectory(
-    cmLocalGhsMultiGenerator const *localGhsMultiGenerator,
-    cmGeneratorTarget *const generatorTarget, cmSourceFile *const sourceFile)
+  cmLocalGhsMultiGenerator const* localGhsMultiGenerator,
+  cmGeneratorTarget* const generatorTarget, cmSourceFile* const sourceFile)
 {
   std::string dir_max;
   dir_max +=
-      localGhsMultiGenerator->GetMakefile()->GetCurrentBinaryDirectory();
+    localGhsMultiGenerator->GetMakefile()->GetCurrentBinaryDirectory();
   dir_max += "/";
   dir_max += generatorTarget->Target->GetName();
   dir_max += "/";
   std::vector<cmSourceGroup> sourceGroups(
-      localGhsMultiGenerator->GetMakefile()->GetSourceGroups());
-  char const *const sourceFullPath = sourceFile->GetFullPath().c_str();
-  cmSourceGroup *sourceGroup =
-      localGhsMultiGenerator->GetMakefile()->FindSourceGroup(sourceFullPath,
-                                                             sourceGroups);
+    localGhsMultiGenerator->GetMakefile()->GetSourceGroups());
+  char const* const sourceFullPath = sourceFile->GetFullPath().c_str();
+  cmSourceGroup* sourceGroup =
+    localGhsMultiGenerator->GetMakefile()->FindSourceGroup(sourceFullPath,
+                                                           sourceGroups);
   std::string const sgPath(sourceGroup->GetFullName());
   dir_max += sgPath;
   dir_max += "/Objs/libs/";
@@ -695,8 +623,8 @@ std::string cmGhsMultiTargetGenerator::ComputeLongestObjectDirectory(
   return dir_max;
 }
 
-bool cmGhsMultiTargetGenerator::IsNotKernel(std::string const &config,
-                                            const std::string &language)
+bool cmGhsMultiTargetGenerator::IsNotKernel(std::string const& config,
+                                            const std::string& language)
 {
   bool output;
   std::vector<std::string> options;
@@ -707,38 +635,34 @@ bool cmGhsMultiTargetGenerator::IsNotKernel(std::string const &config,
 }
 
 bool cmGhsMultiTargetGenerator::DetermineIfTargetGroup(
-    const cmGeneratorTarget *target)
+  const cmGeneratorTarget* target)
 {
   bool output = false;
-  std::vector<cmSourceFile *> sources;
+  std::vector<cmSourceFile*> sources;
   std::string config =
-      target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
+    target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
   target->GetSourceFiles(sources, config);
-  for (std::vector<cmSourceFile *>::const_iterator sources_i = sources.begin();
-       sources.end() != sources_i; ++sources_i)
-    {
-    if ("int" == (*sources_i)->GetExtension())
-      {
+  for (std::vector<cmSourceFile*>::const_iterator sources_i = sources.begin();
+       sources.end() != sources_i; ++sources_i) {
+    if ("int" == (*sources_i)->GetExtension()) {
       output = true;
-      }
     }
+  }
   return output;
 }
 
 bool cmGhsMultiTargetGenerator::DetermineIfDynamicDownload(
-  std::string const &config, const std::string &language)
+  std::string const& config, const std::string& language)
 {
   std::vector<std::string> options;
   bool output = false;
   this->GeneratorTarget->GetCompileOptions(options, config, language);
   for (std::vector<std::string>::const_iterator options_i = options.begin();
-       options_i != options.end(); ++options_i)
-    {
+       options_i != options.end(); ++options_i) {
     std::string option = *options_i;
-    if (this->DDOption == option)
-      {
+    if (this->DDOption == option) {
       output = true;
-      }
     }
+  }
   return output;
 }
diff --git a/Source/cmGhsMultiTargetGenerator.h b/Source/cmGhsMultiTargetGenerator.h
index 9f18eeb..92a1109 100644
--- a/Source/cmGhsMultiTargetGenerator.h
+++ b/Source/cmGhsMultiTargetGenerator.h
@@ -34,91 +34,91 @@ public:
   virtual void Generate();
 
   bool IncludeThisTarget();
-  std::vector<cmSourceFile *> GetSources() const;
+  std::vector<cmSourceFile*> GetSources() const;
   GhsMultiGpj::Types GetGpjTag() const;
   static GhsMultiGpj::Types GetGpjTag(const cmGeneratorTarget* target);
-  const char *GetAbsBuildFilePath() const
+  const char* GetAbsBuildFilePath() const
   {
     return this->AbsBuildFilePath.c_str();
   }
-  const char *GetRelBuildFileName() const
+  const char* GetRelBuildFileName() const
   {
     return this->RelBuildFileName.c_str();
   }
-  const char *GetAbsBuildFileName() const
+  const char* GetAbsBuildFileName() const
   {
     return this->AbsBuildFileName.c_str();
   }
-  const char *GetAbsOutputFileName() const
+  const char* GetAbsOutputFileName() const
   {
     return this->AbsOutputFileName.c_str();
   }
 
-  static std::string GetRelBuildFilePath(const cmGeneratorTarget *target);
-  static std::string GetAbsPathToRoot(const cmGeneratorTarget *target);
-  static std::string GetAbsBuildFilePath(const cmGeneratorTarget *target);
-  static std::string GetRelBuildFileName(const cmGeneratorTarget *target);
-  static std::string GetBuildFileName(const cmGeneratorTarget *target);
-  static std::string AddSlashIfNeededToPath(std::string const &input);
+  static std::string GetRelBuildFilePath(const cmGeneratorTarget* target);
+  static std::string GetAbsPathToRoot(const cmGeneratorTarget* target);
+  static std::string GetAbsBuildFilePath(const cmGeneratorTarget* target);
+  static std::string GetRelBuildFileName(const cmGeneratorTarget* target);
+  static std::string GetBuildFileName(const cmGeneratorTarget* target);
+  static std::string AddSlashIfNeededToPath(std::string const& input);
 
 private:
-  cmGlobalGhsMultiGenerator *GetGlobalGenerator() const;
-  cmGeneratedFileStream *GetFolderBuildStreams()
+  cmGlobalGhsMultiGenerator* GetGlobalGenerator() const;
+  cmGeneratedFileStream* GetFolderBuildStreams()
   {
     return this->FolderBuildStreams[""];
   };
   bool IsTargetGroup() const { return this->TargetGroup; }
 
-  void WriteTypeSpecifics(const std::string &config, bool notKernel);
-  void WriteCompilerFlags(const std::string &config,
-    const std::string &language);
-  void WriteCompilerDefinitions(const std::string &config,
-                                const std::string &language);
+  void WriteTypeSpecifics(const std::string& config, bool notKernel);
+  void WriteCompilerFlags(const std::string& config,
+                          const std::string& language);
+  void WriteCompilerDefinitions(const std::string& config,
+                                const std::string& language);
 
-  void SetCompilerFlags(std::string const &config, const std::string &language,
+  void SetCompilerFlags(std::string const& config, const std::string& language,
                         bool const notKernel);
-  std::string GetDefines(const std::string &langugae,
-                         std::string const &config);
+  std::string GetDefines(const std::string& langugae,
+                         std::string const& config);
 
-  void WriteIncludes(const std::string &config, const std::string &language);
+  void WriteIncludes(const std::string& config, const std::string& language);
   void WriteTargetLinkLibraries(std::string const& config,
                                 std::string const& language);
   void WriteCustomCommands();
-  void
-  WriteCustomCommandsHelper(std::vector<cmCustomCommand> const &commandsSet,
-                            cmTarget::CustomCommandType commandType);
+  void WriteCustomCommandsHelper(
+    std::vector<cmCustomCommand> const& commandsSet,
+    cmTarget::CustomCommandType commandType);
   void WriteSources(
-      std::vector<cmSourceFile *> const &objectSources,
-      std::map<const cmSourceFile *, std::string> const &objectNames);
-  static std::map<const cmSourceFile *, std::string>
-  GetObjectNames(std::vector<cmSourceFile *> *objectSources,
-                 cmLocalGhsMultiGenerator *localGhsMultiGenerator,
-                 cmGeneratorTarget *generatorTarget);
-  static void WriteObjectLangOverride(cmGeneratedFileStream *fileStream,
-                                      cmSourceFile *sourceFile);
-  static void WriteObjectDir(cmGeneratedFileStream *fileStream,
-                             std::string const &dir);
-  std::string GetOutputDirectory(const std::string &config) const;
-  std::string GetOutputFilename(const std::string &config) const;
+    std::vector<cmSourceFile*> const& objectSources,
+    std::map<const cmSourceFile*, std::string> const& objectNames);
+  static std::map<const cmSourceFile*, std::string> GetObjectNames(
+    std::vector<cmSourceFile*>* objectSources,
+    cmLocalGhsMultiGenerator* localGhsMultiGenerator,
+    cmGeneratorTarget* generatorTarget);
+  static void WriteObjectLangOverride(cmGeneratedFileStream* fileStream,
+                                      cmSourceFile* sourceFile);
+  static void WriteObjectDir(cmGeneratedFileStream* fileStream,
+                             std::string const& dir);
+  std::string GetOutputDirectory(const std::string& config) const;
+  std::string GetOutputFilename(const std::string& config) const;
   static std::string ComputeLongestObjectDirectory(
-      cmLocalGhsMultiGenerator const *localGhsMultiGenerator,
-      cmGeneratorTarget *generatorTarget, cmSourceFile *const sourceFile);
+    cmLocalGhsMultiGenerator const* localGhsMultiGenerator,
+    cmGeneratorTarget* generatorTarget, cmSourceFile* const sourceFile);
 
-  bool IsNotKernel(std::string const &config, const std::string &language);
+  bool IsNotKernel(std::string const& config, const std::string& language);
   static bool DetermineIfTargetGroup(const cmGeneratorTarget* target);
-  bool DetermineIfDynamicDownload(std::string const &config,
-                                  const std::string &language);
+  bool DetermineIfDynamicDownload(std::string const& config,
+                                  const std::string& language);
 
   cmGeneratorTarget* GeneratorTarget;
-  cmLocalGhsMultiGenerator *LocalGenerator;
-  cmMakefile *Makefile;
+  cmLocalGhsMultiGenerator* LocalGenerator;
+  cmMakefile* Makefile;
   std::string AbsBuildFilePath;
   std::string RelBuildFilePath;
   std::string AbsBuildFileName;
   std::string RelBuildFileName;
   std::string RelOutputFileName;
   std::string AbsOutputFileName;
-  std::map<std::string, cmGeneratedFileStream *> FolderBuildStreams;
+  std::map<std::string, cmGeneratedFileStream*> FolderBuildStreams;
   bool TargetGroup;
   bool DynamicDownload;
   static std::string const DDOption;
diff --git a/Source/cmGlobalBorlandMakefileGenerator.cxx b/Source/cmGlobalBorlandMakefileGenerator.cxx
index 48a04c3..0f4de73 100644
--- a/Source/cmGlobalBorlandMakefileGenerator.cxx
+++ b/Source/cmGlobalBorlandMakefileGenerator.cxx
@@ -30,11 +30,8 @@ cmGlobalBorlandMakefileGenerator::cmGlobalBorlandMakefileGenerator(cmake* cm)
   this->UnixCD = false;
 }
 
-
-void cmGlobalBorlandMakefileGenerator
-::EnableLanguage(std::vector<std::string>const& l,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalBorlandMakefileGenerator::EnableLanguage(
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   std::string outdir = this->CMakeInstance->GetHomeOutputDirectory();
   mf->AddDefinition("BORLAND", "1");
@@ -44,20 +41,19 @@ void cmGlobalBorlandMakefileGenerator
 }
 
 ///! Create a local generator appropriate to this Global Generator
-cmLocalGenerator *cmGlobalBorlandMakefileGenerator::CreateLocalGenerator(
-    cmMakefile *mf)
+cmLocalGenerator* cmGlobalBorlandMakefileGenerator::CreateLocalGenerator(
+  cmMakefile* mf)
 {
   cmLocalUnixMakefileGenerator3* lg =
-      new cmLocalUnixMakefileGenerator3(this, mf);
+    new cmLocalUnixMakefileGenerator3(this, mf);
   lg->SetMakefileVariableSize(32);
   lg->SetMakeCommandEscapeTargetTwice(true);
   lg->SetBorlandMakeCurlyHack(true);
   return lg;
 }
 
-
-void cmGlobalBorlandMakefileGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalBorlandMakefileGenerator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalBorlandMakefileGenerator::GetActualName();
   entry.Brief = "Generates Borland makefiles.";
diff --git a/Source/cmGlobalBorlandMakefileGenerator.h b/Source/cmGlobalBorlandMakefileGenerator.h
index b59c86d..4e10f10 100644
--- a/Source/cmGlobalBorlandMakefileGenerator.h
+++ b/Source/cmGlobalBorlandMakefileGenerator.h
@@ -23,27 +23,31 @@ class cmGlobalBorlandMakefileGenerator : public cmGlobalUnixMakefileGenerator3
 {
 public:
   cmGlobalBorlandMakefileGenerator(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalBorlandMakefileGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<
+      cmGlobalBorlandMakefileGenerator>();
+  }
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalBorlandMakefileGenerator::GetActualName();}
-  static std::string GetActualName() {return "Borland Makefiles";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalBorlandMakefileGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "Borland Makefiles"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
   ///! Create a local generator appropriate to this Global Generator
-  virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 
   virtual bool AllowNotParallel() const { return false; }
   virtual bool AllowDeleteOnError() const { return false; }
diff --git a/Source/cmGlobalCommonGenerator.cxx b/Source/cmGlobalCommonGenerator.cxx
index dc8e5a7..900b08e 100644
--- a/Source/cmGlobalCommonGenerator.cxx
+++ b/Source/cmGlobalCommonGenerator.cxx
@@ -11,8 +11,8 @@
 ============================================================================*/
 #include "cmGlobalCommonGenerator.h"
 
-cmGlobalCommonGenerator::cmGlobalCommonGenerator(cmake* cm):
-  cmGlobalGenerator(cm)
+cmGlobalCommonGenerator::cmGlobalCommonGenerator(cmake* cm)
+  : cmGlobalGenerator(cm)
 {
 }
 
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;
 }
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 1576f09..fcf8127 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -24,12 +24,12 @@
 #include "cmTargetDepend.h" // For cmTargetDependSet
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cmFileLockPool.h"
-# ifdef CMake_HAVE_CXX11_UNORDERED_MAP
-#  include <unordered_map>
-# else
-#  include <cmsys/hash_map.hxx>
-# endif
+#include "cmFileLockPool.h"
+#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
+#include <unordered_map>
+#else
+#include <cmsys/hash_map.hxx>
+#endif
 #endif
 
 class cmake;
@@ -55,19 +55,19 @@ public:
   cmGlobalGenerator(cmake* cm);
   virtual ~cmGlobalGenerator();
 
-  virtual cmLocalGenerator*
-  CreateLocalGenerator(cmMakefile* mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   ///! Get the name for this generator
   virtual std::string GetName() const { return "Generic"; }
 
   /** Check whether the given name matches the current generator.  */
   virtual bool MatchesGeneratorName(const std::string& name) const
-  { return this->GetName() == name; }
+  {
+    return this->GetName() == name;
+  }
 
   /** Tell the generator about the target system.  */
-  virtual bool SetSystemName(std::string const&, cmMakefile*)
-    { return true; }
+  virtual bool SetSystemName(std::string const&, cmMakefile*) { return true; }
 
   /** Set the generator-specific platform name.  Returns true if platform
       is supported and false otherwise.  */
@@ -86,14 +86,15 @@ public:
   bool Compute();
   virtual void AddExtraIDETargets() {}
 
-  enum TargetTypes {
+  enum TargetTypes
+  {
     AllTargets,
     ImportedOnly
   };
 
-  void CreateImportedGenerationObjects(cmMakefile* mf,
-                             std::vector<std::string> const& targets,
-                             std::vector<cmGeneratorTarget const*>& exports);
+  void CreateImportedGenerationObjects(
+    cmMakefile* mf, std::vector<std::string> const& targets,
+    std::vector<cmGeneratorTarget const*>& exports);
   void CreateGenerationObjects(TargetTypes targetTypes = AllTargets);
 
   /**
@@ -114,31 +115,28 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 
   /**
    * Resolve the CMAKE_<lang>_COMPILER setting for the given language.
    * Intended to be called from EnableLanguage.
    */
-  void ResolveLanguageCompiler(const std::string &lang, cmMakefile *mf,
+  void ResolveLanguageCompiler(const std::string& lang, cmMakefile* mf,
                                bool optional) const;
 
   /**
    * Try to determine system information, get it from another generator
    */
-  void EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
-                                            cmMakefile* mf);
+  void EnableLanguagesFromGenerator(cmGlobalGenerator* gen, cmMakefile* mf);
 
   /**
    * Try running cmake and building a file. This is used for dynamically
    * loaded commands, not as part of the usual build process.
    */
   int TryCompile(const std::string& srcdir, const std::string& bindir,
-                         const std::string& projectName,
-                         const std::string& targetName,
-                         bool fast, std::string& output, cmMakefile* mf);
-
+                 const std::string& projectName, const std::string& targetName,
+                 bool fast, std::string& output, cmMakefile* mf);
 
   /**
    * Build a file given the following information. This is a more direct call
@@ -148,22 +146,19 @@ public:
    */
   int Build(const std::string& srcdir, const std::string& bindir,
             const std::string& projectName, const std::string& targetName,
-            std::string& output,
-            const std::string& makeProgram, const std::string& config,
-            bool clean, bool fast, bool verbose,
-            double timeout,
-            cmSystemTools::OutputOption outputflag=cmSystemTools::OUTPUT_NONE,
+            std::string& output, const std::string& makeProgram,
+            const std::string& config, bool clean, bool fast, bool verbose,
+            double timeout, cmSystemTools::OutputOption outputflag =
+                              cmSystemTools::OUTPUT_NONE,
             std::vector<std::string> const& nativeOptions =
-            std::vector<std::string>());
+              std::vector<std::string>());
 
   virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand,
-    const std::string& makeProgram,
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
     const std::string& projectName, const std::string& projectDir,
-    const std::string& targetName, const std::string& config,
-    bool fast, bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
   /** Generate a "cmake --build" call for a given target and config.  */
   std::string GenerateCMakeBuildCommand(const std::string& target,
@@ -172,36 +167,38 @@ public:
                                         bool ignoreErrors);
 
   ///! Get the CMake instance
-  cmake *GetCMakeInstance() const { return this->CMakeInstance; }
+  cmake* GetCMakeInstance() const { return this->CMakeInstance; }
 
   void SetConfiguredFilesPath(cmGlobalGenerator* gen);
-  const std::vector<cmMakefile*>& GetMakefiles() const {
-    return this->Makefiles;}
-  const std::vector<cmLocalGenerator *>& GetLocalGenerators() const {
-    return this->LocalGenerators;}
-
-  cmMakefile* GetCurrentMakefile() const
+  const std::vector<cmMakefile*>& GetMakefiles() const
+  {
+    return this->Makefiles;
+  }
+  const std::vector<cmLocalGenerator*>& GetLocalGenerators() const
   {
-    return this->CurrentMakefile;
+    return this->LocalGenerators;
   }
 
-  void SetCurrentMakefile(cmMakefile* mf)
-  {this->CurrentMakefile = mf;}
+  cmMakefile* GetCurrentMakefile() const { return this->CurrentMakefile; }
+
+  void SetCurrentMakefile(cmMakefile* mf) { this->CurrentMakefile = mf; }
 
-  void AddMakefile(cmMakefile *mf);
+  void AddMakefile(cmMakefile* mf);
 
   ///! Set an generator for an "external makefile based project"
   void SetExternalMakefileProjectGenerator(
-                           cmExternalMakefileProjectGenerator *extraGenerator);
+    cmExternalMakefileProjectGenerator* extraGenerator);
 
   std::string GetExtraGeneratorName() const;
 
   void AddInstallComponent(const char* component);
 
   const std::set<std::string>* GetInstallComponents() const
-    { return &this->InstallComponents; }
+  {
+    return &this->InstallComponents;
+  }
 
-  cmExportSetMap& GetExportSets() {return this->ExportSets;}
+  cmExportSetMap& GetExportSets() { return this->ExportSets; }
 
   /** Add a file to the manifest of generated targets for a configuration.  */
   void AddToManifest(std::string const& f);
@@ -278,17 +275,17 @@ public:
 
   static bool IsReservedTarget(std::string const& name);
 
-  virtual const char* GetAllTargetName()         const { return "ALL_BUILD"; }
-  virtual const char* GetInstallTargetName()       const { return "INSTALL"; }
-  virtual const char* GetInstallLocalTargetName()  const { return 0; }
-  virtual const char* GetInstallStripTargetName()  const { return 0; }
-  virtual const char* GetPreinstallTargetName()    const { return 0; }
-  virtual const char* GetTestTargetName()        const { return "RUN_TESTS"; }
-  virtual const char* GetPackageTargetName()       const { return "PACKAGE"; }
+  virtual const char* GetAllTargetName() const { return "ALL_BUILD"; }
+  virtual const char* GetInstallTargetName() const { return "INSTALL"; }
+  virtual const char* GetInstallLocalTargetName() const { return 0; }
+  virtual const char* GetInstallStripTargetName() const { return 0; }
+  virtual const char* GetPreinstallTargetName() const { return 0; }
+  virtual const char* GetTestTargetName() const { return "RUN_TESTS"; }
+  virtual const char* GetPackageTargetName() const { return "PACKAGE"; }
   virtual const char* GetPackageSourceTargetName() const { return 0; }
-  virtual const char* GetEditCacheTargetName()     const { return 0; }
-  virtual const char* GetRebuildCacheTargetName()  const { return 0; }
-  virtual const char* GetCleanTargetName()         const { return 0; }
+  virtual const char* GetEditCacheTargetName() const { return 0; }
+  virtual const char* GetRebuildCacheTargetName() const { return 0; }
+  virtual const char* GetCleanTargetName() const { return 0; }
 
   // Lookup edit_cache target command preferred by this generator.
   virtual std::string GetEditCacheCommand() const { return ""; }
@@ -299,10 +296,13 @@ public:
   // what targets does the specified target depend on directly
   // via a target_link_libraries or add_dependencies
   TargetDependSet const& GetTargetDirectDepends(
-      const cmGeneratorTarget* target);
+    const cmGeneratorTarget* target);
 
   const std::map<std::string, std::vector<cmLocalGenerator*> >& GetProjectMap()
-                                               const {return this->ProjectMap;}
+    const
+  {
+    return this->ProjectMap;
+  }
 
   // track files replaced during a Generate
   void FileReplacedDuringGenerate(const std::string& filename);
@@ -313,9 +313,9 @@ public:
 
   /** Return whether the given binary directory is unused.  */
   bool BinaryDirectoryIsNew(const std::string& dir)
-    {
+  {
     return this->BinaryDirectories.insert(dir).second;
-    }
+  }
 
   /** Return true if the generated build tree may contain multiple builds.
       i.e. "Can I build Debug and Release in the same tree?" */
@@ -331,13 +331,15 @@ public:
   void ProcessEvaluationFiles();
 
   std::map<std::string, cmExportBuildFileGenerator*>& GetBuildExportSets()
-    {return this->BuildExportSets;}
+  {
+    return this->BuildExportSets;
+  }
   void AddBuildExportSet(cmExportBuildFileGenerator*);
   void AddBuildExportExportSet(cmExportBuildFileGenerator*);
-  bool IsExportedTargetsFile(const std::string &filename) const;
-  bool GenerateImportFile(const std::string &file);
-  cmExportBuildFileGenerator*
-  GetExportedTargetsFile(const std::string &filename) const;
+  bool IsExportedTargetsFile(const std::string& filename) const;
+  bool GenerateImportFile(const std::string& file);
+  cmExportBuildFileGenerator* GetExportedTargetsFile(
+    const std::string& filename) const;
   void AddCMP0042WarnTarget(const std::string& target);
 
   virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
@@ -348,24 +350,27 @@ public:
 
   void SetFilenameTargetDepends(cmSourceFile* sf,
                                 std::set<const cmGeneratorTarget*> tgts);
-  const std::set<const cmGeneratorTarget*>&
-  GetFilenameTargetDepends(cmSourceFile* sf) const;
+  const std::set<const cmGeneratorTarget*>& GetFilenameTargetDepends(
+    cmSourceFile* sf) const;
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   cmFileLockPool& GetFileLockPool() { return FileLockPool; }
 #endif
 
   bool GetConfigureDoneCMP0026() const
-  { return this->ConfigureDoneCMP0026AndCMP0024; }
+  {
+    return this->ConfigureDoneCMP0026AndCMP0024;
+  }
 
   std::string MakeSilentFlag;
+
 protected:
   typedef std::vector<cmLocalGenerator*> GeneratorVector;
   // for a project collect all its targets by following depend
   // information, and also collect all the targets
   void GetTargetSets(TargetDependSet& projectTargets,
-                             TargetDependSet& originalTargets,
-                             cmLocalGenerator* root, GeneratorVector const&);
+                     TargetDependSet& originalTargets, cmLocalGenerator* root,
+                     GeneratorVector const&);
   bool IsRootOnlyTarget(cmGeneratorTarget* target) const;
   void AddTargetDepends(const cmGeneratorTarget* target,
                         TargetDependSet& projectTargets);
@@ -395,15 +400,15 @@ protected:
   virtual void InitializeProgressMarks() {}
   void CreateDefaultGlobalTargets(cmTargets* targets);
   cmTarget CreateGlobalTarget(const std::string& name, const char* message,
-    const cmCustomCommandLines* commandLines,
-    std::vector<std::string> depends, const char* workingDir,
-    bool uses_terminal);
+                              const cmCustomCommandLines* commandLines,
+                              std::vector<std::string> depends,
+                              const char* workingDir, bool uses_terminal);
 
   std::string FindMakeProgramFile;
   std::string ConfiguredFilesPath;
-  cmake *CMakeInstance;
+  cmake* CMakeInstance;
   std::vector<cmMakefile*> Makefiles;
-  std::vector<cmLocalGenerator *> LocalGenerators;
+  std::vector<cmLocalGenerator*> LocalGenerators;
   cmMakefile* CurrentMakefile;
   // map from project name to vector of local generators in that project
   std::map<std::string, std::vector<cmLocalGenerator*> > ProjectMap;
@@ -420,26 +425,25 @@ protected:
   cmTarget* FindTargetImpl(std::string const& name) const;
 
   cmGeneratorTarget* FindGeneratorTargetImpl(std::string const& name) const;
-  cmGeneratorTarget*
-  FindImportedGeneratorTargetImpl(std::string const& name) const;
+  cmGeneratorTarget* FindImportedGeneratorTargetImpl(
+    std::string const& name) const;
 
   const char* GetPredefinedTargetsFolder();
   virtual bool UseFolderProperty();
 
 private:
-
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# ifdef CMake_HAVE_CXX11_UNORDERED_MAP
+#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
   typedef std::unordered_map<std::string, cmTarget*> TargetMap;
   typedef std::unordered_map<std::string, cmGeneratorTarget*>
     GeneratorTargetMap;
-# else
+#else
   typedef cmsys::hash_map<std::string, cmTarget*> TargetMap;
   typedef cmsys::hash_map<std::string, cmGeneratorTarget*> GeneratorTargetMap;
-# endif
+#endif
 #else
-  typedef std::map<std::string,cmTarget *> TargetMap;
-  typedef std::map<std::string,cmGeneratorTarget *> GeneratorTargetMap;
+  typedef std::map<std::string, cmTarget*> TargetMap;
+  typedef std::map<std::string, cmGeneratorTarget*> GeneratorTargetMap;
 #endif
   // Map efficiently from target name to cmTarget instance.
   // Do not use this structure for looping over all targets.
@@ -460,7 +464,10 @@ private:
   std::map<std::string, std::string> LanguageToOriginalSharedLibFlags;
 
   // Record hashes for rules and outputs.
-  struct RuleHash { char Data[32]; };
+  struct RuleHash
+  {
+    char Data[32];
+  };
   std::map<std::string, RuleHash> RuleHashes;
   void CheckRuleHashes();
   void CheckRuleHashes(std::string const& pfile, std::string const& home);
@@ -489,9 +496,9 @@ private:
   TargetDependMap TargetDependencies;
 
   friend class cmake;
-  void CreateGeneratorTargets(TargetTypes targetTypes, cmMakefile* mf,
-                   cmLocalGenerator* lg,
-                   std::map<cmTarget*, cmGeneratorTarget*> const& importedMap);
+  void CreateGeneratorTargets(
+    TargetTypes targetTypes, cmMakefile* mf, cmLocalGenerator* lg,
+    std::map<cmTarget*, cmGeneratorTarget*> const& importedMap);
   void CreateGeneratorTargets(TargetTypes targetTypes);
 
   void ClearGeneratorMembers();
@@ -504,9 +511,16 @@ private:
     long LastDiskTime;
     std::set<std::string> All;
     std::set<std::string> Generated;
-    DirectoryContent(): LastDiskTime(-1) {}
-    DirectoryContent(DirectoryContent const& dc):
-      LastDiskTime(dc.LastDiskTime), All(dc.All), Generated(dc.Generated) {}
+    DirectoryContent()
+      : LastDiskTime(-1)
+    {
+    }
+    DirectoryContent(DirectoryContent const& dc)
+      : LastDiskTime(dc.LastDiskTime)
+      , All(dc.All)
+      , Generated(dc.Generated)
+    {
+    }
   };
   std::map<std::string, DirectoryContent> DirectoryContentMap;
 
@@ -517,7 +531,7 @@ private:
   std::set<std::string> CMP0042WarnTargets;
 
   mutable std::map<cmSourceFile*, std::set<cmGeneratorTarget const*> >
-  FilenameTargetDepends;
+    FilenameTargetDepends;
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   // Pool of file locks
diff --git a/Source/cmGlobalGeneratorFactory.h b/Source/cmGlobalGeneratorFactory.h
index 18d4324..640497a 100644
--- a/Source/cmGlobalGeneratorFactory.h
+++ b/Source/cmGlobalGeneratorFactory.h
@@ -30,8 +30,8 @@ public:
   virtual ~cmGlobalGeneratorFactory() {}
 
   /** Create a GlobalGenerator */
-  virtual cmGlobalGenerator* CreateGlobalGenerator(
-      const std::string& n, cmake* cm) const = 0;
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& n,
+                                                   cmake* cm) const = 0;
 
   /** Get the documentation entry for this factory */
   virtual void GetDocumentation(cmDocumentationEntry& entry) const = 0;
@@ -43,23 +43,30 @@ public:
   virtual bool SupportsToolset() const = 0;
 };
 
-template<class T>
+template <class T>
 class cmGlobalGeneratorSimpleFactory : public cmGlobalGeneratorFactory
 {
 public:
   /** Create a GlobalGenerator */
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const {
-    if (name != T::GetActualName()) return 0;
-    return new T(cm); }
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
+    if (name != T::GetActualName())
+      return 0;
+    return new T(cm);
+  }
 
   /** Get the documentation entry for this factory */
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const {
-    T::GetDocumentation(entry); }
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
+    T::GetDocumentation(entry);
+  }
 
   /** Get the names of the current registered generators */
-  virtual void GetGenerators(std::vector<std::string>& names) const {
-    names.push_back(T::GetActualName()); }
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
+    names.push_back(T::GetActualName());
+  }
 
   /** Determine whether or not this generator supports toolsets */
   virtual bool SupportsToolset() const { return T::SupportsToolset(); }
diff --git a/Source/cmGlobalGhsMultiGenerator.cxx b/Source/cmGlobalGhsMultiGenerator.cxx
index df7011c..8a80f46 100644
--- a/Source/cmGlobalGhsMultiGenerator.cxx
+++ b/Source/cmGlobalGhsMultiGenerator.cxx
@@ -19,11 +19,12 @@
 #include <cmAlgorithms.h>
 #include <cmsys/SystemTools.hxx>
 
-const char *cmGlobalGhsMultiGenerator::FILE_EXTENSION = ".gpj";
-const char *cmGlobalGhsMultiGenerator::DEFAULT_MAKE_PROGRAM = "gbuild";
+const char* cmGlobalGhsMultiGenerator::FILE_EXTENSION = ".gpj";
+const char* cmGlobalGhsMultiGenerator::DEFAULT_MAKE_PROGRAM = "gbuild";
 
 cmGlobalGhsMultiGenerator::cmGlobalGhsMultiGenerator(cmake* cm)
-  : cmGlobalGenerator(cm), OSDirRelative(false)
+  : cmGlobalGenerator(cm)
+  , OSDirRelative(false)
 {
   this->GhsBuildCommandInitialized = false;
 }
@@ -33,13 +34,13 @@ cmGlobalGhsMultiGenerator::~cmGlobalGhsMultiGenerator()
   cmDeleteAll(TargetFolderBuildStreams);
 }
 
-cmLocalGenerator *
-cmGlobalGhsMultiGenerator::CreateLocalGenerator(cmMakefile* mf)
+cmLocalGenerator* cmGlobalGhsMultiGenerator::CreateLocalGenerator(
+  cmMakefile* mf)
 {
   return new cmLocalGhsMultiGenerator(this, mf);
 }
 
-void cmGlobalGhsMultiGenerator::GetDocumentation(cmDocumentationEntry &entry)
+void cmGlobalGhsMultiGenerator::GetDocumentation(cmDocumentationEntry& entry)
 {
   entry.Name = GetActualName();
   entry.Brief =
@@ -47,7 +48,7 @@ void cmGlobalGhsMultiGenerator::GetDocumentation(cmDocumentationEntry &entry)
 }
 
 void cmGlobalGhsMultiGenerator::EnableLanguage(
-  std::vector<std::string> const &l, cmMakefile *mf, bool optional)
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   mf->AddDefinition("CMAKE_SYSTEM_NAME", "GHS-MULTI");
   mf->AddDefinition("CMAKE_SYSTEM_PROCESSOR", "ARM");
@@ -68,38 +69,35 @@ void cmGlobalGhsMultiGenerator::EnableLanguage(
   mf->AddDefinition("CMAKE_CXX_COMPILER_ID", "GHS");
   mf->AddDefinition("CMAKE_CXX_COMPILER_FORCED", "TRUE");
 
-  if (!ghsCompRoot.empty())
-    {
-    static const char *compPreFix = "comp_";
+  if (!ghsCompRoot.empty()) {
+    static const char* compPreFix = "comp_";
     std::string compFilename =
       cmsys::SystemTools::FindLastString(ghsCompRoot.c_str(), compPreFix);
     cmsys::SystemTools::ReplaceString(compFilename, compPreFix, "");
     mf->AddDefinition("CMAKE_SYSTEM_VERSION", compFilename.c_str());
-    }
+  }
 
   mf->AddDefinition("GHSMULTI", "1"); // identifier for user CMake files
   this->cmGlobalGenerator::EnableLanguage(l, mf, optional);
 }
 
-void cmGlobalGhsMultiGenerator::FindMakeProgram(cmMakefile *mf)
+void cmGlobalGhsMultiGenerator::FindMakeProgram(cmMakefile* mf)
 {
   // The GHS generator knows how to lookup its build tool
   // directly instead of needing a helper module to do it, so we
   // do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
-  if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
-    {
+  if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
     mf->AddDefinition("CMAKE_MAKE_PROGRAM",
                       this->GetGhsBuildCommand().c_str());
-    }
+  }
 }
 
-std::string const &cmGlobalGhsMultiGenerator::GetGhsBuildCommand()
+std::string const& cmGlobalGhsMultiGenerator::GetGhsBuildCommand()
 {
-  if (!this->GhsBuildCommandInitialized)
-    {
+  if (!this->GhsBuildCommandInitialized) {
     this->GhsBuildCommandInitialized = true;
     this->GhsBuildCommand = this->FindGhsBuildCommand();
-    }
+  }
   return this->GhsBuildCommand;
 }
 
@@ -109,10 +107,9 @@ std::string cmGlobalGhsMultiGenerator::FindGhsBuildCommand()
   userPaths.push_back(this->GetCompRoot());
   std::string makeProgram =
     cmSystemTools::FindProgram(DEFAULT_MAKE_PROGRAM, userPaths);
-  if (makeProgram.empty())
-    {
+  if (makeProgram.empty()) {
     makeProgram = DEFAULT_MAKE_PROGRAM;
-    }
+  }
   return makeProgram;
 }
 
@@ -120,8 +117,8 @@ std::string cmGlobalGhsMultiGenerator::GetCompRoot()
 {
   std::string output;
 
-  const std::vector<std::string>
-    potentialDirsHardPaths(GetCompRootHardPaths());
+  const std::vector<std::string> potentialDirsHardPaths(
+    GetCompRootHardPaths());
   const std::vector<std::string> potentialDirsRegistry(GetCompRootRegistry());
 
   std::vector<std::string> potentialDirsComplete;
@@ -137,16 +134,14 @@ std::string cmGlobalGhsMultiGenerator::GetCompRoot()
   for (std::vector<std::string>::const_iterator potentialDirsCompleteIt =
          potentialDirsComplete.begin();
        potentialDirsCompleteIt != potentialDirsComplete.end();
-       ++potentialDirsCompleteIt)
-    {
+       ++potentialDirsCompleteIt) {
     const std::string dirName(
       cmsys::SystemTools::GetFilenameName(*potentialDirsCompleteIt));
-    if (dirName.compare(outputDirName) > 0)
-      {
+    if (dirName.compare(outputDirName) > 0) {
       output = *potentialDirsCompleteIt;
       outputDirName = dirName;
-      }
     }
+  }
 
   return output;
 }
@@ -156,10 +151,9 @@ std::vector<std::string> cmGlobalGhsMultiGenerator::GetCompRootHardPaths()
   std::vector<std::string> output;
   cmSystemTools::Glob("C:/ghs", "comp_[^;]+", output);
   for (std::vector<std::string>::iterator outputIt = output.begin();
-       outputIt != output.end(); ++outputIt)
-    {
+       outputIt != output.end(); ++outputIt) {
     *outputIt = "C:/ghs/" + *outputIt;
-    }
+  }
   return output;
 }
 
@@ -182,21 +176,19 @@ std::vector<std::string> cmGlobalGhsMultiGenerator::GetCompRootRegistry()
 }
 
 void cmGlobalGhsMultiGenerator::OpenBuildFileStream(
-  std::string const &filepath, cmGeneratedFileStream **filestream)
+  std::string const& filepath, cmGeneratedFileStream** filestream)
 {
   // Get a stream where to generate things.
-  if (NULL == *filestream)
-    {
+  if (NULL == *filestream) {
     *filestream = new cmGeneratedFileStream(filepath.c_str());
-    if (NULL != *filestream)
-      {
+    if (NULL != *filestream) {
       OpenBuildFileStream(*filestream);
-      }
     }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::OpenBuildFileStream(
-  cmGeneratedFileStream *filestream)
+  cmGeneratedFileStream* filestream)
 {
   *filestream << "#!gbuild" << std::endl;
 }
@@ -213,39 +205,30 @@ void cmGlobalGhsMultiGenerator::OpenBuildFileStream()
   this->Open(std::string(""), buildFilePath, &this->TargetFolderBuildStreams);
   OpenBuildFileStream(GetBuildFileStream());
 
-  char const *osDir =
+  char const* osDir =
     this->GetCMakeInstance()->GetCacheDefinition("GHS_OS_DIR");
-  if (NULL == osDir)
-    {
+  if (NULL == osDir) {
     osDir = "";
     cmSystemTools::Error("GHS_OS_DIR cache variable must be set");
-    }
-  else
-    {
+  } else {
     this->GetCMakeInstance()->MarkCliAsUsed("GHS_OS_DIR");
-    }
+  }
   std::string fOSDir(this->trimQuotes(osDir));
   cmSystemTools::ReplaceString(fOSDir, "\\", "/");
-  if (!fOSDir.empty() && ('c' == fOSDir[0] || 'C' == fOSDir[0]))
-    {
+  if (!fOSDir.empty() && ('c' == fOSDir[0] || 'C' == fOSDir[0])) {
     this->OSDirRelative = false;
-    }
-  else
-    {
+  } else {
     this->OSDirRelative = true;
-    }
+  }
 
-  char const *bspName =
+  char const* bspName =
     this->GetCMakeInstance()->GetCacheDefinition("GHS_BSP_NAME");
-  if (NULL == bspName)
-    {
+  if (NULL == bspName) {
     bspName = "";
     cmSystemTools::Error("GHS_BSP_NAME cache variable must be set");
-    }
-  else
-    {
+  } else {
     this->GetCMakeInstance()->MarkCliAsUsed("GHS_BSP_NAME");
-    }
+  }
   std::string fBspName(this->trimQuotes(bspName));
   cmSystemTools::ReplaceString(fBspName, "\\", "/");
   this->WriteMacros();
@@ -254,114 +237,98 @@ void cmGlobalGhsMultiGenerator::OpenBuildFileStream()
   GhsMultiGpj::WriteGpjTag(GhsMultiGpj::PROJECT, this->GetBuildFileStream());
   this->WriteDisclaimer(this->GetBuildFileStream());
   *this->GetBuildFileStream() << "# Top Level Project File" << std::endl;
-  if (!fBspName.empty())
-    {
+  if (!fBspName.empty()) {
     *this->GetBuildFileStream() << "    -bsp " << fBspName << std::endl;
-    }
+  }
   this->WriteCompilerOptions(fOSDir);
 }
 
 void cmGlobalGhsMultiGenerator::CloseBuildFileStream(
-  cmGeneratedFileStream **filestream)
+  cmGeneratedFileStream** filestream)
 {
-  if (filestream)
-    {
+  if (filestream) {
     delete *filestream;
     *filestream = NULL;
-    }
-  else
-    {
+  } else {
     cmSystemTools::Error("Build file stream was not open.");
-    }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::Generate()
 {
   this->cmGlobalGenerator::Generate();
 
-  if (!this->LocalGenerators.empty())
-    {
+  if (!this->LocalGenerators.empty()) {
     this->OpenBuildFileStream();
 
     // Build all the folder build files
-    for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-      {
-      cmLocalGhsMultiGenerator *lg =
-        static_cast<cmLocalGhsMultiGenerator *>(this->LocalGenerators[i]);
+    for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
+      cmLocalGhsMultiGenerator* lg =
+        static_cast<cmLocalGhsMultiGenerator*>(this->LocalGenerators[i]);
       std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets();
       this->UpdateBuildFiles(tgts);
-      }
     }
+  }
 
   cmDeleteAll(TargetFolderBuildStreams);
   this->TargetFolderBuildStreams.clear();
 }
 
 void cmGlobalGhsMultiGenerator::GenerateBuildCommand(
-  std::vector<std::string> &makeCommand, const std::string &makeProgram,
-  const std::string & /*projectName*/, const std::string & /*projectDir*/,
-  const std::string &targetName, const std::string & /*config*/,
-  bool /*fast*/, bool /*verbose*/,
-  std::vector<std::string> const &makeOptions)
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& /*projectName*/, const std::string& /*projectDir*/,
+  const std::string& targetName, const std::string& /*config*/, bool /*fast*/,
+  bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   makeCommand.push_back(
-    this->SelectMakeProgram(makeProgram, this->GetGhsBuildCommand())
-    );
-
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
-  if (!targetName.empty())
-    {
-    if (targetName == "clean")
-      {
+    this->SelectMakeProgram(makeProgram, this->GetGhsBuildCommand()));
+
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
+  if (!targetName.empty()) {
+    if (targetName == "clean") {
       makeCommand.push_back("-clean");
-      }
-    else
-      {
+    } else {
       makeCommand.push_back(targetName);
-      }
     }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::WriteMacros()
 {
-  char const *ghsGpjMacros =
+  char const* ghsGpjMacros =
     this->GetCMakeInstance()->GetCacheDefinition("GHS_GPJ_MACROS");
-  if (NULL != ghsGpjMacros)
-    {
+  if (NULL != ghsGpjMacros) {
     std::vector<std::string> expandedList;
     cmSystemTools::ExpandListArgument(std::string(ghsGpjMacros), expandedList);
     for (std::vector<std::string>::const_iterator expandedListI =
            expandedList.begin();
-         expandedListI != expandedList.end(); ++expandedListI)
-      {
+         expandedListI != expandedList.end(); ++expandedListI) {
       *this->GetBuildFileStream() << "macro " << *expandedListI << std::endl;
-      }
     }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::WriteHighLevelDirectives()
 {
   *this->GetBuildFileStream() << "primaryTarget=arm_integrity.tgt"
                               << std::endl;
-  char const *const customization =
+  char const* const customization =
     this->GetCMakeInstance()->GetCacheDefinition("GHS_CUSTOMIZATION");
-  if (NULL != customization && strlen(customization) > 0)
-    {
-    *this->GetBuildFileStream() << "customization="
-                                << trimQuotes(customization)
-                                << std::endl;
+  if (NULL != customization && strlen(customization) > 0) {
+    *this->GetBuildFileStream()
+      << "customization=" << trimQuotes(customization) << std::endl;
     this->GetCMakeInstance()->MarkCliAsUsed("GHS_CUSTOMIZATION");
-    }
+  }
 }
 
-void cmGlobalGhsMultiGenerator::WriteCompilerOptions(std::string const &fOSDir)
+void cmGlobalGhsMultiGenerator::WriteCompilerOptions(std::string const& fOSDir)
 {
   *this->GetBuildFileStream() << "    -os_dir=\"" << fOSDir << "\""
                               << std::endl;
 }
 
-void cmGlobalGhsMultiGenerator::WriteDisclaimer(std::ostream *os)
+void cmGlobalGhsMultiGenerator::WriteDisclaimer(std::ostream* os)
 {
   (*os) << "#" << std::endl
         << "# CMAKE generated file: DO NOT EDIT!" << std::endl
@@ -372,10 +339,10 @@ void cmGlobalGhsMultiGenerator::WriteDisclaimer(std::ostream *os)
 }
 
 void cmGlobalGhsMultiGenerator::AddFilesUpToPath(
-  cmGeneratedFileStream *mainBuildFile,
-  std::map<std::string, cmGeneratedFileStream *> *targetFolderBuildStreams,
-  char const *homeOutputDirectory, std::string const &path,
-  GhsMultiGpj::Types projType, std::string const &relPath)
+  cmGeneratedFileStream* mainBuildFile,
+  std::map<std::string, cmGeneratedFileStream*>* targetFolderBuildStreams,
+  char const* homeOutputDirectory, std::string const& path,
+  GhsMultiGpj::Types projType, std::string const& relPath)
 {
   std::string workingPath(path);
   cmSystemTools::ConvertToUnixSlashes(workingPath);
@@ -383,55 +350,50 @@ void cmGlobalGhsMultiGenerator::AddFilesUpToPath(
     cmSystemTools::SplitString(workingPath);
   std::string workingRelPath(relPath);
   cmSystemTools::ConvertToUnixSlashes(workingRelPath);
-  if (!workingRelPath.empty())
-    {
+  if (!workingRelPath.empty()) {
     workingRelPath += "/";
-    }
+  }
   std::string pathUpTo;
   for (std::vector<cmsys::String>::const_iterator splitPathI =
          splitPath.begin();
-       splitPath.end() != splitPathI; ++splitPathI)
-    {
+       splitPath.end() != splitPathI; ++splitPathI) {
     pathUpTo += *splitPathI;
     if (targetFolderBuildStreams->end() ==
-        targetFolderBuildStreams->find(pathUpTo))
-      {
+        targetFolderBuildStreams->find(pathUpTo)) {
       AddFilesUpToPathNewBuildFile(
-        mainBuildFile, targetFolderBuildStreams, homeOutputDirectory,
-        pathUpTo, splitPath.begin() == splitPathI, workingRelPath, projType);
-      }
+        mainBuildFile, targetFolderBuildStreams, homeOutputDirectory, pathUpTo,
+        splitPath.begin() == splitPathI, workingRelPath, projType);
+    }
     AddFilesUpToPathAppendNextFile(targetFolderBuildStreams, pathUpTo,
                                    splitPathI, splitPath.end(), projType);
     pathUpTo += "/";
-    }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::Open(
-  std::string const &mapKeyName, std::string const &fileName,
-  std::map<std::string, cmGeneratedFileStream *> *fileMap)
+  std::string const& mapKeyName, std::string const& fileName,
+  std::map<std::string, cmGeneratedFileStream*>* fileMap)
 {
-  if (fileMap->end() == fileMap->find(fileName))
-    {
-    cmGeneratedFileStream *temp(new cmGeneratedFileStream);
+  if (fileMap->end() == fileMap->find(fileName)) {
+    cmGeneratedFileStream* temp(new cmGeneratedFileStream);
     temp->open(fileName.c_str());
     (*fileMap)[mapKeyName] = temp;
-    }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::AddFilesUpToPathNewBuildFile(
-  cmGeneratedFileStream *mainBuildFile,
-  std::map<std::string, cmGeneratedFileStream *> *targetFolderBuildStreams,
-  char const *homeOutputDirectory, std::string const &pathUpTo,
-  bool const isFirst, std::string const &relPath,
+  cmGeneratedFileStream* mainBuildFile,
+  std::map<std::string, cmGeneratedFileStream*>* targetFolderBuildStreams,
+  char const* homeOutputDirectory, std::string const& pathUpTo,
+  bool const isFirst, std::string const& relPath,
   GhsMultiGpj::Types const projType)
 {
   // create folders up to file path
   std::string absPath = std::string(homeOutputDirectory) + "/" + relPath;
   std::string newPath = absPath + pathUpTo;
-  if (!cmSystemTools::FileExists(newPath.c_str()))
-    {
+  if (!cmSystemTools::FileExists(newPath.c_str())) {
     cmSystemTools::MakeDirectory(newPath.c_str());
-    }
+  }
 
   // Write out to filename for first time
   std::string relFilename(GetFileNameFromPath(pathUpTo));
@@ -442,16 +404,15 @@ void cmGlobalGhsMultiGenerator::AddFilesUpToPathNewBuildFile(
   WriteDisclaimer((*targetFolderBuildStreams)[pathUpTo]);
 
   // Add to main build file
-  if (isFirst)
-    {
+  if (isFirst) {
     *mainBuildFile << relFilename << " ";
     GhsMultiGpj::WriteGpjTag(projType, mainBuildFile);
-    }
+  }
 }
 
 void cmGlobalGhsMultiGenerator::AddFilesUpToPathAppendNextFile(
-  std::map<std::string, cmGeneratedFileStream *> *targetFolderBuildStreams,
-  std::string const &pathUpTo,
+  std::map<std::string, cmGeneratedFileStream*>* targetFolderBuildStreams,
+  std::string const& pathUpTo,
   std::vector<cmsys::String>::const_iterator splitPathI,
   std::vector<cmsys::String>::const_iterator end,
   GhsMultiGpj::Types const projType)
@@ -459,25 +420,23 @@ void cmGlobalGhsMultiGenerator::AddFilesUpToPathAppendNextFile(
   std::vector<cmsys::String>::const_iterator splitPathNextI = splitPathI + 1;
   if (end != splitPathNextI &&
       targetFolderBuildStreams->end() ==
-      targetFolderBuildStreams->find(pathUpTo + "/" + *splitPathNextI))
-    {
+        targetFolderBuildStreams->find(pathUpTo + "/" + *splitPathNextI)) {
     std::string nextFilename(*splitPathNextI);
     nextFilename = GetFileNameFromPath(nextFilename);
     *(*targetFolderBuildStreams)[pathUpTo] << nextFilename << " ";
     GhsMultiGpj::WriteGpjTag(projType, (*targetFolderBuildStreams)[pathUpTo]);
-    }
+  }
 }
 
-std::string
-cmGlobalGhsMultiGenerator::GetFileNameFromPath(std::string const &path)
+std::string cmGlobalGhsMultiGenerator::GetFileNameFromPath(
+  std::string const& path)
 {
   std::string output(path);
-  if (!path.empty())
-    {
+  if (!path.empty()) {
     cmSystemTools::ConvertToUnixSlashes(output);
     std::vector<cmsys::String> splitPath = cmSystemTools::SplitString(output);
     output += "/" + splitPath.back() + FILE_EXTENSION;
-    }
+  }
   return output;
 }
 
@@ -485,64 +444,56 @@ void cmGlobalGhsMultiGenerator::UpdateBuildFiles(
   std::vector<cmGeneratorTarget*> tgts)
 {
   for (std::vector<cmGeneratorTarget*>::iterator tgtsI = tgts.begin();
-       tgtsI != tgts.end(); ++tgtsI)
-    {
-    const cmGeneratorTarget *tgt = *tgtsI;
-    if (IsTgtForBuild(tgt))
-      {
-      char const *rawFolderName = tgt->GetProperty("FOLDER");
-      if (NULL == rawFolderName)
-        {
+       tgtsI != tgts.end(); ++tgtsI) {
+    const cmGeneratorTarget* tgt = *tgtsI;
+    if (IsTgtForBuild(tgt)) {
+      char const* rawFolderName = tgt->GetProperty("FOLDER");
+      if (NULL == rawFolderName) {
         rawFolderName = "";
-        }
+      }
       std::string folderName(rawFolderName);
       if (this->TargetFolderBuildStreams.end() ==
-          this->TargetFolderBuildStreams.find(folderName))
-        {
+          this->TargetFolderBuildStreams.find(folderName)) {
         this->AddFilesUpToPath(
           GetBuildFileStream(), &this->TargetFolderBuildStreams,
           this->GetCMakeInstance()->GetHomeOutputDirectory(), folderName,
           GhsMultiGpj::PROJECT);
-        }
+      }
       std::vector<cmsys::String> splitPath = cmSystemTools::SplitString(
-            cmGhsMultiTargetGenerator::GetRelBuildFileName(tgt));
+        cmGhsMultiTargetGenerator::GetRelBuildFileName(tgt));
       std::string foldNameRelBuildFile(*(splitPath.end() - 2) + "/" +
                                        splitPath.back());
       *this->TargetFolderBuildStreams[folderName] << foldNameRelBuildFile
                                                   << " ";
-      GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag(
-                                 tgt),
+      GhsMultiGpj::WriteGpjTag(cmGhsMultiTargetGenerator::GetGpjTag(tgt),
                                this->TargetFolderBuildStreams[folderName]);
-      }
     }
+  }
 }
 
-bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmGeneratorTarget *tgt)
+bool cmGlobalGhsMultiGenerator::IsTgtForBuild(const cmGeneratorTarget* tgt)
 {
   const std::string config =
     tgt->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
-  std::vector<cmSourceFile *> tgtSources;
+  std::vector<cmSourceFile*> tgtSources;
   tgt->GetSourceFiles(tgtSources, config);
   bool tgtInBuild = true;
-  char const *excludeFromAll = tgt->GetProperty("EXCLUDE_FROM_ALL");
+  char const* excludeFromAll = tgt->GetProperty("EXCLUDE_FROM_ALL");
   if (NULL != excludeFromAll && '1' == excludeFromAll[0] &&
-    '\0' == excludeFromAll[1])
-  {
+      '\0' == excludeFromAll[1]) {
     tgtInBuild = false;
   }
   return !tgtSources.empty() && tgtInBuild;
 }
 
-std::string cmGlobalGhsMultiGenerator::trimQuotes(std::string const &str)
+std::string cmGlobalGhsMultiGenerator::trimQuotes(std::string const& str)
 {
   std::string result;
   result.reserve(str.size());
-  for (const char *ch = str.c_str(); *ch != '\0'; ++ch)
-    {
-    if (*ch != '"')
-      {
+  for (const char* ch = str.c_str(); *ch != '\0'; ++ch) {
+    if (*ch != '"') {
       result += *ch;
-      }
     }
+  }
   return result;
 }
diff --git a/Source/cmGlobalGhsMultiGenerator.h b/Source/cmGlobalGhsMultiGenerator.h
index 5de9d2b..473d153 100644
--- a/Source/cmGlobalGhsMultiGenerator.h
+++ b/Source/cmGlobalGhsMultiGenerator.h
@@ -23,16 +23,18 @@ class cmGlobalGhsMultiGenerator : public cmGlobalGenerator
 {
 public:
   /// The default name of GHS MULTI's build file. Typically: monolith.gpj.
-  static const char *FILE_EXTENSION;
+  static const char* FILE_EXTENSION;
 
   cmGlobalGhsMultiGenerator(cmake* cm);
   ~cmGlobalGhsMultiGenerator();
 
-  static cmGlobalGeneratorFactory *NewFactory()
-  { return new cmGlobalGeneratorSimpleFactory<cmGlobalGhsMultiGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<cmGlobalGhsMultiGenerator>();
+  }
 
   ///! create the correct local generator
-  virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   /// @return the name of this generator.
   static std::string GetActualName() { return "Green Hills MULTI"; }
@@ -41,7 +43,7 @@ public:
   virtual std::string GetName() const { return this->GetActualName(); }
 
   /// Overloaded methods. @see cmGlobalGenerator::GetDocumentation()
-  static void GetDocumentation(cmDocumentationEntry &entry);
+  static void GetDocumentation(cmDocumentationEntry& entry);
 
   /**
    * Utilized by the generator factory to determine if this generator
@@ -53,49 +55,48 @@ public:
   * Try to determine system information such as shared library
   * extension, pthreads, byte order etc.
   */
-  virtual void EnableLanguage(std::vector<std::string> const &languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
   /*
   * Determine what program to use for building the project.
   */
-  virtual void FindMakeProgram(cmMakefile *);
+  virtual void FindMakeProgram(cmMakefile*);
 
-  cmGeneratedFileStream *GetBuildFileStream()
+  cmGeneratedFileStream* GetBuildFileStream()
   {
     return this->TargetFolderBuildStreams[""];
   }
 
-  static void OpenBuildFileStream(std::string const &filepath,
-                                  cmGeneratedFileStream **filestream);
-  static void OpenBuildFileStream(cmGeneratedFileStream *filestream);
-  static void CloseBuildFileStream(cmGeneratedFileStream **filestream);
+  static void OpenBuildFileStream(std::string const& filepath,
+                                  cmGeneratedFileStream** filestream);
+  static void OpenBuildFileStream(cmGeneratedFileStream* filestream);
+  static void CloseBuildFileStream(cmGeneratedFileStream** filestream);
   /// Write the common disclaimer text at the top of each build file.
-  static void WriteDisclaimer(std::ostream *os);
+  static void WriteDisclaimer(std::ostream* os);
   std::vector<std::string> GetLibDirs() { return this->LibDirs; }
 
   static void AddFilesUpToPath(
-      cmGeneratedFileStream *mainBuildFile,
-      std::map<std::string, cmGeneratedFileStream *> *targetFolderBuildStreams,
-      char const *homeOutputDirectory, std::string const &path,
-      GhsMultiGpj::Types projType, std::string const &relPath = "");
-  static void Open(std::string const &mapKeyName, std::string const &fileName,
-                   std::map<std::string, cmGeneratedFileStream *> *fileMap);
-
-  static std::string trimQuotes(std::string const &str);
+    cmGeneratedFileStream* mainBuildFile,
+    std::map<std::string, cmGeneratedFileStream*>* targetFolderBuildStreams,
+    char const* homeOutputDirectory, std::string const& path,
+    GhsMultiGpj::Types projType, std::string const& relPath = "");
+  static void Open(std::string const& mapKeyName, std::string const& fileName,
+                   std::map<std::string, cmGeneratedFileStream*>* fileMap);
+
+  static std::string trimQuotes(std::string const& str);
   inline bool IsOSDirRelative() { return this->OSDirRelative; }
 
 protected:
   virtual void Generate();
   virtual void GenerateBuildCommand(
-      std::vector<std::string> &makeCommand, const std::string &makeProgram,
-      const std::string &projectName, const std::string &projectDir,
-      const std::string &targetName, const std::string &config, bool fast,
-      bool verbose,
-      std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+    const std::string& projectName, const std::string& projectDir,
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
 private:
-  std::string const &GetGhsBuildCommand();
+  std::string const& GetGhsBuildCommand();
   std::string FindGhsBuildCommand();
   std::string GetCompRoot();
   std::vector<std::string> GetCompRootHardPaths();
@@ -104,32 +105,32 @@ private:
 
   void WriteMacros();
   void WriteHighLevelDirectives();
-  void WriteCompilerOptions(std::string const &fOSDir);
+  void WriteCompilerOptions(std::string const& fOSDir);
 
   static void AddFilesUpToPathNewBuildFile(
-      cmGeneratedFileStream *mainBuildFile,
-      std::map<std::string, cmGeneratedFileStream *> *targetFolderBuildStreams,
-      char const *homeOutputDirectory, std::string const &pathUpTo,
-      bool isFirst, std::string const &relPath, GhsMultiGpj::Types projType);
+    cmGeneratedFileStream* mainBuildFile,
+    std::map<std::string, cmGeneratedFileStream*>* targetFolderBuildStreams,
+    char const* homeOutputDirectory, std::string const& pathUpTo, bool isFirst,
+    std::string const& relPath, GhsMultiGpj::Types projType);
   static void AddFilesUpToPathAppendNextFile(
-      std::map<std::string, cmGeneratedFileStream *> *targetFolderBuildStreams,
-      std::string const &pathUpTo,
-      std::vector<cmsys::String>::const_iterator splitPathI,
-      std::vector<cmsys::String>::const_iterator end,
-      GhsMultiGpj::Types projType);
-  static std::string GetFileNameFromPath(std::string const &path);
+    std::map<std::string, cmGeneratedFileStream*>* targetFolderBuildStreams,
+    std::string const& pathUpTo,
+    std::vector<cmsys::String>::const_iterator splitPathI,
+    std::vector<cmsys::String>::const_iterator end,
+    GhsMultiGpj::Types projType);
+  static std::string GetFileNameFromPath(std::string const& path);
   void UpdateBuildFiles(std::vector<cmGeneratorTarget*> tgts);
-  bool IsTgtForBuild(const cmGeneratorTarget *tgt);
+  bool IsTgtForBuild(const cmGeneratorTarget* tgt);
 
-  std::vector<cmGeneratedFileStream *> TargetSubProjects;
-  std::map<std::string, cmGeneratedFileStream *> TargetFolderBuildStreams;
+  std::vector<cmGeneratedFileStream*> TargetSubProjects;
+  std::map<std::string, cmGeneratedFileStream*> TargetFolderBuildStreams;
 
   std::vector<std::string> LibDirs;
 
   bool OSDirRelative;
   bool GhsBuildCommandInitialized;
   std::string GhsBuildCommand;
-  static const char *DEFAULT_MAKE_PROGRAM;
+  static const char* DEFAULT_MAKE_PROGRAM;
 };
 
 #endif
diff --git a/Source/cmGlobalJOMMakefileGenerator.cxx b/Source/cmGlobalJOMMakefileGenerator.cxx
index 6ae82d8..0bdd624 100644
--- a/Source/cmGlobalJOMMakefileGenerator.cxx
+++ b/Source/cmGlobalJOMMakefileGenerator.cxx
@@ -29,10 +29,8 @@ cmGlobalJOMMakefileGenerator::cmGlobalJOMMakefileGenerator(cmake* cm)
   this->MakeSilentFlag = "/nologo";
 }
 
-void cmGlobalJOMMakefileGenerator
-::EnableLanguage(std::vector<std::string>const& l,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalJOMMakefileGenerator::EnableLanguage(
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   // pick a default
   mf->AddDefinition("CMAKE_GENERATOR_CC", "cl");
@@ -40,19 +38,17 @@ void cmGlobalJOMMakefileGenerator
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
 }
 
-void cmGlobalJOMMakefileGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalJOMMakefileGenerator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalJOMMakefileGenerator::GetActualName();
   entry.Brief = "Generates JOM makefiles.";
 }
 
-void cmGlobalJOMMakefileGenerator::PrintCompilerAdvice(std::ostream& os,
-                                                  std::string const& lang,
-                                                  const char* envVar) const
+void cmGlobalJOMMakefileGenerator::PrintCompilerAdvice(
+  std::ostream& os, std::string const& lang, const char* envVar) const
 {
-  if(lang == "CXX" || lang == "C")
-    {
+  if (lang == "CXX" || lang == "C") {
     /* clang-format off */
     os <<
       "To use the JOM generator with Visual C++, cmake must be run from a "
@@ -60,6 +56,6 @@ void cmGlobalJOMMakefileGenerator::PrintCompilerAdvice(std::ostream& os,
       "environment is unable to invoke the cl compiler. To fix this problem, "
       "run cmake from the Visual Studio Command Prompt (vcvarsall.bat).\n";
     /* clang-format on */
-    }
+  }
   this->cmGlobalUnixMakefileGenerator3::PrintCompilerAdvice(os, lang, envVar);
 }
diff --git a/Source/cmGlobalJOMMakefileGenerator.h b/Source/cmGlobalJOMMakefileGenerator.h
index 1869fed..bb2273a 100644
--- a/Source/cmGlobalJOMMakefileGenerator.h
+++ b/Source/cmGlobalJOMMakefileGenerator.h
@@ -23,15 +23,18 @@ class cmGlobalJOMMakefileGenerator : public cmGlobalUnixMakefileGenerator3
 {
 public:
   cmGlobalJOMMakefileGenerator(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalJOMMakefileGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<cmGlobalJOMMakefileGenerator>();
+  }
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalJOMMakefileGenerator::GetActualName();}
+  virtual std::string GetName() const
+  {
+    return cmGlobalJOMMakefileGenerator::GetActualName();
+  }
   // use NMake Makefiles in the name so that scripts/tests that depend on the
   // name NMake Makefiles will work
-  static std::string GetActualName() {return "NMake Makefiles JOM";}
+  static std::string GetActualName() { return "NMake Makefiles JOM"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
@@ -40,8 +43,9 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
+
 private:
   void PrintCompilerAdvice(std::ostream& os, std::string const& lang,
                            const char* envVar) const;
diff --git a/Source/cmGlobalKdevelopGenerator.cxx b/Source/cmGlobalKdevelopGenerator.cxx
index f2de750..5c1e733 100644
--- a/Source/cmGlobalKdevelopGenerator.cxx
+++ b/Source/cmGlobalKdevelopGenerator.cxx
@@ -25,15 +25,15 @@
 #include <cmsys/FStream.hxx>
 #include <cmsys/SystemTools.hxx>
 
-void cmGlobalKdevelopGenerator
-::GetDocumentation(cmDocumentationEntry& entry, const std::string&) const
+void cmGlobalKdevelopGenerator::GetDocumentation(cmDocumentationEntry& entry,
+                                                 const std::string&) const
 {
   entry.Name = this->GetName();
   entry.Brief = "Generates KDevelop 3 project files.";
 }
 
 cmGlobalKdevelopGenerator::cmGlobalKdevelopGenerator()
-:cmExternalMakefileProjectGenerator()
+  : cmExternalMakefileProjectGenerator()
 {
   this->SupportedGlobalGenerators.push_back("Unix Makefiles");
 #ifdef CMAKE_USE_NINJA
@@ -46,372 +46,312 @@ void cmGlobalKdevelopGenerator::Generate()
   // for each sub project in the project create
   // a kdevelop project
   for (std::map<std::string, std::vector<cmLocalGenerator*> >::const_iterator
-       it = this->GlobalGenerator->GetProjectMap().begin();
-      it!= this->GlobalGenerator->GetProjectMap().end();
-      ++it)
-    {
-    std::string outputDir=it->second[0]->GetCurrentBinaryDirectory();
-    std::string projectDir=it->second[0]->GetSourceDirectory();
-    std::string projectName=it->second[0]->GetProjectName();
+         it = this->GlobalGenerator->GetProjectMap().begin();
+       it != this->GlobalGenerator->GetProjectMap().end(); ++it) {
+    std::string outputDir = it->second[0]->GetCurrentBinaryDirectory();
+    std::string projectDir = it->second[0]->GetSourceDirectory();
+    std::string projectName = it->second[0]->GetProjectName();
     std::string cmakeFilePattern("CMakeLists.txt;*.cmake;");
     std::string fileToOpen;
-    const std::vector<cmLocalGenerator*>& lgs= it->second;
+    const std::vector<cmLocalGenerator*>& lgs = it->second;
     // create the project.kdevelop.filelist file
-    if(!this->CreateFilelistFile(lgs, outputDir, projectDir,
-                                 projectName, cmakeFilePattern, fileToOpen))
-      {
+    if (!this->CreateFilelistFile(lgs, outputDir, projectDir, projectName,
+                                  cmakeFilePattern, fileToOpen)) {
       cmSystemTools::Error("Can not create filelist file");
       return;
-      }
-    //try to find the name of an executable so we have something to
-    //run from kdevelop for now just pick the first executable found
+    }
+    // try to find the name of an executable so we have something to
+    // run from kdevelop for now just pick the first executable found
     std::string executable;
-    for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
-         lg!=lgs.end(); lg++)
-      {
+    for (std::vector<cmLocalGenerator*>::const_iterator lg = lgs.begin();
+         lg != lgs.end(); lg++) {
       std::vector<cmGeneratorTarget*> const& targets =
-          (*lg)->GetGeneratorTargets();
+        (*lg)->GetGeneratorTargets();
       for (std::vector<cmGeneratorTarget*>::const_iterator ti =
-           targets.begin(); ti != targets.end(); ti++)
-        {
-        if ((*ti)->GetType()==cmState::EXECUTABLE)
-          {
+             targets.begin();
+           ti != targets.end(); ti++) {
+        if ((*ti)->GetType() == cmState::EXECUTABLE) {
           executable = (*ti)->GetLocation("");
           break;
-          }
         }
-      if (!executable.empty())
-        {
+      }
+      if (!executable.empty()) {
         break;
-        }
       }
+    }
 
     // now create a project file
-    this->CreateProjectFile(outputDir, projectDir, projectName,
-                            executable, cmakeFilePattern, fileToOpen);
-    }
+    this->CreateProjectFile(outputDir, projectDir, projectName, executable,
+                            cmakeFilePattern, fileToOpen);
+  }
 }
 
-bool cmGlobalKdevelopGenerator
-::CreateFilelistFile(const std::vector<cmLocalGenerator*>& lgs,
-                     const std::string& outputDir,
-                     const std::string& projectDirIn,
-                     const std::string& projectname,
-                     std::string& cmakeFilePattern,
-                     std::string& fileToOpen)
+bool cmGlobalKdevelopGenerator::CreateFilelistFile(
+  const std::vector<cmLocalGenerator*>& lgs, const std::string& outputDir,
+  const std::string& projectDirIn, const std::string& projectname,
+  std::string& cmakeFilePattern, std::string& fileToOpen)
 {
   std::string projectDir = projectDirIn + "/";
-  std::string filename = outputDir+ "/" + projectname +".kdevelop.filelist";
+  std::string filename = outputDir + "/" + projectname + ".kdevelop.filelist";
 
   std::set<std::string> files;
   std::string tmp;
 
   std::vector<std::string> hdrExts =
-      this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
-
-  for (std::vector<cmLocalGenerator*>::const_iterator it=lgs.begin();
-       it!=lgs.end(); it++)
-    {
-    cmMakefile* makefile=(*it)->GetMakefile();
-    const std::vector<std::string>& listFiles=makefile->GetListFiles();
-    for (std::vector<std::string>::const_iterator lt=listFiles.begin();
-         lt!=listFiles.end(); lt++)
-      {
-      tmp=*lt;
+    this->GlobalGenerator->GetCMakeInstance()->GetHeaderExtensions();
+
+  for (std::vector<cmLocalGenerator*>::const_iterator it = lgs.begin();
+       it != lgs.end(); it++) {
+    cmMakefile* makefile = (*it)->GetMakefile();
+    const std::vector<std::string>& listFiles = makefile->GetListFiles();
+    for (std::vector<std::string>::const_iterator lt = listFiles.begin();
+         lt != listFiles.end(); lt++) {
+      tmp = *lt;
       cmSystemTools::ReplaceString(tmp, projectDir.c_str(), "");
       // make sure the file is part of this source tree
-      if ((tmp[0]!='/') &&
-          (strstr(tmp.c_str(),
-                  cmake::GetCMakeFilesDirectoryPostSlash())==0))
-        {
+      if ((tmp[0] != '/') &&
+          (strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) ==
+           0)) {
         files.insert(tmp);
-        tmp=cmSystemTools::GetFilenameName(tmp);
-        //add all files which dont match the default
+        tmp = cmSystemTools::GetFilenameName(tmp);
+        // add all files which dont match the default
         // */CMakeLists.txt;*cmake; to the file pattern
-        if ((tmp!="CMakeLists.txt")
-            && (strstr(tmp.c_str(), ".cmake")==0))
-          {
-          cmakeFilePattern+=tmp+";";
-          }
+        if ((tmp != "CMakeLists.txt") &&
+            (strstr(tmp.c_str(), ".cmake") == 0)) {
+          cmakeFilePattern += tmp + ";";
         }
       }
+    }
 
-    //get all sources
-    std::vector<cmGeneratorTarget*> targets=(*it)->GetGeneratorTargets();
+    // get all sources
+    std::vector<cmGeneratorTarget*> targets = (*it)->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-         ti != targets.end(); ti++)
-      {
+         ti != targets.end(); ti++) {
       std::vector<cmSourceFile*> sources;
       cmGeneratorTarget* gt = *ti;
-      gt->GetSourceFiles(sources, gt->Target->GetMakefile()
-                                    ->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-      for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
-           si!=sources.end(); si++)
-        {
-        tmp=(*si)->GetFullPath();
-        std::string headerBasename=cmSystemTools::GetFilenamePath(tmp);
-        headerBasename+="/";
-        headerBasename+=cmSystemTools::GetFilenameWithoutExtension(tmp);
+      gt->GetSourceFiles(sources, gt->Target->GetMakefile()->GetSafeDefinition(
+                                    "CMAKE_BUILD_TYPE"));
+      for (std::vector<cmSourceFile*>::const_iterator si = sources.begin();
+           si != sources.end(); si++) {
+        tmp = (*si)->GetFullPath();
+        std::string headerBasename = cmSystemTools::GetFilenamePath(tmp);
+        headerBasename += "/";
+        headerBasename += cmSystemTools::GetFilenameWithoutExtension(tmp);
 
         cmSystemTools::ReplaceString(tmp, projectDir.c_str(), "");
 
-        if ((tmp[0]!='/')  &&
-            (strstr(tmp.c_str(),
-                  cmake::GetCMakeFilesDirectoryPostSlash())==0) &&
-           (cmSystemTools::GetFilenameExtension(tmp)!=".moc"))
-          {
+        if ((tmp[0] != '/') &&
+            (strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) ==
+             0) &&
+            (cmSystemTools::GetFilenameExtension(tmp) != ".moc")) {
           files.insert(tmp);
 
           // check if there's a matching header around
-          for(std::vector<std::string>::const_iterator
-                ext = hdrExts.begin(); ext != hdrExts.end(); ++ext)
-            {
-            std::string hname=headerBasename;
+          for (std::vector<std::string>::const_iterator ext = hdrExts.begin();
+               ext != hdrExts.end(); ++ext) {
+            std::string hname = headerBasename;
             hname += ".";
             hname += *ext;
-            if(cmSystemTools::FileExists(hname.c_str()))
-              {
+            if (cmSystemTools::FileExists(hname.c_str())) {
               cmSystemTools::ReplaceString(hname, projectDir.c_str(), "");
               files.insert(hname);
               break;
-              }
             }
           }
         }
-      for (std::vector<std::string>::const_iterator lt=listFiles.begin();
-           lt!=listFiles.end(); lt++)
-        {
-        tmp=*lt;
+      }
+      for (std::vector<std::string>::const_iterator lt = listFiles.begin();
+           lt != listFiles.end(); lt++) {
+        tmp = *lt;
         cmSystemTools::ReplaceString(tmp, projectDir.c_str(), "");
-        if ((tmp[0]!='/') &&
-            (strstr(tmp.c_str(),
-                    cmake::GetCMakeFilesDirectoryPostSlash())==0))
-          {
+        if ((tmp[0] != '/') &&
+            (strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) ==
+             0)) {
           files.insert(tmp);
-          }
         }
       }
     }
+  }
 
-  //check if the output file already exists and read it
-  //insert all files which exist into the set of files
+  // check if the output file already exists and read it
+  // insert all files which exist into the set of files
   cmsys::ifstream oldFilelist(filename.c_str());
-  if (oldFilelist)
-    {
-    while (cmSystemTools::GetLineFromStream(oldFilelist, tmp))
-      {
-      if (tmp[0]=='/')
-        {
+  if (oldFilelist) {
+    while (cmSystemTools::GetLineFromStream(oldFilelist, tmp)) {
+      if (tmp[0] == '/') {
         continue;
-        }
-      std::string completePath=projectDir+tmp;
-      if (cmSystemTools::FileExists(completePath.c_str()))
-        {
+      }
+      std::string completePath = projectDir + tmp;
+      if (cmSystemTools::FileExists(completePath.c_str())) {
         files.insert(tmp);
-        }
       }
-    oldFilelist.close();
     }
+    oldFilelist.close();
+  }
 
-  //now write the new filename
+  // now write the new filename
   cmGeneratedFileStream fout(filename.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return false;
-    }
+  }
 
-  fileToOpen="";
-  for (std::set<std::string>::const_iterator it=files.begin();
-       it!=files.end(); it++)
-    {
+  fileToOpen = "";
+  for (std::set<std::string>::const_iterator it = files.begin();
+       it != files.end(); it++) {
     // get the full path to the file
-    tmp=cmSystemTools::CollapseFullPath(*it, projectDir.c_str());
+    tmp = cmSystemTools::CollapseFullPath(*it, projectDir.c_str());
     // just select the first source file
-    if (fileToOpen.empty())
-    {
-       std::string ext = cmSystemTools::GetFilenameExtension(tmp);
-       if ((ext==".c") || (ext==".cc") || (ext==".cpp")  || (ext==".cxx")
-           || (ext==".C") || (ext==".h") || (ext==".hpp"))
-       {
-       fileToOpen=tmp;
-       }
+    if (fileToOpen.empty()) {
+      std::string ext = cmSystemTools::GetFilenameExtension(tmp);
+      if ((ext == ".c") || (ext == ".cc") || (ext == ".cpp") ||
+          (ext == ".cxx") || (ext == ".C") || (ext == ".h") ||
+          (ext == ".hpp")) {
+        fileToOpen = tmp;
+      }
     }
     // make it relative to the project dir
     cmSystemTools::ReplaceString(tmp, projectDir.c_str(), "");
     // only put relative paths
-    if (!tmp.empty() && tmp[0] != '/')
-      {
-      fout << tmp.c_str() <<"\n";
-      }
+    if (!tmp.empty() && tmp[0] != '/') {
+      fout << tmp.c_str() << "\n";
     }
+  }
   return true;
 }
 
-
 /* create the project file, if it already exists, merge it with the
 existing one, otherwise create a new one */
-void cmGlobalKdevelopGenerator
-::CreateProjectFile(const std::string& outputDir,
-                    const std::string& projectDir,
-                    const std::string& projectname,
-                    const std::string& executable,
-                    const std::string& cmakeFilePattern,
-                    const std::string& fileToOpen)
+void cmGlobalKdevelopGenerator::CreateProjectFile(
+  const std::string& outputDir, const std::string& projectDir,
+  const std::string& projectname, const std::string& executable,
+  const std::string& cmakeFilePattern, const std::string& fileToOpen)
 {
   this->Blacklist.clear();
 
-  std::string filename=outputDir+"/";
-  filename+=projectname+".kdevelop";
-  std::string sessionFilename=outputDir+"/";
-  sessionFilename+=projectname+".kdevses";
+  std::string filename = outputDir + "/";
+  filename += projectname + ".kdevelop";
+  std::string sessionFilename = outputDir + "/";
+  sessionFilename += projectname + ".kdevses";
 
-  if (cmSystemTools::FileExists(filename.c_str()))
-    {
-    this->MergeProjectFiles(outputDir, projectDir, filename,
-                            executable, cmakeFilePattern,
-                            fileToOpen, sessionFilename);
-    }
-  else
-    {
+  if (cmSystemTools::FileExists(filename.c_str())) {
+    this->MergeProjectFiles(outputDir, projectDir, filename, executable,
+                            cmakeFilePattern, fileToOpen, sessionFilename);
+  } else {
     // add all subdirectories which are cmake build directories to the
     // kdevelop blacklist so they are not monitored for added or removed files
     // since this is handled by adding files to the cmake files
     cmsys::Directory d;
-    if (d.Load(projectDir))
-      {
+    if (d.Load(projectDir)) {
       size_t numf = d.GetNumberOfFiles();
-      for (unsigned int i = 0; i < numf; i++)
-        {
+      for (unsigned int i = 0; i < numf; i++) {
         std::string nextFile = d.GetFile(i);
-        if ((nextFile!=".") && (nextFile!=".."))
-          {
+        if ((nextFile != ".") && (nextFile != "..")) {
           std::string tmp = projectDir;
           tmp += "/";
           tmp += nextFile;
-          if (cmSystemTools::FileIsDirectory(tmp))
-            {
+          if (cmSystemTools::FileIsDirectory(tmp)) {
             tmp += "/CMakeCache.txt";
-            if ((nextFile == "CMakeFiles")
-                || (cmSystemTools::FileExists(tmp.c_str())))
-              {
+            if ((nextFile == "CMakeFiles") ||
+                (cmSystemTools::FileExists(tmp.c_str()))) {
               this->Blacklist.push_back(nextFile);
-              }
             }
           }
         }
       }
-    this->CreateNewProjectFile(outputDir, projectDir, filename,
-                               executable, cmakeFilePattern,
-                               fileToOpen, sessionFilename);
     }
-
+    this->CreateNewProjectFile(outputDir, projectDir, filename, executable,
+                               cmakeFilePattern, fileToOpen, sessionFilename);
+  }
 }
 
-void cmGlobalKdevelopGenerator
-::MergeProjectFiles(const std::string& outputDir,
-                    const std::string& projectDir,
-                    const std::string& filename,
-                    const std::string& executable,
-                    const std::string& cmakeFilePattern,
-                    const std::string& fileToOpen,
-                    const std::string& sessionFilename)
+void cmGlobalKdevelopGenerator::MergeProjectFiles(
+  const std::string& outputDir, const std::string& projectDir,
+  const std::string& filename, const std::string& executable,
+  const std::string& cmakeFilePattern, const std::string& fileToOpen,
+  const std::string& sessionFilename)
 {
   cmsys::ifstream oldProjectFile(filename.c_str());
-  if (!oldProjectFile)
-    {
-    this->CreateNewProjectFile(outputDir, projectDir, filename,
-                               executable, cmakeFilePattern,
-                               fileToOpen, sessionFilename);
+  if (!oldProjectFile) {
+    this->CreateNewProjectFile(outputDir, projectDir, filename, executable,
+                               cmakeFilePattern, fileToOpen, sessionFilename);
     return;
-    }
+  }
 
   /* Read the existing project file (line by line), copy all lines
     into the new project file, except the ones which can be reliably
     set from contents of the CMakeLists.txt */
   std::string tmp;
   std::vector<std::string> lines;
-  while (cmSystemTools::GetLineFromStream(oldProjectFile, tmp))
-    {
+  while (cmSystemTools::GetLineFromStream(oldProjectFile, tmp)) {
     lines.push_back(tmp);
-    }
+  }
   oldProjectFile.close();
 
   cmGeneratedFileStream fout(filename.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
 
-  for (std::vector<std::string>::const_iterator it=lines.begin();
-       it!=lines.end(); it++)
-    {
-    const char* line=(*it).c_str();
+  for (std::vector<std::string>::const_iterator it = lines.begin();
+       it != lines.end(); it++) {
+    const char* line = (*it).c_str();
     // skip these tags as they are always replaced
-    if ((strstr(line, "<projectdirectory>")!=0)
-        || (strstr(line, "<projectmanagement>")!=0)
-        || (strstr(line, "<absoluteprojectpath>")!=0)
-        || (strstr(line, "<filelistdirectory>")!=0)
-        || (strstr(line, "<buildtool>")!=0)
-        || (strstr(line, "<builddir>")!=0))
-      {
+    if ((strstr(line, "<projectdirectory>") != 0) ||
+        (strstr(line, "<projectmanagement>") != 0) ||
+        (strstr(line, "<absoluteprojectpath>") != 0) ||
+        (strstr(line, "<filelistdirectory>") != 0) ||
+        (strstr(line, "<buildtool>") != 0) ||
+        (strstr(line, "<builddir>") != 0)) {
       continue;
-      }
+    }
 
     // output the line from the file if it is not one of the above tags
-    fout<<*it<<"\n";
+    fout << *it << "\n";
     // if this is the <general> tag output the stuff that goes in the
     // general tag
-    if (strstr(line, "<general>"))
-      {
-      fout<< "  <projectmanagement>KDevCustomProject</projectmanagement>\n";
-      fout<< "  <projectdirectory>" <<projectDir
-          << "</projectdirectory>\n";   //this one is important
-      fout<<"  <absoluteprojectpath>true</absoluteprojectpath>\n";
-      //and this one
-      }
+    if (strstr(line, "<general>")) {
+      fout << "  <projectmanagement>KDevCustomProject</projectmanagement>\n";
+      fout << "  <projectdirectory>" << projectDir
+           << "</projectdirectory>\n"; // this one is important
+      fout << "  <absoluteprojectpath>true</absoluteprojectpath>\n";
+      // and this one
+    }
     // inside kdevcustomproject the <filelistdirectory> must be put
-    if (strstr(line, "<kdevcustomproject>"))
-      {
-      fout<<"    <filelistdirectory>"<<outputDir
-          <<"</filelistdirectory>\n";
-      }
+    if (strstr(line, "<kdevcustomproject>")) {
+      fout << "    <filelistdirectory>" << outputDir
+           << "</filelistdirectory>\n";
+    }
     // buildtool and builddir go inside <build>
-    if (strstr(line, "<build>"))
-      {
-      fout<<"      <buildtool>make</buildtool>\n";
-      fout<<"      <builddir>"<<outputDir<<"</builddir>\n";
-      }
+    if (strstr(line, "<build>")) {
+      fout << "      <buildtool>make</buildtool>\n";
+      fout << "      <builddir>" << outputDir << "</builddir>\n";
     }
+  }
 }
 
-void cmGlobalKdevelopGenerator
-::CreateNewProjectFile(const std::string& outputDir,
-                       const std::string& projectDir,
-                       const std::string& filename,
-                       const std::string& executable,
-                       const std::string& cmakeFilePattern,
-                       const std::string& fileToOpen,
-                       const std::string& sessionFilename)
+void cmGlobalKdevelopGenerator::CreateNewProjectFile(
+  const std::string& outputDir, const std::string& projectDir,
+  const std::string& filename, const std::string& executable,
+  const std::string& cmakeFilePattern, const std::string& fileToOpen,
+  const std::string& sessionFilename)
 {
   cmGeneratedFileStream fout(filename.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
   cmXMLWriter xml(fout);
 
   // check for a version control system
   bool hasSvn = cmSystemTools::FileExists((projectDir + "/.svn").c_str());
   bool hasCvs = cmSystemTools::FileExists((projectDir + "/CVS").c_str());
 
-  bool enableCxx = (this->GlobalGenerator->GetLanguageEnabled("C")
-                          || this->GlobalGenerator->GetLanguageEnabled("CXX"));
+  bool enableCxx = (this->GlobalGenerator->GetLanguageEnabled("C") ||
+                    this->GlobalGenerator->GetLanguageEnabled("CXX"));
   bool enableFortran = this->GlobalGenerator->GetLanguageEnabled("Fortran");
   std::string primaryLanguage = "C++";
-  if (enableFortran && !enableCxx)
-    {
-    primaryLanguage="Fortran77";
-    }
+  if (enableFortran && !enableCxx) {
+    primaryLanguage = "Fortran77";
+  }
 
   xml.StartDocument();
   xml.StartElement("kdevelop");
@@ -428,24 +368,19 @@ void cmGlobalKdevelopGenerator
 
   // setup additional languages
   xml.StartElement("secondaryLanguages");
-  if (enableFortran && enableCxx)
-    {
+  if (enableFortran && enableCxx) {
     xml.Element("language", "Fortran");
-    }
-  if (enableCxx)
-    {
+  }
+  if (enableCxx) {
     xml.Element("language", "C");
-    }
+  }
   xml.EndElement();
 
-  if (hasSvn)
-    {
+  if (hasSvn) {
     xml.Element("versioncontrol", "kdevsubversion");
-    }
-  else if (hasCvs)
-    {
+  } else if (hasCvs) {
     xml.Element("versioncontrol", "kdevcvsservice");
-    }
+  }
 
   xml.EndElement(); // general
   xml.StartElement("kdevcustomproject");
@@ -471,8 +406,9 @@ void cmGlobalKdevelopGenerator
   xml.Element("abortonerror", "false");
   xml.Element("numberofjobs", 1);
   xml.Element("dontact", "false");
-  xml.Element("makebin", this->GlobalGenerator->GetLocalGenerators()[0]->
-      GetMakefile()->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"));
+  xml.Element("makebin", this->GlobalGenerator->GetLocalGenerators()[0]
+                           ->GetMakefile()
+                           ->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"));
   xml.Element("selectedenvironment", "default");
 
   xml.StartElement("environments");
@@ -493,12 +429,11 @@ void cmGlobalKdevelopGenerator
   xml.EndElement(); // make
 
   xml.StartElement("blacklist");
-  for(std::vector<std::string>::const_iterator dirIt=this->Blacklist.begin();
-      dirIt != this->Blacklist.end();
-      ++dirIt)
-    {
+  for (std::vector<std::string>::const_iterator dirIt =
+         this->Blacklist.begin();
+       dirIt != this->Blacklist.end(); ++dirIt) {
     xml.Element("path", *dirIt);
-    }
+  }
   xml.EndElement();
 
   xml.EndElement(); // kdevcustomproject
@@ -534,8 +469,7 @@ void cmGlobalKdevelopGenerator
   xml.Element("ignoredevhelp");
   xml.EndElement(); // kdevdoctreeview;
 
-  if (enableCxx)
-    {
+  if (enableCxx) {
     xml.StartElement("cppsupportpart");
     xml.StartElement("filetemplates");
     xml.Element("interfacesuffix", ".h");
@@ -558,10 +492,9 @@ void cmGlobalKdevelopGenerator
     xml.EndElement(); // codecompletion
     xml.Element("references");
     xml.EndElement(); // kdevcppsupport;
-    }
+  }
 
-  if (enableFortran)
-    {
+  if (enableFortran) {
     xml.StartElement("kdevfortransupport");
     xml.StartElement("ftnchek");
     xml.Element("division", "false");
@@ -582,7 +515,7 @@ void cmGlobalKdevelopGenerator
     xml.Element("portabilityonly");
     xml.EndElement(); // ftnchek
     xml.EndElement(); // kdevfortransupport;
-    }
+  }
 
   // set up file groups. maybe this can be used with the CMake SOURCE_GROUP()
   // command
@@ -594,8 +527,7 @@ void cmGlobalKdevelopGenerator
   xml.Attribute("name", "CMake");
   xml.EndElement();
 
-  if (enableCxx)
-    {
+  if (enableCxx) {
     xml.StartElement("group");
     xml.Attribute("pattern", "*.h;*.hxx;*.hpp");
     xml.Attribute("name", "Header");
@@ -610,16 +542,15 @@ void cmGlobalKdevelopGenerator
     xml.Attribute("pattern", "*.cpp;*.C;*.cxx;*.cc");
     xml.Attribute("name", "C++ Sources");
     xml.EndElement();
-    }
+  }
 
-  if (enableFortran)
-    {
+  if (enableFortran) {
     xml.StartElement("group");
     xml.Attribute("pattern",
-        "*.f;*.F;*.f77;*.F77;*.f90;*.F90;*.for;*.f95;*.F95");
+                  "*.f;*.F;*.f77;*.F77;*.f90;*.F90;*.for;*.f95;*.F95");
     xml.Attribute("name", "Fortran Sources");
     xml.EndElement();
-    }
+  }
 
   xml.StartElement("group");
   xml.Attribute("pattern", "*.ui");
@@ -638,18 +569,16 @@ void cmGlobalKdevelopGenerator
   xml.EndElement(); // kdevelop;
   xml.EndDocument();
 
-  if (sessionFilename.empty())
-    {
+  if (sessionFilename.empty()) {
     return;
-    }
+  }
 
   // and a session file, so that kdevelop opens a file if it opens the
   // project the first time
   cmGeneratedFileStream devses(sessionFilename.c_str());
-  if(!devses)
-    {
+  if (!devses) {
     return;
-    }
+  }
   cmXMLWriter sesxml(devses);
   sesxml.StartDocument("UTF-8");
   sesxml.Doctype("KDevPrjSession");
diff --git a/Source/cmGlobalKdevelopGenerator.h b/Source/cmGlobalKdevelopGenerator.h
index 0d59fc5..315e38e 100644
--- a/Source/cmGlobalKdevelopGenerator.h
+++ b/Source/cmGlobalKdevelopGenerator.h
@@ -34,15 +34,20 @@ public:
   cmGlobalKdevelopGenerator();
 
   virtual std::string GetName() const
-                          { return cmGlobalKdevelopGenerator::GetActualName();}
-  static std::string GetActualName()                     { return "KDevelop3";}
+  {
+    return cmGlobalKdevelopGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "KDevelop3"; }
   static cmExternalMakefileProjectGenerator* New()
-                                      { return new cmGlobalKdevelopGenerator; }
+  {
+    return new cmGlobalKdevelopGenerator;
+  }
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const std::string& fullName) const;
 
   virtual void Generate();
+
 private:
   /*** Create the foo.kdevelop.filelist file, return false if it doesn't
     succeed.  If the file already exists the contents will be merged.
diff --git a/Source/cmGlobalMSYSMakefileGenerator.cxx b/Source/cmGlobalMSYSMakefileGenerator.cxx
index 88eb4f3..6bf178a 100644
--- a/Source/cmGlobalMSYSMakefileGenerator.cxx
+++ b/Source/cmGlobalMSYSMakefileGenerator.cxx
@@ -26,8 +26,8 @@ cmGlobalMSYSMakefileGenerator::cmGlobalMSYSMakefileGenerator(cmake* cm)
   cm->GetState()->SetMSYSShell(true);
 }
 
-std::string
-cmGlobalMSYSMakefileGenerator::FindMinGW(std::string const& makeloc)
+std::string cmGlobalMSYSMakefileGenerator::FindMinGW(
+  std::string const& makeloc)
 {
   std::string fstab = makeloc;
   fstab += "/../etc/fstab";
@@ -35,23 +35,19 @@ cmGlobalMSYSMakefileGenerator::FindMinGW(std::string const& makeloc)
   std::string path;
   std::string mount;
   std::string mingwBin;
-  while(fin)
-    {
+  while (fin) {
     fin >> path;
     fin >> mount;
-    if(mount == "/mingw")
-      {
+    if (mount == "/mingw") {
       mingwBin = path;
       mingwBin += "/bin";
-      }
     }
+  }
   return mingwBin;
 }
 
-void cmGlobalMSYSMakefileGenerator
-::EnableLanguage(std::vector<std::string>const& l,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalMSYSMakefileGenerator::EnableLanguage(
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   this->FindMakeProgram(mf);
   std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
@@ -63,40 +59,35 @@ void cmGlobalMSYSMakefileGenerator
   locations.push_back("c:/mingw/bin");
   std::string tgcc = cmSystemTools::FindProgram("gcc", locations);
   std::string gcc = "gcc.exe";
-  if(!tgcc.empty())
-    {
+  if (!tgcc.empty()) {
     gcc = tgcc;
-    }
+  }
   std::string tgxx = cmSystemTools::FindProgram("g++", locations);
   std::string gxx = "g++.exe";
-  if(!tgxx.empty())
-    {
+  if (!tgxx.empty()) {
     gxx = tgxx;
-    }
+  }
   std::string trc = cmSystemTools::FindProgram("windres", locations);
   std::string rc = "windres.exe";
-  if(!trc.empty())
-    {
+  if (!trc.empty()) {
     rc = trc;
-    }
+  }
   mf->AddDefinition("MSYS", "1");
   mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str());
   mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str());
   mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str());
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
 
-  if(!mf->IsSet("CMAKE_AR") &&
-      !this->CMakeInstance->GetIsInTryCompile() &&
-      !(1==l.size() && l[0]=="NONE"))
-    {
-    cmSystemTools::Error
-      ("CMAKE_AR was not found, please set to archive program. ",
-       mf->GetDefinition("CMAKE_AR"));
-    }
+  if (!mf->IsSet("CMAKE_AR") && !this->CMakeInstance->GetIsInTryCompile() &&
+      !(1 == l.size() && l[0] == "NONE")) {
+    cmSystemTools::Error(
+      "CMAKE_AR was not found, please set to archive program. ",
+      mf->GetDefinition("CMAKE_AR"));
+  }
 }
 
-void cmGlobalMSYSMakefileGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalMSYSMakefileGenerator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalMSYSMakefileGenerator::GetActualName();
   entry.Brief = "Generates MSYS makefiles.";
diff --git a/Source/cmGlobalMSYSMakefileGenerator.h b/Source/cmGlobalMSYSMakefileGenerator.h
index 2cefc97..d687d19 100644
--- a/Source/cmGlobalMSYSMakefileGenerator.h
+++ b/Source/cmGlobalMSYSMakefileGenerator.h
@@ -23,14 +23,17 @@ class cmGlobalMSYSMakefileGenerator : public cmGlobalUnixMakefileGenerator3
 {
 public:
   cmGlobalMSYSMakefileGenerator(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalMSYSMakefileGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<cmGlobalMSYSMakefileGenerator>();
+  }
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalMSYSMakefileGenerator::GetActualName();}
-  static std::string GetActualName() {return "MSYS Makefiles";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalMSYSMakefileGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "MSYS Makefiles"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
@@ -39,8 +42,8 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 
 private:
   std::string FindMinGW(std::string const& makeloc);
diff --git a/Source/cmGlobalMinGWMakefileGenerator.cxx b/Source/cmGlobalMinGWMakefileGenerator.cxx
index fab9eda..05f1b36 100644
--- a/Source/cmGlobalMinGWMakefileGenerator.cxx
+++ b/Source/cmGlobalMinGWMakefileGenerator.cxx
@@ -25,10 +25,8 @@ cmGlobalMinGWMakefileGenerator::cmGlobalMinGWMakefileGenerator(cmake* cm)
   cm->GetState()->SetMinGWMake(true);
 }
 
-void cmGlobalMinGWMakefileGenerator
-::EnableLanguage(std::vector<std::string>const& l,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalMinGWMakefileGenerator::EnableLanguage(
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   this->FindMakeProgram(mf);
   std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
@@ -38,30 +36,27 @@ void cmGlobalMinGWMakefileGenerator
   locations.push_back("c:/mingw/bin");
   std::string tgcc = cmSystemTools::FindProgram("gcc", locations);
   std::string gcc = "gcc.exe";
-  if(!tgcc.empty())
-    {
+  if (!tgcc.empty()) {
     gcc = tgcc;
-    }
+  }
   std::string tgxx = cmSystemTools::FindProgram("g++", locations);
   std::string gxx = "g++.exe";
-  if(!tgxx.empty())
-    {
+  if (!tgxx.empty()) {
     gxx = tgxx;
-    }
+  }
   std::string trc = cmSystemTools::FindProgram("windres", locations);
   std::string rc = "windres.exe";
-  if(!trc.empty())
-    {
+  if (!trc.empty()) {
     rc = trc;
-    }
+  }
   mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str());
   mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str());
   mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str());
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
 }
 
-void cmGlobalMinGWMakefileGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalMinGWMakefileGenerator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalMinGWMakefileGenerator::GetActualName();
   entry.Brief = "Generates a make file for use with mingw32-make.";
diff --git a/Source/cmGlobalMinGWMakefileGenerator.h b/Source/cmGlobalMinGWMakefileGenerator.h
index 3b00126..90cfde7 100644
--- a/Source/cmGlobalMinGWMakefileGenerator.h
+++ b/Source/cmGlobalMinGWMakefileGenerator.h
@@ -23,13 +23,17 @@ class cmGlobalMinGWMakefileGenerator : public cmGlobalUnixMakefileGenerator3
 {
 public:
   cmGlobalMinGWMakefileGenerator(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalMinGWMakefileGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<
+      cmGlobalMinGWMakefileGenerator>();
+  }
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalMinGWMakefileGenerator::GetActualName();}
-  static std::string GetActualName() {return "MinGW Makefiles";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalMinGWMakefileGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "MinGW Makefiles"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
@@ -38,8 +42,8 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 };
 
 #endif
diff --git a/Source/cmGlobalNMakeMakefileGenerator.cxx b/Source/cmGlobalNMakeMakefileGenerator.cxx
index 6080f96..605a773 100644
--- a/Source/cmGlobalNMakeMakefileGenerator.cxx
+++ b/Source/cmGlobalNMakeMakefileGenerator.cxx
@@ -29,10 +29,8 @@ cmGlobalNMakeMakefileGenerator::cmGlobalNMakeMakefileGenerator(cmake* cm)
   this->MakeSilentFlag = "/nologo";
 }
 
-void cmGlobalNMakeMakefileGenerator
-::EnableLanguage(std::vector<std::string>const& l,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalNMakeMakefileGenerator::EnableLanguage(
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   // pick a default
   mf->AddDefinition("CMAKE_GENERATOR_CC", "cl");
@@ -40,19 +38,17 @@ void cmGlobalNMakeMakefileGenerator
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
 }
 
-void cmGlobalNMakeMakefileGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalNMakeMakefileGenerator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalNMakeMakefileGenerator::GetActualName();
   entry.Brief = "Generates NMake makefiles.";
 }
 
-void cmGlobalNMakeMakefileGenerator::PrintCompilerAdvice(std::ostream& os,
-                                                  std::string const& lang,
-                                                  const char* envVar) const
+void cmGlobalNMakeMakefileGenerator::PrintCompilerAdvice(
+  std::ostream& os, std::string const& lang, const char* envVar) const
 {
-  if(lang == "CXX" || lang == "C")
-    {
+  if (lang == "CXX" || lang == "C") {
     /* clang-format off */
     os <<
       "To use the NMake generator with Visual C++, cmake must be run from a "
@@ -60,6 +56,6 @@ void cmGlobalNMakeMakefileGenerator::PrintCompilerAdvice(std::ostream& os,
       "environment is unable to invoke the cl compiler. To fix this problem, "
       "run cmake from the Visual Studio Command Prompt (vcvarsall.bat).\n";
     /* clang-format on */
-    }
+  }
   this->cmGlobalUnixMakefileGenerator3::PrintCompilerAdvice(os, lang, envVar);
 }
diff --git a/Source/cmGlobalNMakeMakefileGenerator.h b/Source/cmGlobalNMakeMakefileGenerator.h
index 3c8375a..3ab684e 100644
--- a/Source/cmGlobalNMakeMakefileGenerator.h
+++ b/Source/cmGlobalNMakeMakefileGenerator.h
@@ -23,13 +23,17 @@ class cmGlobalNMakeMakefileGenerator : public cmGlobalUnixMakefileGenerator3
 {
 public:
   cmGlobalNMakeMakefileGenerator(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalNMakeMakefileGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<
+      cmGlobalNMakeMakefileGenerator>();
+  }
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalNMakeMakefileGenerator::GetActualName();}
-  static std::string GetActualName() {return "NMake Makefiles";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalNMakeMakefileGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "NMake Makefiles"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
@@ -38,8 +42,9 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
+
 private:
   void PrintCompilerAdvice(std::ostream& os, std::string const& lang,
                            const char* envVar) const;
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index 6f631e5..012ef90 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -30,15 +30,14 @@ const char* cmGlobalNinjaGenerator::INDENT = "  ";
 
 void cmGlobalNinjaGenerator::Indent(std::ostream& os, int count)
 {
-  for(int i = 0; i < count; ++i)
+  for (int i = 0; i < count; ++i)
     os << cmGlobalNinjaGenerator::INDENT;
 }
 
 void cmGlobalNinjaGenerator::WriteDivider(std::ostream& os)
 {
-  os
-    << "# ======================================"
-    << "=======================================\n";
+  os << "# ======================================"
+     << "=======================================\n";
 }
 
 void cmGlobalNinjaGenerator::WriteComment(std::ostream& os,
@@ -51,11 +50,10 @@ void cmGlobalNinjaGenerator::WriteComment(std::ostream& os,
   std::string::size_type lpos = 0;
   std::string::size_type rpos;
   os << "\n#############################################\n";
-  while((rpos = replace.find('\n', lpos)) != std::string::npos)
-    {
+  while ((rpos = replace.find('\n', lpos)) != std::string::npos) {
     os << "# " << replace.substr(lpos, rpos - lpos) << "\n";
     lpos = rpos + 1;
-    }
+  }
   os << "# " << replace.substr(lpos) << "\n\n";
 }
 
@@ -64,35 +62,29 @@ std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name)
   // Ninja rule names must match "[a-zA-Z0-9_.-]+".  Use ".xx" to encode
   // "." and all invalid characters as hexadecimal.
   std::string encoded;
-  for (std::string::const_iterator i = name.begin();
-       i != name.end(); ++i)
-    {
-    if (isalnum(*i) || *i == '_' || *i == '-')
-      {
+  for (std::string::const_iterator i = name.begin(); i != name.end(); ++i) {
+    if (isalnum(*i) || *i == '_' || *i == '-') {
       encoded += *i;
-      }
-    else
-      {
+    } else {
       char buf[16];
       sprintf(buf, ".%02x", static_cast<unsigned int>(*i));
       encoded += buf;
-      }
     }
+  }
   return encoded;
 }
 
 static bool IsIdentChar(char c)
 {
-  return
-    ('a' <= c && c <= 'z') ||
-    ('+' <= c && c <= '9') ||  // +,-./ and numbers
-    ('A' <= c && c <= 'Z') ||
-    (c == '_') || (c == '$') || (c == '\\') ||
+  return ('a' <= c && c <= 'z') ||
+    ('+' <= c && c <= '9') || // +,-./ and numbers
+    ('A' <= c && c <= 'Z') || (c == '_') || (c == '$') || (c == '\\') ||
     (c == ' ') || (c == ':');
 }
 
-std::string cmGlobalNinjaGenerator::EncodeIdent(const std::string &ident,
-                                                std::ostream &vars) {
+std::string cmGlobalNinjaGenerator::EncodeIdent(const std::string& ident,
+                                                std::ostream& vars)
+{
   if (std::find_if(ident.begin(), ident.end(),
                    std::not1(std::ptr_fun(IsIdentChar))) != ident.end()) {
     static unsigned VarNum = 0;
@@ -108,7 +100,7 @@ std::string cmGlobalNinjaGenerator::EncodeIdent(const std::string &ident,
   }
 }
 
-std::string cmGlobalNinjaGenerator::EncodeLiteral(const std::string &lit)
+std::string cmGlobalNinjaGenerator::EncodeLiteral(const std::string& lit)
 {
   std::string result = lit;
   cmSystemTools::ReplaceString(result, "$", "$$");
@@ -116,7 +108,7 @@ std::string cmGlobalNinjaGenerator::EncodeLiteral(const std::string &lit)
   return result;
 }
 
-std::string cmGlobalNinjaGenerator::EncodePath(const std::string &path)
+std::string cmGlobalNinjaGenerator::EncodePath(const std::string& path)
 {
   std::string result = path;
 #ifdef _WIN32
@@ -128,42 +120,35 @@ std::string cmGlobalNinjaGenerator::EncodePath(const std::string &path)
   return EncodeLiteral(result);
 }
 
-std::string cmGlobalNinjaGenerator::EncodeDepfileSpace(const std::string &path)
+std::string cmGlobalNinjaGenerator::EncodeDepfileSpace(const std::string& path)
 {
   std::string result = path;
   cmSystemTools::ReplaceString(result, " ", "\\ ");
   return result;
 }
 
-void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
-                                        const std::string& comment,
-                                        const std::string& rule,
-                                        const cmNinjaDeps& outputs,
-                                        const cmNinjaDeps& explicitDeps,
-                                        const cmNinjaDeps& implicitDeps,
-                                        const cmNinjaDeps& orderOnlyDeps,
-                                        const cmNinjaVars& variables,
-                                        const std::string& rspfile,
-                                        int cmdLineLimit,
-                                        bool* usedResponseFile)
+void cmGlobalNinjaGenerator::WriteBuild(
+  std::ostream& os, const std::string& comment, const std::string& rule,
+  const cmNinjaDeps& outputs, const cmNinjaDeps& explicitDeps,
+  const cmNinjaDeps& implicitDeps, const cmNinjaDeps& orderOnlyDeps,
+  const cmNinjaVars& variables, const std::string& rspfile, int cmdLineLimit,
+  bool* usedResponseFile)
 {
   // Make sure there is a rule.
-  if(rule.empty())
-    {
+  if (rule.empty()) {
     cmSystemTools::Error("No rule for WriteBuildStatement! called "
                          "with comment: ",
                          comment.c_str());
     return;
-    }
+  }
 
   // Make sure there is at least one output file.
-  if(outputs.empty())
-    {
+  if (outputs.empty()) {
     cmSystemTools::Error("No output files for WriteBuildStatement! called "
                          "with comment: ",
                          comment.c_str());
     return;
-    }
+  }
 
   cmGlobalNinjaGenerator::WriteComment(os, comment);
 
@@ -172,32 +157,26 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
   // TODO: Better formatting for when there are multiple input/output files.
 
   // Write explicit dependencies.
-  for(cmNinjaDeps::const_iterator i = explicitDeps.begin();
-      i != explicitDeps.end();
-      ++i)
-    {
+  for (cmNinjaDeps::const_iterator i = explicitDeps.begin();
+       i != explicitDeps.end(); ++i) {
     arguments += " " + EncodeIdent(EncodePath(*i), os);
-    }
+  }
 
   // Write implicit dependencies.
-  if(!implicitDeps.empty())
-    {
+  if (!implicitDeps.empty()) {
     arguments += " |";
-    for(cmNinjaDeps::const_iterator i = implicitDeps.begin();
-        i != implicitDeps.end();
-        ++i)
+    for (cmNinjaDeps::const_iterator i = implicitDeps.begin();
+         i != implicitDeps.end(); ++i)
       arguments += " " + EncodeIdent(EncodePath(*i), os);
-    }
+  }
 
   // Write order-only dependencies.
-  if(!orderOnlyDeps.empty())
-    {
+  if (!orderOnlyDeps.empty()) {
     arguments += " ||";
-    for(cmNinjaDeps::const_iterator i = orderOnlyDeps.begin();
-        i != orderOnlyDeps.end();
-        ++i)
+    for (cmNinjaDeps::const_iterator i = orderOnlyDeps.begin();
+         i != orderOnlyDeps.end(); ++i)
       arguments += " " + EncodeIdent(EncodePath(*i), os);
-    }
+  }
 
   arguments += "\n";
 
@@ -205,15 +184,13 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
 
   // Write outputs files.
   build += "build";
-  for(cmNinjaDeps::const_iterator i = outputs.begin();
-      i != outputs.end(); ++i)
-    {
+  for (cmNinjaDeps::const_iterator i = outputs.begin(); i != outputs.end();
+       ++i) {
     build += " " + EncodeIdent(EncodePath(*i), os);
-    if (this->ComputingUnknownDependencies)
-      {
-      this->CombinedBuildOutputs.insert( EncodePath(*i) );
-      }
+    if (this->ComputingUnknownDependencies) {
+      this->CombinedBuildOutputs.insert(EncodePath(*i));
     }
+  }
   build += ":";
 
   // Write the rule.
@@ -221,10 +198,10 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
 
   // Write the variables bound to this build statement.
   std::ostringstream variable_assignments;
-  for(cmNinjaVars::const_iterator i = variables.begin();
-      i != variables.end(); ++i)
-    cmGlobalNinjaGenerator::WriteVariable(variable_assignments,
-                                          i->first, i->second, "", 1);
+  for (cmNinjaVars::const_iterator i = variables.begin(); i != variables.end();
+       ++i)
+    cmGlobalNinjaGenerator::WriteVariable(variable_assignments, i->first,
+                                          i->second, "", 1);
 
   // check if a response file rule should be used
   std::string buildstr = build;
@@ -233,45 +210,33 @@ void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
   bool useResponseFile = false;
   if (cmdLineLimit < 0 ||
       (cmdLineLimit > 0 &&
-       (args.size() + buildstr.size() + assignments.size())
-       > static_cast<size_t>(cmdLineLimit))) {
+       (args.size() + buildstr.size() + assignments.size()) >
+         static_cast<size_t>(cmdLineLimit))) {
     variable_assignments.str(std::string());
-    cmGlobalNinjaGenerator::WriteVariable(variable_assignments,
-                                          "RSP_FILE", rspfile, "", 1);
+    cmGlobalNinjaGenerator::WriteVariable(variable_assignments, "RSP_FILE",
+                                          rspfile, "", 1);
     assignments += variable_assignments.str();
     useResponseFile = true;
   }
-  if (usedResponseFile)
-    {
+  if (usedResponseFile) {
     *usedResponseFile = useResponseFile;
-    }
+  }
 
   os << buildstr << args << assignments;
 }
 
-void cmGlobalNinjaGenerator::WritePhonyBuild(std::ostream& os,
-                                             const std::string& comment,
-                                             const cmNinjaDeps& outputs,
-                                             const cmNinjaDeps& explicitDeps,
-                                             const cmNinjaDeps& implicitDeps,
-                                             const cmNinjaDeps& orderOnlyDeps,
-                                             const cmNinjaVars& variables)
+void cmGlobalNinjaGenerator::WritePhonyBuild(
+  std::ostream& os, const std::string& comment, const cmNinjaDeps& outputs,
+  const cmNinjaDeps& explicitDeps, const cmNinjaDeps& implicitDeps,
+  const cmNinjaDeps& orderOnlyDeps, const cmNinjaVars& variables)
 {
-  this->WriteBuild(os,
-                   comment,
-                   "phony",
-                   outputs,
-                   explicitDeps,
-                   implicitDeps,
-                   orderOnlyDeps,
-                   variables);
+  this->WriteBuild(os, comment, "phony", outputs, explicitDeps, implicitDeps,
+                   orderOnlyDeps, variables);
 }
 
 void cmGlobalNinjaGenerator::AddCustomCommandRule()
 {
-  this->AddRule("CUSTOM_COMMAND",
-                "$COMMAND",
-                "$DESC",
+  this->AddRule("CUSTOM_COMMAND", "$COMMAND", "$DESC",
                 "Rule for running custom commands.",
                 /*depfile*/ "",
                 /*deptype*/ "",
@@ -281,21 +246,17 @@ void cmGlobalNinjaGenerator::AddCustomCommandRule()
                 /*generator*/ false);
 }
 
-void
-cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command,
-                                                const std::string& description,
-                                                const std::string& comment,
-                                                bool uses_terminal,
-                                                bool restat,
-                                                const cmNinjaDeps& outputs,
-                                                const cmNinjaDeps& deps,
-                                                const cmNinjaDeps& orderOnly)
+void cmGlobalNinjaGenerator::WriteCustomCommandBuild(
+  const std::string& command, const std::string& description,
+  const std::string& comment, bool uses_terminal, bool restat,
+  const cmNinjaDeps& outputs, const cmNinjaDeps& deps,
+  const cmNinjaDeps& orderOnly)
 {
   std::string cmd = command;
 #ifdef _WIN32
-   if (cmd.empty())
-      // TODO Shouldn't an empty command be handled by ninja?
-      cmd = "cmd.exe /c";
+  if (cmd.empty())
+    // TODO Shouldn't an empty command be handled by ninja?
+    cmd = "cmd.exe /c";
 #endif
 
   this->AddCustomCommandRule();
@@ -303,48 +264,35 @@ cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command,
   cmNinjaVars vars;
   vars["COMMAND"] = cmd;
   vars["DESC"] = EncodeLiteral(description);
-  if (restat)
-    {
+  if (restat) {
     vars["restat"] = "1";
-    }
-  if (uses_terminal && SupportsConsolePool())
-    {
+  }
+  if (uses_terminal && SupportsConsolePool()) {
     vars["pool"] = "console";
-    }
+  }
 
-  this->WriteBuild(*this->BuildFileStream,
-                   comment,
-                   "CUSTOM_COMMAND",
-                   outputs,
-                   deps,
-                   cmNinjaDeps(),
-                   orderOnly,
-                   vars);
-
-  if (this->ComputingUnknownDependencies)
-    {
-    //we need to track every dependency that comes in, since we are trying
-    //to find dependencies that are side effects of build commands
-    for(cmNinjaDeps::const_iterator i = deps.begin(); i != deps.end(); ++i)
-      {
+  this->WriteBuild(*this->BuildFileStream, comment, "CUSTOM_COMMAND", outputs,
+                   deps, cmNinjaDeps(), orderOnly, vars);
+
+  if (this->ComputingUnknownDependencies) {
+    // we need to track every dependency that comes in, since we are trying
+    // to find dependencies that are side effects of build commands
+    for (cmNinjaDeps::const_iterator i = deps.begin(); i != deps.end(); ++i) {
       this->CombinedCustomCommandExplicitDependencies.insert(EncodePath(*i));
-      }
     }
+  }
 }
 
-void
-cmGlobalNinjaGenerator::AddMacOSXContentRule()
+void cmGlobalNinjaGenerator::AddMacOSXContentRule()
 {
-  cmLocalGenerator *lg = this->LocalGenerators[0];
+  cmLocalGenerator* lg = this->LocalGenerators[0];
 
   std::ostringstream cmd;
   cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(),
                                    cmLocalGenerator::SHELL)
       << " -E copy $in $out";
 
-  this->AddRule("COPY_OSX_CONTENT",
-                cmd.str(),
-                "Copying OS X Content $out",
+  this->AddRule("COPY_OSX_CONTENT", cmd.str(), "Copying OS X Content $out",
                 "Rule for copying OS X bundle content file.",
                 /*depfile*/ "",
                 /*deptype*/ "",
@@ -354,9 +302,8 @@ cmGlobalNinjaGenerator::AddMacOSXContentRule()
                 /*generator*/ false);
 }
 
-void
-cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input,
-                                                const std::string& output)
+void cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input,
+                                                     const std::string& output)
 {
   this->AddMacOSXContentRule();
 
@@ -366,45 +313,32 @@ cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input,
   deps.push_back(input);
   cmNinjaVars vars;
 
-  this->WriteBuild(*this->BuildFileStream,
-                   "",
-                   "COPY_OSX_CONTENT",
-                   outputs,
-                   deps,
-                   cmNinjaDeps(),
-                   cmNinjaDeps(),
-                   cmNinjaVars());
+  this->WriteBuild(*this->BuildFileStream, "", "COPY_OSX_CONTENT", outputs,
+                   deps, cmNinjaDeps(), cmNinjaDeps(), cmNinjaVars());
 }
 
-void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
-                                       const std::string& name,
-                                       const std::string& command,
-                                       const std::string& description,
-                                       const std::string& comment,
-                                       const std::string& depfile,
-                                       const std::string& deptype,
-                                       const std::string& rspfile,
-                                       const std::string& rspcontent,
-                                       const std::string& restat,
-                                       bool generator)
+void cmGlobalNinjaGenerator::WriteRule(
+  std::ostream& os, const std::string& name, const std::string& command,
+  const std::string& description, const std::string& comment,
+  const std::string& depfile, const std::string& deptype,
+  const std::string& rspfile, const std::string& rspcontent,
+  const std::string& restat, bool generator)
 {
   // Make sure the rule has a name.
-  if(name.empty())
-    {
+  if (name.empty()) {
     cmSystemTools::Error("No name given for WriteRuleStatement! called "
                          "with comment: ",
                          comment.c_str());
     return;
-    }
+  }
 
   // Make sure a command is given.
-  if(command.empty())
-    {
+  if (command.empty()) {
     cmSystemTools::Error("No command given for WriteRuleStatement! called "
                          "with comment: ",
                          comment.c_str());
     return;
-    }
+  }
 
   cmGlobalNinjaGenerator::WriteComment(os, comment);
 
@@ -412,54 +346,47 @@ void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
   os << "rule " << name << "\n";
 
   // Write the depfile if any.
-  if(!depfile.empty())
-    {
+  if (!depfile.empty()) {
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "depfile = " << depfile << "\n";
-    }
+  }
 
   // Write the deptype if any.
-  if (!deptype.empty())
-    {
+  if (!deptype.empty()) {
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "deps = " << deptype << "\n";
-    }
+  }
 
   // Write the command.
   cmGlobalNinjaGenerator::Indent(os, 1);
   os << "command = " << command << "\n";
 
   // Write the description if any.
-  if(!description.empty())
-    {
+  if (!description.empty()) {
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "description = " << description << "\n";
-    }
+  }
 
-  if(!rspfile.empty())
-    {
-    if (rspcontent.empty())
-      {
+  if (!rspfile.empty()) {
+    if (rspcontent.empty()) {
       cmSystemTools::Error("No rspfile_content given!", comment.c_str());
       return;
-      }
+    }
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "rspfile = " << rspfile << "\n";
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "rspfile_content = " << rspcontent << "\n";
-    }
+  }
 
-  if(!restat.empty())
-    {
+  if (!restat.empty()) {
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "restat = " << restat << "\n";
-    }
+  }
 
-  if(generator)
-    {
+  if (generator) {
     cmGlobalNinjaGenerator::Indent(os, 1);
     os << "generator = 1\n";
-    }
+  }
 
   os << "\n";
 }
@@ -471,20 +398,18 @@ void cmGlobalNinjaGenerator::WriteVariable(std::ostream& os,
                                            int indent)
 {
   // Make sure we have a name.
-  if(name.empty())
-    {
+  if (name.empty()) {
     cmSystemTools::Error("No name given for WriteVariable! called "
                          "with comment: ",
                          comment.c_str());
     return;
-    }
+  }
 
   // Do not add a variable if the value is empty.
   std::string val = cmSystemTools::TrimWhitespace(value);
-  if(val.empty())
-    {
+  if (val.empty()) {
     return;
-    }
+  }
 
   cmGlobalNinjaGenerator::WriteComment(os, comment);
   cmGlobalNinjaGenerator::Indent(os, indent);
@@ -505,12 +430,12 @@ void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os,
 {
   cmGlobalNinjaGenerator::WriteComment(os, comment);
   os << "default";
-  for(cmNinjaDeps::const_iterator i = targets.begin(); i != targets.end(); ++i)
+  for (cmNinjaDeps::const_iterator i = targets.begin(); i != targets.end();
+       ++i)
     os << " " << *i;
   os << "\n";
 }
 
-
 cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
   : cmGlobalCommonGenerator(cm)
   , BuildFileStream(0)
@@ -530,17 +455,14 @@ cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm)
   this->FindMakeProgramFile = "CMakeNinjaFindMake.cmake";
 }
 
-
 // Virtual public methods.
 
-cmLocalGenerator*
-cmGlobalNinjaGenerator::CreateLocalGenerator(cmMakefile* mf)
+cmLocalGenerator* cmGlobalNinjaGenerator::CreateLocalGenerator(cmMakefile* mf)
 {
   return new cmLocalNinjaGenerator(this, mf);
 }
 
-void cmGlobalNinjaGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalNinjaGenerator::GetDocumentation(cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalNinjaGenerator::GetActualName();
   entry.Brief = "Generates build.ninja files.";
@@ -555,21 +477,20 @@ void cmGlobalNinjaGenerator::Generate()
   // Check minimum Ninja version.
   if (cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
                                     this->NinjaVersion.c_str(),
-                                    RequiredNinjaVersion().c_str()))
-    {
+                                    RequiredNinjaVersion().c_str())) {
     std::ostringstream msg;
     msg << "The detected version of Ninja (" << this->NinjaVersion;
     msg << ") is less than the version of Ninja required by CMake (";
     msg << this->RequiredNinjaVersion() << ").";
     this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, msg.str());
     return;
-    }
+  }
   this->OpenBuildFileStream();
   this->OpenRulesFileStream();
 
   this->PolicyCMP0058 =
-    this->LocalGenerators[0]->GetMakefile()
-    ->GetPolicyStatus(cmPolicies::CMP0058);
+    this->LocalGenerators[0]->GetMakefile()->GetPolicyStatus(
+      cmPolicies::CMP0058);
   this->ComputingUnknownDependencies =
     (this->PolicyCMP0058 == cmPolicies::OLD ||
      this->PolicyCMP0058 == cmPolicies::WARN);
@@ -595,48 +516,40 @@ void cmGlobalNinjaGenerator::Generate()
 void cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf)
 {
   this->cmGlobalGenerator::FindMakeProgram(mf);
-  if (const char* ninjaCommand = mf->GetDefinition("CMAKE_MAKE_PROGRAM"))
-    {
+  if (const char* ninjaCommand = mf->GetDefinition("CMAKE_MAKE_PROGRAM")) {
     this->NinjaCommand = ninjaCommand;
     std::vector<std::string> command;
     command.push_back(this->NinjaCommand);
     command.push_back("--version");
     std::string version;
-    cmSystemTools::RunSingleCommand(command,
-                                    &version, 0, 0, 0,
+    cmSystemTools::RunSingleCommand(command, &version, 0, 0, 0,
                                     cmSystemTools::OUTPUT_NONE);
     this->NinjaVersion = cmSystemTools::TrimWhitespace(version);
-    }
+  }
 }
 
-void cmGlobalNinjaGenerator
-::EnableLanguage(std::vector<std::string>const& langs,
-                 cmMakefile* mf,
-                 bool optional)
+void cmGlobalNinjaGenerator::EnableLanguage(
+  std::vector<std::string> const& langs, cmMakefile* mf, bool optional)
 {
-  if (std::find(langs.begin(), langs.end(), "Fortran") != langs.end())
-    {
+  if (std::find(langs.begin(), langs.end(), "Fortran") != langs.end()) {
     cmSystemTools::Error("The Ninja generator does not support Fortran yet.");
-    }
+  }
   this->cmGlobalGenerator::EnableLanguage(langs, mf, optional);
-  for(std::vector<std::string>::const_iterator l = langs.begin();
-      l != langs.end(); ++l)
-    {
-    if(*l == "NONE")
-      {
+  for (std::vector<std::string>::const_iterator l = langs.begin();
+       l != langs.end(); ++l) {
+    if (*l == "NONE") {
       continue;
-      }
-    this->ResolveLanguageCompiler(*l, mf, optional);
     }
+    this->ResolveLanguageCompiler(*l, mf, optional);
+  }
 #ifdef _WIN32
   if (mf->IsOn("CMAKE_COMPILER_IS_MINGW") ||
       strcmp(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID"), "GNU") == 0 ||
       strcmp(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID"), "GNU") == 0 ||
       strcmp(mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID"), "GNU") == 0 ||
-      strcmp(mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID"), "GNU") == 0)
-    {
+      strcmp(mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID"), "GNU") == 0) {
     this->UsingGCCOnWindows = true;
-    }
+  }
 #endif
 }
 
@@ -648,78 +561,53 @@ void cmGlobalNinjaGenerator
 //   cmGlobalXCodeGenerator
 // Called by:
 //   cmGlobalGenerator::Build()
-void cmGlobalNinjaGenerator
-::GenerateBuildCommand(std::vector<std::string>& makeCommand,
-                       const std::string& makeProgram,
-                       const std::string& /*projectName*/,
-                       const std::string& /*projectDir*/,
-                       const std::string& targetName,
-                       const std::string& /*config*/,
-                       bool /*fast*/,
-                       bool verbose,
-                       std::vector<std::string> const& makeOptions)
+void cmGlobalNinjaGenerator::GenerateBuildCommand(
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& /*projectName*/, const std::string& /*projectDir*/,
+  const std::string& targetName, const std::string& /*config*/, bool /*fast*/,
+  bool verbose, std::vector<std::string> const& makeOptions)
 {
-  makeCommand.push_back(
-    this->SelectMakeProgram(makeProgram)
-    );
+  makeCommand.push_back(this->SelectMakeProgram(makeProgram));
 
-  if(verbose)
-    {
+  if (verbose) {
     makeCommand.push_back("-v");
-    }
+  }
 
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
-  if(!targetName.empty())
-    {
-    if(targetName == "clean")
-      {
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
+  if (!targetName.empty()) {
+    if (targetName == "clean") {
       makeCommand.push_back("-t");
       makeCommand.push_back("clean");
-      }
-    else
-      {
+    } else {
       makeCommand.push_back(targetName);
-      }
     }
+  }
 }
 
 // Non-virtual public methods.
 
-void cmGlobalNinjaGenerator::AddRule(const std::string& name,
-                                     const std::string& command,
-                                     const std::string& description,
-                                     const std::string& comment,
-                                     const std::string& depfile,
-                                     const std::string& deptype,
-                                     const std::string& rspfile,
-                                     const std::string& rspcontent,
-                                     const std::string& restat,
-                                     bool generator)
+void cmGlobalNinjaGenerator::AddRule(
+  const std::string& name, const std::string& command,
+  const std::string& description, const std::string& comment,
+  const std::string& depfile, const std::string& deptype,
+  const std::string& rspfile, const std::string& rspcontent,
+  const std::string& restat, bool generator)
 {
   // Do not add the same rule twice.
-  if (this->HasRule(name))
-    {
+  if (this->HasRule(name)) {
     return;
-    }
+  }
 
   this->Rules.insert(name);
-  cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream,
-                                    name,
-                                    command,
-                                    description,
-                                    comment,
-                                    depfile,
-                                    deptype,
-                                    rspfile,
-                                    rspcontent,
-                                    restat,
-                                    generator);
-
-  this->RuleCmdLength[name] = (int) command.size();
+  cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream, name, command,
+                                    description, comment, depfile, deptype,
+                                    rspfile, rspcontent, restat, generator);
+
+  this->RuleCmdLength[name] = (int)command.size();
 }
 
-bool cmGlobalNinjaGenerator::HasRule(const std::string &name)
+bool cmGlobalNinjaGenerator::HasRule(const std::string& name)
 {
   RulesSetType::const_iterator rule = this->Rules.find(name);
   return (rule != this->Rules.end());
@@ -734,8 +622,8 @@ std::string cmGlobalNinjaGenerator::GetEditCacheCommand() const
   return cmSystemTools::GetCMakeGUICommand();
 }
 
-void cmGlobalNinjaGenerator
-::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
+void cmGlobalNinjaGenerator::ComputeTargetObjectDirectory(
+  cmGeneratorTarget* gt) const
 {
   // Compute full path to object file directory for this target.
   std::string dir;
@@ -757,16 +645,14 @@ void cmGlobalNinjaGenerator::OpenBuildFileStream()
   buildFilePath += cmGlobalNinjaGenerator::NINJA_BUILD_FILE;
 
   // Get a stream where to generate things.
-  if (!this->BuildFileStream)
-    {
+  if (!this->BuildFileStream) {
     this->BuildFileStream = new cmGeneratedFileStream(buildFilePath.c_str());
-    if (!this->BuildFileStream)
-      {
+    if (!this->BuildFileStream) {
       // An error message is generated by the constructor if it cannot
       // open the file.
       return;
-      }
     }
+  }
 
   // Write the do not edit header.
   this->WriteDisclaimer(*this->BuildFileStream);
@@ -774,21 +660,17 @@ void cmGlobalNinjaGenerator::OpenBuildFileStream()
   // Write a comment about this file.
   *this->BuildFileStream
     << "# This file contains all the build statements describing the\n"
-    << "# compilation DAG.\n\n"
-    ;
+    << "# compilation DAG.\n\n";
 }
 
 void cmGlobalNinjaGenerator::CloseBuildFileStream()
 {
-  if (this->BuildFileStream)
-    {
+  if (this->BuildFileStream) {
     delete this->BuildFileStream;
     this->BuildFileStream = 0;
-    }
-  else
-    {
+  } else {
     cmSystemTools::Error("Build file stream was not open.");
-   }
+  }
 }
 
 void cmGlobalNinjaGenerator::OpenRulesFileStream()
@@ -800,16 +682,14 @@ void cmGlobalNinjaGenerator::OpenRulesFileStream()
   rulesFilePath += cmGlobalNinjaGenerator::NINJA_RULES_FILE;
 
   // Get a stream where to generate things.
-  if (!this->RulesFileStream)
-    {
+  if (!this->RulesFileStream) {
     this->RulesFileStream = new cmGeneratedFileStream(rulesFilePath.c_str());
-    if (!this->RulesFileStream)
-      {
+    if (!this->RulesFileStream) {
       // An error message is generated by the constructor if it cannot
       // open the file.
       return;
-      }
     }
+  }
 
   // Write the do not edit header.
   this->WriteDisclaimer(*this->RulesFileStream);
@@ -826,21 +706,18 @@ void cmGlobalNinjaGenerator::OpenRulesFileStream()
 
 void cmGlobalNinjaGenerator::CloseRulesFileStream()
 {
-  if (this->RulesFileStream)
-    {
+  if (this->RulesFileStream) {
     delete this->RulesFileStream;
     this->RulesFileStream = 0;
-    }
-  else
-    {
+  } else {
     cmSystemTools::Error("Rules file stream was not open.");
-   }
+  }
 }
 
 std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
 {
-  cmLocalNinjaGenerator *ng =
-    static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]);
+  cmLocalNinjaGenerator* ng =
+    static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
   std::string convPath = ng->Convert(path, cmOutputConverter::HOME_OUTPUT);
 #ifdef _WIN32
   cmSystemTools::ReplaceString(convPath, "/", "\\");
@@ -848,12 +725,12 @@ std::string cmGlobalNinjaGenerator::ConvertToNinjaPath(const std::string& path)
   return convPath;
 }
 
-std::string
-cmGlobalNinjaGenerator::ConvertToNinjaFolderRule(const std::string& path)
+std::string cmGlobalNinjaGenerator::ConvertToNinjaFolderRule(
+  const std::string& path)
 {
-  cmLocalNinjaGenerator *ng =
-    static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]);
-  std::string convPath = ng->Convert(path+"/all", cmOutputConverter::HOME);
+  cmLocalNinjaGenerator* ng =
+    static_cast<cmLocalNinjaGenerator*>(this->LocalGenerators[0]);
+  std::string convPath = ng->Convert(path + "/all", cmOutputConverter::HOME);
 #ifdef _WIN32
   cmSystemTools::ReplaceString(convPath, "/", "\\");
 #endif
@@ -861,32 +738,27 @@ cmGlobalNinjaGenerator::ConvertToNinjaFolderRule(const std::string& path)
 }
 
 void cmGlobalNinjaGenerator::AddCXXCompileCommand(
-                                      const std::string &commandLine,
-                                      const std::string &sourceFile)
+  const std::string& commandLine, const std::string& sourceFile)
 {
   // Compute Ninja's build file path.
   std::string buildFileDir =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
-  if (!this->CompileCommandsStream)
-    {
+  if (!this->CompileCommandsStream) {
     std::string buildFilePath = buildFileDir + "/compile_commands.json";
 
     // Get a stream where to generate things.
     this->CompileCommandsStream =
       new cmGeneratedFileStream(buildFilePath.c_str());
     *this->CompileCommandsStream << "[";
-    } else {
+  } else {
     *this->CompileCommandsStream << "," << std::endl;
-    }
+  }
 
   std::string sourceFileName = sourceFile;
-  if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str())) {
     sourceFileName = cmSystemTools::CollapseFullPath(
-      sourceFileName,
-      this->GetCMakeInstance()->GetHomeOutputDirectory());
-    }
-
+      sourceFileName, this->GetCMakeInstance()->GetHomeOutputDirectory());
+  }
 
   /* clang-format off */
   *this->CompileCommandsStream << "\n{\n"
@@ -902,23 +774,19 @@ void cmGlobalNinjaGenerator::AddCXXCompileCommand(
 
 void cmGlobalNinjaGenerator::CloseCompileCommandsStream()
 {
-  if (this->CompileCommandsStream)
-    {
+  if (this->CompileCommandsStream) {
     *this->CompileCommandsStream << "\n]";
     delete this->CompileCommandsStream;
     this->CompileCommandsStream = 0;
-    }
-
+  }
 }
 
 void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os)
 {
-  os
-    << "# CMAKE generated file: DO NOT EDIT!\n"
-    << "# Generated by \"" << this->GetName() << "\""
-    << " Generator, CMake Version "
-    << cmVersion::GetMajorVersion() << "."
-    << cmVersion::GetMinorVersion() << "\n\n";
+  os << "# CMAKE generated file: DO NOT EDIT!\n"
+     << "# Generated by \"" << this->GetName() << "\""
+     << " Generator, CMake Version " << cmVersion::GetMajorVersion() << "."
+     << cmVersion::GetMinorVersion() << "\n\n";
 }
 
 void cmGlobalNinjaGenerator::AddDependencyToAll(cmGeneratorTarget* target)
@@ -933,22 +801,20 @@ void cmGlobalNinjaGenerator::AddDependencyToAll(const std::string& input)
 
 void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
 {
-  for (std::map<std::string, std::set<std::string> >::iterator
-       i = this->AssumedSourceDependencies.begin();
+  for (std::map<std::string, std::set<std::string> >::iterator i =
+         this->AssumedSourceDependencies.begin();
        i != this->AssumedSourceDependencies.end(); ++i) {
     cmNinjaDeps deps;
     std::copy(i->second.begin(), i->second.end(), std::back_inserter(deps));
     WriteCustomCommandBuild(/*command=*/"", /*description=*/"",
                             "Assume dependencies for generated source file.",
-                            /*uses_terminal*/false,
-                            /*restat*/true,
-                            cmNinjaDeps(1, i->first), deps);
+                            /*uses_terminal*/ false,
+                            /*restat*/ true, cmNinjaDeps(1, i->first), deps);
   }
 }
 
-void
-cmGlobalNinjaGenerator
-::AppendTargetOutputs(cmGeneratorTarget const* target, cmNinjaDeps& outputs)
+void cmGlobalNinjaGenerator::AppendTargetOutputs(
+  cmGeneratorTarget const* target, cmNinjaDeps& outputs)
 {
   std::string configName =
     target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
@@ -960,43 +826,41 @@ cmGlobalNinjaGenerator
   bool realname = target->IsFrameworkOnApple();
 
   switch (target->GetType()) {
-  case cmState::EXECUTABLE:
-  case cmState::SHARED_LIBRARY:
-  case cmState::STATIC_LIBRARY:
-  case cmState::MODULE_LIBRARY:
-    {
-    outputs.push_back(this->ConvertToNinjaPath(
-      target->GetFullPath(configName, false, realname)));
-    break;
+    case cmState::EXECUTABLE:
+    case cmState::SHARED_LIBRARY:
+    case cmState::STATIC_LIBRARY:
+    case cmState::MODULE_LIBRARY: {
+      outputs.push_back(this->ConvertToNinjaPath(
+        target->GetFullPath(configName, false, realname)));
+      break;
     }
-  case cmState::OBJECT_LIBRARY:
-  case cmState::UTILITY: {
-    std::string path = this->ConvertToNinjaPath(
-      target->GetLocalGenerator()->GetCurrentBinaryDirectory());
-    if (path.empty() || path == ".")
-      outputs.push_back(target->GetName());
-    else {
-      path += "/";
-      path += target->GetName();
-      outputs.push_back(path);
+    case cmState::OBJECT_LIBRARY:
+    case cmState::UTILITY: {
+      std::string path = this->ConvertToNinjaPath(
+        target->GetLocalGenerator()->GetCurrentBinaryDirectory());
+      if (path.empty() || path == ".")
+        outputs.push_back(target->GetName());
+      else {
+        path += "/";
+        path += target->GetName();
+        outputs.push_back(path);
+      }
+      break;
     }
-    break;
-  }
 
-  case cmState::GLOBAL_TARGET:
-    // Always use the target in HOME instead of an unused duplicate in a
-    // subdirectory.
-    outputs.push_back(target->GetName());
-    break;
+    case cmState::GLOBAL_TARGET:
+      // Always use the target in HOME instead of an unused duplicate in a
+      // subdirectory.
+      outputs.push_back(target->GetName());
+      break;
 
-  default:
-    return;
+    default:
+      return;
   }
 }
 
-void
-cmGlobalNinjaGenerator
-::AppendTargetDepends(cmGeneratorTarget const* target, cmNinjaDeps& outputs)
+void cmGlobalNinjaGenerator::AppendTargetDepends(
+  cmGeneratorTarget const* target, cmNinjaDeps& outputs)
 {
   if (target->GetType() == cmState::GLOBAL_TARGET) {
     // Global targets only depend on other utilities, which may not appear in
@@ -1007,12 +871,10 @@ cmGlobalNinjaGenerator
     cmNinjaDeps outs;
     cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);
     for (cmTargetDependSet::const_iterator i = targetDeps.begin();
-         i != targetDeps.end(); ++i)
-      {
-      if ((*i)->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+         i != targetDeps.end(); ++i) {
+      if ((*i)->GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
+      }
       this->AppendTargetOutputs(*i, outs);
     }
     std::sort(outs.begin(), outs.end());
@@ -1021,7 +883,8 @@ cmGlobalNinjaGenerator
 }
 
 void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
-                                            cmGeneratorTarget* target) {
+                                            cmGeneratorTarget* target)
+{
   cmNinjaDeps outputs;
   this->AppendTargetOutputs(target, outputs);
   // Mark the target's outputs as ambiguous to ensure that no other target uses
@@ -1051,10 +914,7 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
     cmNinjaDeps deps;
     this->AppendTargetOutputs(i->second, deps);
 
-    this->WritePhonyBuild(os,
-                          "",
-                          cmNinjaDeps(1, i->first),
-                          deps);
+    this->WritePhonyBuild(os, "", cmNinjaDeps(1, i->first), deps);
   }
 }
 
@@ -1064,75 +924,68 @@ void cmGlobalNinjaGenerator::WriteFolderTargets(std::ostream& os)
   os << "# Folder targets.\n\n";
 
   std::map<std::string, cmNinjaDeps> targetsPerFolder;
-  for (std::vector<cmLocalGenerator *>::const_iterator
-       lgi = this->LocalGenerators.begin();
-       lgi != this->LocalGenerators.end(); ++lgi)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator lgi =
+         this->LocalGenerators.begin();
+       lgi != this->LocalGenerators.end(); ++lgi) {
     cmLocalGenerator const* lg = *lgi;
     const std::string currentSourceFolder(
       lg->GetStateSnapshot().GetDirectory().GetCurrentSource());
     // The directory-level rule should depend on the target-level rules
     // for all targets in the directory.
     targetsPerFolder[currentSourceFolder] = cmNinjaDeps();
-    for (std::vector<cmGeneratorTarget*>::const_iterator
-         ti = lg->GetGeneratorTargets().begin();
-         ti != lg->GetGeneratorTargets().end(); ++ti)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti =
+           lg->GetGeneratorTargets().begin();
+         ti != lg->GetGeneratorTargets().end(); ++ti) {
       cmGeneratorTarget const* gt = *ti;
       cmState::TargetType const type = gt->GetType();
-      if((type == cmState::EXECUTABLE ||
-          type == cmState::STATIC_LIBRARY ||
-          type == cmState::SHARED_LIBRARY ||
-          type == cmState::MODULE_LIBRARY ||
-          type == cmState::OBJECT_LIBRARY ||
-          type == cmState::UTILITY) &&
-         !gt->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-        {
+      if ((type == cmState::EXECUTABLE || type == cmState::STATIC_LIBRARY ||
+           type == cmState::SHARED_LIBRARY ||
+           type == cmState::MODULE_LIBRARY ||
+           type == cmState::OBJECT_LIBRARY || type == cmState::UTILITY) &&
+          !gt->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
         targetsPerFolder[currentSourceFolder].push_back(gt->GetName());
-        }
       }
+    }
 
     // The directory-level rule should depend on the directory-level
     // rules of the subdirectories.
     std::vector<cmState::Snapshot> const& children =
       lg->GetStateSnapshot().GetChildren();
-    for(std::vector<cmState::Snapshot>::const_iterator
-        stateIt = children.begin(); stateIt != children.end(); ++stateIt)
-      {
+    for (std::vector<cmState::Snapshot>::const_iterator stateIt =
+           children.begin();
+         stateIt != children.end(); ++stateIt) {
       targetsPerFolder[currentSourceFolder].push_back(
         this->ConvertToNinjaFolderRule(
           stateIt->GetDirectory().GetCurrentSource()));
-      }
     }
+  }
 
   std::string const rootSourceDir =
     this->LocalGenerators[0]->GetSourceDirectory();
-  for (std::map<std::string, cmNinjaDeps >::const_iterator it =
-       targetsPerFolder.begin(); it != targetsPerFolder.end(); ++it)
-    {
-    cmGlobalNinjaGenerator::WriteDivider( os );
+  for (std::map<std::string, cmNinjaDeps>::const_iterator it =
+         targetsPerFolder.begin();
+       it != targetsPerFolder.end(); ++it) {
+    cmGlobalNinjaGenerator::WriteDivider(os);
     std::string const& currentSourceDir = it->first;
 
     // Do not generate a rule for the root source dir.
-    if (rootSourceDir.length() >= currentSourceDir.length())
-      {
+    if (rootSourceDir.length() >= currentSourceDir.length()) {
       continue;
-      }
+    }
 
     std::string const comment = "Folder: " + currentSourceDir;
     cmNinjaDeps output(1);
     output.push_back(this->ConvertToNinjaFolderRule(currentSourceDir));
 
     this->WritePhonyBuild(os, comment, output, it->second);
-    }
+  }
 }
 
 void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
 {
-  if (!this->ComputingUnknownDependencies)
-    {
+  if (!this->ComputingUnknownDependencies) {
     return;
-    }
+  }
 
   // We need to collect the set of known build outputs.
   // Start with those generated by WriteBuild calls.
@@ -1141,11 +994,12 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
   std::set<std::string> knownDependencies;
   knownDependencies.swap(this->CombinedBuildOutputs);
 
-  //now write out the unknown explicit dependencies.
+  // now write out the unknown explicit dependencies.
 
-  //union the configured files, evaluations files and the CombinedBuildOutputs,
-  //and then difference with CombinedExplicitDependencies to find the explicit
-  //dependencies that we have no rule for
+  // union the configured files, evaluations files and the
+  // CombinedBuildOutputs,
+  // and then difference with CombinedExplicitDependencies to find the explicit
+  // dependencies that we have no rule for
 
   cmGlobalNinjaGenerator::WriteDivider(os);
   /* clang-format off */
@@ -1154,108 +1008,93 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
      << "# otherwise ordered by order-only dependencies.\n\n";
   /* clang-format on */
 
-  //get the list of files that cmake itself has generated as a
-  //product of configuration.
+  // get the list of files that cmake itself has generated as a
+  // product of configuration.
 
-  for (std::vector<cmLocalGenerator *>::const_iterator i =
-       this->LocalGenerators.begin(); i != this->LocalGenerators.end(); ++i)
-    {
-    //get the vector of files created by this makefile and convert them
-    //to ninja paths, which are all relative in respect to the build directory
+  for (std::vector<cmLocalGenerator*>::const_iterator i =
+         this->LocalGenerators.begin();
+       i != this->LocalGenerators.end(); ++i) {
+    // get the vector of files created by this makefile and convert them
+    // to ninja paths, which are all relative in respect to the build directory
     const std::vector<std::string>& files =
-                                    (*i)->GetMakefile()->GetOutputFiles();
+      (*i)->GetMakefile()->GetOutputFiles();
     typedef std::vector<std::string>::const_iterator vect_it;
-    for(vect_it j = files.begin(); j != files.end(); ++j)
-      {
-      knownDependencies.insert( this->ConvertToNinjaPath( *j ) );
-      }
-    //get list files which are implicit dependencies as well and will be phony
-    //for rebuild manifest
+    for (vect_it j = files.begin(); j != files.end(); ++j) {
+      knownDependencies.insert(this->ConvertToNinjaPath(*j));
+    }
+    // get list files which are implicit dependencies as well and will be phony
+    // for rebuild manifest
     std::vector<std::string> const& lf = (*i)->GetMakefile()->GetListFiles();
     typedef std::vector<std::string>::const_iterator vect_it;
-    for(vect_it j = lf.begin(); j != lf.end(); ++j)
-      {
-      knownDependencies.insert( this->ConvertToNinjaPath( *j ) );
-      }
+    for (vect_it j = lf.begin(); j != lf.end(); ++j) {
+      knownDependencies.insert(this->ConvertToNinjaPath(*j));
+    }
     std::vector<cmGeneratorExpressionEvaluationFile*> const& ef =
-        (*i)->GetMakefile()->GetEvaluationFiles();
-    for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
-        li = ef.begin(); li != ef.end(); ++li)
-      {
-      //get all the files created by generator expressions and convert them
-      //to ninja paths
+      (*i)->GetMakefile()->GetEvaluationFiles();
+    for (std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator li =
+           ef.begin();
+         li != ef.end(); ++li) {
+      // get all the files created by generator expressions and convert them
+      // to ninja paths
       std::vector<std::string> evaluationFiles = (*li)->GetFiles();
-      for(vect_it j = evaluationFiles.begin(); j != evaluationFiles.end(); ++j)
-        {
-        knownDependencies.insert( this->ConvertToNinjaPath( *j ) );
-        }
+      for (vect_it j = evaluationFiles.begin(); j != evaluationFiles.end();
+           ++j) {
+        knownDependencies.insert(this->ConvertToNinjaPath(*j));
       }
     }
-  knownDependencies.insert( "CMakeCache.txt" );
+  }
+  knownDependencies.insert("CMakeCache.txt");
 
-  for(TargetAliasMap::const_iterator i= this->TargetAliases.begin();
-      i != this->TargetAliases.end();
-      ++i)
-    {
-    knownDependencies.insert( this->ConvertToNinjaPath(i->first) );
-    }
+  for (TargetAliasMap::const_iterator i = this->TargetAliases.begin();
+       i != this->TargetAliases.end(); ++i) {
+    knownDependencies.insert(this->ConvertToNinjaPath(i->first));
+  }
 
-  //remove all source files we know will exist.
+  // remove all source files we know will exist.
   typedef std::map<std::string, std::set<std::string> >::const_iterator map_it;
-  for(map_it i = this->AssumedSourceDependencies.begin();
-      i != this->AssumedSourceDependencies.end();
-      ++i)
-    {
-    knownDependencies.insert( this->ConvertToNinjaPath(i->first) );
-    }
+  for (map_it i = this->AssumedSourceDependencies.begin();
+       i != this->AssumedSourceDependencies.end(); ++i) {
+    knownDependencies.insert(this->ConvertToNinjaPath(i->first));
+  }
 
-  //now we difference with CombinedCustomCommandExplicitDependencies to find
-  //the list of items we know nothing about.
-  //We have encoded all the paths in CombinedCustomCommandExplicitDependencies
-  //and knownDependencies so no matter if unix or windows paths they
-  //should all match now.
+  // now we difference with CombinedCustomCommandExplicitDependencies to find
+  // the list of items we know nothing about.
+  // We have encoded all the paths in CombinedCustomCommandExplicitDependencies
+  // and knownDependencies so no matter if unix or windows paths they
+  // should all match now.
 
   std::vector<std::string> unknownExplicitDepends;
   this->CombinedCustomCommandExplicitDependencies.erase("all");
 
   std::set_difference(this->CombinedCustomCommandExplicitDependencies.begin(),
                       this->CombinedCustomCommandExplicitDependencies.end(),
-                      knownDependencies.begin(),
-                      knownDependencies.end(),
+                      knownDependencies.begin(), knownDependencies.end(),
                       std::back_inserter(unknownExplicitDepends));
 
   std::string const rootBuildDirectory =
-      this->GetCMakeInstance()->GetHomeOutputDirectory();
+    this->GetCMakeInstance()->GetHomeOutputDirectory();
   bool const inSourceBuild =
     (rootBuildDirectory == this->GetCMakeInstance()->GetHomeDirectory());
   std::vector<std::string> warnExplicitDepends;
-  for (std::vector<std::string>::const_iterator
-       i = unknownExplicitDepends.begin();
-       i != unknownExplicitDepends.end();
-       ++i)
-    {
-    //verify the file is in the build directory
-    std::string const absDepPath = cmSystemTools::CollapseFullPath(
-                                     *i, rootBuildDirectory.c_str());
-    bool const inBuildDir = cmSystemTools::IsSubDirectory(absDepPath,
-                                                  rootBuildDirectory);
-    if(inBuildDir)
-      {
-      cmNinjaDeps deps(1,*i);
-      this->WritePhonyBuild(os,
-                            "",
-                            deps,
-                            cmNinjaDeps());
-      if (this->PolicyCMP0058 == cmPolicies::WARN &&
-          !inSourceBuild && warnExplicitDepends.size() < 10)
-        {
+  for (std::vector<std::string>::const_iterator i =
+         unknownExplicitDepends.begin();
+       i != unknownExplicitDepends.end(); ++i) {
+    // verify the file is in the build directory
+    std::string const absDepPath =
+      cmSystemTools::CollapseFullPath(*i, rootBuildDirectory.c_str());
+    bool const inBuildDir =
+      cmSystemTools::IsSubDirectory(absDepPath, rootBuildDirectory);
+    if (inBuildDir) {
+      cmNinjaDeps deps(1, *i);
+      this->WritePhonyBuild(os, "", deps, cmNinjaDeps());
+      if (this->PolicyCMP0058 == cmPolicies::WARN && !inSourceBuild &&
+          warnExplicitDepends.size() < 10) {
         warnExplicitDepends.push_back(*i);
-        }
       }
-   }
+    }
+  }
 
-  if (!warnExplicitDepends.empty())
-    {
+  if (!warnExplicitDepends.empty()) {
     std::ostringstream w;
     /* clang-format off */
     w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0058) << "\n"
@@ -1273,7 +1112,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
       ;
     /* clang-format on */
     this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-    }
+  }
 }
 
 void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
@@ -1293,19 +1132,16 @@ void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os)
   cmNinjaDeps outputs;
   outputs.push_back("all");
 
-  this->WritePhonyBuild(os,
-                        "The main all target.",
-                        outputs,
+  this->WritePhonyBuild(os, "The main all target.", outputs,
                         this->AllDependencies);
 
-  cmGlobalNinjaGenerator::WriteDefault(os,
-                                       outputs,
+  cmGlobalNinjaGenerator::WriteDefault(os, outputs,
                                        "Make the all target the default.");
 }
 
 void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
 {
-  cmLocalGenerator *lg = this->LocalGenerators[0];
+  cmLocalGenerator* lg = this->LocalGenerators[0];
 
   std::ostringstream cmd;
   cmd << lg->ConvertToOutputFormat(cmSystemTools::GetCMakeCommand(),
@@ -1316,29 +1152,25 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
       << " -B"
       << lg->ConvertToOutputFormat(lg->GetBinaryDirectory(),
                                    cmLocalGenerator::SHELL);
-  WriteRule(*this->RulesFileStream,
-            "RERUN_CMAKE",
-            cmd.str(),
-            "Re-running CMake...",
-            "Rule for re-running cmake.",
-            /*depfile=*/ "",
-            /*deptype=*/ "",
-            /*rspfile=*/ "",
+  WriteRule(*this->RulesFileStream, "RERUN_CMAKE", cmd.str(),
+            "Re-running CMake...", "Rule for re-running cmake.",
+            /*depfile=*/"",
+            /*deptype=*/"",
+            /*rspfile=*/"",
             /*rspcontent*/ "",
-            /*restat=*/ "",
-            /*generator=*/ true);
+            /*restat=*/"",
+            /*generator=*/true);
 
   cmNinjaDeps implicitDeps;
-  for(std::vector<cmLocalGenerator*>::const_iterator i =
-        this->LocalGenerators.begin(); i != this->LocalGenerators.end(); ++i)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator i =
+         this->LocalGenerators.begin();
+       i != this->LocalGenerators.end(); ++i) {
     std::vector<std::string> const& lf = (*i)->GetMakefile()->GetListFiles();
-    for(std::vector<std::string>::const_iterator fi = lf.begin();
-        fi != lf.end(); ++fi)
-      {
+    for (std::vector<std::string>::const_iterator fi = lf.begin();
+         fi != lf.end(); ++fi) {
       implicitDeps.push_back(this->ConvertToNinjaPath(*fi));
-      }
     }
+  }
   implicitDeps.push_back("CMakeCache.txt");
 
   std::sort(implicitDeps.begin(), implicitDeps.end());
@@ -1348,24 +1180,18 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
   cmNinjaVars variables;
   // Use 'console' pool to get non buffered output of the CMake re-run call
   // Available since Ninja 1.5
-  if(SupportsConsolePool())
-    {
+  if (SupportsConsolePool()) {
     variables["pool"] = "console";
-    }
+  }
 
-  this->WriteBuild(os,
-                   "Re-run CMake if any of its inputs changed.",
+  this->WriteBuild(os, "Re-run CMake if any of its inputs changed.",
                    "RERUN_CMAKE",
-                   /*outputs=*/ cmNinjaDeps(1, NINJA_BUILD_FILE),
-                   /*explicitDeps=*/ cmNinjaDeps(),
-                   implicitDeps,
-                   /*orderOnlyDeps=*/ cmNinjaDeps(),
-                   variables);
-
-  this->WritePhonyBuild(os,
-                        "A missing CMake input file is not an error.",
-                        implicitDeps,
-                        cmNinjaDeps());
+                   /*outputs=*/cmNinjaDeps(1, NINJA_BUILD_FILE),
+                   /*explicitDeps=*/cmNinjaDeps(), implicitDeps,
+                   /*orderOnlyDeps=*/cmNinjaDeps(), variables);
+
+  this->WritePhonyBuild(os, "A missing CMake input file is not an error.",
+                        implicitDeps, cmNinjaDeps());
 }
 
 std::string cmGlobalNinjaGenerator::ninjaCmd() const
@@ -1380,53 +1206,45 @@ std::string cmGlobalNinjaGenerator::ninjaCmd() const
 
 bool cmGlobalNinjaGenerator::SupportsConsolePool() const
 {
-  return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
-    this->NinjaVersion.c_str(),
-    RequiredNinjaVersionForConsolePool().c_str()) == false;
+  return cmSystemTools::VersionCompare(
+           cmSystemTools::OP_LESS, this->NinjaVersion.c_str(),
+           RequiredNinjaVersionForConsolePool().c_str()) == false;
 }
 
 void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
 {
-  WriteRule(*this->RulesFileStream,
-            "CLEAN",
-            ninjaCmd() + " -t clean",
+  WriteRule(*this->RulesFileStream, "CLEAN", ninjaCmd() + " -t clean",
             "Cleaning all built files...",
             "Rule for cleaning all built files.",
-            /*depfile=*/ "",
-            /*deptype=*/ "",
-            /*rspfile=*/ "",
+            /*depfile=*/"",
+            /*deptype=*/"",
+            /*rspfile=*/"",
             /*rspcontent*/ "",
-            /*restat=*/ "",
-            /*generator=*/ false);
-  WriteBuild(os,
-             "Clean all the built files.",
-             "CLEAN",
-             /*outputs=*/ cmNinjaDeps(1, "clean"),
-             /*explicitDeps=*/ cmNinjaDeps(),
-             /*implicitDeps=*/ cmNinjaDeps(),
-             /*orderOnlyDeps=*/ cmNinjaDeps(),
-             /*variables=*/ cmNinjaVars());
+            /*restat=*/"",
+            /*generator=*/false);
+  WriteBuild(os, "Clean all the built files.", "CLEAN",
+             /*outputs=*/cmNinjaDeps(1, "clean"),
+             /*explicitDeps=*/cmNinjaDeps(),
+             /*implicitDeps=*/cmNinjaDeps(),
+             /*orderOnlyDeps=*/cmNinjaDeps(),
+             /*variables=*/cmNinjaVars());
 }
 
 void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
 {
-  WriteRule(*this->RulesFileStream,
-            "HELP",
-            ninjaCmd() + " -t targets",
+  WriteRule(*this->RulesFileStream, "HELP", ninjaCmd() + " -t targets",
             "All primary targets available:",
             "Rule for printing all primary targets available.",
-            /*depfile=*/ "",
-            /*deptype=*/ "",
-            /*rspfile=*/ "",
+            /*depfile=*/"",
+            /*deptype=*/"",
+            /*rspfile=*/"",
             /*rspcontent*/ "",
-            /*restat=*/ "",
-            /*generator=*/ false);
-  WriteBuild(os,
-             "Print all primary targets available.",
-             "HELP",
-             /*outputs=*/ cmNinjaDeps(1, "help"),
-             /*explicitDeps=*/ cmNinjaDeps(),
-             /*implicitDeps=*/ cmNinjaDeps(),
-             /*orderOnlyDeps=*/ cmNinjaDeps(),
-             /*variables=*/ cmNinjaVars());
+            /*restat=*/"",
+            /*generator=*/false);
+  WriteBuild(os, "Print all primary targets available.", "HELP",
+             /*outputs=*/cmNinjaDeps(1, "help"),
+             /*explicitDeps=*/cmNinjaDeps(),
+             /*implicitDeps=*/cmNinjaDeps(),
+             /*orderOnlyDeps=*/cmNinjaDeps(),
+             /*variables=*/cmNinjaVars());
 }
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 56e2bdb..881104f 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -63,10 +63,10 @@ public:
   static void WriteDivider(std::ostream& os);
 
   static std::string EncodeRuleName(std::string const& name);
-  static std::string EncodeIdent(const std::string &ident, std::ostream &vars);
-  static std::string EncodeLiteral(const std::string &lit);
-  std::string EncodePath(const std::string &path);
-  static std::string EncodeDepfileSpace(const std::string &path);
+  static std::string EncodeIdent(const std::string& ident, std::ostream& vars);
+  static std::string EncodeLiteral(const std::string& lit);
+  std::string EncodePath(const std::string& path);
+  static std::string EncodeDepfileSpace(const std::string& path);
 
   /**
    * Write the given @a comment to the output stream @a os. It
@@ -86,23 +86,19 @@ public:
    * It also writes the variables bound to this build statement.
    * @warning no escaping of any kind is done here.
    */
-  void WriteBuild(std::ostream& os,
-                  const std::string& comment,
-                  const std::string& rule,
-                  const cmNinjaDeps& outputs,
+  void WriteBuild(std::ostream& os, const std::string& comment,
+                  const std::string& rule, const cmNinjaDeps& outputs,
                   const cmNinjaDeps& explicitDeps,
                   const cmNinjaDeps& implicitDeps,
                   const cmNinjaDeps& orderOnlyDeps,
                   const cmNinjaVars& variables,
                   const std::string& rspfile = std::string(),
-                  int cmdLineLimit = 0,
-                  bool* usedResponseFile = 0);
+                  int cmdLineLimit = 0, bool* usedResponseFile = 0);
 
   /**
    * Helper to write a build statement with the special 'phony' rule.
    */
-  void WritePhonyBuild(std::ostream& os,
-                       const std::string& comment,
+  void WritePhonyBuild(std::ostream& os, const std::string& comment,
                        const cmNinjaDeps& outputs,
                        const cmNinjaDeps& explicitDeps,
                        const cmNinjaDeps& implicitDeps = cmNinjaDeps(),
@@ -111,10 +107,8 @@ public:
 
   void WriteCustomCommandBuild(const std::string& command,
                                const std::string& description,
-                               const std::string& comment,
-                               bool uses_terminal,
-                               bool restat,
-                               const cmNinjaDeps& outputs,
+                               const std::string& comment, bool uses_terminal,
+                               bool restat, const cmNinjaDeps& outputs,
                                const cmNinjaDeps& deps = cmNinjaDeps(),
                                const cmNinjaDeps& orderOnly = cmNinjaDeps());
   void WriteMacOSXContentBuild(const std::string& input,
@@ -126,43 +120,35 @@ public:
    * It also writes the variables bound to this rule statement.
    * @warning no escaping of any kind is done here.
    */
-  static void WriteRule(std::ostream& os,
-                        const std::string& name,
+  static void WriteRule(std::ostream& os, const std::string& name,
                         const std::string& command,
                         const std::string& description,
-                        const std::string& comment,
-                        const std::string& depfile,
-                        const std::string& deptype,
-                        const std::string& rspfile,
+                        const std::string& comment, const std::string& depfile,
+                        const std::string& deptype, const std::string& rspfile,
                         const std::string& rspcontent,
-                        const std::string& restat,
-                        bool generator);
+                        const std::string& restat, bool generator);
 
   /**
    * Write a variable named @a name to @a os with value @a value and an
    * optional @a comment. An @a indent level can be specified.
    * @warning no escaping of any kind is done here.
    */
-  static void WriteVariable(std::ostream& os,
-                            const std::string& name,
+  static void WriteVariable(std::ostream& os, const std::string& name,
                             const std::string& value,
-                            const std::string& comment = "",
-                            int indent = 0);
+                            const std::string& comment = "", int indent = 0);
 
   /**
    * Write an include statement including @a filename with an optional
    * @a comment to the @a os stream.
    */
-  static void WriteInclude(std::ostream& os,
-                           const std::string& filename,
+  static void WriteInclude(std::ostream& os, const std::string& filename,
                            const std::string& comment = "");
 
   /**
    * Write a default target statement specifying @a targets as
    * the default targets.
    */
-  static void WriteDefault(std::ostream& os,
-                           const cmNinjaDeps& targets,
+  static void WriteDefault(std::ostream& os, const cmNinjaDeps& targets,
                            const std::string& comment = "");
 
   bool IsGCCOnWindows() const { return UsingGCCOnWindows; }
@@ -170,125 +156,130 @@ public:
 public:
   cmGlobalNinjaGenerator(cmake* cm);
 
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaGenerator>();
+  }
 
-  virtual ~cmGlobalNinjaGenerator() { }
+  virtual ~cmGlobalNinjaGenerator() {}
 
   virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
-  virtual std::string GetName() const {
-    return cmGlobalNinjaGenerator::GetActualName(); }
+  virtual std::string GetName() const
+  {
+    return cmGlobalNinjaGenerator::GetActualName();
+  }
 
   static std::string GetActualName() { return "Ninja"; }
 
   static void GetDocumentation(cmDocumentationEntry& entry);
 
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile* mf,
-                              bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile* mf, bool optional);
 
   virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand,
-    const std::string& makeProgram,
-    const std::string& projectName,
-    const std::string& projectDir,
-    const std::string& targetName,
-    const std::string& config,
-    bool fast, bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+    const std::string& projectName, const std::string& projectDir,
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
   // Setup target names
-  virtual const char* GetAllTargetName()           const { return "all"; }
-  virtual const char* GetInstallTargetName()       const { return "install"; }
-  virtual const char* GetInstallLocalTargetName()  const {
+  virtual const char* GetAllTargetName() const { return "all"; }
+  virtual const char* GetInstallTargetName() const { return "install"; }
+  virtual const char* GetInstallLocalTargetName() const
+  {
     return "install/local";
   }
-  virtual const char* GetInstallStripTargetName()  const {
+  virtual const char* GetInstallStripTargetName() const
+  {
     return "install/strip";
   }
-  virtual const char* GetTestTargetName()          const { return "test"; }
-  virtual const char* GetPackageTargetName()       const { return "package"; }
-  virtual const char* GetPackageSourceTargetName() const {
+  virtual const char* GetTestTargetName() const { return "test"; }
+  virtual const char* GetPackageTargetName() const { return "package"; }
+  virtual const char* GetPackageSourceTargetName() const
+  {
     return "package_source";
   }
-  virtual const char* GetEditCacheTargetName()     const {
-    return "edit_cache";
-  }
-  virtual const char* GetRebuildCacheTargetName()  const {
+  virtual const char* GetEditCacheTargetName() const { return "edit_cache"; }
+  virtual const char* GetRebuildCacheTargetName() const
+  {
     return "rebuild_cache";
   }
-  virtual const char* GetCleanTargetName()         const { return "clean"; }
-
+  virtual const char* GetCleanTargetName() const { return "clean"; }
 
-  cmGeneratedFileStream* GetBuildFileStream() const {
-    return this->BuildFileStream; }
+  cmGeneratedFileStream* GetBuildFileStream() const
+  {
+    return this->BuildFileStream;
+  }
 
-  cmGeneratedFileStream* GetRulesFileStream() const {
-    return this->RulesFileStream; }
+  cmGeneratedFileStream* GetRulesFileStream() const
+  {
+    return this->RulesFileStream;
+  }
 
   std::string ConvertToNinjaPath(const std::string& path);
   std::string ConvertToNinjaFolderRule(const std::string& path);
 
-
-  struct MapToNinjaPathImpl {
+  struct MapToNinjaPathImpl
+  {
     cmGlobalNinjaGenerator* GG;
-    MapToNinjaPathImpl(cmGlobalNinjaGenerator* gg): GG(gg) {}
-    std::string operator()(std::string const& path) {
+    MapToNinjaPathImpl(cmGlobalNinjaGenerator* gg)
+      : GG(gg)
+    {
+    }
+    std::string operator()(std::string const& path)
+    {
       return this->GG->ConvertToNinjaPath(path);
     }
   };
-  MapToNinjaPathImpl MapToNinjaPath() {
-    return MapToNinjaPathImpl(this);
-  }
+  MapToNinjaPathImpl MapToNinjaPath() { return MapToNinjaPathImpl(this); }
 
-  void AddCXXCompileCommand(const std::string &commandLine,
-                            const std::string &sourceFile);
+  void AddCXXCompileCommand(const std::string& commandLine,
+                            const std::string& sourceFile);
 
   /**
    * Add a rule to the generated build system.
    * Call WriteRule() behind the scene but perform some check before like:
    * - Do not add twice the same rule.
    */
-  void AddRule(const std::string& name,
-               const std::string& command,
-               const std::string& description,
-               const std::string& comment,
-               const std::string& depfile,
-               const std::string& deptype,
-               const std::string& rspfile,
-               const std::string& rspcontent,
-               const std::string& restat,
-               bool generator);
+  void AddRule(const std::string& name, const std::string& command,
+               const std::string& description, const std::string& comment,
+               const std::string& depfile, const std::string& deptype,
+               const std::string& rspfile, const std::string& rspcontent,
+               const std::string& restat, bool generator);
 
   bool HasRule(const std::string& name);
 
   void AddCustomCommandRule();
   void AddMacOSXContentRule();
 
-  bool HasCustomCommandOutput(const std::string &output) {
+  bool HasCustomCommandOutput(const std::string& output)
+  {
     return this->CustomCommandOutputs.find(output) !=
-           this->CustomCommandOutputs.end();
+      this->CustomCommandOutputs.end();
   }
 
   /// Called when we have seen the given custom command.  Returns true
   /// if we has seen it before.
-  bool SeenCustomCommand(cmCustomCommand const *cc) {
+  bool SeenCustomCommand(cmCustomCommand const* cc)
+  {
     return !this->CustomCommands.insert(cc).second;
   }
 
   /// Called when we have seen the given custom command output.
-  void SeenCustomCommandOutput(const std::string &output) {
+  void SeenCustomCommandOutput(const std::string& output)
+  {
     this->CustomCommandOutputs.insert(output);
     // We don't need the assumed dependencies anymore, because we have
     // an output.
     this->AssumedSourceDependencies.erase(output);
   }
 
-  void AddAssumedSourceDependencies(const std::string &source,
-                                    const cmNinjaDeps &deps) {
-    std::set<std::string> &ASD = this->AssumedSourceDependencies[source];
+  void AddAssumedSourceDependencies(const std::string& source,
+                                    const cmNinjaDeps& deps)
+  {
+    std::set<std::string>& ASD = this->AssumedSourceDependencies[source];
     // Because we may see the same source file multiple times (same source
     // specified in multiple targets), compute the union of any assumed
     // dependencies.
@@ -302,14 +293,17 @@ public:
   void AddDependencyToAll(cmGeneratorTarget* target);
   void AddDependencyToAll(const std::string& input);
 
-  const std::vector<cmLocalGenerator*>& GetLocalGenerators() const {
-    return LocalGenerators; }
+  const std::vector<cmLocalGenerator*>& GetLocalGenerators() const
+  {
+    return LocalGenerators;
+  }
 
-  bool IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target) {
-    return cmGlobalGenerator::IsExcluded(root, target); }
+  bool IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target)
+  {
+    return cmGlobalGenerator::IsExcluded(root, target);
+  }
 
-  int GetRuleCmdLength(const std::string& name) {
-    return RuleCmdLength[name]; }
+  int GetRuleCmdLength(const std::string& name) { return RuleCmdLength[name]; }
 
   void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target);
 
@@ -321,12 +315,10 @@ public:
   bool SupportsConsolePool() const;
 
 protected:
-
   virtual void Generate();
 
   virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; }
 
-
 private:
   virtual std::string GetEditCacheCommand() const;
   virtual void FindMakeProgram(cmMakefile* mf);
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 79b07ba..7b5ea13 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -40,32 +40,28 @@ cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3(cmake* cm)
   this->UnixCD = true;
 }
 
-void cmGlobalUnixMakefileGenerator3
-::EnableLanguage(std::vector<std::string>const& languages,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalUnixMakefileGenerator3::EnableLanguage(
+  std::vector<std::string> const& languages, cmMakefile* mf, bool optional)
 {
   this->cmGlobalGenerator::EnableLanguage(languages, mf, optional);
-  for(std::vector<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
-    {
-    if(*l == "NONE")
-      {
+  for (std::vector<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
+    if (*l == "NONE") {
       continue;
-      }
-    this->ResolveLanguageCompiler(*l, mf, optional);
     }
+    this->ResolveLanguageCompiler(*l, mf, optional);
+  }
 }
 
 ///! Create a local generator appropriate to this Global Generator
 cmLocalGenerator* cmGlobalUnixMakefileGenerator3::CreateLocalGenerator(
-    cmMakefile* mf)
+  cmMakefile* mf)
 {
   return new cmLocalUnixMakefileGenerator3(this, mf);
 }
 
-void cmGlobalUnixMakefileGenerator3
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalUnixMakefileGenerator3::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalUnixMakefileGenerator3::GetActualName();
   entry.Brief = "Generates standard UNIX makefiles.";
@@ -75,40 +71,34 @@ std::string cmGlobalUnixMakefileGenerator3::GetEditCacheCommand() const
 {
   // If generating for an extra IDE, the edit_cache target cannot
   // launch a terminal-interactive tool, so always use cmake-gui.
-  if(!this->GetExtraGeneratorName().empty())
-    {
+  if (!this->GetExtraGeneratorName().empty()) {
     return cmSystemTools::GetCMakeGUICommand();
-    }
+  }
 
   // Use an internal cache entry to track the latest dialog used
   // to edit the cache, and use that for the edit_cache target.
   cmake* cm = this->GetCMakeInstance();
   std::string editCacheCommand = cm->GetCMakeEditCommand();
-  if(!cm->GetCacheDefinition("CMAKE_EDIT_COMMAND") ||
-     !editCacheCommand.empty())
-    {
-    if(editCacheCommand.empty())
-      {
+  if (!cm->GetCacheDefinition("CMAKE_EDIT_COMMAND") ||
+      !editCacheCommand.empty()) {
+    if (editCacheCommand.empty()) {
       editCacheCommand = cmSystemTools::GetCMakeCursesCommand();
-      }
-    if(editCacheCommand.empty())
-      {
+    }
+    if (editCacheCommand.empty()) {
       editCacheCommand = cmSystemTools::GetCMakeGUICommand();
-      }
-    if(!editCacheCommand.empty())
-      {
-      cm->AddCacheEntry
-        ("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
-         "Path to cache edit program executable.", cmState::INTERNAL);
-      }
     }
+    if (!editCacheCommand.empty()) {
+      cm->AddCacheEntry("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
+                        "Path to cache edit program executable.",
+                        cmState::INTERNAL);
+    }
+  }
   const char* edit_cmd = cm->GetCacheDefinition("CMAKE_EDIT_COMMAND");
-  return edit_cmd? edit_cmd : "";
+  return edit_cmd ? edit_cmd : "";
 }
 
-void
-cmGlobalUnixMakefileGenerator3
-::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
+void cmGlobalUnixMakefileGenerator3::ComputeTargetObjectDirectory(
+  cmGeneratorTarget* gt) const
 {
   // Compute full path to object file directory for this target.
   std::string dir;
@@ -134,11 +124,10 @@ void cmGlobalUnixMakefileGenerator3::Generate()
 
   // initialize progress
   unsigned long total = 0;
-  for(ProgressMapType::const_iterator pmi = this->ProgressMap.begin();
-      pmi != this->ProgressMap.end(); ++pmi)
-    {
+  for (ProgressMapType::const_iterator pmi = this->ProgressMap.begin();
+       pmi != this->ProgressMap.end(); ++pmi) {
     total += pmi->second.NumberOfActions;
-    }
+  }
 
   // write each target's progress.make this loop is done twice. Bascially the
   // Generate pass counts all the actions, the first loop below determines
@@ -148,21 +137,19 @@ void cmGlobalUnixMakefileGenerator3::Generate()
   // well. This is because the all targets require more information that is
   // computed in the first loop.
   unsigned long current = 0;
-  for(ProgressMapType::iterator pmi = this->ProgressMap.begin();
-      pmi != this->ProgressMap.end(); ++pmi)
-    {
+  for (ProgressMapType::iterator pmi = this->ProgressMap.begin();
+       pmi != this->ProgressMap.end(); ++pmi) {
     pmi->second.WriteProgressVariables(total, current);
-    }
-  for(unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    cmLocalGenerator *lg = this->LocalGenerators[i];
+  }
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
+    cmLocalGenerator* lg = this->LocalGenerators[i];
     std::string markFileName = lg->GetCurrentBinaryDirectory();
     markFileName += "/";
     markFileName += cmake::GetCMakeFilesDirectory();
     markFileName += "/progress.marks";
     cmGeneratedFileStream markFile(markFileName.c_str());
     markFile << this->CountProgressMarksInAll(lg) << "\n";
-    }
+  }
 
   // write the main makefile
   this->WriteMainMakefile2();
@@ -176,29 +163,30 @@ void cmGlobalUnixMakefileGenerator3::Generate()
 }
 
 void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(
-    const std::string &sourceFile, const std::string &workingDirectory,
-    const std::string &compileCommand) {
-  if (this->CommandDatabase == NULL)
-    {
+  const std::string& sourceFile, const std::string& workingDirectory,
+  const std::string& compileCommand)
+{
+  if (this->CommandDatabase == NULL) {
     std::string commandDatabaseName =
-      std::string(this->GetCMakeInstance()->GetHomeOutputDirectory())
-      + "/compile_commands.json";
+      std::string(this->GetCMakeInstance()->GetHomeOutputDirectory()) +
+      "/compile_commands.json";
     this->CommandDatabase =
       new cmGeneratedFileStream(commandDatabaseName.c_str());
     *this->CommandDatabase << "[" << std::endl;
-    } else {
+  } else {
     *this->CommandDatabase << "," << std::endl;
-    }
+  }
   *this->CommandDatabase << "{" << std::endl
-      << "  \"directory\": \""
-      << cmGlobalGenerator::EscapeJSON(workingDirectory) << "\","
-      << std::endl
-      << "  \"command\": \"" <<
-      cmGlobalGenerator::EscapeJSON(compileCommand) << "\","
-      << std::endl
-      << "  \"file\": \"" <<
-      cmGlobalGenerator::EscapeJSON(sourceFile) << "\""
-      << std::endl << "}";
+                         << "  \"directory\": \""
+                         << cmGlobalGenerator::EscapeJSON(workingDirectory)
+                         << "\"," << std::endl
+                         << "  \"command\": \""
+                         << cmGlobalGenerator::EscapeJSON(compileCommand)
+                         << "\"," << std::endl
+                         << "  \"file\": \""
+                         << cmGlobalGenerator::EscapeJSON(sourceFile) << "\""
+                         << std::endl
+                         << "}";
 }
 
 void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
@@ -211,14 +199,13 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
   makefileName += cmake::GetCMakeFilesDirectory();
   makefileName += "/Makefile2";
   cmGeneratedFileStream makefileStream(makefileName.c_str());
-  if(!makefileStream)
-    {
+  if (!makefileStream) {
     return;
-    }
+  }
 
   // get a local generator for some useful methods
-  cmLocalUnixMakefileGenerator3 *lg =
-    static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
+  cmLocalUnixMakefileGenerator3* lg =
+    static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);
 
   // Write the do not edit header.
   lg->WriteDisclaimer(makefileStream);
@@ -234,46 +221,38 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
   lg->WriteMakeRule(makefileStream,
                     "Default target executed when no arguments are "
                     "given to make.",
-                    "default_target",
-                    depends,
-                    no_commands, true);
+                    "default_target", depends, no_commands, true);
 
   depends.clear();
 
   // The all and preinstall rules might never have any dependencies
   // added to them.
-  if(this->EmptyRuleHackDepends != "")
-    {
+  if (this->EmptyRuleHackDepends != "") {
     depends.push_back(this->EmptyRuleHackDepends);
-    }
+  }
 
   // Write and empty all:
-  lg->WriteMakeRule(makefileStream,
-                    "The main recursive all target", "all",
+  lg->WriteMakeRule(makefileStream, "The main recursive all target", "all",
                     depends, no_commands, true);
 
   // Write an empty preinstall:
-  lg->WriteMakeRule(makefileStream,
-                    "The main recursive preinstall target", "preinstall",
-                    depends, no_commands, true);
+  lg->WriteMakeRule(makefileStream, "The main recursive preinstall target",
+                    "preinstall", depends, no_commands, true);
 
   // Write out the "special" stuff
   lg->WriteSpecialTargetsTop(makefileStream);
 
   // write the target convenience rules
   unsigned int i;
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    lg =
-      static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
-    this->WriteConvenienceRules2(makefileStream,lg);
-    }
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
+    lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
+    this->WriteConvenienceRules2(makefileStream, lg);
+  }
 
-  lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
+  lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);
   lg->WriteSpecialTargetsBottom(makefileStream);
 }
 
-
 void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
 {
   // Open the output file.  This should not be copy-if-different
@@ -284,48 +263,45 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   cmakefileName += cmake::GetCMakeFilesDirectory();
   cmakefileName += "/Makefile.cmake";
   cmGeneratedFileStream cmakefileStream(cmakefileName.c_str());
-  if(!cmakefileStream)
-    {
+  if (!cmakefileStream) {
     return;
-    }
+  }
 
   std::string makefileName =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
   makefileName += "/Makefile";
 
   // get a local generator for some useful methods
-  cmLocalUnixMakefileGenerator3 *lg =
-    static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
+  cmLocalUnixMakefileGenerator3* lg =
+    static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);
 
   // Write the do not edit header.
   lg->WriteDisclaimer(cmakefileStream);
 
   // Save the generator name
-  cmakefileStream
-    << "# The generator used is:\n"
-    << "set(CMAKE_DEPENDS_GENERATOR \"" << this->GetName() << "\")\n\n";
+  cmakefileStream << "# The generator used is:\n"
+                  << "set(CMAKE_DEPENDS_GENERATOR \"" << this->GetName()
+                  << "\")\n\n";
 
   // for each cmMakefile get its list of dependencies
   std::vector<std::string> lfiles;
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    lg =
-      static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
+  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
+    lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
 
     // Get the list of files contributing to this generation step.
-    lfiles.insert(lfiles.end(),lg->GetMakefile()->GetListFiles().begin(),
+    lfiles.insert(lfiles.end(), lg->GetMakefile()->GetListFiles().begin(),
                   lg->GetMakefile()->GetListFiles().end());
-    }
+  }
   // Sort the list and remove duplicates.
   std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
 #if !defined(__VMS) // The Compaq STL on VMS crashes, so accept duplicates.
   std::vector<std::string>::iterator new_end =
-    std::unique(lfiles.begin(),lfiles.end());
+    std::unique(lfiles.begin(), lfiles.end());
   lfiles.erase(new_end, lfiles.end());
 #endif
 
   // reset lg to the first makefile
-  lg = static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
+  lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[0]);
 
   // Build the path to the cache file.
   std::string cache = this->GetCMakeInstance()->GetHomeOutputDirectory();
@@ -335,19 +311,14 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   cmakefileStream
     << "# The top level Makefile was generated from the following files:\n"
     << "set(CMAKE_MAKEFILE_DEPENDS\n"
-    << "  \""
-    << lg->Convert(cache,
-                   cmLocalGenerator::START_OUTPUT) << "\"\n";
-  for(std::vector<std::string>::const_iterator i = lfiles.begin();
-      i !=  lfiles.end(); ++i)
-    {
-    cmakefileStream
-      << "  \""
-      << lg->Convert(*i, cmLocalGenerator::START_OUTPUT)
-      << "\"\n";
-    }
-  cmakefileStream
-    << "  )\n\n";
+    << "  \"" << lg->Convert(cache, cmLocalGenerator::START_OUTPUT) << "\"\n";
+  for (std::vector<std::string>::const_iterator i = lfiles.begin();
+       i != lfiles.end(); ++i) {
+    cmakefileStream << "  \""
+                    << lg->Convert(*i, cmLocalGenerator::START_OUTPUT)
+                    << "\"\n";
+  }
+  cmakefileStream << "  )\n\n";
 
   // Build the path to the cache check file.
   std::string check = this->GetCMakeInstance()->GetHomeOutputDirectory();
@@ -355,96 +326,83 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   check += "/cmake.check_cache";
 
   // Set the corresponding makefile in the cmake file.
-  cmakefileStream
-    << "# The corresponding makefile is:\n"
-    << "set(CMAKE_MAKEFILE_OUTPUTS\n"
-    << "  \""
-    << lg->Convert(makefileName,
-                   cmLocalGenerator::START_OUTPUT) << "\"\n"
-    << "  \""
-    << lg->Convert(check,
-                   cmLocalGenerator::START_OUTPUT) << "\"\n";
+  cmakefileStream << "# The corresponding makefile is:\n"
+                  << "set(CMAKE_MAKEFILE_OUTPUTS\n"
+                  << "  \""
+                  << lg->Convert(makefileName, cmLocalGenerator::START_OUTPUT)
+                  << "\"\n"
+                  << "  \""
+                  << lg->Convert(check, cmLocalGenerator::START_OUTPUT)
+                  << "\"\n";
   cmakefileStream << "  )\n\n";
 
   // CMake must rerun if a byproduct is missing.
   {
-  cmakefileStream
-    << "# Byproducts of CMake generate step:\n"
-    << "set(CMAKE_MAKEFILE_PRODUCTS\n";
-  const std::vector<std::string>& outfiles =
-    lg->GetMakefile()->GetOutputFiles();
-  for(std::vector<std::string>::const_iterator k = outfiles.begin();
-      k != outfiles.end(); ++k)
-    {
-    cmakefileStream << "  \"" <<
-      lg->Convert(*k,cmLocalGenerator::HOME_OUTPUT)
-                    << "\"\n";
-    }
-
-  // add in all the directory information files
-  std::string tmpStr;
-  for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    lg =
-      static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
-    tmpStr = lg->GetCurrentBinaryDirectory();
-    tmpStr += cmake::GetCMakeFilesDirectory();
-    tmpStr += "/CMakeDirectoryInformation.cmake";
-    cmakefileStream << "  \"" <<
-      lg->Convert(tmpStr,cmLocalGenerator::HOME_OUTPUT)
-                    << "\"\n";
-    }
-  cmakefileStream << "  )\n\n";
+    cmakefileStream << "# Byproducts of CMake generate step:\n"
+                    << "set(CMAKE_MAKEFILE_PRODUCTS\n";
+    const std::vector<std::string>& outfiles =
+      lg->GetMakefile()->GetOutputFiles();
+    for (std::vector<std::string>::const_iterator k = outfiles.begin();
+         k != outfiles.end(); ++k) {
+      cmakefileStream << "  \""
+                      << lg->Convert(*k, cmLocalGenerator::HOME_OUTPUT)
+                      << "\"\n";
+    }
+
+    // add in all the directory information files
+    std::string tmpStr;
+    for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
+      lg =
+        static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
+      tmpStr = lg->GetCurrentBinaryDirectory();
+      tmpStr += cmake::GetCMakeFilesDirectory();
+      tmpStr += "/CMakeDirectoryInformation.cmake";
+      cmakefileStream << "  \""
+                      << lg->Convert(tmpStr, cmLocalGenerator::HOME_OUTPUT)
+                      << "\"\n";
+    }
+    cmakefileStream << "  )\n\n";
   }
 
   this->WriteMainCMakefileLanguageRules(cmakefileStream,
                                         this->LocalGenerators);
 }
 
-void cmGlobalUnixMakefileGenerator3
-::WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream,
-                                  std::vector<cmLocalGenerator *> &lGenerators
-                                  )
+void cmGlobalUnixMakefileGenerator3::WriteMainCMakefileLanguageRules(
+  cmGeneratedFileStream& cmakefileStream,
+  std::vector<cmLocalGenerator*>& lGenerators)
 {
-  cmLocalUnixMakefileGenerator3 *lg;
+  cmLocalUnixMakefileGenerator3* lg;
 
   // now list all the target info files
-  cmakefileStream
-    << "# Dependency information for all targets:\n";
-  cmakefileStream
-    << "set(CMAKE_DEPEND_INFO_FILES\n";
-  for (unsigned int i = 0; i < lGenerators.size(); ++i)
-    {
-    lg = static_cast<cmLocalUnixMakefileGenerator3 *>(lGenerators[i]);
+  cmakefileStream << "# Dependency information for all targets:\n";
+  cmakefileStream << "set(CMAKE_DEPEND_INFO_FILES\n";
+  for (unsigned int i = 0; i < lGenerators.size(); ++i) {
+    lg = static_cast<cmLocalUnixMakefileGenerator3*>(lGenerators[i]);
     // for all of out targets
     std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets();
     for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-         l != tgts.end(); l++)
-      {
-      if(((*l)->GetType() == cmState::EXECUTABLE) ||
-         ((*l)->GetType() == cmState::STATIC_LIBRARY) ||
-         ((*l)->GetType() == cmState::SHARED_LIBRARY) ||
-         ((*l)->GetType() == cmState::MODULE_LIBRARY) ||
-         ((*l)->GetType() == cmState::OBJECT_LIBRARY) ||
-         ((*l)->GetType() == cmState::UTILITY))
-        {
+         l != tgts.end(); l++) {
+      if (((*l)->GetType() == cmState::EXECUTABLE) ||
+          ((*l)->GetType() == cmState::STATIC_LIBRARY) ||
+          ((*l)->GetType() == cmState::SHARED_LIBRARY) ||
+          ((*l)->GetType() == cmState::MODULE_LIBRARY) ||
+          ((*l)->GetType() == cmState::OBJECT_LIBRARY) ||
+          ((*l)->GetType() == cmState::UTILITY)) {
         cmGeneratorTarget* gt = *l;
         std::string tname = lg->GetRelativeTargetDirectory(gt);
         tname += "/DependInfo.cmake";
         cmSystemTools::ConvertToUnixSlashes(tname);
         cmakefileStream << "  \"" << tname << "\"\n";
-        }
       }
     }
+  }
   cmakefileStream << "  )\n";
 }
 
-void
-cmGlobalUnixMakefileGenerator3
-::WriteDirectoryRule2(std::ostream& ruleFileStream,
-                      cmLocalUnixMakefileGenerator3* lg,
-                      const char* pass, bool check_all,
-                      bool check_relink)
+void cmGlobalUnixMakefileGenerator3::WriteDirectoryRule2(
+  std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg,
+  const char* pass, bool check_all, bool check_relink)
 {
   // Get the relative path to the subdirectory from the top.
   std::string makeTarget = lg->GetCurrentBinaryDirectory();
@@ -455,80 +413,67 @@ cmGlobalUnixMakefileGenerator3
   // for all targets in the directory.
   std::vector<std::string> depends;
   std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator l = targets.begin();
-      l != targets.end(); ++l)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator l = targets.begin();
+       l != targets.end(); ++l) {
     cmGeneratorTarget* gtarget = *l;
     int type = gtarget->GetType();
-    if((type == cmState::EXECUTABLE) ||
-       (type == cmState::STATIC_LIBRARY) ||
-       (type == cmState::SHARED_LIBRARY) ||
-       (type == cmState::MODULE_LIBRARY) ||
-       (type == cmState::OBJECT_LIBRARY) ||
-       (type == cmState::UTILITY))
-      {
+    if ((type == cmState::EXECUTABLE) || (type == cmState::STATIC_LIBRARY) ||
+        (type == cmState::SHARED_LIBRARY) ||
+        (type == cmState::MODULE_LIBRARY) ||
+        (type == cmState::OBJECT_LIBRARY) || (type == cmState::UTILITY)) {
       // Add this to the list of depends rules in this directory.
-      if((!check_all || !gtarget->GetPropertyAsBool("EXCLUDE_FROM_ALL")) &&
-         (!check_relink ||
-          gtarget
-            ->NeedRelinkBeforeInstall(lg->GetConfigName())))
-        {
+      if ((!check_all || !gtarget->GetPropertyAsBool("EXCLUDE_FROM_ALL")) &&
+          (!check_relink ||
+           gtarget->NeedRelinkBeforeInstall(lg->GetConfigName()))) {
         std::string tname = lg->GetRelativeTargetDirectory(gtarget);
         tname += "/";
         tname += pass;
         depends.push_back(tname);
-        }
       }
     }
+  }
 
   // The directory-level rule should depend on the directory-level
   // rules of the subdirectories.
-  std::vector<cmState::Snapshot> children
-      = lg->GetStateSnapshot().GetChildren();
-  for(std::vector<cmState::Snapshot>::const_iterator
-        ci = children.begin(); ci != children.end(); ++ci)
-    {
+  std::vector<cmState::Snapshot> children =
+    lg->GetStateSnapshot().GetChildren();
+  for (std::vector<cmState::Snapshot>::const_iterator ci = children.begin();
+       ci != children.end(); ++ci) {
     std::string subdir = ci->GetDirectory().GetCurrentBinary();
     subdir += "/";
     subdir += pass;
     depends.push_back(subdir);
-    }
+  }
 
   // Work-around for makes that drop rules that have no dependencies
   // or commands.
-  if(depends.empty() && this->EmptyRuleHackDepends != "")
-    {
+  if (depends.empty() && this->EmptyRuleHackDepends != "") {
     depends.push_back(this->EmptyRuleHackDepends);
-    }
+  }
 
   // Write the rule.
   std::string doc = "Convenience name for \"";
   doc += pass;
   doc += "\" pass in the directory.";
   std::vector<std::string> no_commands;
-  lg->WriteMakeRule(ruleFileStream, doc.c_str(),
-                    makeTarget, depends, no_commands, true);
+  lg->WriteMakeRule(ruleFileStream, doc.c_str(), makeTarget, depends,
+                    no_commands, true);
 }
 
-void
-cmGlobalUnixMakefileGenerator3
-::WriteDirectoryRules2(std::ostream& ruleFileStream,
-                       cmLocalUnixMakefileGenerator3* lg)
+void cmGlobalUnixMakefileGenerator3::WriteDirectoryRules2(
+  std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg)
 {
   // Only subdirectories need these rules.
-  if(lg->IsRootMakefile())
-    {
+  if (lg->IsRootMakefile()) {
     return;
-    }
+  }
 
   // Begin the directory-level rules section.
   std::string dir = lg->GetCurrentBinaryDirectory();
   dir = lg->Convert(dir, cmLocalGenerator::HOME_OUTPUT,
                     cmLocalGenerator::MAKERULE);
   lg->WriteDivider(ruleFileStream);
-  ruleFileStream
-    << "# Directory level rules for directory "
-    << dir << "\n\n";
+  ruleFileStream << "# Directory level rules for directory " << dir << "\n\n";
 
   // Write directory-level rules for "all".
   this->WriteDirectoryRule2(ruleFileStream, lg, "all", true, false);
@@ -540,66 +485,51 @@ cmGlobalUnixMakefileGenerator3
   this->WriteDirectoryRule2(ruleFileStream, lg, "preinstall", true, true);
 }
 
-void cmGlobalUnixMakefileGenerator3
-::GenerateBuildCommand(std::vector<std::string>& makeCommand,
-                       const std::string& makeProgram,
-                       const std::string& /*projectName*/,
-                       const std::string& /*projectDir*/,
-                       const std::string& targetName,
-                       const std::string& /*config*/,
-                       bool fast, bool /*verbose*/,
-                       std::vector<std::string> const& makeOptions)
+void cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& /*projectName*/, const std::string& /*projectDir*/,
+  const std::string& targetName, const std::string& /*config*/, bool fast,
+  bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
-  makeCommand.push_back(
-    this->SelectMakeProgram(makeProgram)
-    );
+  makeCommand.push_back(this->SelectMakeProgram(makeProgram));
 
   // Since we have full control over the invocation of nmake, let us
   // make it quiet.
-  if (cmHasLiteralPrefix(this->GetName(), "NMake Makefiles"))
-    {
+  if (cmHasLiteralPrefix(this->GetName(), "NMake Makefiles")) {
     makeCommand.push_back("/NOLOGO");
-    }
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
-  if (!targetName.empty())
-    {
+  }
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
+  if (!targetName.empty()) {
     cmMakefile* mf;
-    if (!this->Makefiles.empty())
-      {
+    if (!this->Makefiles.empty()) {
       mf = this->Makefiles[0];
-      }
-    else
-      {
+    } else {
       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());
       snapshot.SetDefaultDefinitions();
       mf = new cmMakefile(this, snapshot);
-      }
+    }
 
     std::string tname = targetName;
-    if(fast)
-      {
+    if (fast) {
       tname += "/fast";
-      }
+    }
     cmOutputConverter conv(mf->GetStateSnapshot());
-    tname = conv.Convert(tname,cmOutputConverter::HOME_OUTPUT);
+    tname = conv.Convert(tname, cmOutputConverter::HOME_OUTPUT);
     cmSystemTools::ConvertToOutputSlashes(tname);
     makeCommand.push_back(tname);
-    if (this->Makefiles.empty())
-      {
+    if (this->Makefiles.empty()) {
       delete mf;
-      }
     }
+  }
 }
 
-void
-cmGlobalUnixMakefileGenerator3
-::WriteConvenienceRules(std::ostream& ruleFileStream,
-                        std::set<std::string> &emitted)
+void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules(
+  std::ostream& ruleFileStream, std::set<std::string>& emitted)
 {
   std::vector<std::string> depends;
   std::vector<std::string> commands;
@@ -608,54 +538,43 @@ cmGlobalUnixMakefileGenerator3
 
   // write the target convenience rules
   unsigned int i;
-  cmLocalUnixMakefileGenerator3 *lg;
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    lg = static_cast<cmLocalUnixMakefileGenerator3 *>
-      (this->LocalGenerators[i]);
+  cmLocalUnixMakefileGenerator3* lg;
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
+    lg = static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
     // for each target Generate the rule files for each target.
     std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-        t != targets.end(); ++t)
-      {
+    for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+         t != targets.end(); ++t) {
       cmGeneratorTarget* gtarget = *t;
       // Don't emit the same rule twice (e.g. two targets with the same
       // simple name)
       int type = gtarget->GetType();
       std::string name = gtarget->GetName();
-      if(!name.empty() &&
-         emitted.insert(name).second &&
-         // Handle user targets here.  Global targets are handled in
-         // the local generator on a per-directory basis.
-         ((type == cmState::EXECUTABLE) ||
-          (type == cmState::STATIC_LIBRARY) ||
-          (type == cmState::SHARED_LIBRARY) ||
-          (type == cmState::MODULE_LIBRARY) ||
-          (type == cmState::OBJECT_LIBRARY) ||
-          (type == cmState::UTILITY)))
-        {
+      if (!name.empty() && emitted.insert(name).second &&
+          // Handle user targets here.  Global targets are handled in
+          // the local generator on a per-directory basis.
+          ((type == cmState::EXECUTABLE) ||
+           (type == cmState::STATIC_LIBRARY) ||
+           (type == cmState::SHARED_LIBRARY) ||
+           (type == cmState::MODULE_LIBRARY) ||
+           (type == cmState::OBJECT_LIBRARY) || (type == cmState::UTILITY))) {
         // Add a rule to build the target by name.
         lg->WriteDivider(ruleFileStream);
-        ruleFileStream
-          << "# Target rules for targets named "
-          << name << "\n\n";
+        ruleFileStream << "# Target rules for targets named " << name
+                       << "\n\n";
 
         // Write the rule.
         commands.clear();
         std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
         tmp += "Makefile2";
-        commands.push_back(lg->GetRecursiveMakeCall
-                            (tmp.c_str(),name));
+        commands.push_back(lg->GetRecursiveMakeCall(tmp.c_str(), name));
         depends.clear();
         depends.push_back("cmake_check_build_system");
-        lg->WriteMakeRule(ruleFileStream,
-                          "Build rule for target.",
-                          name, depends, commands,
-                          true);
+        lg->WriteMakeRule(ruleFileStream, "Build rule for target.", name,
+                          depends, commands, true);
 
         // Add a fast rule to build the target
-        std::string localName =
-                          lg->GetRelativeTargetDirectory(gtarget);
+        std::string localName = lg->GetRelativeTargetDirectory(gtarget);
         std::string makefileName;
         makefileName = localName;
         makefileName += "/build.make";
@@ -665,66 +584,56 @@ cmGlobalUnixMakefileGenerator3
         makeTargetName += "/build";
         localName = name;
         localName += "/fast";
-        commands.push_back(lg->GetRecursiveMakeCall
-                            (makefileName.c_str(), makeTargetName));
+        commands.push_back(
+          lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
         lg->WriteMakeRule(ruleFileStream, "fast build rule for target.",
                           localName, depends, commands, true);
 
         // Add a local name for the rule to relink the target before
         // installation.
-        if(gtarget
-             ->NeedRelinkBeforeInstall(lg->GetConfigName()))
-          {
+        if (gtarget->NeedRelinkBeforeInstall(lg->GetConfigName())) {
           makeTargetName = lg->GetRelativeTargetDirectory(gtarget);
           makeTargetName += "/preinstall";
           localName = name;
           localName += "/preinstall";
           depends.clear();
           commands.clear();
-          commands.push_back(lg->GetRecursiveMakeCall
-                             (makefileName.c_str(), makeTargetName));
+          commands.push_back(
+            lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
           lg->WriteMakeRule(ruleFileStream,
                             "Manual pre-install relink rule for target.",
                             localName, depends, commands, true);
-          }
         }
       }
     }
+  }
 }
 
-
-void
-cmGlobalUnixMakefileGenerator3
-::WriteConvenienceRules2(std::ostream& ruleFileStream,
-                         cmLocalUnixMakefileGenerator3 *lg)
+void cmGlobalUnixMakefileGenerator3::WriteConvenienceRules2(
+  std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg)
 {
   std::vector<std::string> depends;
   std::vector<std::string> commands;
   std::string localName;
   std::string makeTargetName;
 
-
   // write the directory level rules for this local gen
-  this->WriteDirectoryRules2(ruleFileStream,lg);
+  this->WriteDirectoryRules2(ruleFileStream, lg);
 
   depends.push_back("cmake_check_build_system");
 
   // for each target Generate the rule files for each target.
   std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
     cmGeneratorTarget* gtarget = *t;
     int type = gtarget->GetType();
     std::string name = gtarget->GetName();
-    if (!name.empty()
-     && (  (type == cmState::EXECUTABLE)
-        || (type == cmState::STATIC_LIBRARY)
-        || (type == cmState::SHARED_LIBRARY)
-        || (type == cmState::MODULE_LIBRARY)
-        || (type == cmState::OBJECT_LIBRARY)
-        || (type == cmState::UTILITY)))
-      {
+    if (!name.empty() &&
+        ((type == cmState::EXECUTABLE) || (type == cmState::STATIC_LIBRARY) ||
+         (type == cmState::SHARED_LIBRARY) ||
+         (type == cmState::MODULE_LIBRARY) ||
+         (type == cmState::OBJECT_LIBRARY) || (type == cmState::UTILITY))) {
       std::string makefileName;
       // Add a rule to build the target by name.
       localName = lg->GetRelativeTargetDirectory(gtarget);
@@ -734,28 +643,25 @@ cmGlobalUnixMakefileGenerator3
       bool needRequiresStep = this->NeedRequiresStep(gtarget);
 
       lg->WriteDivider(ruleFileStream);
-      ruleFileStream
-        << "# Target rules for target "
-        << localName << "\n\n";
+      ruleFileStream << "# Target rules for target " << localName << "\n\n";
 
       commands.clear();
       makeTargetName = localName;
       makeTargetName += "/depend";
-      commands.push_back(lg->GetRecursiveMakeCall
-                         (makefileName.c_str(),makeTargetName));
+      commands.push_back(
+        lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
 
       // add requires if we need it for this generator
-      if (needRequiresStep)
-        {
+      if (needRequiresStep) {
         makeTargetName = localName;
         makeTargetName += "/requires";
-        commands.push_back(lg->GetRecursiveMakeCall
-                          (makefileName.c_str(),makeTargetName));
-        }
+        commands.push_back(
+          lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
+      }
       makeTargetName = localName;
       makeTargetName += "/build";
-      commands.push_back(lg->GetRecursiveMakeCall
-                         (makefileName.c_str(),makeTargetName));
+      commands.push_back(
+        lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
 
       // Write the rule.
       localName += "/all";
@@ -765,76 +671,68 @@ cmGlobalUnixMakefileGenerator3
       progress.Dir = lg->GetBinaryDirectory();
       progress.Dir += cmake::GetCMakeFilesDirectory();
       {
-      std::ostringstream progressArg;
-      const char* sep = "";
-      std::vector<unsigned long>& progFiles =
-        this->ProgressMap[gtarget].Marks;
-      for (std::vector<unsigned long>::iterator i = progFiles.begin();
-           i != progFiles.end(); ++i)
-        {
-        progressArg << sep << *i;
-        sep = ",";
+        std::ostringstream progressArg;
+        const char* sep = "";
+        std::vector<unsigned long>& progFiles =
+          this->ProgressMap[gtarget].Marks;
+        for (std::vector<unsigned long>::iterator i = progFiles.begin();
+             i != progFiles.end(); ++i) {
+          progressArg << sep << *i;
+          sep = ",";
         }
-      progress.Arg = progressArg.str();
+        progress.Arg = progressArg.str();
       }
 
       bool targetMessages = true;
-      if (const char* tgtMsg = this->GetCMakeInstance()
-                                   ->GetState()
-                                   ->GetGlobalProperty("TARGET_MESSAGES"))
-        {
+      if (const char* tgtMsg =
+            this->GetCMakeInstance()->GetState()->GetGlobalProperty(
+              "TARGET_MESSAGES")) {
         targetMessages = cmSystemTools::IsOn(tgtMsg);
-        }
+      }
 
-      if (targetMessages)
-        {
+      if (targetMessages) {
         lg->AppendEcho(commands, "Built target " + name,
-          cmLocalUnixMakefileGenerator3::EchoNormal, &progress);
-        }
+                       cmLocalUnixMakefileGenerator3::EchoNormal, &progress);
+      }
 
       this->AppendGlobalTargetDepends(depends, gtarget);
       lg->WriteMakeRule(ruleFileStream, "All Build rule for target.",
                         localName, depends, commands, true);
 
       // add the all/all dependency
-      if(!this->IsExcluded(this->LocalGenerators[0], gtarget))
-        {
+      if (!this->IsExcluded(this->LocalGenerators[0], gtarget)) {
         depends.clear();
         depends.push_back(localName);
         commands.clear();
-        lg->WriteMakeRule(ruleFileStream, "Include target in all.",
-                          "all", depends, commands, true);
-        }
+        lg->WriteMakeRule(ruleFileStream, "Include target in all.", "all",
+                          depends, commands, true);
+      }
 
       // Write the rule.
       commands.clear();
 
       {
-      // TODO: Convert the total progress count to a make variable.
-      std::ostringstream progCmd;
-      progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
-      // # in target
-      progCmd << lg->Convert(progress.Dir,
-                              cmLocalGenerator::FULL,
-                              cmLocalGenerator::SHELL);
-      //
-      std::set<cmGeneratorTarget const*> emitted;
-      progCmd << " "
-              << this->CountProgressMarksInTarget(gtarget, emitted);
-      commands.push_back(progCmd.str());
+        // TODO: Convert the total progress count to a make variable.
+        std::ostringstream progCmd;
+        progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
+        // # in target
+        progCmd << lg->Convert(progress.Dir, cmLocalGenerator::FULL,
+                               cmLocalGenerator::SHELL);
+        //
+        std::set<cmGeneratorTarget const*> emitted;
+        progCmd << " " << this->CountProgressMarksInTarget(gtarget, emitted);
+        commands.push_back(progCmd.str());
       }
       std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
       tmp += "Makefile2";
-      commands.push_back(lg->GetRecursiveMakeCall
-                          (tmp.c_str(),localName));
+      commands.push_back(lg->GetRecursiveMakeCall(tmp.c_str(), localName));
       {
-      std::ostringstream progCmd;
-      progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
-      progCmd << lg->Convert(progress.Dir,
-                              cmLocalGenerator::FULL,
-                              cmLocalGenerator::SHELL);
-      progCmd << " 0";
-      commands.push_back(progCmd.str());
+        std::ostringstream progCmd;
+        progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
+        progCmd << lg->Convert(progress.Dir, cmLocalGenerator::FULL,
+                               cmLocalGenerator::SHELL);
+        progCmd << " 0";
+        commands.push_back(progCmd.str());
       }
       depends.clear();
       depends.push_back("cmake_check_build_system");
@@ -848,32 +746,29 @@ cmGlobalUnixMakefileGenerator3
       commands.clear();
       depends.clear();
       depends.push_back(localName);
-      lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
-                        name, depends, commands, true);
+      lg->WriteMakeRule(ruleFileStream, "Convenience name for target.", name,
+                        depends, commands, true);
 
       // Add rules to prepare the target for installation.
-      if(gtarget
-           ->NeedRelinkBeforeInstall(lg->GetConfigName()))
-        {
+      if (gtarget->NeedRelinkBeforeInstall(lg->GetConfigName())) {
         localName = lg->GetRelativeTargetDirectory(gtarget);
         localName += "/preinstall";
         depends.clear();
         commands.clear();
-        commands.push_back(lg->GetRecursiveMakeCall
-                            (makefileName.c_str(), localName));
+        commands.push_back(
+          lg->GetRecursiveMakeCall(makefileName.c_str(), localName));
         lg->WriteMakeRule(ruleFileStream,
-                          "Pre-install relink rule for target.",
-                          localName, depends, commands, true);
+                          "Pre-install relink rule for target.", localName,
+                          depends, commands, true);
 
-        if(!this->IsExcluded(this->LocalGenerators[0], gtarget))
-          {
+        if (!this->IsExcluded(this->LocalGenerators[0], gtarget)) {
           depends.clear();
           depends.push_back(localName);
           commands.clear();
           lg->WriteMakeRule(ruleFileStream, "Prepare target for install.",
                             "preinstall", depends, commands, true);
-          }
         }
+      }
 
       // add the clean rule
       localName = lg->GetRelativeTargetDirectory(gtarget);
@@ -881,16 +776,16 @@ cmGlobalUnixMakefileGenerator3
       makeTargetName += "/clean";
       depends.clear();
       commands.clear();
-      commands.push_back(lg->GetRecursiveMakeCall
-                          (makefileName.c_str(), makeTargetName));
+      commands.push_back(
+        lg->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
       lg->WriteMakeRule(ruleFileStream, "clean rule for target.",
                         makeTargetName, depends, commands, true);
       commands.clear();
       depends.push_back(makeTargetName);
-      lg->WriteMakeRule(ruleFileStream, "clean rule for target.",
-                        "clean", depends, commands, true);
-      }
+      lg->WriteMakeRule(ruleFileStream, "clean rule for target.", "clean",
+                        depends, commands, true);
     }
+  }
 }
 
 // Build a map that contains a the set of targets used by each local
@@ -899,33 +794,29 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
 {
   this->DirectoryTargetsMap.clear();
   // Loop over all targets in all local generators.
-  for(std::vector<cmLocalGenerator*>::const_iterator
-        lgi = this->LocalGenerators.begin();
-      lgi != this->LocalGenerators.end(); ++lgi)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator lgi =
+         this->LocalGenerators.begin();
+       lgi != this->LocalGenerators.end(); ++lgi) {
     cmLocalGenerator* lg = *lgi;
     std::vector<cmGeneratorTarget*> targets = lg->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
-        t != targets.end(); ++t)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator t = targets.begin();
+         t != targets.end(); ++t) {
       cmGeneratorTarget* gt = *t;
 
       cmLocalGenerator* tlg = gt->GetLocalGenerator();
 
-      if(gt->GetType() == cmState::INTERFACE_LIBRARY
-          || gt->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-        {
+      if (gt->GetType() == cmState::INTERFACE_LIBRARY ||
+          gt->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
         continue;
-        }
+      }
 
       cmState::Snapshot csnp = lg->GetStateSnapshot();
       cmState::Snapshot tsnp = tlg->GetStateSnapshot();
 
       // Consider the directory containing the target and all its
       // parents until something excludes the target.
-      for( ; csnp.IsValid() && !this->IsExcluded(csnp, tsnp);
-          csnp = csnp.GetBuildsystemDirectoryParent())
-        {
+      for (; csnp.IsValid() && !this->IsExcluded(csnp, tsnp);
+           csnp = csnp.GetBuildsystemDirectoryParent()) {
         // This local generator includes the target.
         std::set<cmGeneratorTarget const*>& targetSet =
           this->DirectoryTargetsMap[csnp];
@@ -935,57 +826,48 @@ void cmGlobalUnixMakefileGenerator3::InitializeProgressMarks()
         // target may still be included if it is a dependency of a
         // non-excluded target.
         TargetDependSet const& tgtdeps = this->GetTargetDirectDepends(gt);
-        for(TargetDependSet::const_iterator ti = tgtdeps.begin();
-            ti != tgtdeps.end(); ++ti)
-          {
+        for (TargetDependSet::const_iterator ti = tgtdeps.begin();
+             ti != tgtdeps.end(); ++ti) {
           targetSet.insert(*ti);
-          }
         }
       }
     }
+  }
 }
 
-size_t
-cmGlobalUnixMakefileGenerator3
-::CountProgressMarksInTarget(cmGeneratorTarget const* target,
-                             std::set<cmGeneratorTarget const*>& emitted)
+size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInTarget(
+  cmGeneratorTarget const* target, std::set<cmGeneratorTarget const*>& emitted)
 {
   size_t count = 0;
-  if(emitted.insert(target).second)
-    {
+  if (emitted.insert(target).second) {
     count = this->ProgressMap[target].Marks.size();
     TargetDependSet const& depends = this->GetTargetDirectDepends(target);
-    for(TargetDependSet::const_iterator di = depends.begin();
-        di != depends.end(); ++di)
-      {
-      if ((*di)->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+    for (TargetDependSet::const_iterator di = depends.begin();
+         di != depends.end(); ++di) {
+      if ((*di)->GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
-      count += this->CountProgressMarksInTarget(*di, emitted);
       }
+      count += this->CountProgressMarksInTarget(*di, emitted);
     }
+  }
   return count;
 }
 
-size_t
-cmGlobalUnixMakefileGenerator3
-::CountProgressMarksInAll(cmLocalGenerator* lg)
+size_t cmGlobalUnixMakefileGenerator3::CountProgressMarksInAll(
+  cmLocalGenerator* lg)
 {
   size_t count = 0;
   std::set<cmGeneratorTarget const*> emitted;
-  std::set<cmGeneratorTarget const*> const& targets
-      = this->DirectoryTargetsMap[lg->GetStateSnapshot()];
-  for(std::set<cmGeneratorTarget const*>::const_iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
+  std::set<cmGeneratorTarget const*> const& targets =
+    this->DirectoryTargetsMap[lg->GetStateSnapshot()];
+  for (std::set<cmGeneratorTarget const*>::const_iterator t = targets.begin();
+       t != targets.end(); ++t) {
     count += this->CountProgressMarksInTarget(*t, emitted);
-    }
+  }
   return count;
 }
 
-void
-cmGlobalUnixMakefileGenerator3::RecordTargetProgress(
+void cmGlobalUnixMakefileGenerator3::RecordTargetProgress(
   cmMakefileTargetGenerator* tg)
 {
   TargetProgress& tp = this->ProgressMap[tg->GetGeneratorTarget()];
@@ -993,141 +875,122 @@ cmGlobalUnixMakefileGenerator3::RecordTargetProgress(
   tp.VariableFile = tg->GetProgressFileNameFull();
 }
 
-void
-cmGlobalUnixMakefileGenerator3::TargetProgress
-::WriteProgressVariables(unsigned long total, unsigned long &current)
+void cmGlobalUnixMakefileGenerator3::TargetProgress::WriteProgressVariables(
+  unsigned long total, unsigned long& current)
 {
   cmGeneratedFileStream fout(this->VariableFile.c_str());
-  for(unsigned long i = 1; i <= this->NumberOfActions; ++i)
-    {
+  for (unsigned long i = 1; i <= this->NumberOfActions; ++i) {
     fout << "CMAKE_PROGRESS_" << i << " = ";
-    if (total <= 100)
-      {
+    if (total <= 100) {
       unsigned long num = i + current;
       fout << num;
       this->Marks.push_back(num);
-      }
-    else if (((i+current)*100)/total > ((i-1+current)*100)/total)
-      {
-      unsigned long num = ((i+current)*100)/total;
+    } else if (((i + current) * 100) / total >
+               ((i - 1 + current) * 100) / total) {
+      unsigned long num = ((i + current) * 100) / total;
       fout << num;
       this->Marks.push_back(num);
-      }
-    fout << "\n";
     }
+    fout << "\n";
+  }
   fout << "\n";
   current += this->NumberOfActions;
 }
 
-void
-cmGlobalUnixMakefileGenerator3
-::AppendGlobalTargetDepends(std::vector<std::string>& depends,
-                            cmGeneratorTarget* target)
+void cmGlobalUnixMakefileGenerator3::AppendGlobalTargetDepends(
+  std::vector<std::string>& depends, cmGeneratorTarget* target)
 {
   TargetDependSet const& depends_set = this->GetTargetDirectDepends(target);
-  for(TargetDependSet::const_iterator i = depends_set.begin();
-      i != depends_set.end(); ++i)
-    {
+  for (TargetDependSet::const_iterator i = depends_set.begin();
+       i != depends_set.end(); ++i) {
     // Create the target-level dependency.
     cmGeneratorTarget const* dep = *i;
-    if (dep->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (dep->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     cmLocalUnixMakefileGenerator3* lg3 =
       static_cast<cmLocalUnixMakefileGenerator3*>(dep->GetLocalGenerator());
     std::string tgtName =
-        lg3->GetRelativeTargetDirectory(const_cast<cmGeneratorTarget*>(dep));
+      lg3->GetRelativeTargetDirectory(const_cast<cmGeneratorTarget*>(dep));
     tgtName += "/all";
     depends.push_back(tgtName);
-    }
+  }
 }
 
-void cmGlobalUnixMakefileGenerator3::WriteHelpRule
-(std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3 *lg)
+void cmGlobalUnixMakefileGenerator3::WriteHelpRule(
+  std::ostream& ruleFileStream, cmLocalUnixMakefileGenerator3* lg)
 {
   // add the help target
   std::string path;
   std::vector<std::string> no_depends;
   std::vector<std::string> commands;
-  lg->AppendEcho(commands,"The following are some of the valid targets "
-                 "for this Makefile:");
-  lg->AppendEcho(commands,"... all (the default if no target is provided)");
-  lg->AppendEcho(commands,"... clean");
-  lg->AppendEcho(commands,"... depend");
+  lg->AppendEcho(commands, "The following are some of the valid targets "
+                           "for this Makefile:");
+  lg->AppendEcho(commands, "... all (the default if no target is provided)");
+  lg->AppendEcho(commands, "... clean");
+  lg->AppendEcho(commands, "... depend");
 
   // Keep track of targets already listed.
   std::set<std::string> emittedTargets;
 
   // for each local generator
   unsigned int i;
-  cmLocalUnixMakefileGenerator3 *lg2;
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
+  cmLocalUnixMakefileGenerator3* lg2;
+  for (i = 0; i < this->LocalGenerators.size(); ++i) {
     lg2 =
-      static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
+      static_cast<cmLocalUnixMakefileGenerator3*>(this->LocalGenerators[i]);
     // for the passed in makefile or if this is the top Makefile wripte out
     // the targets
-    if (lg2 == lg || lg->IsRootMakefile())
-      {
+    if (lg2 == lg || lg->IsRootMakefile()) {
       // for each target Generate the rule files for each target.
       std::vector<cmGeneratorTarget*> targets = lg2->GetGeneratorTargets();
-      for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-          t != targets.end(); ++t)
-        {
+      for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+           t != targets.end(); ++t) {
         cmGeneratorTarget* target = *t;
         cmState::TargetType type = target->GetType();
-        if((type == cmState::EXECUTABLE) ||
-           (type == cmState::STATIC_LIBRARY) ||
-           (type == cmState::SHARED_LIBRARY) ||
-           (type == cmState::MODULE_LIBRARY) ||
-           (type == cmState::OBJECT_LIBRARY) ||
-           (type == cmState::GLOBAL_TARGET) ||
-           (type == cmState::UTILITY))
-          {
+        if ((type == cmState::EXECUTABLE) ||
+            (type == cmState::STATIC_LIBRARY) ||
+            (type == cmState::SHARED_LIBRARY) ||
+            (type == cmState::MODULE_LIBRARY) ||
+            (type == cmState::OBJECT_LIBRARY) ||
+            (type == cmState::GLOBAL_TARGET) || (type == cmState::UTILITY)) {
           std::string name = target->GetName();
-          if(emittedTargets.insert(name).second)
-            {
+          if (emittedTargets.insert(name).second) {
             path = "... ";
             path += name;
-            lg->AppendEcho(commands,path.c_str());
-            }
+            lg->AppendEcho(commands, path.c_str());
           }
         }
       }
     }
+  }
   std::vector<std::string> const& localHelp = lg->GetLocalHelp();
-  for(std::vector<std::string>::const_iterator o = localHelp.begin();
-      o != localHelp.end(); ++o)
-    {
+  for (std::vector<std::string>::const_iterator o = localHelp.begin();
+       o != localHelp.end(); ++o) {
     path = "... ";
     path += *o;
     lg->AppendEcho(commands, path.c_str());
-    }
-  lg->WriteMakeRule(ruleFileStream, "Help Target",
-                    "help",
-                    no_depends, commands, true);
+  }
+  lg->WriteMakeRule(ruleFileStream, "Help Target", "help", no_depends,
+                    commands, true);
   ruleFileStream << "\n\n";
 }
 
-
-bool cmGlobalUnixMakefileGenerator3
-::NeedRequiresStep(const cmGeneratorTarget* target)
+bool cmGlobalUnixMakefileGenerator3::NeedRequiresStep(
+  const cmGeneratorTarget* target)
 {
   std::set<std::string> languages;
-  target->GetLanguages(languages,
-                       target->Target->GetMakefile()
-                       ->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-  for(std::set<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
-    {
+  target->GetLanguages(
+    languages,
+    target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+  for (std::set<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
     std::string var = "CMAKE_NEEDS_REQUIRES_STEP_";
     var += *l;
     var += "_FLAG";
-    if(target->Target->GetMakefile()->GetDefinition(var))
-      {
+    if (target->Target->GetMakefile()->GetDefinition(var)) {
       return true;
-      }
     }
+  }
   return false;
 }
diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h
index b035df4..f951b2a 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.h
+++ b/Source/cmGlobalUnixMakefileGenerator3.h
@@ -56,14 +56,18 @@ class cmGlobalUnixMakefileGenerator3 : public cmGlobalCommonGenerator
 {
 public:
   cmGlobalUnixMakefileGenerator3(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalUnixMakefileGenerator3>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<
+      cmGlobalUnixMakefileGenerator3>();
+  }
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalUnixMakefileGenerator3::GetActualName();}
-  static std::string GetActualName() {return "Unix Makefiles";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalUnixMakefileGenerator3::GetActualName();
+  }
+  static std::string GetActualName() { return "Unix Makefiles"; }
 
   /**
    * Utilized by the generator factory to determine if this generator
@@ -74,14 +78,14 @@ public:
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
-  virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 
   virtual void Configure();
 
@@ -92,17 +96,16 @@ public:
    */
   virtual void Generate();
 
-
   void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream,
-                                       std::vector<cmLocalGenerator *> &);
+                                       std::vector<cmLocalGenerator*>&);
 
   // write out the help rule listing the valid targets
   void WriteHelpRule(std::ostream& ruleFileStream,
-                     cmLocalUnixMakefileGenerator3 *);
+                     cmLocalUnixMakefileGenerator3*);
 
   // write the top level target rules
   void WriteConvenienceRules(std::ostream& ruleFileStream,
-                             std::set<std::string> &emitted);
+                             std::set<std::string>& emitted);
 
   /** Get the command to use for a target that has no rule.  This is
       used for multiple output dependencies and for cmake_force.  */
@@ -114,22 +117,18 @@ public:
 
   // change the build command for speed
   virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand,
-    const std::string& makeProgram,
-    const std::string& projectName,
-    const std::string& projectDir,
-    const std::string& targetName,
-    const std::string& config,
-    bool fast, bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+    const std::string& projectName, const std::string& projectDir,
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
   /** Record per-target progress information.  */
   void RecordTargetProgress(cmMakefileTargetGenerator* tg);
 
-  void AddCXXCompileCommand(const std::string &sourceFile,
-                            const std::string &workingDirectory,
-                            const std::string &compileCommand);
+  void AddCXXCompileCommand(const std::string& sourceFile,
+                            const std::string& workingDirectory,
+                            const std::string& compileCommand);
 
   /** Does the make tool tolerate .NOTPARALLEL? */
   virtual bool AllowNotParallel() const { return true; }
@@ -143,6 +142,7 @@ public:
   bool DefineWindowsNULL;
   bool PassMakeflags;
   bool UnixCD;
+
 protected:
   void WriteMainMakefile2();
   void WriteMainCMakefile();
@@ -151,9 +151,8 @@ protected:
                               cmLocalUnixMakefileGenerator3*);
 
   void WriteDirectoryRule2(std::ostream& ruleFileStream,
-                           cmLocalUnixMakefileGenerator3* lg,
-                           const char* pass, bool check_all,
-                           bool check_relink);
+                           cmLocalUnixMakefileGenerator3* lg, const char* pass,
+                           bool check_all, bool check_relink);
   void WriteDirectoryRules2(std::ostream& ruleFileStream,
                             cmLocalUnixMakefileGenerator3* lg);
 
@@ -164,17 +163,17 @@ protected:
   bool NeedRequiresStep(cmGeneratorTarget const*);
 
   // Target name hooks for superclass.
-  const char* GetAllTargetName()           const { return "all"; }
-  const char* GetInstallTargetName()       const { return "install"; }
-  const char* GetInstallLocalTargetName()  const { return "install/local"; }
-  const char* GetInstallStripTargetName()  const { return "install/strip"; }
-  const char* GetPreinstallTargetName()    const { return "preinstall"; }
-  const char* GetTestTargetName()          const { return "test"; }
-  const char* GetPackageTargetName()       const { return "package"; }
+  const char* GetAllTargetName() const { return "all"; }
+  const char* GetInstallTargetName() const { return "install"; }
+  const char* GetInstallLocalTargetName() const { return "install/local"; }
+  const char* GetInstallStripTargetName() const { return "install/strip"; }
+  const char* GetPreinstallTargetName() const { return "preinstall"; }
+  const char* GetTestTargetName() const { return "test"; }
+  const char* GetPackageTargetName() const { return "package"; }
   const char* GetPackageSourceTargetName() const { return "package_source"; }
-  const char* GetEditCacheTargetName()     const { return "edit_cache"; }
-  const char* GetRebuildCacheTargetName()  const { return "rebuild_cache"; }
-  const char* GetCleanTargetName()         const { return "clean"; }
+  const char* GetEditCacheTargetName() const { return "edit_cache"; }
+  const char* GetRebuildCacheTargetName() const { return "rebuild_cache"; }
+  const char* GetCleanTargetName() const { return "clean"; }
 
   virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; }
 
@@ -193,28 +192,34 @@ protected:
   // Store per-target progress counters.
   struct TargetProgress
   {
-    TargetProgress(): NumberOfActions(0) {}
+    TargetProgress()
+      : NumberOfActions(0)
+    {
+    }
     unsigned long NumberOfActions;
     std::string VariableFile;
     std::vector<unsigned long> Marks;
     void WriteProgressVariables(unsigned long total, unsigned long& current);
   };
   typedef std::map<cmGeneratorTarget const*, TargetProgress,
-                   cmGeneratorTarget::StrictTargetComparison> ProgressMapType;
+                   cmGeneratorTarget::StrictTargetComparison>
+    ProgressMapType;
   ProgressMapType ProgressMap;
 
-  size_t CountProgressMarksInTarget(cmGeneratorTarget const* target,
-                                 std::set<cmGeneratorTarget const*>& emitted);
+  size_t CountProgressMarksInTarget(
+    cmGeneratorTarget const* target,
+    std::set<cmGeneratorTarget const*>& emitted);
   size_t CountProgressMarksInAll(cmLocalGenerator* lg);
 
-  cmGeneratedFileStream *CommandDatabase;
+  cmGeneratedFileStream* CommandDatabase;
+
 private:
   virtual const char* GetBuildIgnoreErrorsFlag() const { return "-i"; }
   virtual std::string GetEditCacheCommand() const;
 
-  std::map<cmState::Snapshot,
-           std::set<cmGeneratorTarget const*>,
-           cmState::Snapshot::StrictWeakOrder> DirectoryTargetsMap;
+  std::map<cmState::Snapshot, std::set<cmGeneratorTarget const*>,
+           cmState::Snapshot::StrictWeakOrder>
+    DirectoryTargetsMap;
   virtual void InitializeProgressMarks();
 };
 
diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx
index 441c2df..90ff98b 100644
--- a/Source/cmGlobalVisualStudio10Generator.cxx
+++ b/Source/cmGlobalVisualStudio10Generator.cxx
@@ -26,16 +26,14 @@ static const char vs10generatorName[] = "Visual Studio 10 2010";
 // Map generator name without year to name with year.
 static const char* cmVS10GenName(const std::string& name, std::string& genName)
 {
-  if(strncmp(name.c_str(), vs10generatorName,
-             sizeof(vs10generatorName)-6) != 0)
-    {
+  if (strncmp(name.c_str(), vs10generatorName,
+              sizeof(vs10generatorName) - 6) != 0) {
     return 0;
-    }
+  }
   const char* p = name.c_str() + sizeof(vs10generatorName) - 6;
-  if(cmHasLiteralPrefix(p, " 2010"))
-    {
+  if (cmHasLiteralPrefix(p, " 2010")) {
     p += 5;
-    }
+  }
   genName = std::string(vs10generatorName) + p;
   return p;
 }
@@ -44,45 +42,42 @@ class cmGlobalVisualStudio10Generator::Factory
   : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const
-    {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
     std::string genName;
     const char* p = cmVS10GenName(name, genName);
-    if(!p)
-      { return 0; }
-    if(!*p)
-      {
+    if (!p) {
+      return 0;
+    }
+    if (!*p) {
       return new cmGlobalVisualStudio10Generator(cm, genName, "");
-      }
-    if(*p++ != ' ')
-      { return 0; }
-    if(strcmp(p, "Win64") == 0)
-      {
+    }
+    if (*p++ != ' ') {
+      return 0;
+    }
+    if (strcmp(p, "Win64") == 0) {
       return new cmGlobalVisualStudio10Generator(cm, genName, "x64");
-      }
-    if(strcmp(p, "IA64") == 0)
-      {
+    }
+    if (strcmp(p, "IA64") == 0) {
       return new cmGlobalVisualStudio10Generator(cm, genName, "Itanium");
-      }
-    return 0;
     }
+    return 0;
+  }
 
   virtual void GetDocumentation(cmDocumentationEntry& entry) const
-    {
+  {
     entry.Name = std::string(vs10generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2010 project files.  "
-      "Optional [arch] can be \"Win64\" or \"IA64\"."
-      ;
-    }
+    entry.Brief = "Generates Visual Studio 2010 project files.  "
+                  "Optional [arch] can be \"Win64\" or \"IA64\".";
+  }
 
   virtual void GetGenerators(std::vector<std::string>& names) const
-    {
+  {
     names.push_back(vs10generatorName);
     names.push_back(vs10generatorName + std::string(" IA64"));
     names.push_back(vs10generatorName + std::string(" Win64"));
-    }
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -92,14 +87,15 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio10Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio8Generator(cm, name, platformName)
 {
   std::string vc10Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\10.0\\Setup\\VC;"
-    "ProductDir", vc10Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc10Express, cmSystemTools::KeyWOW64_32);
   this->SystemIsWindowsCE = false;
   this->SystemIsWindowsPhone = false;
   this->SystemIsWindowsStore = false;
@@ -107,15 +103,13 @@ cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(cmake* cm,
   this->Version = VS10;
 }
 
-bool
-cmGlobalVisualStudio10Generator::MatchesGeneratorName(
-                                               const std::string& name) const
+bool cmGlobalVisualStudio10Generator::MatchesGeneratorName(
+  const std::string& name) const
 {
   std::string genName;
-  if(cmVS10GenName(name, genName))
-    {
+  if (cmVS10GenName(name, genName)) {
     return genName == this->GetName();
-    }
+  }
   return false;
 }
 
@@ -124,110 +118,88 @@ bool cmGlobalVisualStudio10Generator::SetSystemName(std::string const& s,
 {
   this->SystemName = s;
   this->SystemVersion = mf->GetSafeDefinition("CMAKE_SYSTEM_VERSION");
-  if(!this->InitializeSystem(mf))
-    {
+  if (!this->InitializeSystem(mf)) {
     return false;
-    }
+  }
   return this->cmGlobalVisualStudio8Generator::SetSystemName(s, mf);
 }
 
-bool
-cmGlobalVisualStudio10Generator::SetGeneratorPlatform(std::string const& p,
-                                                      cmMakefile* mf)
+bool cmGlobalVisualStudio10Generator::SetGeneratorPlatform(
+  std::string const& p, cmMakefile* mf)
 {
-  if(!this->cmGlobalVisualStudio8Generator::SetGeneratorPlatform(p, mf))
-    {
+  if (!this->cmGlobalVisualStudio8Generator::SetGeneratorPlatform(p, mf)) {
     return false;
-    }
-  if(this->GetPlatformName() == "Itanium" || this->GetPlatformName() == "x64")
-    {
-    if(this->IsExpressEdition() && !this->Find64BitTools(mf))
-      {
+  }
+  if (this->GetPlatformName() == "Itanium" ||
+      this->GetPlatformName() == "x64") {
+    if (this->IsExpressEdition() && !this->Find64BitTools(mf)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool
-cmGlobalVisualStudio10Generator::SetGeneratorToolset(std::string const& ts,
-                                                     cmMakefile* mf)
+bool cmGlobalVisualStudio10Generator::SetGeneratorToolset(
+  std::string const& ts, cmMakefile* mf)
 {
   if (this->SystemIsWindowsCE && ts.empty() &&
-      this->DefaultPlatformToolset.empty())
-    {
+      this->DefaultPlatformToolset.empty()) {
     std::ostringstream e;
     e << this->GetName() << " Windows CE version '" << this->SystemVersion
       << "' requires CMAKE_GENERATOR_TOOLSET to be set.";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   this->GeneratorToolset = ts;
-  if(const char* toolset = this->GetPlatformToolset())
-    {
+  if (const char* toolset = this->GetPlatformToolset()) {
     mf->AddDefinition("CMAKE_VS_PLATFORM_TOOLSET", toolset);
-    }
+  }
   return true;
 }
 
 bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf)
 {
-  if (this->SystemName == "Windows")
-    {
-    if (!this->InitializeWindows(mf))
-      {
+  if (this->SystemName == "Windows") {
+    if (!this->InitializeWindows(mf)) {
       return false;
-      }
     }
-  else if (this->SystemName == "WindowsCE")
-    {
+  } else if (this->SystemName == "WindowsCE") {
     this->SystemIsWindowsCE = true;
-    if (!this->InitializeWindowsCE(mf))
-      {
+    if (!this->InitializeWindowsCE(mf)) {
       return false;
-      }
     }
-  else if (this->SystemName == "WindowsPhone")
-    {
+  } else if (this->SystemName == "WindowsPhone") {
     this->SystemIsWindowsPhone = true;
-    if(!this->InitializeWindowsPhone(mf))
-      {
+    if (!this->InitializeWindowsPhone(mf)) {
       return false;
-      }
     }
-  else if (this->SystemName == "WindowsStore")
-    {
+  } else if (this->SystemName == "WindowsStore") {
     this->SystemIsWindowsStore = true;
-    if(!this->InitializeWindowsStore(mf))
-      {
+    if (!this->InitializeWindowsStore(mf)) {
       return false;
-      }
     }
-  else if(this->SystemName == "Android")
-    {
-    if(this->DefaultPlatformName != "Win32")
-      {
+  } else if (this->SystemName == "Android") {
+    if (this->DefaultPlatformName != "Win32") {
       std::ostringstream e;
       e << "CMAKE_SYSTEM_NAME is 'Android' but CMAKE_GENERATOR "
         << "specifies a platform too: '" << this->GetName() << "'";
       mf->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
+    }
     std::string v = this->GetInstalledNsightTegraVersion();
-    if(v.empty())
-      {
+    if (v.empty()) {
       mf->IssueMessage(cmake::FATAL_ERROR,
-        "CMAKE_SYSTEM_NAME is 'Android' but "
-        "'NVIDIA Nsight Tegra Visual Studio Edition' "
-        "is not installed.");
+                       "CMAKE_SYSTEM_NAME is 'Android' but "
+                       "'NVIDIA Nsight Tegra Visual Studio Edition' "
+                       "is not installed.");
       return false;
-      }
+    }
     this->DefaultPlatformName = "Tegra-Android";
     this->DefaultPlatformToolset = "Default";
     this->NsightTegraVersion = v;
     mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v.c_str());
-    }
+  }
 
   return true;
 }
@@ -239,14 +211,13 @@ bool cmGlobalVisualStudio10Generator::InitializeWindows(cmMakefile*)
 
 bool cmGlobalVisualStudio10Generator::InitializeWindowsCE(cmMakefile* mf)
 {
-  if (this->DefaultPlatformName != "Win32")
-    {
+  if (this->DefaultPlatformName != "Win32") {
     std::ostringstream e;
     e << "CMAKE_SYSTEM_NAME is 'WindowsCE' but CMAKE_GENERATOR "
       << "specifies a platform too: '" << this->GetName() << "'";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   this->DefaultPlatformToolset = this->SelectWindowsCEToolset();
 
@@ -269,16 +240,14 @@ bool cmGlobalVisualStudio10Generator::InitializeWindowsStore(cmMakefile* mf)
   return false;
 }
 
-bool
-cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(
+bool cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(
   std::string& toolset) const
 {
   toolset = "";
   return false;
 }
 
-bool
-cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
+bool cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
   std::string& toolset) const
 {
   toolset = "";
@@ -287,29 +256,25 @@ cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
 
 std::string cmGlobalVisualStudio10Generator::SelectWindowsCEToolset() const
 {
-  if (this->SystemVersion == "8.0")
-    {
+  if (this->SystemVersion == "8.0") {
     return "CE800";
-    }
+  }
   return "";
 }
 
 void cmGlobalVisualStudio10Generator::WriteSLNHeader(std::ostream& fout)
 {
   fout << "Microsoft Visual Studio Solution File, Format Version 11.00\n";
-  if (this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     fout << "# Visual C++ Express 2010\n";
-    }
-  else
-    {
+  } else {
     fout << "# Visual Studio 2010\n";
-    }
+  }
 }
 
 ///! Create a local generator appropriate to this Global Generator
 cmLocalGenerator* cmGlobalVisualStudio10Generator::CreateLocalGenerator(
-    cmMakefile* mf)
+  cmMakefile* mf)
 {
   return new cmLocalVisualStudio10Generator(this, mf);
 }
@@ -318,8 +283,7 @@ void cmGlobalVisualStudio10Generator::Generate()
 {
   this->LongestSource = LongestSourcePath();
   this->cmGlobalVisualStudio8Generator::Generate();
-  if(this->LongestSource.Length > 0)
-    {
+  if (this->LongestSource.Length > 0) {
     cmLocalGenerator* lg = this->LongestSource.Target->GetLocalGenerator();
     std::ostringstream e;
     /* clang-format off */
@@ -344,26 +308,23 @@ void cmGlobalVisualStudio10Generator::Generate()
       "which then triggers the VS 10 property dialog bug.";
     /* clang-format on */
     lg->IssueMessage(cmake::WARNING, e.str().c_str());
-    }
+  }
 }
 
-void cmGlobalVisualStudio10Generator
-::EnableLanguage(std::vector<std::string>const &  lang,
-                 cmMakefile *mf, bool optional)
+void cmGlobalVisualStudio10Generator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
   cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional);
 }
 
 const char* cmGlobalVisualStudio10Generator::GetPlatformToolset() const
 {
-  if(!this->GeneratorToolset.empty())
-    {
+  if (!this->GeneratorToolset.empty()) {
     return this->GeneratorToolset.c_str();
-    }
-  if(!this->DefaultPlatformToolset.empty())
-    {
+  }
+  if (!this->DefaultPlatformToolset.empty()) {
     return this->DefaultPlatformToolset.c_str();
-    }
+  }
   return 0;
 }
 
@@ -376,11 +337,10 @@ void cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf)
 
 std::string const& cmGlobalVisualStudio10Generator::GetMSBuildCommand()
 {
-  if(!this->MSBuildCommandInitialized)
-    {
+  if (!this->MSBuildCommandInitialized) {
     this->MSBuildCommandInitialized = true;
     this->MSBuildCommand = this->FindMSBuildCommand();
-    }
+  }
   return this->MSBuildCommand;
 }
 
@@ -391,39 +351,33 @@ std::string cmGlobalVisualStudio10Generator::FindMSBuildCommand()
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\";
   mskey += this->GetToolsVersion();
   mskey += ";MSBuildToolsPath";
-  if(cmSystemTools::ReadRegistryValue(mskey.c_str(), msbuild,
-                                      cmSystemTools::KeyWOW64_32))
-    {
+  if (cmSystemTools::ReadRegistryValue(mskey.c_str(), msbuild,
+                                       cmSystemTools::KeyWOW64_32)) {
     cmSystemTools::ConvertToUnixSlashes(msbuild);
     msbuild += "/";
-    }
+  }
   msbuild += "MSBuild.exe";
   return msbuild;
 }
 
 std::string cmGlobalVisualStudio10Generator::FindDevEnvCommand()
 {
-  if(this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     // Visual Studio Express >= 10 do not have "devenv.com" or
     // "VCExpress.exe" that we can use to build reliably.
     // Tell the caller it needs to use MSBuild instead.
     return "";
-    }
+  }
   // Skip over the cmGlobalVisualStudio8Generator implementation because
   // we expect a real devenv and do not want to look for VCExpress.
   return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
 }
 
 void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
-  std::vector<std::string>& makeCommand,
-  const std::string& makeProgram,
-  const std::string& projectName,
-  const std::string& projectDir,
-  const std::string& targetName,
-  const std::string& config,
-  bool fast, bool verbose,
-  std::vector<std::string> const& makeOptions)
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& projectName, const std::string& projectDir,
+  const std::string& targetName, const std::string& config, bool fast,
+  bool verbose, std::vector<std::string> const& makeOptions)
 {
   // Select the caller- or user-preferred make program, else MSBuild.
   std::string makeProgramSelected =
@@ -432,99 +386,82 @@ void cmGlobalVisualStudio10Generator::GenerateBuildCommand(
   // Check if the caller explicitly requested a devenv tool.
   std::string makeProgramLower = makeProgramSelected;
   cmSystemTools::LowerCase(makeProgramLower);
-  bool useDevEnv =
-    (makeProgramLower.find("devenv") != std::string::npos ||
-     makeProgramLower.find("vcexpress") != std::string::npos);
+  bool useDevEnv = (makeProgramLower.find("devenv") != std::string::npos ||
+                    makeProgramLower.find("vcexpress") != std::string::npos);
 
   // MSBuild is preferred (and required for VS Express), but if the .sln has
   // an Intel Fortran .vfproj then we have to use devenv. Parse it to find out.
   cmSlnData slnData;
   {
-  std::string slnFile;
-  if(!projectDir.empty())
-    {
-    slnFile = projectDir;
-    slnFile += "/";
-    }
-  slnFile += projectName;
-  slnFile += ".sln";
-  cmVisualStudioSlnParser parser;
-  if(parser.ParseFile(slnFile, slnData,
-                      cmVisualStudioSlnParser::DataGroupProjects))
-    {
-    std::vector<cmSlnProjectEntry> slnProjects = slnData.GetProjects();
-    for(std::vector<cmSlnProjectEntry>::iterator i = slnProjects.begin();
-        !useDevEnv && i != slnProjects.end(); ++i)
-      {
-      std::string proj = i->GetRelativePath();
-      if(proj.size() > 7 &&
-         proj.substr(proj.size()-7) == ".vfproj")
-        {
-        useDevEnv = true;
+    std::string slnFile;
+    if (!projectDir.empty()) {
+      slnFile = projectDir;
+      slnFile += "/";
+    }
+    slnFile += projectName;
+    slnFile += ".sln";
+    cmVisualStudioSlnParser parser;
+    if (parser.ParseFile(slnFile, slnData,
+                         cmVisualStudioSlnParser::DataGroupProjects)) {
+      std::vector<cmSlnProjectEntry> slnProjects = slnData.GetProjects();
+      for (std::vector<cmSlnProjectEntry>::iterator i = slnProjects.begin();
+           !useDevEnv && i != slnProjects.end(); ++i) {
+        std::string proj = i->GetRelativePath();
+        if (proj.size() > 7 && proj.substr(proj.size() - 7) == ".vfproj") {
+          useDevEnv = true;
         }
       }
     }
   }
-  if(useDevEnv)
-    {
+  if (useDevEnv) {
     // Use devenv to build solutions containing Intel Fortran projects.
     cmGlobalVisualStudio7Generator::GenerateBuildCommand(
-      makeCommand, makeProgram, projectName, projectDir,
-      targetName, config, fast, verbose, makeOptions);
+      makeCommand, makeProgram, projectName, projectDir, targetName, config,
+      fast, verbose, makeOptions);
     return;
-    }
+  }
 
   makeCommand.push_back(makeProgramSelected);
 
   std::string realTarget = targetName;
   // msbuild.exe CxxOnly.sln /t:Build /p:Configuration=Debug /target:ALL_BUILD
-  if(realTarget.empty())
-    {
+  if (realTarget.empty()) {
     realTarget = "ALL_BUILD";
-    }
-  if ( realTarget == "clean" )
-    {
-    makeCommand.push_back(std::string(projectName)+".sln");
+  }
+  if (realTarget == "clean") {
+    makeCommand.push_back(std::string(projectName) + ".sln");
     makeCommand.push_back("/t:Clean");
-    }
-  else
-    {
+  } else {
     std::string targetProject(realTarget);
     targetProject += ".vcxproj";
-    if (targetProject.find('/') == std::string::npos)
-      {
+    if (targetProject.find('/') == std::string::npos) {
       // it might be in a subdir
       if (cmSlnProjectEntry const* proj =
-          slnData.GetProjectByName(realTarget))
-        {
+            slnData.GetProjectByName(realTarget)) {
         targetProject = proj->GetRelativePath();
         cmSystemTools::ConvertToUnixSlashes(targetProject);
-        }
       }
-    makeCommand.push_back(targetProject);
     }
+    makeCommand.push_back(targetProject);
+  }
   std::string configArg = "/p:Configuration=";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     configArg += config;
-    }
-  else
-    {
+  } else {
     configArg += "Debug";
-    }
+  }
   makeCommand.push_back(configArg);
-  makeCommand.push_back(std::string("/p:VisualStudioVersion=")+
+  makeCommand.push_back(std::string("/p:VisualStudioVersion=") +
                         this->GetIDEVersion());
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
 }
 
 bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
 {
-  if(this->GetPlatformToolset())
-    {
+  if (this->GetPlatformToolset()) {
     return true;
-    }
+  }
   // This edition does not come with 64-bit tools.  Look for them.
   //
   // TODO: Detect available tools?  x64\v100 exists but does not work?
@@ -532,18 +469,16 @@ bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
   // c:/Program Files (x86)/MSBuild/Microsoft.Cpp/v4.0/Platforms/
   //   {Itanium,Win32,x64}/PlatformToolsets/{v100,v90,Windows7.1SDK}
   std::string winSDK_7_1;
-  if(cmSystemTools::ReadRegistryValue(
-       "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\"
-       "Windows\\v7.1;InstallationFolder", winSDK_7_1))
-    {
+  if (cmSystemTools::ReadRegistryValue(
+        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\"
+        "Windows\\v7.1;InstallationFolder",
+        winSDK_7_1)) {
     std::ostringstream m;
     m << "Found Windows SDK v7.1: " << winSDK_7_1;
     mf->DisplayStatus(m.str().c_str(), -1);
     this->DefaultPlatformToolset = "Windows7.1SDK";
     return true;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     /* clang-format off */
     e << "Cannot enable 64-bit tools with Visual Studio 2010 Express.\n"
@@ -553,12 +488,11 @@ bool cmGlobalVisualStudio10Generator::Find64BitTools(cmMakefile* mf)
     mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 }
 
-std::string
-cmGlobalVisualStudio10Generator
-::GenerateRuleFile(std::string const& output) const
+std::string cmGlobalVisualStudio10Generator::GenerateRuleFile(
+  std::string const& output) const
 {
   // The VS 10 generator needs to create the .rule files on disk.
   // Hide them away under the CMakeFiles directory.
@@ -573,20 +507,19 @@ cmGlobalVisualStudio10Generator
   return ruleFile;
 }
 
-void cmGlobalVisualStudio10Generator::PathTooLong(
-        cmGeneratorTarget *target, cmSourceFile const* sf,
-        std::string const& sfRel)
+void cmGlobalVisualStudio10Generator::PathTooLong(cmGeneratorTarget* target,
+                                                  cmSourceFile const* sf,
+                                                  std::string const& sfRel)
 {
   size_t len =
-      (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) +
-                1 + sfRel.length());
-  if(len > this->LongestSource.Length)
-    {
+    (strlen(target->GetLocalGenerator()->GetCurrentBinaryDirectory()) + 1 +
+     sfRel.length());
+  if (len > this->LongestSource.Length) {
     this->LongestSource.Length = len;
     this->LongestSource.Target = target;
     this->LongestSource.SourceFile = sf;
     this->LongestSource.SourceRel = sfRel;
-    }
+  }
 }
 
 bool cmGlobalVisualStudio10Generator::IsNsightTegra() const
@@ -604,6 +537,7 @@ std::string cmGlobalVisualStudio10Generator::GetInstalledNsightTegraVersion()
   std::string version;
   cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;"
-    "Version", version, cmSystemTools::KeyWOW64_32);
+    "Version",
+    version, cmSystemTools::KeyWOW64_32);
   return version;
 }
diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h
index 8723fd1..51fd5a5 100644
--- a/Source/cmGlobalVisualStudio10Generator.h
+++ b/Source/cmGlobalVisualStudio10Generator.h
@@ -14,18 +14,16 @@
 
 #include "cmGlobalVisualStudio8Generator.h"
 
-
 /** \class cmGlobalVisualStudio10Generator
  * \brief Write a Unix makefiles.
  *
  * cmGlobalVisualStudio10Generator manages UNIX build process for a tree
  */
-class cmGlobalVisualStudio10Generator :
-  public cmGlobalVisualStudio8Generator
+class cmGlobalVisualStudio10Generator : public cmGlobalVisualStudio8Generator
 {
 public:
   cmGlobalVisualStudio10Generator(cmake* cm, const std::string& name,
-    const std::string& platformName);
+                                  const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
   virtual bool MatchesGeneratorName(const std::string& name) const;
@@ -35,25 +33,21 @@ public:
   virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
 
   virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand,
-    const std::string& makeProgram,
-    const std::string& projectName,
-    const std::string& projectDir,
-    const std::string& targetName,
-    const std::string& config,
-    bool fast, bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+    const std::string& projectName, const std::string& projectDir,
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
   ///! create the correct local generator
-  virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
   virtual void WriteSLNHeader(std::ostream& fout);
 
   /** Generating for Nsight Tegra VS plugin?  */
@@ -71,22 +65,20 @@ public:
 
   /** Return the Windows version targeted on VS 2015 and above.  */
   std::string const& GetWindowsTargetPlatformVersion() const
-    { return this->WindowsTargetPlatformVersion; }
+  {
+    return this->WindowsTargetPlatformVersion;
+  }
 
   /** Return true if building for WindowsCE */
-  bool TargetsWindowsCE() const
-    { return this->SystemIsWindowsCE; }
+  bool TargetsWindowsCE() const { return this->SystemIsWindowsCE; }
 
   /** Return true if building for WindowsPhone */
-  bool TargetsWindowsPhone() const
-    { return this->SystemIsWindowsPhone; }
+  bool TargetsWindowsPhone() const { return this->SystemIsWindowsPhone; }
 
   /** Return true if building for WindowsStore */
-  bool TargetsWindowsStore() const
-    { return this->SystemIsWindowsStore; }
+  bool TargetsWindowsStore() const { return this->SystemIsWindowsStore; }
 
-  virtual const char* GetCMakeCFGIntDir() const
-    { return "$(Configuration)";}
+  virtual const char* GetCMakeCFGIntDir() const { return "$(Configuration)"; }
   bool Find64BitTools(cmMakefile* mf);
 
   /** Generate an <output>.rule file path for a given command output.  */
@@ -131,7 +123,12 @@ private:
   class Factory;
   struct LongestSourcePath
   {
-    LongestSourcePath(): Length(0), Target(0), SourceFile(0) {}
+    LongestSourcePath()
+      : Length(0)
+      , Target(0)
+      , SourceFile(0)
+    {
+    }
     size_t Length;
     cmGeneratorTarget* Target;
     cmSourceFile const* SourceFile;
diff --git a/Source/cmGlobalVisualStudio11Generator.cxx b/Source/cmGlobalVisualStudio11Generator.cxx
index 1a17c6f..295b6eb 100644
--- a/Source/cmGlobalVisualStudio11Generator.cxx
+++ b/Source/cmGlobalVisualStudio11Generator.cxx
@@ -20,16 +20,14 @@ static const char vs11generatorName[] = "Visual Studio 11 2012";
 // Map generator name without year to name with year.
 static const char* cmVS11GenName(const std::string& name, std::string& genName)
 {
-  if(strncmp(name.c_str(), vs11generatorName,
-             sizeof(vs11generatorName)-6) != 0)
-    {
+  if (strncmp(name.c_str(), vs11generatorName,
+              sizeof(vs11generatorName) - 6) != 0) {
     return 0;
-    }
+  }
   const char* p = name.c_str() + sizeof(vs11generatorName) - 6;
-  if(cmHasLiteralPrefix(p, " 2012"))
-    {
+  if (cmHasLiteralPrefix(p, " 2012")) {
     p += 5;
-    }
+  }
   genName = std::string(vs11generatorName) + p;
   return p;
 }
@@ -38,65 +36,60 @@ class cmGlobalVisualStudio11Generator::Factory
   : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const
-    {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
     std::string genName;
     const char* p = cmVS11GenName(name, genName);
-    if(!p)
-      { return 0; }
-    if(!*p)
-      {
+    if (!p) {
+      return 0;
+    }
+    if (!*p) {
       return new cmGlobalVisualStudio11Generator(cm, genName, "");
-      }
-    if(*p++ != ' ')
-      { return 0; }
-    if(strcmp(p, "Win64") == 0)
-      {
+    }
+    if (*p++ != ' ') {
+      return 0;
+    }
+    if (strcmp(p, "Win64") == 0) {
       return new cmGlobalVisualStudio11Generator(cm, genName, "x64");
-      }
-    if(strcmp(p, "ARM") == 0)
-      {
+    }
+    if (strcmp(p, "ARM") == 0) {
       return new cmGlobalVisualStudio11Generator(cm, genName, "ARM");
-      }
+    }
 
     std::set<std::string> installedSDKs =
       cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs();
 
-    if(installedSDKs.find(p) == installedSDKs.end())
-      {
+    if (installedSDKs.find(p) == installedSDKs.end()) {
       return 0;
-      }
+    }
 
     cmGlobalVisualStudio11Generator* ret =
       new cmGlobalVisualStudio11Generator(cm, name, p);
     ret->WindowsCEVersion = "8.00";
     return ret;
-    }
+  }
 
   virtual void GetDocumentation(cmDocumentationEntry& entry) const
-    {
+  {
     entry.Name = std::string(vs11generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2012 project files.  "
-      "Optional [arch] can be \"Win64\" or \"ARM\"."
-      ;
-    }
+    entry.Brief = "Generates Visual Studio 2012 project files.  "
+                  "Optional [arch] can be \"Win64\" or \"ARM\".";
+  }
 
   virtual void GetGenerators(std::vector<std::string>& names) const
-    {
+  {
     names.push_back(vs11generatorName);
     names.push_back(vs11generatorName + std::string(" ARM"));
     names.push_back(vs11generatorName + std::string(" Win64"));
 
     std::set<std::string> installedSDKs =
       cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs();
-    for(std::set<std::string>::const_iterator i =
-        installedSDKs.begin(); i != installedSDKs.end(); ++i)
-      {
+    for (std::set<std::string>::const_iterator i = installedSDKs.begin();
+         i != installedSDKs.end(); ++i) {
       names.push_back(std::string(vs11generatorName) + " " + *i);
-      }
     }
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -106,127 +99,105 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio11Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio11Generator::cmGlobalVisualStudio11Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio10Generator(cm, name, platformName)
 {
   std::string vc11Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\11.0\\Setup\\VC;"
-    "ProductDir", vc11Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc11Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v110";
   this->Version = VS11;
 }
 
-bool
-cmGlobalVisualStudio11Generator::MatchesGeneratorName(
-                                                const std::string& name) const
+bool cmGlobalVisualStudio11Generator::MatchesGeneratorName(
+  const std::string& name) const
 {
   std::string genName;
-  if(cmVS11GenName(name, genName))
-    {
+  if (cmVS11GenName(name, genName)) {
     return genName == this->GetName();
-    }
+  }
   return false;
 }
 
 bool cmGlobalVisualStudio11Generator::InitializeWindowsPhone(cmMakefile* mf)
 {
-  if(!this->SelectWindowsPhoneToolset(this->DefaultPlatformToolset))
-    {
+  if (!this->SelectWindowsPhoneToolset(this->DefaultPlatformToolset)) {
     std::ostringstream e;
-    if(this->DefaultPlatformToolset.empty())
-      {
+    if (this->DefaultPlatformToolset.empty()) {
       e << this->GetName() << " supports Windows Phone '8.0', but not '"
         << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
-      }
-    else
-      {
+    } else {
       e << "A Windows Phone component with CMake requires both the Windows "
         << "Desktop SDK as well as the Windows Phone '" << this->SystemVersion
         << "' SDK. Please make sure that you have both installed";
-      }
+    }
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
   return true;
 }
 
 bool cmGlobalVisualStudio11Generator::InitializeWindowsStore(cmMakefile* mf)
 {
-  if(!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset))
-    {
+  if (!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset)) {
     std::ostringstream e;
-    if(this->DefaultPlatformToolset.empty())
-      {
+    if (this->DefaultPlatformToolset.empty()) {
       e << this->GetName() << " supports Windows Store '8.0', but not '"
         << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
-      }
-    else
-      {
+    } else {
       e << "A Windows Store component with CMake requires both the Windows "
         << "Desktop SDK as well as the Windows Store '" << this->SystemVersion
         << "' SDK. Please make sure that you have both installed";
-      }
+    }
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
   return true;
 }
 
-bool
-cmGlobalVisualStudio11Generator::SelectWindowsPhoneToolset(
+bool cmGlobalVisualStudio11Generator::SelectWindowsPhoneToolset(
   std::string& toolset) const
 {
-  if(this->SystemVersion == "8.0")
-    {
+  if (this->SystemVersion == "8.0") {
     if (this->IsWindowsPhoneToolsetInstalled() &&
-        this->IsWindowsDesktopToolsetInstalled())
-      {
+        this->IsWindowsDesktopToolsetInstalled()) {
       toolset = "v110_wp80";
       return true;
-      }
-    else
-      {
+    } else {
       return false;
-      }
     }
-  return
-    this->cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(toolset);
+  }
+  return this->cmGlobalVisualStudio10Generator::SelectWindowsPhoneToolset(
+    toolset);
 }
 
-bool
-cmGlobalVisualStudio11Generator::SelectWindowsStoreToolset(
+bool cmGlobalVisualStudio11Generator::SelectWindowsStoreToolset(
   std::string& toolset) const
 {
-  if(this->SystemVersion == "8.0")
-    {
-    if(this->IsWindowsStoreToolsetInstalled() &&
-       this->IsWindowsDesktopToolsetInstalled())
-      {
+  if (this->SystemVersion == "8.0") {
+    if (this->IsWindowsStoreToolsetInstalled() &&
+        this->IsWindowsDesktopToolsetInstalled()) {
       toolset = "v110";
       return true;
-      }
-    else
-      {
+    } else {
       return false;
-      }
     }
-  return
-    this->cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(toolset);
+  }
+  return this->cmGlobalVisualStudio10Generator::SelectWindowsStoreToolset(
+    toolset);
 }
 
 void cmGlobalVisualStudio11Generator::WriteSLNHeader(std::ostream& fout)
 {
   fout << "Microsoft Visual Studio Solution File, Format Version 12.00\n";
-  if (this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     fout << "# Visual Studio Express 2012 for Windows Desktop\n";
-    }
-  else
-    {
+  } else {
     fout << "# Visual Studio 2012\n";
-    }
+  }
 }
 
 bool cmGlobalVisualStudio11Generator::UseFolderProperty()
@@ -248,84 +219,67 @@ cmGlobalVisualStudio11Generator::GetInstalledWindowsCESDKs()
                                     cmSystemTools::KeyWOW64_32);
 
   std::set<std::string> ret;
-  for(std::vector<std::string>::const_iterator i =
-      subkeys.begin(); i != subkeys.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = subkeys.begin();
+       i != subkeys.end(); ++i) {
     std::string key = sdksKey;
     key += '\\';
     key += *i;
     key += ';';
 
     std::string path;
-    if(cmSystemTools::ReadRegistryValue(key.c_str(),
-                                        path,
-                                        cmSystemTools::KeyWOW64_32) &&
-        !path.empty())
-      {
+    if (cmSystemTools::ReadRegistryValue(key.c_str(), path,
+                                         cmSystemTools::KeyWOW64_32) &&
+        !path.empty()) {
       ret.insert(*i);
-      }
     }
+  }
 
   return ret;
 }
 
-bool
-cmGlobalVisualStudio11Generator::NeedsDeploy(cmState::TargetType type) const
+bool cmGlobalVisualStudio11Generator::NeedsDeploy(
+  cmState::TargetType type) const
 {
-  if((type == cmState::EXECUTABLE ||
-      type == cmState::SHARED_LIBRARY) &&
-     (this->SystemIsWindowsPhone ||
-      this->SystemIsWindowsStore))
-    {
+  if ((type == cmState::EXECUTABLE || type == cmState::SHARED_LIBRARY) &&
+      (this->SystemIsWindowsPhone || this->SystemIsWindowsStore)) {
     return true;
-    }
+  }
   return cmGlobalVisualStudio10Generator::NeedsDeploy(type);
 }
 
-bool
-cmGlobalVisualStudio11Generator::IsWindowsDesktopToolsetInstalled() const
+bool cmGlobalVisualStudio11Generator::IsWindowsDesktopToolsetInstalled() const
 {
-  const char desktop80Key[] =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-    "VisualStudio\\11.0\\VC\\Libraries\\Extended";
+  const char desktop80Key[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
+                              "VisualStudio\\11.0\\VC\\Libraries\\Extended";
   const char VS2012DesktopExpressKey[] =
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
     "WDExpress\\11.0;InstallDir";
 
   std::vector<std::string> subkeys;
   std::string path;
-  return cmSystemTools::ReadRegistryValue(VS2012DesktopExpressKey,
-                                          path,
+  return cmSystemTools::ReadRegistryValue(VS2012DesktopExpressKey, path,
                                           cmSystemTools::KeyWOW64_32) ||
-         cmSystemTools::GetRegistrySubKeys(desktop80Key,
-                                           subkeys,
-                                           cmSystemTools::KeyWOW64_32);
+    cmSystemTools::GetRegistrySubKeys(desktop80Key, subkeys,
+                                      cmSystemTools::KeyWOW64_32);
 }
 
-bool
-cmGlobalVisualStudio11Generator::IsWindowsPhoneToolsetInstalled() const
+bool cmGlobalVisualStudio11Generator::IsWindowsPhoneToolsetInstalled() const
 {
-  const char wp80Key[] =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-    "Microsoft SDKs\\WindowsPhone\\v8.0\\"
-    "Install Path;Install Path";
+  const char wp80Key[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
+                         "Microsoft SDKs\\WindowsPhone\\v8.0\\"
+                         "Install Path;Install Path";
 
   std::string path;
-  cmSystemTools::ReadRegistryValue(wp80Key,
-                                   path,
-                                   cmSystemTools::KeyWOW64_32);
+  cmSystemTools::ReadRegistryValue(wp80Key, path, cmSystemTools::KeyWOW64_32);
   return !path.empty();
 }
 
-bool
-cmGlobalVisualStudio11Generator::IsWindowsStoreToolsetInstalled() const
+bool cmGlobalVisualStudio11Generator::IsWindowsStoreToolsetInstalled() const
 {
-  const char win80Key[] =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-    "VisualStudio\\11.0\\VC\\Libraries\\Core\\Arm";
+  const char win80Key[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
+                          "VisualStudio\\11.0\\VC\\Libraries\\Core\\Arm";
 
   std::vector<std::string> subkeys;
-  return cmSystemTools::GetRegistrySubKeys(win80Key,
-                                           subkeys,
+  return cmSystemTools::GetRegistrySubKeys(win80Key, subkeys,
                                            cmSystemTools::KeyWOW64_32);
 }
diff --git a/Source/cmGlobalVisualStudio11Generator.h b/Source/cmGlobalVisualStudio11Generator.h
index f3f6b2b..ef6d343 100644
--- a/Source/cmGlobalVisualStudio11Generator.h
+++ b/Source/cmGlobalVisualStudio11Generator.h
@@ -14,14 +14,12 @@
 
 #include "cmGlobalVisualStudio10Generator.h"
 
-
 /** \class cmGlobalVisualStudio11Generator  */
-class cmGlobalVisualStudio11Generator:
-  public cmGlobalVisualStudio10Generator
+class cmGlobalVisualStudio11Generator : public cmGlobalVisualStudio10Generator
 {
 public:
   cmGlobalVisualStudio11Generator(cmake* cm, const std::string& name,
-    const std::string& platformName);
+                                  const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
   virtual bool MatchesGeneratorName(const std::string& name) const;
@@ -49,6 +47,7 @@ protected:
 
   /** Return true if the configuration needs to be deployed */
   virtual bool NeedsDeploy(cmState::TargetType type) const;
+
 private:
   class Factory;
   friend class Factory;
diff --git a/Source/cmGlobalVisualStudio12Generator.cxx b/Source/cmGlobalVisualStudio12Generator.cxx
index 10308a3..318cb39 100644
--- a/Source/cmGlobalVisualStudio12Generator.cxx
+++ b/Source/cmGlobalVisualStudio12Generator.cxx
@@ -20,16 +20,14 @@ static const char vs12generatorName[] = "Visual Studio 12 2013";
 // Map generator name without year to name with year.
 static const char* cmVS12GenName(const std::string& name, std::string& genName)
 {
-  if(strncmp(name.c_str(), vs12generatorName,
-             sizeof(vs12generatorName)-6) != 0)
-    {
+  if (strncmp(name.c_str(), vs12generatorName,
+              sizeof(vs12generatorName) - 6) != 0) {
     return 0;
-    }
+  }
   const char* p = name.c_str() + sizeof(vs12generatorName) - 6;
-  if(cmHasLiteralPrefix(p, " 2013"))
-    {
+  if (cmHasLiteralPrefix(p, " 2013")) {
     p += 5;
-    }
+  }
   genName = std::string(vs12generatorName) + p;
   return p;
 }
@@ -38,45 +36,42 @@ class cmGlobalVisualStudio12Generator::Factory
   : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const
-    {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
     std::string genName;
     const char* p = cmVS12GenName(name, genName);
-    if(!p)
-      { return 0; }
-    if(!*p)
-      {
+    if (!p) {
+      return 0;
+    }
+    if (!*p) {
       return new cmGlobalVisualStudio12Generator(cm, genName, "");
-      }
-    if(*p++ != ' ')
-      { return 0; }
-    if(strcmp(p, "Win64") == 0)
-      {
+    }
+    if (*p++ != ' ') {
+      return 0;
+    }
+    if (strcmp(p, "Win64") == 0) {
       return new cmGlobalVisualStudio12Generator(cm, genName, "x64");
-      }
-    if(strcmp(p, "ARM") == 0)
-      {
+    }
+    if (strcmp(p, "ARM") == 0) {
       return new cmGlobalVisualStudio12Generator(cm, genName, "ARM");
-      }
-    return 0;
     }
+    return 0;
+  }
 
   virtual void GetDocumentation(cmDocumentationEntry& entry) const
-    {
+  {
     entry.Name = std::string(vs12generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2013 project files.  "
-      "Optional [arch] can be \"Win64\" or \"ARM\"."
-      ;
-    }
+    entry.Brief = "Generates Visual Studio 2013 project files.  "
+                  "Optional [arch] can be \"Win64\" or \"ARM\".";
+  }
 
   virtual void GetGenerators(std::vector<std::string>& names) const
-    {
+  {
     names.push_back(vs12generatorName);
     names.push_back(vs12generatorName + std::string(" ARM"));
     names.push_back(vs12generatorName + std::string(" Win64"));
-    }
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -86,165 +81,136 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio12Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio12Generator::cmGlobalVisualStudio12Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio12Generator::cmGlobalVisualStudio12Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio11Generator(cm, name, platformName)
 {
   std::string vc12Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\12.0\\Setup\\VC;"
-    "ProductDir", vc12Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc12Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v120";
   this->Version = VS12;
 }
 
-bool
-cmGlobalVisualStudio12Generator::MatchesGeneratorName(
-                                                const std::string& name) const
+bool cmGlobalVisualStudio12Generator::MatchesGeneratorName(
+  const std::string& name) const
 {
   std::string genName;
-  if(cmVS12GenName(name, genName))
-    {
+  if (cmVS12GenName(name, genName)) {
     return genName == this->GetName();
-    }
+  }
   return false;
 }
 
 bool cmGlobalVisualStudio12Generator::InitializeWindowsPhone(cmMakefile* mf)
 {
-  if(!this->SelectWindowsPhoneToolset(this->DefaultPlatformToolset))
-    {
+  if (!this->SelectWindowsPhoneToolset(this->DefaultPlatformToolset)) {
     std::ostringstream e;
-    if(this->DefaultPlatformToolset.empty())
-      {
+    if (this->DefaultPlatformToolset.empty()) {
       e << this->GetName() << " supports Windows Phone '8.0' and '8.1', but "
-        "not '" << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
-      }
-    else
-      {
+                              "not '"
+        << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
+    } else {
       e << "A Windows Phone component with CMake requires both the Windows "
         << "Desktop SDK as well as the Windows Phone '" << this->SystemVersion
         << "' SDK. Please make sure that you have both installed";
-      }
+    }
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
   return true;
 }
 
 bool cmGlobalVisualStudio12Generator::InitializeWindowsStore(cmMakefile* mf)
 {
-  if(!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset))
-    {
+  if (!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset)) {
     std::ostringstream e;
-    if(this->DefaultPlatformToolset.empty())
-      {
+    if (this->DefaultPlatformToolset.empty()) {
       e << this->GetName() << " supports Windows Store '8.0' and '8.1', but "
-        "not '" << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
-      }
-    else
-      {
+                              "not '"
+        << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
+    } else {
       e << "A Windows Store component with CMake requires both the Windows "
         << "Desktop SDK as well as the Windows Store '" << this->SystemVersion
         << "' SDK. Please make sure that you have both installed";
-      }
+    }
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
   return true;
 }
 
-bool
-cmGlobalVisualStudio12Generator::SelectWindowsPhoneToolset(
+bool cmGlobalVisualStudio12Generator::SelectWindowsPhoneToolset(
   std::string& toolset) const
 {
-  if(this->SystemVersion == "8.1")
-    {
+  if (this->SystemVersion == "8.1") {
     if (this->IsWindowsPhoneToolsetInstalled() &&
-        this->IsWindowsDesktopToolsetInstalled())
-      {
+        this->IsWindowsDesktopToolsetInstalled()) {
       toolset = "v120_wp81";
       return true;
-      }
-    else
-      {
+    } else {
       return false;
-      }
     }
-  return
-    this->cmGlobalVisualStudio11Generator::SelectWindowsPhoneToolset(toolset);
+  }
+  return this->cmGlobalVisualStudio11Generator::SelectWindowsPhoneToolset(
+    toolset);
 }
 
-bool
-cmGlobalVisualStudio12Generator::SelectWindowsStoreToolset(
+bool cmGlobalVisualStudio12Generator::SelectWindowsStoreToolset(
   std::string& toolset) const
 {
-  if(this->SystemVersion == "8.1")
-    {
-    if(this->IsWindowsStoreToolsetInstalled() &&
-       this->IsWindowsDesktopToolsetInstalled())
-      {
+  if (this->SystemVersion == "8.1") {
+    if (this->IsWindowsStoreToolsetInstalled() &&
+        this->IsWindowsDesktopToolsetInstalled()) {
       toolset = "v120";
       return true;
-      }
-    else
-      {
+    } else {
       return false;
-      }
     }
-  return
-    this->cmGlobalVisualStudio11Generator::SelectWindowsStoreToolset(toolset);
+  }
+  return this->cmGlobalVisualStudio11Generator::SelectWindowsStoreToolset(
+    toolset);
 }
 
 void cmGlobalVisualStudio12Generator::WriteSLNHeader(std::ostream& fout)
 {
   fout << "Microsoft Visual Studio Solution File, Format Version 12.00\n";
-  if (this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     fout << "# Visual Studio Express 2013 for Windows Desktop\n";
-    }
-  else
-    {
+  } else {
     fout << "# Visual Studio 2013\n";
-    }
+  }
 }
 
-bool
-cmGlobalVisualStudio12Generator::IsWindowsDesktopToolsetInstalled() const
+bool cmGlobalVisualStudio12Generator::IsWindowsDesktopToolsetInstalled() const
 {
-  const char desktop81Key[] =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-    "VisualStudio\\12.0\\VC\\LibraryDesktop";
+  const char desktop81Key[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
+                              "VisualStudio\\12.0\\VC\\LibraryDesktop";
 
   std::vector<std::string> subkeys;
-  return cmSystemTools::GetRegistrySubKeys(desktop81Key,
-                                           subkeys,
+  return cmSystemTools::GetRegistrySubKeys(desktop81Key, subkeys,
                                            cmSystemTools::KeyWOW64_32);
 }
 
-bool
-cmGlobalVisualStudio12Generator::IsWindowsPhoneToolsetInstalled() const
+bool cmGlobalVisualStudio12Generator::IsWindowsPhoneToolsetInstalled() const
 {
   const char wp81Key[] =
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
     "Microsoft SDKs\\WindowsPhone\\v8.1\\Install Path;Install Path";
 
   std::string path;
-  cmSystemTools::ReadRegistryValue(wp81Key,
-                                   path,
-                                   cmSystemTools::KeyWOW64_32);
+  cmSystemTools::ReadRegistryValue(wp81Key, path, cmSystemTools::KeyWOW64_32);
   return !path.empty();
 }
 
-bool
-cmGlobalVisualStudio12Generator::IsWindowsStoreToolsetInstalled() const
+bool cmGlobalVisualStudio12Generator::IsWindowsStoreToolsetInstalled() const
 {
-  const char win81Key[] =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-    "VisualStudio\\12.0\\VC\\Libraries\\Core\\Arm";
+  const char win81Key[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
+                          "VisualStudio\\12.0\\VC\\Libraries\\Core\\Arm";
 
   std::vector<std::string> subkeys;
-  return cmSystemTools::GetRegistrySubKeys(win81Key,
-                                           subkeys,
+  return cmSystemTools::GetRegistrySubKeys(win81Key, subkeys,
                                            cmSystemTools::KeyWOW64_32);
 }
diff --git a/Source/cmGlobalVisualStudio12Generator.h b/Source/cmGlobalVisualStudio12Generator.h
index a7939aa..567e240 100644
--- a/Source/cmGlobalVisualStudio12Generator.h
+++ b/Source/cmGlobalVisualStudio12Generator.h
@@ -14,23 +14,21 @@
 
 #include "cmGlobalVisualStudio11Generator.h"
 
-
 /** \class cmGlobalVisualStudio12Generator  */
-class cmGlobalVisualStudio12Generator:
-  public cmGlobalVisualStudio11Generator
+class cmGlobalVisualStudio12Generator : public cmGlobalVisualStudio11Generator
 {
 public:
   cmGlobalVisualStudio12Generator(cmake* cm, const std::string& name,
-    const std::string& platformName);
+                                  const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
   virtual bool MatchesGeneratorName(const std::string& name) const;
 
   virtual void WriteSLNHeader(std::ostream& fout);
 
-  //in Visual Studio 2013 they detached the MSBuild tools version
-  //from the .Net Framework version and instead made it have it's own
-  //version number
+  // in Visual Studio 2013 they detached the MSBuild tools version
+  // from the .Net Framework version and instead made it have it's own
+  // version number
   virtual const char* GetToolsVersion() { return "12.0"; }
 protected:
   virtual bool InitializeWindowsPhone(cmMakefile* mf);
diff --git a/Source/cmGlobalVisualStudio14Generator.cxx b/Source/cmGlobalVisualStudio14Generator.cxx
index 8f93e17..e190e84 100644
--- a/Source/cmGlobalVisualStudio14Generator.cxx
+++ b/Source/cmGlobalVisualStudio14Generator.cxx
@@ -20,16 +20,14 @@ static const char vs14generatorName[] = "Visual Studio 14 2015";
 // Map generator name without year to name with year.
 static const char* cmVS14GenName(const std::string& name, std::string& genName)
 {
-  if(strncmp(name.c_str(), vs14generatorName,
-             sizeof(vs14generatorName)-6) != 0)
-    {
+  if (strncmp(name.c_str(), vs14generatorName,
+              sizeof(vs14generatorName) - 6) != 0) {
     return 0;
-    }
+  }
   const char* p = name.c_str() + sizeof(vs14generatorName) - 6;
-  if(cmHasLiteralPrefix(p, " 2015"))
-    {
+  if (cmHasLiteralPrefix(p, " 2015")) {
     p += 5;
-    }
+  }
   genName = std::string(vs14generatorName) + p;
   return p;
 }
@@ -38,45 +36,42 @@ class cmGlobalVisualStudio14Generator::Factory
   : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const
-    {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
     std::string genName;
     const char* p = cmVS14GenName(name, genName);
-    if(!p)
-      { return 0; }
-    if(!*p)
-      {
+    if (!p) {
+      return 0;
+    }
+    if (!*p) {
       return new cmGlobalVisualStudio14Generator(cm, genName, "");
-      }
-    if(*p++ != ' ')
-      { return 0; }
-    if(strcmp(p, "Win64") == 0)
-      {
+    }
+    if (*p++ != ' ') {
+      return 0;
+    }
+    if (strcmp(p, "Win64") == 0) {
       return new cmGlobalVisualStudio14Generator(cm, genName, "x64");
-      }
-    if(strcmp(p, "ARM") == 0)
-      {
+    }
+    if (strcmp(p, "ARM") == 0) {
       return new cmGlobalVisualStudio14Generator(cm, genName, "ARM");
-      }
-    return 0;
     }
+    return 0;
+  }
 
   virtual void GetDocumentation(cmDocumentationEntry& entry) const
-    {
+  {
     entry.Name = std::string(vs14generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2015 project files.  "
-      "Optional [arch] can be \"Win64\" or \"ARM\"."
-      ;
-    }
+    entry.Brief = "Generates Visual Studio 2015 project files.  "
+                  "Optional [arch] can be \"Win64\" or \"ARM\".";
+  }
 
   virtual void GetGenerators(std::vector<std::string>& names) const
-    {
+  {
     names.push_back(vs14generatorName);
     names.push_back(vs14generatorName + std::string(" ARM"));
     names.push_back(vs14generatorName + std::string(" Win64"));
-    }
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -86,63 +81,56 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio14Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio14Generator::cmGlobalVisualStudio14Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio14Generator::cmGlobalVisualStudio14Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio12Generator(cm, name, platformName)
 {
   std::string vc14Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\14.0\\Setup\\VC;"
-    "ProductDir", vc14Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc14Express, cmSystemTools::KeyWOW64_32);
   this->DefaultPlatformToolset = "v140";
   this->Version = VS14;
 }
 
-bool
-cmGlobalVisualStudio14Generator::MatchesGeneratorName(
-                                                const std::string& name) const
+bool cmGlobalVisualStudio14Generator::MatchesGeneratorName(
+  const std::string& name) const
 {
   std::string genName;
-  if(cmVS14GenName(name, genName))
-    {
+  if (cmVS14GenName(name, genName)) {
     return genName == this->GetName();
-    }
+  }
   return false;
 }
 
 bool cmGlobalVisualStudio14Generator::InitializeWindows(cmMakefile* mf)
 {
-  if (cmHasLiteralPrefix(this->SystemVersion, "10.0"))
-    {
+  if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) {
     return this->SelectWindows10SDK(mf, false);
-    }
+  }
   return true;
 }
 
 bool cmGlobalVisualStudio14Generator::InitializeWindowsStore(cmMakefile* mf)
 {
-  std::ostringstream  e;
-  if(!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset))
-    {
-    if(this->DefaultPlatformToolset.empty())
-      {
+  std::ostringstream e;
+  if (!this->SelectWindowsStoreToolset(this->DefaultPlatformToolset)) {
+    if (this->DefaultPlatformToolset.empty()) {
       e << this->GetName() << " supports Windows Store '8.0', '8.1' and "
-        "'10.0', but not '" << this->SystemVersion <<
-        "'.  Check CMAKE_SYSTEM_VERSION.";
-      }
-    else
-      {
+                              "'10.0', but not '"
+        << this->SystemVersion << "'.  Check CMAKE_SYSTEM_VERSION.";
+    } else {
       e << "A Windows Store component with CMake requires both the Windows "
         << "Desktop SDK as well as the Windows Store '" << this->SystemVersion
         << "' SDK. Please make sure that you have both installed";
-      }
+    }
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
-  if (cmHasLiteralPrefix(this->SystemVersion, "10.0"))
-    {
+  }
+  if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) {
     return this->SelectWindows10SDK(mf, true);
-    }
+  }
   return true;
 }
 
@@ -151,85 +139,73 @@ bool cmGlobalVisualStudio14Generator::SelectWindows10SDK(cmMakefile* mf,
 {
   // Find the default version of the Windows 10 SDK.
   this->WindowsTargetPlatformVersion = this->GetWindows10SDKVersion();
-  if (required && this->WindowsTargetPlatformVersion.empty())
-    {
-    std::ostringstream  e;
+  if (required && this->WindowsTargetPlatformVersion.empty()) {
+    std::ostringstream e;
     e << "Could not find an appropriate version of the Windows 10 SDK"
       << " installed on this machine";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
   mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION",
                     this->WindowsTargetPlatformVersion.c_str());
   return true;
 }
 
-bool
-cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset(
+bool cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset(
   std::string& toolset) const
 {
-  if (cmHasLiteralPrefix(this->SystemVersion, "10.0"))
-    {
+  if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) {
     if (this->IsWindowsStoreToolsetInstalled() &&
-        this->IsWindowsDesktopToolsetInstalled())
-      {
+        this->IsWindowsDesktopToolsetInstalled()) {
       toolset = "v140";
       return true;
-      }
-    else
-      {
+    } else {
       return false;
-      }
     }
-  return
-    this->cmGlobalVisualStudio12Generator::SelectWindowsStoreToolset(toolset);
+  }
+  return this->cmGlobalVisualStudio12Generator::SelectWindowsStoreToolset(
+    toolset);
 }
 
 void cmGlobalVisualStudio14Generator::WriteSLNHeader(std::ostream& fout)
 {
   // Visual Studio 14 writes .sln format 12.00
   fout << "Microsoft Visual Studio Solution File, Format Version 12.00\n";
-  if (this->ExpressEdition)
-    {
+  if (this->ExpressEdition) {
     fout << "# Visual Studio Express 14 for Windows Desktop\n";
-    }
-  else
-    {
+  } else {
     fout << "# Visual Studio 14\n";
-    }
+  }
 }
 
-bool
-cmGlobalVisualStudio14Generator::IsWindowsDesktopToolsetInstalled() const
+bool cmGlobalVisualStudio14Generator::IsWindowsDesktopToolsetInstalled() const
 {
-  const char desktop10Key[] =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-    "VisualStudio\\14.0\\VC\\Runtimes";
+  const char desktop10Key[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
+                              "VisualStudio\\14.0\\VC\\Runtimes";
 
   std::vector<std::string> vc14;
-  return cmSystemTools::GetRegistrySubKeys(desktop10Key,
-    vc14, cmSystemTools::KeyWOW64_32);
+  return cmSystemTools::GetRegistrySubKeys(desktop10Key, vc14,
+                                           cmSystemTools::KeyWOW64_32);
 }
 
-bool
-cmGlobalVisualStudio14Generator::IsWindowsStoreToolsetInstalled() const
+bool cmGlobalVisualStudio14Generator::IsWindowsStoreToolsetInstalled() const
 {
   const char universal10Key[] =
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
     "VisualStudio\\14.0\\Setup\\Build Tools for Windows 10;SrcPath";
 
   std::string win10SDK;
-  return cmSystemTools::ReadRegistryValue(universal10Key,
-    win10SDK, cmSystemTools::KeyWOW64_32);
+  return cmSystemTools::ReadRegistryValue(universal10Key, win10SDK,
+                                          cmSystemTools::KeyWOW64_32);
 }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
 struct NoWindowsH
 {
   bool operator()(std::string const& p)
-    {
+  {
     return !cmSystemTools::FileExists(p + "/um/windows.h", true);
-    }
+  }
 };
 #endif
 
@@ -241,15 +217,14 @@ std::string cmGlobalVisualStudio14Generator::GetWindows10SDKVersion()
   std::string win10Root;
   if (!cmSystemTools::ReadRegistryValue(
         "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\"
-        "Windows Kits\\Installed Roots;KitsRoot10", win10Root,
-        cmSystemTools::KeyWOW64_32) &&
+        "Windows Kits\\Installed Roots;KitsRoot10",
+        win10Root, cmSystemTools::KeyWOW64_32) &&
       !cmSystemTools::ReadRegistryValue(
         "HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\"
-        "Windows Kits\\Installed Roots;KitsRoot10", win10Root,
-        cmSystemTools::KeyWOW64_32))
-    {
+        "Windows Kits\\Installed Roots;KitsRoot10",
+        win10Root, cmSystemTools::KeyWOW64_32)) {
     return std::string();
-    }
+  }
 
   std::vector<std::string> sdks;
   std::string path = win10Root + "Include/*";
@@ -261,31 +236,27 @@ std::string cmGlobalVisualStudio14Generator::GetWindows10SDKVersion()
   sdks.erase(std::remove_if(sdks.begin(), sdks.end(), NoWindowsH()),
              sdks.end());
 
-  if (!sdks.empty())
-    {
+  if (!sdks.empty()) {
     // Only use the filename, which will be the SDK version.
-    for (std::vector<std::string>::iterator i = sdks.begin();
-         i != sdks.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = sdks.begin(); i != sdks.end();
+         ++i) {
       *i = cmSystemTools::GetFilenameName(*i);
-      }
+    }
 
     // Sort the results to make sure we select the most recent one.
     std::sort(sdks.begin(), sdks.end(), cmSystemTools::VersionCompareGreater);
 
     // Look for a SDK exactly matching the requested target version.
-    for (std::vector<std::string>::iterator i = sdks.begin();
-         i != sdks.end(); ++i)
-      {
-      if (cmSystemTools::VersionCompareEqual(*i, this->SystemVersion))
-        {
+    for (std::vector<std::string>::iterator i = sdks.begin(); i != sdks.end();
+         ++i) {
+      if (cmSystemTools::VersionCompareEqual(*i, this->SystemVersion)) {
         return *i;
-        }
       }
+    }
 
     // Use the latest Windows 10 SDK since the exact version is not available.
     return sdks.at(0);
-    }
+  }
 #endif
   // Return an empty string
   return std::string();
diff --git a/Source/cmGlobalVisualStudio14Generator.h b/Source/cmGlobalVisualStudio14Generator.h
index 57e6284..a00f6c7 100644
--- a/Source/cmGlobalVisualStudio14Generator.h
+++ b/Source/cmGlobalVisualStudio14Generator.h
@@ -14,14 +14,12 @@
 
 #include "cmGlobalVisualStudio12Generator.h"
 
-
 /** \class cmGlobalVisualStudio14Generator  */
-class cmGlobalVisualStudio14Generator:
-  public cmGlobalVisualStudio12Generator
+class cmGlobalVisualStudio14Generator : public cmGlobalVisualStudio12Generator
 {
 public:
   cmGlobalVisualStudio14Generator(cmake* cm, const std::string& name,
-    const std::string& platformName);
+                                  const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
   virtual bool MatchesGeneratorName(const std::string& name) const;
diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx
index 2aec245..45d9522 100644
--- a/Source/cmGlobalVisualStudio71Generator.cxx
+++ b/Source/cmGlobalVisualStudio71Generator.cxx
@@ -17,8 +17,8 @@
 #include "cmMakefile.h"
 #include "cmake.h"
 
-cmGlobalVisualStudio71Generator::cmGlobalVisualStudio71Generator(cmake* cm,
-  const std::string& platformName)
+cmGlobalVisualStudio71Generator::cmGlobalVisualStudio71Generator(
+  cmake* cm, const std::string& platformName)
   : cmGlobalVisualStudio7Generator(cm, platformName)
 {
   this->ProjectConfigurationSectionName = "ProjectConfiguration";
@@ -76,10 +76,9 @@ std::string cmGlobalVisualStudio71Generator::GetUserMacrosRegKeyBase()
 #endif
 }
 
-void cmGlobalVisualStudio71Generator
-::WriteSLNFile(std::ostream& fout,
-               cmLocalGenerator* root,
-               std::vector<cmLocalGenerator*>& generators)
+void cmGlobalVisualStudio71Generator::WriteSLNFile(
+  std::ostream& fout, cmLocalGenerator* root,
+  std::vector<cmLocalGenerator*>& generators)
 {
   std::vector<std::string> configs;
   root->GetMakefile()->GetConfigurations(configs);
@@ -102,23 +101,20 @@ void cmGlobalVisualStudio71Generator
   this->WriteTargetsToSolution(targetsSlnString, root, orderedProjectTargets);
 
   // VS 7 does not support folders specified first.
-  if (this->GetVersion() <= VS71)
-    {
+  if (this->GetVersion() <= VS71) {
     fout << targetsSlnString.str();
-    }
+  }
 
   // Generate folder specification.
   bool useFolderProperty = this->UseFolderProperty();
-  if (useFolderProperty)
-    {
+  if (useFolderProperty) {
     this->WriteFolders(fout);
-    }
+  }
 
   // Now write the actual target specification content.
-  if (this->GetVersion() > VS71)
-    {
+  if (this->GetVersion() > VS71) {
     fout << targetsSlnString.str();
-    }
+  }
 
   // Write out the configurations information for the solution
   fout << "Global\n";
@@ -130,13 +126,12 @@ void cmGlobalVisualStudio71Generator
   this->WriteTargetConfigurations(fout, configs, orderedProjectTargets);
   fout << "\tEndGlobalSection\n";
 
-  if (useFolderProperty)
-    {
+  if (useFolderProperty) {
     // Write out project folders
     fout << "\tGlobalSection(NestedProjects) = preSolution\n";
     this->WriteFoldersContent(fout);
     fout << "\tEndGlobalSection\n";
-    }
+  }
 
   // Write out global sections
   this->WriteSLNGlobalSections(fout, root);
@@ -145,58 +140,50 @@ void cmGlobalVisualStudio71Generator
   this->WriteSLNFooter(fout);
 }
 
-void
-cmGlobalVisualStudio71Generator
-::WriteSolutionConfigurations(std::ostream& fout,
-                              std::vector<std::string> const& configs)
+void cmGlobalVisualStudio71Generator::WriteSolutionConfigurations(
+  std::ostream& fout, std::vector<std::string> const& configs)
 {
   fout << "\tGlobalSection(SolutionConfiguration) = preSolution\n";
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
     fout << "\t\t" << *i << " = " << *i << "\n";
-    }
+  }
   fout << "\tEndGlobalSection\n";
 }
 
 // Write a dsp file into the SLN file,
 // Note, that dependencies from executables to
 // the libraries it uses are also done here
-void
-cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
-                                              const std::string& dspname,
-                                              const char* dir,
-                                              cmGeneratorTarget const* t)
+void cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
+                                                   const std::string& dspname,
+                                                   const char* dir,
+                                                   cmGeneratorTarget const* t)
 {
   // check to see if this is a fortran build
   const char* ext = ".vcproj";
   const char* project =
     "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"";
-  if(this->TargetIsFortranOnly(t))
-    {
+  if (this->TargetIsFortranOnly(t)) {
     ext = ".vfproj";
     project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \"";
-    }
+  }
   const char* targetExt = t->GetProperty("GENERATOR_FILE_NAME_EXT");
-  if(targetExt)
-    {
+  if (targetExt) {
     ext = targetExt;
-    }
+  }
 
   std::string guid = this->GetGUID(dspname);
-  fout << project
-       << dspname << "\", \""
-       << this->ConvertToSolutionPath(dir) << (dir[0]? "\\":"")
-       << dspname << ext << "\", \"{" << guid << "}\"\n";
+  fout << project << dspname << "\", \"" << this->ConvertToSolutionPath(dir)
+       << (dir[0] ? "\\" : "") << dspname << ext << "\", \"{" << guid
+       << "}\"\n";
   fout << "\tProjectSection(ProjectDependencies) = postProject\n";
   this->WriteProjectDepends(fout, dspname, dir, t);
   fout << "\tEndProjectSection\n";
 
-  fout <<"EndProject\n";
+  fout << "EndProject\n";
 
   UtilityDependsMap::iterator ui = this->UtilityDepends.find(t);
-  if(ui != this->UtilityDepends.end())
-    {
+  if (ui != this->UtilityDepends.end()) {
     const char* uname = ui->second.c_str();
     /* clang-format off */
     fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \""
@@ -209,82 +196,64 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
          << "\tEndProjectSection\n"
          << "EndProject\n";
     /* clang-format on */
-    }
+  }
 }
 
 // Write a dsp file into the SLN file,
 // Note, that dependencies from executables to
 // the libraries it uses are also done here
-void
-cmGlobalVisualStudio71Generator
-::WriteProjectDepends(std::ostream& fout,
-                      const std::string&,
-                      const char*, cmGeneratorTarget const* target)
+void cmGlobalVisualStudio71Generator::WriteProjectDepends(
+  std::ostream& fout, const std::string&, const char*,
+  cmGeneratorTarget const* target)
 {
   VSDependSet const& depends = this->VSTargetDepends[target];
-  for(VSDependSet::const_iterator di = depends.begin();
-      di != depends.end(); ++di)
-    {
+  for (VSDependSet::const_iterator di = depends.begin(); di != depends.end();
+       ++di) {
     const char* name = di->c_str();
     std::string guid = this->GetGUID(name);
-    if(guid.empty())
-      {
+    if (guid.empty()) {
       std::string m = "Target: ";
       m += target->GetName();
       m += " depends on unknown target: ";
       m += name;
       cmSystemTools::Error(m.c_str());
-      }
-    fout << "\t\t{" << guid << "} = {" << guid << "}\n";
     }
+    fout << "\t\t{" << guid << "} = {" << guid << "}\n";
+  }
 }
 
 // Write a dsp file into the SLN file, Note, that dependencies from
 // executables to the libraries it uses are also done here
-void cmGlobalVisualStudio71Generator
-::WriteExternalProject(std::ostream& fout,
-                       const std::string& name,
-                       const char* location,
-                       const char* typeGuid,
-                       const std::set<std::string>& depends)
+void cmGlobalVisualStudio71Generator::WriteExternalProject(
+  std::ostream& fout, const std::string& name, const char* location,
+  const char* typeGuid, const std::set<std::string>& depends)
 {
   fout << "Project(\"{"
        << (typeGuid ? typeGuid : this->ExternalProjectType(location))
-       << "}\") = \""
-       << name << "\", \""
+       << "}\") = \"" << name << "\", \""
        << this->ConvertToSolutionPath(location) << "\", \"{"
-       << this->GetGUID(name)
-       << "}\"\n";
+       << this->GetGUID(name) << "}\"\n";
 
   // write out the dependencies here VS 7.1 includes dependencies with the
   // project instead of in the global section
-  if(!depends.empty())
-    {
+  if (!depends.empty()) {
     fout << "\tProjectSection(ProjectDependencies) = postProject\n";
     std::set<std::string>::const_iterator it;
-    for(it = depends.begin(); it != depends.end(); ++it)
-      {
-      if(!it->empty())
-        {
-        fout << "\t\t{"
-             << this->GetGUID(it->c_str())
-             << "} = {"
-             << this->GetGUID(it->c_str())
-             << "}\n";
-        }
+    for (it = depends.begin(); it != depends.end(); ++it) {
+      if (!it->empty()) {
+        fout << "\t\t{" << this->GetGUID(it->c_str()) << "} = {"
+             << this->GetGUID(it->c_str()) << "}\n";
       }
-    fout << "\tEndProjectSection\n";
     }
+    fout << "\tEndProjectSection\n";
+  }
 
   fout << "EndProject\n";
-
-
 }
 
 // Write a dsp file into the SLN file, Note, that dependencies from
 // executables to the libraries it uses are also done here
-void cmGlobalVisualStudio71Generator
-::WriteProjectConfigurations(
+void cmGlobalVisualStudio71Generator::WriteProjectConfigurations(
   std::ostream& fout, const std::string& name, cmState::TargetType,
   std::vector<std::string> const& configs,
   const std::set<std::string>& configsPartOfDefaultBuild,
@@ -293,19 +262,17 @@ void cmGlobalVisualStudio71Generator
   const std::string& platformName =
     !platformMapping.empty() ? platformMapping : this->GetPlatformName();
   std::string guid = this->GetGUID(name);
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
-    fout << "\t\t{" << guid << "}." << *i
-         << ".ActiveCfg = " << *i << "|" << platformName << std::endl;
-    std::set<std::string>::const_iterator
-      ci = configsPartOfDefaultBuild.find(*i);
-    if(!(ci == configsPartOfDefaultBuild.end()))
-      {
-      fout << "\t\t{" << guid << "}." << *i
-           << ".Build.0 = " << *i << "|" << platformName << std::endl;
-      }
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
+    fout << "\t\t{" << guid << "}." << *i << ".ActiveCfg = " << *i << "|"
+         << platformName << std::endl;
+    std::set<std::string>::const_iterator ci =
+      configsPartOfDefaultBuild.find(*i);
+    if (!(ci == configsPartOfDefaultBuild.end())) {
+      fout << "\t\t{" << guid << "}." << *i << ".Build.0 = " << *i << "|"
+           << platformName << std::endl;
     }
+  }
 }
 
 // ouput standard header for dsw file
@@ -314,8 +281,8 @@ void cmGlobalVisualStudio71Generator::WriteSLNHeader(std::ostream& fout)
   fout << "Microsoft Visual Studio Solution File, Format Version 8.00\n";
 }
 
-void cmGlobalVisualStudio71Generator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalVisualStudio71Generator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalVisualStudio71Generator::GetActualName();
   entry.Brief = "Deprecated. Generates Visual Studio .NET 2003 project files.";
diff --git a/Source/cmGlobalVisualStudio71Generator.h b/Source/cmGlobalVisualStudio71Generator.h
index d20ffbc..9ad1fad 100644
--- a/Source/cmGlobalVisualStudio71Generator.h
+++ b/Source/cmGlobalVisualStudio71Generator.h
@@ -14,7 +14,6 @@
 
 #include "cmGlobalVisualStudio7Generator.h"
 
-
 /** \class cmGlobalVisualStudio71Generator
  * \brief Write a Unix makefiles.
  *
@@ -25,14 +24,18 @@ class cmGlobalVisualStudio71Generator : public cmGlobalVisualStudio7Generator
 public:
   cmGlobalVisualStudio71Generator(cmake* cm,
                                   const std::string& platformName = "");
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalVisualStudio71Generator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<
+      cmGlobalVisualStudio71Generator>();
+  }
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalVisualStudio71Generator::GetActualName();}
-  static std::string GetActualName() {return "Visual Studio 7 .NET 2003";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalVisualStudio71Generator::GetActualName();
+  }
+  static std::string GetActualName() { return "Visual Studio 7 .NET 2003"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
@@ -52,25 +55,22 @@ public:
 
 protected:
   virtual const char* GetIDEVersion() { return "7.1"; }
-  virtual void WriteSLNFile(std::ostream& fout,
-                            cmLocalGenerator* root,
+  virtual void WriteSLNFile(std::ostream& fout, cmLocalGenerator* root,
                             std::vector<cmLocalGenerator*>& generators);
   virtual void WriteSolutionConfigurations(
     std::ostream& fout, std::vector<std::string> const& configs);
-  virtual void WriteProject(std::ostream& fout,
-                            const std::string& name, const char* path,
-                            const cmGeneratorTarget *t);
-  virtual void WriteProjectDepends(std::ostream& fout,
-                           const std::string& name, const char* path,
-                           cmGeneratorTarget const* t);
+  virtual void WriteProject(std::ostream& fout, const std::string& name,
+                            const char* path, const cmGeneratorTarget* t);
+  virtual void WriteProjectDepends(std::ostream& fout, const std::string& name,
+                                   const char* path,
+                                   cmGeneratorTarget const* t);
   virtual void WriteProjectConfigurations(
     std::ostream& fout, const std::string& name, cmState::TargetType type,
     std::vector<std::string> const& configs,
     const std::set<std::string>& configsPartOfDefaultBuild,
     const std::string& platformMapping = "");
   virtual void WriteExternalProject(std::ostream& fout,
-                                    const std::string& name,
-                                    const char* path,
+                                    const std::string& name, const char* path,
                                     const char* typeGuid,
                                     const std::set<std::string>& depends);
   virtual void WriteSLNHeader(std::ostream& fout);
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index 6fefa9e..cfe5e49 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -22,47 +22,44 @@
 
 #include <assert.h>
 
-static cmVS7FlagTable cmVS7ExtraFlagTable[] =
-{
+static cmVS7FlagTable cmVS7ExtraFlagTable[] = {
   // Precompiled header and related options.  Note that the
   // UsePrecompiledHeader entries are marked as "Continue" so that the
   // corresponding PrecompiledHeaderThrough entry can be found.
-  {"UsePrecompiledHeader", "YX", "Automatically Generate", "2",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeaderThrough", "YX", "Precompiled Header Name", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "3",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"WholeProgramOptimization", "LTCG", "WholeProgramOptimization", "true", 0},
+  { "UsePrecompiledHeader", "YX", "Automatically Generate", "2",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeaderThrough", "YX", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "UsePrecompiledHeader", "Yu", "Use Precompiled Header", "3",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "WholeProgramOptimization", "LTCG", "WholeProgramOptimization", "true",
+    0 },
 
   // Exception handling mode.  If no entries match, it will be FALSE.
-  {"ExceptionHandling", "GX", "enable c++ exceptions", "true", 0},
-  {"ExceptionHandling", "EHsc", "enable c++ exceptions", "true", 0},
+  { "ExceptionHandling", "GX", "enable c++ exceptions", "true", 0 },
+  { "ExceptionHandling", "EHsc", "enable c++ exceptions", "true", 0 },
   // The EHa option does not have an IDE setting.  Let it go to false,
   // and have EHa passed on the command line by leaving out the table
   // entry.
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
 
-cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(cmake *cm,
-  const std::string& platformName)
+cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(
+  cmake* cm, const std::string& platformName)
   : cmGlobalVisualStudioGenerator(cm)
 {
   this->IntelProjectVersion = 0;
   this->DevEnvCommandInitialized = false;
   this->MasmEnabled = false;
 
-  if (platformName.empty())
-    {
+  if (platformName.empty()) {
     this->DefaultPlatformName = "Win32";
-    }
-  else
-    {
+  } else {
     this->DefaultPlatformName = platformName;
-    }
+  }
   this->ExtraFlagTable = cmVS7ExtraFlagTable;
   this->Version = VS7;
 }
@@ -77,8 +74,7 @@ cmGlobalVisualStudio7Generator::~cmGlobalVisualStudio7Generator()
 
 const char* cmGlobalVisualStudio7Generator::GetIntelProjectVersion()
 {
-  if(!this->IntelProjectVersion)
-    {
+  if (!this->IntelProjectVersion) {
     // Compute the version of the Intel plugin to the VS IDE.
     // If the key does not exist then use a default guess.
     std::string intelVersion;
@@ -88,41 +84,33 @@ const char* cmGlobalVisualStudio7Generator::GetIntelProjectVersion()
                                      cmSystemTools::KeyWOW64_32);
     unsigned int intelVersionNumber = ~0u;
     sscanf(intelVersion.c_str(), "%u", &intelVersionNumber);
-    if(intelVersionNumber >= 11)
-      {
+    if (intelVersionNumber >= 11) {
       // Default to latest known project file version.
       intelVersion = "11.0";
-      }
-    else if(intelVersionNumber == 10)
-      {
+    } else if (intelVersionNumber == 10) {
       // Version 10.x actually uses 9.10 in project files!
       intelVersion = "9.10";
-      }
-    else
-      {
+    } else {
       // Version <= 9: use ProductVersion from registry.
-      }
-    this->IntelProjectVersion = strdup(intelVersion.c_str());
     }
+    this->IntelProjectVersion = strdup(intelVersion.c_str());
+  }
   return this->IntelProjectVersion;
 }
 
-void cmGlobalVisualStudio7Generator
-::EnableLanguage(std::vector<std::string>const &  lang,
-                 cmMakefile *mf, bool optional)
+void cmGlobalVisualStudio7Generator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
   mf->AddDefinition("CMAKE_GENERATOR_RC", "rc");
   mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
-  if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
-    {
+  if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) {
     mf->AddCacheDefinition(
-      "CMAKE_CONFIGURATION_TYPES",
-      "Debug;Release;MinSizeRel;RelWithDebInfo",
+      "CMAKE_CONFIGURATION_TYPES", "Debug;Release;MinSizeRel;RelWithDebInfo",
       "Semicolon separated list of supported configuration types, "
       "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
       "anything else will be ignored.",
       cmState::STRING);
-    }
+  }
 
   // Create list of configurations requested by user's cache, if any.
   this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
@@ -135,14 +123,11 @@ void cmGlobalVisualStudio7Generator
   // for running commands and using dll's that the IDE environment
   // does not know about.
   const char* extraPath = cmSystemTools::GetEnv("CMAKE_MSVCIDE_RUN_PATH");
-  if(extraPath)
-    {
-    mf->AddCacheDefinition
-      ("CMAKE_MSVCIDE_RUN_PATH", extraPath,
-       "Saved environment variable CMAKE_MSVCIDE_RUN_PATH",
-       cmState::STATIC);
-    }
-
+  if (extraPath) {
+    mf->AddCacheDefinition("CMAKE_MSVCIDE_RUN_PATH", extraPath,
+                           "Saved environment variable CMAKE_MSVCIDE_RUN_PATH",
+                           cmState::STATIC);
+  }
 }
 
 void cmGlobalVisualStudio7Generator::FindMakeProgram(cmMakefile* mf)
@@ -154,11 +139,10 @@ void cmGlobalVisualStudio7Generator::FindMakeProgram(cmMakefile* mf)
 
 std::string const& cmGlobalVisualStudio7Generator::GetDevEnvCommand()
 {
-  if(!this->DevEnvCommandInitialized)
-    {
+  if (!this->DevEnvCommandInitialized) {
     this->DevEnvCommandInitialized = true;
     this->DevEnvCommand = this->FindDevEnvCommand();
-    }
+  }
   return this->DevEnvCommand;
 }
 
@@ -166,12 +150,11 @@ std::string cmGlobalVisualStudio7Generator::FindDevEnvCommand()
 {
   std::string vscmd;
   std::string vskey = this->GetRegistryBase() + ";InstallDir";
-  if(cmSystemTools::ReadRegistryValue(vskey.c_str(), vscmd,
-                                      cmSystemTools::KeyWOW64_32))
-    {
+  if (cmSystemTools::ReadRegistryValue(vskey.c_str(), vscmd,
+                                       cmSystemTools::KeyWOW64_32)) {
     cmSystemTools::ConvertToUnixSlashes(vscmd);
     vscmd += "/";
-    }
+  }
   vscmd += "devenv.com";
   return vscmd;
 }
@@ -180,45 +163,28 @@ const char* cmGlobalVisualStudio7Generator::ExternalProjectType(
   const char* location)
 {
   std::string extension = cmSystemTools::GetFilenameLastExtension(location);
-  if (extension == ".vbproj")
-    {
+  if (extension == ".vbproj") {
     return "F184B08F-C81C-45F6-A57F-5ABD9991F28F";
-    }
-  else if (extension == ".csproj")
-    {
+  } else if (extension == ".csproj") {
     return "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC";
-    }
-  else if (extension == ".fsproj")
-    {
+  } else if (extension == ".fsproj") {
     return "F2A71F9B-5D33-465A-A702-920D77279786";
-    }
-  else if (extension == ".vdproj")
-    {
+  } else if (extension == ".vdproj") {
     return "54435603-DBB4-11D2-8724-00A0C9A8B90C";
-    }
-  else if (extension == ".dbproj")
-    {
+  } else if (extension == ".dbproj") {
     return "C8D11400-126E-41CD-887F-60BD40844F9E";
-    }
-  else if (extension == ".wixproj")
-    {
+  } else if (extension == ".wixproj") {
     return "930C7802-8A8C-48F9-8165-68863BCCD9DD";
-    }
-  else if (extension == ".pyproj")
-    {
+  } else if (extension == ".pyproj") {
     return "888888A0-9F3D-457C-B088-3A5042F75D52";
-    }
+  }
   return "8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942";
 }
 void cmGlobalVisualStudio7Generator::GenerateBuildCommand(
-  std::vector<std::string>& makeCommand,
-  const std::string& makeProgram,
-  const std::string& projectName,
-  const std::string& /*projectDir*/,
-  const std::string& targetName,
-  const std::string& config,
-  bool /*fast*/, bool /*verbose*/,
-  std::vector<std::string> const& makeOptions)
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& projectName, const std::string& /*projectDir*/,
+  const std::string& targetName, const std::string& config, bool /*fast*/,
+  bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   // Select the caller- or user-preferred make program, else devenv.
   std::string makeProgramSelected =
@@ -229,67 +195,55 @@ void cmGlobalVisualStudio7Generator::GenerateBuildCommand(
   // command-line compatible with devenv.
   std::string makeProgramLower = makeProgramSelected;
   cmSystemTools::LowerCase(makeProgramLower);
-  if(makeProgramLower.find("msbuild") != std::string::npos)
-    {
+  if (makeProgramLower.find("msbuild") != std::string::npos) {
     makeProgramSelected = this->GetDevEnvCommand();
-    }
+  }
 
   makeCommand.push_back(makeProgramSelected);
 
   makeCommand.push_back(std::string(projectName) + ".sln");
   std::string realTarget = targetName;
   bool clean = false;
-  if ( realTarget == "clean" )
-    {
+  if (realTarget == "clean") {
     clean = true;
     realTarget = "ALL_BUILD";
-    }
-  if(clean)
-    {
+  }
+  if (clean) {
     makeCommand.push_back("/clean");
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("/build");
-    }
+  }
 
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     makeCommand.push_back(config);
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("Debug");
-    }
+  }
   makeCommand.push_back("/project");
 
-  if (!realTarget.empty())
-    {
+  if (!realTarget.empty()) {
     makeCommand.push_back(realTarget);
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("ALL_BUILD");
-    }
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
+  }
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
 }
 
 ///! Create a local generator appropriate to this Global Generator
-cmLocalGenerator *cmGlobalVisualStudio7Generator::CreateLocalGenerator(
-    cmMakefile* mf)
+cmLocalGenerator* cmGlobalVisualStudio7Generator::CreateLocalGenerator(
+  cmMakefile* mf)
 {
-  cmLocalVisualStudio7Generator *lg =
+  cmLocalVisualStudio7Generator* lg =
     new cmLocalVisualStudio7Generator(this, mf);
   return lg;
 }
 
 std::string const& cmGlobalVisualStudio7Generator::GetPlatformName() const
 {
-  if(!this->GeneratorPlatform.empty())
-    {
+  if (!this->GeneratorPlatform.empty()) {
     return this->GeneratorPlatform;
-    }
+  }
   return this->DefaultPlatformName;
 }
 
@@ -304,14 +258,11 @@ bool cmGlobalVisualStudio7Generator::SetSystemName(std::string const& s,
 bool cmGlobalVisualStudio7Generator::SetGeneratorPlatform(std::string const& p,
                                                           cmMakefile* mf)
 {
-  if(this->GetPlatformName() == "x64")
-    {
+  if (this->GetPlatformName() == "x64") {
     mf->AddDefinition("CMAKE_FORCE_WIN64", "TRUE");
-    }
-  else if(this->GetPlatformName() == "Itanium")
-    {
+  } else if (this->GetPlatformName() == "Itanium") {
     mf->AddDefinition("CMAKE_FORCE_IA64", "TRUE");
-    }
+  }
   mf->AddDefinition("CMAKE_VS_PLATFORM_NAME", this->GetPlatformName().c_str());
   return this->cmGlobalVisualStudioGenerator::SetGeneratorPlatform(p, mf);
 }
@@ -325,37 +276,30 @@ void cmGlobalVisualStudio7Generator::Generate()
   this->OutputSLNFile();
   // If any solution or project files changed during the generation,
   // tell Visual Studio to reload them...
-  if(!cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (!cmSystemTools::GetErrorOccuredFlag()) {
     this->CallVisualStudioMacro(MacroReload);
-    }
+  }
 
-  if (this->Version == VS71 &&
-      !this->CMakeInstance->GetIsInTryCompile())
-    {
+  if (this->Version == VS71 && !this->CMakeInstance->GetIsInTryCompile()) {
     const char* cmakeWarnVS71 =
       this->CMakeInstance->GetState()->GetCacheEntryValue("CMAKE_WARN_VS71");
-    if (!cmakeWarnVS71 || !cmSystemTools::IsOff(cmakeWarnVS71))
-      {
+    if (!cmakeWarnVS71 || !cmSystemTools::IsOff(cmakeWarnVS71)) {
       this->CMakeInstance->IssueMessage(
         cmake::WARNING,
         "The \"Visual Studio 7 .NET 2003\" generator is deprecated "
         "and will be removed in a future version of CMake."
         "\n"
-        "Add CMAKE_WARN_VS71=OFF to the cache to disable this warning."
-        );
-      }
+        "Add CMAKE_WARN_VS71=OFF to the cache to disable this warning.");
     }
+  }
 }
 
-void cmGlobalVisualStudio7Generator
-::OutputSLNFile(cmLocalGenerator* root,
-                std::vector<cmLocalGenerator*>& generators)
+void cmGlobalVisualStudio7Generator::OutputSLNFile(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
-  if(generators.empty())
-    {
+  if (generators.empty()) {
     return;
-    }
+  }
   this->CurrentProject = root->GetProjectName();
   std::string fname = root->GetCurrentBinaryDirectory();
   fname += "/";
@@ -363,308 +307,250 @@ void cmGlobalVisualStudio7Generator
   fname += ".sln";
   cmGeneratedFileStream fout(fname.c_str());
   fout.SetCopyIfDifferent(true);
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
   this->WriteSLNFile(fout, root, generators);
-  if (fout.Close())
-    {
+  if (fout.Close()) {
     this->FileReplacedDuringGenerate(fname);
-    }
+  }
 }
 
 // output the SLN file
 void cmGlobalVisualStudio7Generator::OutputSLNFile()
 {
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     this->OutputSLNFile(it->second[0], it->second);
-    }
+  }
 }
 
-
 void cmGlobalVisualStudio7Generator::WriteTargetConfigurations(
-  std::ostream& fout,
-  std::vector<std::string> const& configs,
+  std::ostream& fout, std::vector<std::string> const& configs,
   OrderedTargetDependSet const& projectTargets)
 {
   // loop over again and write out configurations for each target
   // in the solution
-  for(OrderedTargetDependSet::const_iterator tt =
-        projectTargets.begin(); tt != projectTargets.end(); ++tt)
-    {
+  for (OrderedTargetDependSet::const_iterator tt = projectTargets.begin();
+       tt != projectTargets.end(); ++tt) {
     cmGeneratorTarget const* target = *tt;
-    if(target->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (target->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     const char* expath = target->GetProperty("EXTERNAL_MSPROJECT");
-    if(expath)
-      {
+    if (expath) {
       std::set<std::string> allConfigurations(configs.begin(), configs.end());
       const char* mapping = target->GetProperty("VS_PLATFORM_MAPPING");
       this->WriteProjectConfigurations(
-        fout, target->GetName().c_str(), target->GetType(),
-        configs, allConfigurations, mapping ? mapping : "");
-      }
-    else
-      {
+        fout, target->GetName().c_str(), target->GetType(), configs,
+        allConfigurations, mapping ? mapping : "");
+    } else {
       const std::set<std::string>& configsPartOfDefaultBuild =
         this->IsPartOfDefaultBuild(configs, projectTargets, target);
-      const char *vcprojName =
-        target->GetProperty("GENERATOR_FILE_NAME");
-      if (vcprojName)
-        {
+      const char* vcprojName = target->GetProperty("GENERATOR_FILE_NAME");
+      if (vcprojName) {
         this->WriteProjectConfigurations(fout, vcprojName, target->GetType(),
                                          configs, configsPartOfDefaultBuild);
-        }
       }
     }
+  }
 }
 
-
 void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
-    std::ostream& fout,
-    cmLocalGenerator* root,
-    OrderedTargetDependSet const& projectTargets)
+  std::ostream& fout, cmLocalGenerator* root,
+  OrderedTargetDependSet const& projectTargets)
 {
   VisualStudioFolders.clear();
 
-  for(OrderedTargetDependSet::const_iterator tt =
-        projectTargets.begin(); tt != projectTargets.end(); ++tt)
-    {
+  for (OrderedTargetDependSet::const_iterator tt = projectTargets.begin();
+       tt != projectTargets.end(); ++tt) {
     cmGeneratorTarget const* target = *tt;
-    if(target->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (target->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     bool written = false;
 
     // handle external vc project files
     const char* expath = target->GetProperty("EXTERNAL_MSPROJECT");
-    if(expath)
-      {
+    if (expath) {
       std::string project = target->GetName();
       std::string location = expath;
 
-      this->WriteExternalProject(fout,
-                                 project.c_str(),
-                                 location.c_str(),
+      this->WriteExternalProject(fout, project.c_str(), location.c_str(),
                                  target->GetProperty("VS_PROJECT_TYPE"),
                                  target->GetUtilities());
       written = true;
-      }
-    else
-      {
-      const char *vcprojName =
-        target->GetProperty("GENERATOR_FILE_NAME");
-      if(vcprojName)
-        {
+    } else {
+      const char* vcprojName = target->GetProperty("GENERATOR_FILE_NAME");
+      if (vcprojName) {
         cmLocalGenerator* lg = target->GetLocalGenerator();
         std::string dir = lg->GetCurrentBinaryDirectory();
-        dir = root->Convert(dir.c_str(),
-                            cmLocalGenerator::START_OUTPUT);
-        if(dir == ".")
-          {
+        dir = root->Convert(dir.c_str(), cmLocalGenerator::START_OUTPUT);
+        if (dir == ".") {
           dir = ""; // msbuild cannot handle ".\" prefix
-          }
-        this->WriteProject(fout, vcprojName, dir.c_str(),
-                           target);
-        written = true;
         }
+        this->WriteProject(fout, vcprojName, dir.c_str(), target);
+        written = true;
       }
+    }
 
     // Create "solution folder" information from FOLDER target property
     //
-    if (written && this->UseFolderProperty())
-      {
-      const char *targetFolder = target->GetProperty("FOLDER");
-      if (targetFolder)
-        {
+    if (written && this->UseFolderProperty()) {
+      const char* targetFolder = target->GetProperty("FOLDER");
+      if (targetFolder) {
         std::vector<cmsys::String> tokens =
           cmSystemTools::SplitString(targetFolder, '/', false);
 
         std::string cumulativePath = "";
 
-        for(std::vector<cmsys::String>::iterator iter = tokens.begin();
-            iter != tokens.end(); ++iter)
-          {
-          if(!iter->size())
-            {
+        for (std::vector<cmsys::String>::iterator iter = tokens.begin();
+             iter != tokens.end(); ++iter) {
+          if (!iter->size()) {
             continue;
-            }
+          }
 
-          if (cumulativePath.empty())
-            {
+          if (cumulativePath.empty()) {
             cumulativePath = "CMAKE_FOLDER_GUID_" + *iter;
-            }
-          else
-            {
-            VisualStudioFolders[cumulativePath].insert(
-              cumulativePath + "/" + *iter);
+          } else {
+            VisualStudioFolders[cumulativePath].insert(cumulativePath + "/" +
+                                                       *iter);
 
             cumulativePath = cumulativePath + "/" + *iter;
-            }
           }
+        }
 
-        if (!cumulativePath.empty())
-          {
+        if (!cumulativePath.empty()) {
           VisualStudioFolders[cumulativePath].insert(target->GetName());
-          }
         }
       }
     }
+  }
 }
 
-
 void cmGlobalVisualStudio7Generator::WriteTargetDepends(
-    std::ostream& fout,
-    OrderedTargetDependSet const& projectTargets
-    )
+  std::ostream& fout, OrderedTargetDependSet const& projectTargets)
 {
-  for(OrderedTargetDependSet::const_iterator tt =
-        projectTargets.begin(); tt != projectTargets.end(); ++tt)
-    {
+  for (OrderedTargetDependSet::const_iterator tt = projectTargets.begin();
+       tt != projectTargets.end(); ++tt) {
     cmGeneratorTarget const* target = *tt;
-    if(target->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (target->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
-    const char *vcprojName =
-      target->GetProperty("GENERATOR_FILE_NAME");
-    if (vcprojName)
-      {
-      std::string dir = target->GetLocalGenerator()
-              ->GetCurrentSourceDirectory();
-      this->WriteProjectDepends(fout, vcprojName,
-                                dir.c_str(), target);
-      }
     }
+    const char* vcprojName = target->GetProperty("GENERATOR_FILE_NAME");
+    if (vcprojName) {
+      std::string dir =
+        target->GetLocalGenerator()->GetCurrentSourceDirectory();
+      this->WriteProjectDepends(fout, vcprojName, dir.c_str(), target);
+    }
+  }
 }
 
 void cmGlobalVisualStudio7Generator::WriteFolders(std::ostream& fout)
 {
-  const char *prefix = "CMAKE_FOLDER_GUID_";
+  const char* prefix = "CMAKE_FOLDER_GUID_";
   const std::string::size_type skip_prefix = strlen(prefix);
   std::string guidProjectTypeFolder = "2150E333-8FDC-42A3-9474-1A3956D46DE8";
-  for(std::map<std::string,std::set<std::string> >::iterator iter =
-    VisualStudioFolders.begin(); iter != VisualStudioFolders.end(); ++iter)
-    {
+  for (std::map<std::string, std::set<std::string> >::iterator iter =
+         VisualStudioFolders.begin();
+       iter != VisualStudioFolders.end(); ++iter) {
     std::string fullName = iter->first;
     std::string guid = this->GetGUID(fullName.c_str());
 
     cmSystemTools::ReplaceString(fullName, "/", "\\");
-    if (cmSystemTools::StringStartsWith(fullName.c_str(), prefix))
-      {
+    if (cmSystemTools::StringStartsWith(fullName.c_str(), prefix)) {
       fullName = fullName.substr(skip_prefix);
-      }
+    }
 
     std::string nameOnly = cmSystemTools::GetFilenameName(fullName);
 
-    fout << "Project(\"{" <<
-      guidProjectTypeFolder << "}\") = \"" <<
-      nameOnly << "\", \"" <<
-      fullName << "\", \"{" <<
-      guid <<
-      "}\"\nEndProject\n";
-    }
+    fout << "Project(\"{" << guidProjectTypeFolder << "}\") = \"" << nameOnly
+         << "\", \"" << fullName << "\", \"{" << guid << "}\"\nEndProject\n";
+  }
 }
 
 void cmGlobalVisualStudio7Generator::WriteFoldersContent(std::ostream& fout)
 {
-  for(std::map<std::string,std::set<std::string> >::iterator iter =
-    VisualStudioFolders.begin(); iter != VisualStudioFolders.end(); ++iter)
-    {
+  for (std::map<std::string, std::set<std::string> >::iterator iter =
+         VisualStudioFolders.begin();
+       iter != VisualStudioFolders.end(); ++iter) {
     std::string key(iter->first);
     std::string guidParent(this->GetGUID(key.c_str()));
 
-    for(std::set<std::string>::iterator it = iter->second.begin();
-        it != iter->second.end(); ++it)
-      {
+    for (std::set<std::string>::iterator it = iter->second.begin();
+         it != iter->second.end(); ++it) {
       std::string value(*it);
       std::string guid(this->GetGUID(value.c_str()));
 
       fout << "\t\t{" << guid << "} = {" << guidParent << "}\n";
-      }
     }
+  }
 }
 
-std::string
-cmGlobalVisualStudio7Generator::ConvertToSolutionPath(const char* path)
+std::string cmGlobalVisualStudio7Generator::ConvertToSolutionPath(
+  const char* path)
 {
   // Convert to backslashes.  Do not use ConvertToOutputPath because
   // we will add quoting ourselves, and we know these projects always
   // use windows slashes.
   std::string d = path;
   std::string::size_type pos = 0;
-  while((pos = d.find('/', pos)) != d.npos)
-    {
+  while ((pos = d.find('/', pos)) != d.npos) {
     d[pos++] = '\\';
-    }
+  }
   return d;
 }
 
-void cmGlobalVisualStudio7Generator
-::WriteSLNGlobalSections(std::ostream& fout,
-                         cmLocalGenerator* root)
+void cmGlobalVisualStudio7Generator::WriteSLNGlobalSections(
+  std::ostream& fout, cmLocalGenerator* root)
 {
   bool extensibilityGlobalsOverridden = false;
   bool extensibilityAddInsOverridden = false;
   const std::vector<std::string> propKeys =
-      root->GetMakefile()->GetPropertyKeys();
-  for(std::vector<std::string>::const_iterator it = propKeys.begin();
-      it != propKeys.end(); ++it)
-    {
-    if(it->find("VS_GLOBAL_SECTION_") == 0)
-      {
+    root->GetMakefile()->GetPropertyKeys();
+  for (std::vector<std::string>::const_iterator it = propKeys.begin();
+       it != propKeys.end(); ++it) {
+    if (it->find("VS_GLOBAL_SECTION_") == 0) {
       std::string sectionType;
       std::string name = it->substr(18);
-      if(name.find("PRE_") == 0)
-        {
+      if (name.find("PRE_") == 0) {
         name = name.substr(4);
         sectionType = "preSolution";
-        }
-      else if(name.find("POST_") == 0)
-        {
+      } else if (name.find("POST_") == 0) {
         name = name.substr(5);
         sectionType = "postSolution";
-        }
-      else
+      } else
         continue;
-      if(!name.empty())
-        {
-        if(name == "ExtensibilityGlobals" && sectionType == "postSolution")
+      if (!name.empty()) {
+        if (name == "ExtensibilityGlobals" && sectionType == "postSolution")
           extensibilityGlobalsOverridden = true;
-        else if(name == "ExtensibilityAddIns" && sectionType == "postSolution")
+        else if (name == "ExtensibilityAddIns" &&
+                 sectionType == "postSolution")
           extensibilityAddInsOverridden = true;
         fout << "\tGlobalSection(" << name << ") = " << sectionType << "\n";
         std::vector<std::string> keyValuePairs;
         cmSystemTools::ExpandListArgument(
-              root->GetMakefile()->GetProperty(it->c_str()),
-              keyValuePairs);
-        for(std::vector<std::string>::const_iterator itPair =
-            keyValuePairs.begin(); itPair != keyValuePairs.end(); ++itPair)
-          {
+          root->GetMakefile()->GetProperty(it->c_str()), keyValuePairs);
+        for (std::vector<std::string>::const_iterator itPair =
+               keyValuePairs.begin();
+             itPair != keyValuePairs.end(); ++itPair) {
           const std::string::size_type posEqual = itPair->find('=');
-          if(posEqual != std::string::npos)
-            {
+          if (posEqual != std::string::npos) {
             const std::string key =
               cmSystemTools::TrimWhitespace(itPair->substr(0, posEqual));
             const std::string value =
               cmSystemTools::TrimWhitespace(itPair->substr(posEqual + 1));
             fout << "\t\t" << key << " = " << value << "\n";
-            }
           }
-        fout << "\tEndGlobalSection\n";
         }
+        fout << "\tEndGlobalSection\n";
       }
     }
-  if(!extensibilityGlobalsOverridden)
+  }
+  if (!extensibilityGlobalsOverridden)
     fout << "\tGlobalSection(ExtensibilityGlobals) = postSolution\n"
          << "\tEndGlobalSection\n";
-  if(!extensibilityAddInsOverridden)
+  if (!extensibilityAddInsOverridden)
     fout << "\tGlobalSection(ExtensibilityAddIns) = postSolution\n"
          << "\tEndGlobalSection\n";
 }
@@ -675,9 +561,8 @@ void cmGlobalVisualStudio7Generator::WriteSLNFooter(std::ostream& fout)
   fout << "EndGlobal\n";
 }
 
-std::string
-cmGlobalVisualStudio7Generator::WriteUtilityDepend(
-        cmGeneratorTarget const* target)
+std::string cmGlobalVisualStudio7Generator::WriteUtilityDepend(
+  cmGeneratorTarget const* target)
 {
   std::vector<std::string> configs;
   target->Target->GetMakefile()->GetConfigurations(configs);
@@ -705,9 +590,8 @@ cmGlobalVisualStudio7Generator::WriteUtilityDepend(
     "\t<Configurations>\n"
     ;
   /* clang-format on */
-  for(std::vector<std::string>::iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = configs.begin();
+       i != configs.end(); ++i) {
     /* clang-format off */
     fout <<
       "\t\t<Configuration\n"
@@ -721,7 +605,7 @@ cmGlobalVisualStudio7Generator::WriteUtilityDepend(
       "\t\t</Configuration>\n"
       ;
     /* clang-format on */
-    }
+  }
   /* clang-format off */
   fout <<
     "\t</Configurations>\n"
@@ -731,10 +615,9 @@ cmGlobalVisualStudio7Generator::WriteUtilityDepend(
     ;
   /* clang-format on */
 
-  if(fout.Close())
-    {
+  if (fout.Close()) {
     this->FileReplacedDuringGenerate(fname);
-    }
+  }
   return pname;
 }
 
@@ -742,10 +625,9 @@ std::string cmGlobalVisualStudio7Generator::GetGUID(std::string const& name)
 {
   std::string const& guidStoreName = name + "_GUID_CMAKE";
   if (const char* storedGUID =
-      this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str()))
-    {
+        this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str())) {
     return std::string(storedGUID);
-    }
+  }
   // Compute a GUID that is deterministic but unique to the build tree.
   std::string input = this->CMakeInstance->GetState()->GetBinaryDirectory();
   input += "|";
@@ -754,31 +636,26 @@ std::string cmGlobalVisualStudio7Generator::GetGUID(std::string const& name)
   cmUuid uuidGenerator;
 
   std::vector<unsigned char> uuidNamespace;
-  uuidGenerator.StringToBinary(
-    "ee30c4be-5192-4fb0-b335-722a2dffe760", uuidNamespace);
+  uuidGenerator.StringToBinary("ee30c4be-5192-4fb0-b335-722a2dffe760",
+                               uuidNamespace);
 
   std::string guid = uuidGenerator.FromMd5(uuidNamespace, input);
 
   return cmSystemTools::UpperCase(guid);
 }
 
-void
-cmGlobalVisualStudio7Generator
-::AppendDirectoryForConfig(const std::string& prefix,
-                           const std::string& config,
-                           const std::string& suffix,
-                           std::string& dir)
+void cmGlobalVisualStudio7Generator::AppendDirectoryForConfig(
+  const std::string& prefix, const std::string& config,
+  const std::string& suffix, std::string& dir)
 {
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     dir += prefix;
     dir += config;
     dir += suffix;
-    }
+  }
 }
 
-std::set<std::string>
-cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
+std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
   std::vector<std::string> const& configs,
   OrderedTargetDependSet const& projectTargets,
   cmGeneratorTarget const* target)
@@ -787,61 +664,52 @@ cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
   // if it is a utilitiy target then only make it part of the
   // default build if another target depends on it
   int type = target->GetType();
-  if (type == cmState::GLOBAL_TARGET)
-    {
+  if (type == cmState::GLOBAL_TARGET) {
     // check if INSTALL target is part of default build
-    if(target->GetName() == "INSTALL")
-      {
+    if (target->GetName() == "INSTALL") {
       // inspect CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD properties
-      for(std::vector<std::string>::const_iterator i = configs.begin();
-          i != configs.end(); ++i)
-        {
-        const char* propertyValue = target->Target->GetMakefile()
-          ->GetDefinition("CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD");
+      for (std::vector<std::string>::const_iterator i = configs.begin();
+           i != configs.end(); ++i) {
+        const char* propertyValue =
+          target->Target->GetMakefile()->GetDefinition(
+            "CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD");
         cmGeneratorExpression ge;
-        cmsys::auto_ptr<cmCompiledGeneratorExpression>
-          cge = ge.Parse(propertyValue);
-        if(cmSystemTools::IsOn(cge->Evaluate(target->GetLocalGenerator(),
-                                             *i)))
-          {
+        cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
+          ge.Parse(propertyValue);
+        if (cmSystemTools::IsOn(
+              cge->Evaluate(target->GetLocalGenerator(), *i))) {
           activeConfigs.insert(*i);
-          }
         }
       }
-    return activeConfigs;
     }
-  if(type == cmState::UTILITY && !this->IsDependedOn(projectTargets, target))
-    {
     return activeConfigs;
-    }
+  }
+  if (type == cmState::UTILITY &&
+      !this->IsDependedOn(projectTargets, target)) {
+    return activeConfigs;
+  }
   // inspect EXCLUDE_FROM_DEFAULT_BUILD[_<CONFIG>] properties
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
     const char* propertyValue =
       target->GetFeature("EXCLUDE_FROM_DEFAULT_BUILD", i->c_str());
-    if(cmSystemTools::IsOff(propertyValue))
-      {
+    if (cmSystemTools::IsOff(propertyValue)) {
       activeConfigs.insert(*i);
-      }
     }
+  }
   return activeConfigs;
 }
 
-bool
-cmGlobalVisualStudio7Generator
-::IsDependedOn(OrderedTargetDependSet const& projectTargets,
-               cmGeneratorTarget const* gtIn)
+bool cmGlobalVisualStudio7Generator::IsDependedOn(
+  OrderedTargetDependSet const& projectTargets, cmGeneratorTarget const* gtIn)
 {
   for (OrderedTargetDependSet::const_iterator l = projectTargets.begin();
-       l != projectTargets.end(); ++l)
-    {
+       l != projectTargets.end(); ++l) {
     TargetDependSet const& tgtdeps = this->GetTargetDirectDepends(*l);
-    if(tgtdeps.count(gtIn))
-      {
+    if (tgtdeps.count(gtIn)) {
       return true;
-      }
     }
+  }
   return false;
 }
 
diff --git a/Source/cmGlobalVisualStudio7Generator.h b/Source/cmGlobalVisualStudio7Generator.h
index a360bd9..2092343 100644
--- a/Source/cmGlobalVisualStudio7Generator.h
+++ b/Source/cmGlobalVisualStudio7Generator.h
@@ -35,7 +35,7 @@ public:
   std::string const& GetPlatformName() const;
 
   ///! Create a local generator appropriate to this Global Generator
-  virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile* mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   virtual bool SetSystemName(std::string const& s, cmMakefile* mf);
 
@@ -51,23 +51,19 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 
   /**
    * Try running cmake and building a file. This is used for dynamically
    * loaded commands, not as part of the usual build process.
    */
   virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand,
-    const std::string& makeProgram,
-    const std::string& projectName,
-    const std::string& projectDir,
-    const std::string& targetName,
-    const std::string& config,
-    bool fast, bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+    const std::string& projectName, const std::string& projectDir,
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
   /**
    * Generate the DSW workspace file.
@@ -85,12 +81,16 @@ public:
 
   ///! What is the configurations directory variable called?
   virtual const char* GetCMakeCFGIntDir() const
-    { return "$(ConfigurationName)"; }
+  {
+    return "$(ConfigurationName)";
+  }
 
   /** Return true if the target project file should have the option
       LinkLibraryDependencies and link to .sln dependencies. */
   virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget*)
-  { return false; }
+  {
+    return false;
+  }
 
   const char* GetIntelProjectVersion();
 
@@ -117,12 +117,11 @@ protected:
                              std::vector<cmLocalGenerator*>& generators);
   virtual void WriteSLNFile(std::ostream& fout, cmLocalGenerator* root,
                             std::vector<cmLocalGenerator*>& generators) = 0;
-  virtual void WriteProject(std::ostream& fout,
-                            const std::string& name, const char* path,
-                            const cmGeneratorTarget *t) = 0;
-  virtual void WriteProjectDepends(std::ostream& fout,
-                           const std::string& name, const char* path,
-                           cmGeneratorTarget const* t) = 0;
+  virtual void WriteProject(std::ostream& fout, const std::string& name,
+                            const char* path, const cmGeneratorTarget* t) = 0;
+  virtual void WriteProjectDepends(std::ostream& fout, const std::string& name,
+                                   const char* path,
+                                   cmGeneratorTarget const* t) = 0;
   virtual void WriteProjectConfigurations(
     std::ostream& fout, const std::string& name, cmState::TargetType type,
     std::vector<std::string> const& configs,
@@ -132,40 +131,34 @@ protected:
                                       cmLocalGenerator* root);
   virtual void WriteSLNFooter(std::ostream& fout);
   virtual void WriteSLNHeader(std::ostream& fout) = 0;
-  virtual std::string WriteUtilityDepend(const cmGeneratorTarget *target);
+  virtual std::string WriteUtilityDepend(const cmGeneratorTarget* target);
 
   virtual void WriteTargetsToSolution(
-    std::ostream& fout,
-    cmLocalGenerator* root,
+    std::ostream& fout, cmLocalGenerator* root,
     OrderedTargetDependSet const& projectTargets);
   virtual void WriteTargetDepends(
-    std::ostream& fout,
-    OrderedTargetDependSet const& projectTargets);
+    std::ostream& fout, OrderedTargetDependSet const& projectTargets);
   virtual void WriteTargetConfigurations(
-    std::ostream& fout,
-    std::vector<std::string> const& configs,
+    std::ostream& fout, std::vector<std::string> const& configs,
     OrderedTargetDependSet const& projectTargets);
 
-  virtual void WriteExternalProject(std::ostream& fout,
-                                    const std::string& name,
-                                    const char* path,
-                                    const char* typeGuid,
-                                    const std::set<std::string>&
-                                    dependencies) = 0;
+  virtual void WriteExternalProject(
+    std::ostream& fout, const std::string& name, const char* path,
+    const char* typeGuid, const std::set<std::string>& dependencies) = 0;
 
   std::string ConvertToSolutionPath(const char* path);
 
-  std::set<std::string>
-    IsPartOfDefaultBuild(std::vector<std::string> const& configs,
-                         OrderedTargetDependSet const& projectTargets,
-                         cmGeneratorTarget const* target);
+  std::set<std::string> IsPartOfDefaultBuild(
+    std::vector<std::string> const& configs,
+    OrderedTargetDependSet const& projectTargets,
+    cmGeneratorTarget const* target);
   bool IsDependedOn(OrderedTargetDependSet const& projectTargets,
                     cmGeneratorTarget const* target);
   std::map<std::string, std::string> GUIDMap;
 
   virtual void WriteFolders(std::ostream& fout);
   virtual void WriteFoldersContent(std::ostream& fout);
-  std::map<std::string,std::set<std::string> > VisualStudioFolders;
+  std::map<std::string, std::set<std::string> > VisualStudioFolders;
 
   // Set during OutputSLNFile with the name of the current project.
   // There is one SLN file per project.
diff --git a/Source/cmGlobalVisualStudio8Generator.cxx b/Source/cmGlobalVisualStudio8Generator.cxx
index 76baf0d..dfe196a 100644
--- a/Source/cmGlobalVisualStudio8Generator.cxx
+++ b/Source/cmGlobalVisualStudio8Generator.cxx
@@ -22,69 +22,64 @@
 
 static const char vs8generatorName[] = "Visual Studio 8 2005";
 
-class cmGlobalVisualStudio8Generator::Factory
-  : public cmGlobalGeneratorFactory
+class cmGlobalVisualStudio8Generator::Factory : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const {
-    if(strncmp(name.c_str(), vs8generatorName,
-               sizeof(vs8generatorName) - 1) != 0)
-      {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
+    if (strncmp(name.c_str(), vs8generatorName,
+                sizeof(vs8generatorName) - 1) != 0) {
       return 0;
-      }
+    }
 
     const char* p = name.c_str() + sizeof(vs8generatorName) - 1;
-    if(p[0] == '\0')
-      {
+    if (p[0] == '\0') {
       return new cmGlobalVisualStudio8Generator(cm, name, "");
-      }
+    }
 
-    if(p[0] != ' ')
-      {
+    if (p[0] != ' ') {
       return 0;
-      }
+    }
 
     ++p;
 
-    if(!strcmp(p, "Win64"))
-      {
+    if (!strcmp(p, "Win64")) {
       return new cmGlobalVisualStudio8Generator(cm, name, "x64");
-      }
+    }
 
     cmVisualStudioWCEPlatformParser parser(p);
     parser.ParseVersion("8.0");
-    if (!parser.Found())
-      {
+    if (!parser.Found()) {
       return 0;
-      }
+    }
 
     cmGlobalVisualStudio8Generator* ret =
-        new cmGlobalVisualStudio8Generator(cm, name, p);
+      new cmGlobalVisualStudio8Generator(cm, name, p);
     ret->WindowsCEVersion = parser.GetOSVersion();
     return ret;
   }
 
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const {
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
     entry.Name = std::string(vs8generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2005 project files.  "
-      "Optional [arch] can be \"Win64\"."
-      ;
+    entry.Brief = "Generates Visual Studio 2005 project files.  "
+                  "Optional [arch] can be \"Win64\".";
   }
 
-  virtual void GetGenerators(std::vector<std::string>& names) const {
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
     names.push_back(vs8generatorName);
     names.push_back(vs8generatorName + std::string(" Win64"));
     cmVisualStudioWCEPlatformParser parser;
     parser.ParseVersion("8.0");
     const std::vector<std::string>& availablePlatforms =
       parser.GetAvailablePlatforms();
-    for(std::vector<std::string>::const_iterator i =
-        availablePlatforms.begin(); i != availablePlatforms.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i =
+           availablePlatforms.begin();
+         i != availablePlatforms.end(); ++i) {
       names.push_back("Visual Studio 8 2005 " + *i);
-      }
+    }
   }
 
   virtual bool SupportsToolset() const { return false; }
@@ -95,8 +90,8 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio8Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio71Generator(cm, platformName)
 {
   this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
@@ -106,65 +101,57 @@ cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(cmake* cm,
   std::string vc8Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\8.0\\Setup\\VC;"
-    "ProductDir", vc8Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc8Express, cmSystemTools::KeyWOW64_32);
 }
 
 std::string cmGlobalVisualStudio8Generator::FindDevEnvCommand()
 {
   // First look for VCExpress.
   std::string vsxcmd;
-  std::string vsxkey =
-    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\";
+  std::string vsxkey = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\";
   vsxkey += this->GetIDEVersion();
   vsxkey += ";InstallDir";
-  if(cmSystemTools::ReadRegistryValue(vsxkey.c_str(), vsxcmd,
-                                      cmSystemTools::KeyWOW64_32))
-    {
+  if (cmSystemTools::ReadRegistryValue(vsxkey.c_str(), vsxcmd,
+                                       cmSystemTools::KeyWOW64_32)) {
     cmSystemTools::ConvertToUnixSlashes(vsxcmd);
     vsxcmd += "/VCExpress.exe";
     return vsxcmd;
-    }
+  }
   // Now look for devenv.
   return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
 }
 
-void cmGlobalVisualStudio8Generator
-::EnableLanguage(std::vector<std::string>const &  lang,
-                 cmMakefile *mf, bool optional)
+void cmGlobalVisualStudio8Generator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
-  for(std::vector<std::string>::const_iterator it = lang.begin();
-      it != lang.end(); ++it)
-    {
-    if(*it == "ASM_MASM")
-      {
+  for (std::vector<std::string>::const_iterator it = lang.begin();
+       it != lang.end(); ++it) {
+    if (*it == "ASM_MASM") {
       this->MasmEnabled = true;
-      }
     }
+  }
   this->AddPlatformDefinitions(mf);
   cmGlobalVisualStudio7Generator::EnableLanguage(lang, mf, optional);
 }
 
 void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf)
 {
-  if(this->TargetsWindowsCE())
-  {
+  if (this->TargetsWindowsCE()) {
     mf->AddDefinition("CMAKE_VS_WINCE_VERSION",
-      this->WindowsCEVersion.c_str());
+                      this->WindowsCEVersion.c_str());
   }
 }
 
 bool cmGlobalVisualStudio8Generator::SetGeneratorPlatform(std::string const& p,
                                                           cmMakefile* mf)
 {
-  if(this->DefaultPlatformName == "Win32")
-    {
+  if (this->DefaultPlatformName == "Win32") {
     this->GeneratorPlatform = p;
     return this->cmGlobalVisualStudio7Generator::SetGeneratorPlatform("", mf);
-    }
-  else
-    {
+  } else {
     return this->cmGlobalVisualStudio7Generator::SetGeneratorPlatform(p, mf);
-    }
+  }
 }
 
 // ouput standard header for dsw file
@@ -174,8 +161,8 @@ void cmGlobalVisualStudio8Generator::WriteSLNHeader(std::ostream& fout)
   fout << "# Visual Studio 2005\n";
 }
 
-void cmGlobalVisualStudio8Generator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalVisualStudio8Generator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalVisualStudio8Generator::GetActualName();
   entry.Brief = "Generates Visual Studio 8 2005 project files.";
@@ -203,25 +190,23 @@ std::string cmGlobalVisualStudio8Generator::GetUserMacrosDirectory()
     "InstalledProducts\\KB926748;";
   std::string vc8sp1;
   if (!cmSystemTools::ReadRegistryValue(vc8sp1Registry, vc8sp1) &&
-      !cmSystemTools::ReadRegistryValue(vc8exSP1Registry, vc8sp1))
-    {
+      !cmSystemTools::ReadRegistryValue(vc8exSP1Registry, vc8sp1)) {
     return "";
-    }
+  }
 
   std::string base;
   std::string path;
 
   // base begins with the VisualStudioProjectsLocation reg value...
   if (cmSystemTools::ReadRegistryValue(
-    "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\8.0;"
-    "VisualStudioProjectsLocation",
-    base))
-    {
+        "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\8.0;"
+        "VisualStudioProjectsLocation",
+        base)) {
     cmSystemTools::ConvertToUnixSlashes(base);
 
     // 8.0 macros folder:
     path = base + "/VSMacros80";
-    }
+  }
 
   // path is (correctly) still empty if we did not read the base value from
   // the Registry value
@@ -245,103 +230,93 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
   cmMakefile* mf = lg->GetMakefile();
 
   // Skip the target if no regeneration is to be done.
-  if(mf->IsOn("CMAKE_SUPPRESS_REGENERATION"))
-    {
+  if (mf->IsOn("CMAKE_SUPPRESS_REGENERATION")) {
     return false;
-    }
+  }
 
   cmCustomCommandLines noCommandLines;
   cmTarget* tgt =
     mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false,
-                          no_working_directory, no_depends,
-                          noCommandLines);
+                          no_working_directory, no_depends, noCommandLines);
 
   cmGeneratorTarget* gt = new cmGeneratorTarget(tgt, lg);
   lg->AddGeneratorTarget(gt);
 
   // Organize in the "predefined targets" folder:
   //
-  if (this->UseFolderProperty())
-    {
+  if (this->UseFolderProperty()) {
     tgt->SetProperty("FOLDER", this->GetPredefinedTargetsFolder());
-    }
+  }
 
   // Create a list of all stamp files for this project.
   std::vector<std::string> stamps;
   std::string stampList = cmake::GetCMakeFilesDirectoryPostSlash();
   stampList += "generate.stamp.list";
   {
-  std::string stampListFile =
-    generators[0]->GetMakefile()->GetCurrentBinaryDirectory();
-  stampListFile += "/";
-  stampListFile += stampList;
-  std::string stampFile;
-  cmGeneratedFileStream fout(stampListFile.c_str());
-  for(std::vector<cmLocalGenerator*>::const_iterator
-        gi = generators.begin(); gi != generators.end(); ++gi)
-    {
-    stampFile = (*gi)->GetMakefile()->GetCurrentBinaryDirectory();
-    stampFile += "/";
-    stampFile += cmake::GetCMakeFilesDirectoryPostSlash();
-    stampFile += "generate.stamp";
-    fout << stampFile << "\n";
-    stamps.push_back(stampFile);
+    std::string stampListFile =
+      generators[0]->GetMakefile()->GetCurrentBinaryDirectory();
+    stampListFile += "/";
+    stampListFile += stampList;
+    std::string stampFile;
+    cmGeneratedFileStream fout(stampListFile.c_str());
+    for (std::vector<cmLocalGenerator*>::const_iterator gi =
+           generators.begin();
+         gi != generators.end(); ++gi) {
+      stampFile = (*gi)->GetMakefile()->GetCurrentBinaryDirectory();
+      stampFile += "/";
+      stampFile += cmake::GetCMakeFilesDirectoryPostSlash();
+      stampFile += "generate.stamp";
+      fout << stampFile << "\n";
+      stamps.push_back(stampFile);
     }
   }
 
   // Add a custom rule to re-run CMake if any input files changed.
   {
-  // Collect the input files used to generate all targets in this
-  // project.
-  std::vector<std::string> listFiles;
-  for(unsigned int j = 0; j < generators.size(); ++j)
-    {
-    cmMakefile* lmf = generators[j]->GetMakefile();
-    listFiles.insert(listFiles.end(), lmf->GetListFiles().begin(),
-                     lmf->GetListFiles().end());
-    }
-  // Sort the list of input files and remove duplicates.
-  std::sort(listFiles.begin(), listFiles.end(),
-            std::less<std::string>());
-  std::vector<std::string>::iterator new_end =
-    std::unique(listFiles.begin(), listFiles.end());
-  listFiles.erase(new_end, listFiles.end());
-
-  // Create a rule to re-run CMake.
-  std::string stampName = cmake::GetCMakeFilesDirectoryPostSlash();
-  stampName += "generate.stamp";
-  cmCustomCommandLine commandLine;
-  commandLine.push_back(cmSystemTools::GetCMakeCommand());
-  std::string argH = "-H";
-  argH += lg->GetSourceDirectory();
-  commandLine.push_back(argH);
-  std::string argB = "-B";
-  argB += lg->GetBinaryDirectory();
-  commandLine.push_back(argB);
-  commandLine.push_back("--check-stamp-list");
-  commandLine.push_back(stampList.c_str());
-  commandLine.push_back("--vs-solution-file");
-  commandLine.push_back("\"$(SolutionPath)\"");
-  cmCustomCommandLines commandLines;
-  commandLines.push_back(commandLine);
-
-  // Add the rule.  Note that we cannot use the CMakeLists.txt
-  // file as the main dependency because it would get
-  // overwritten by the CreateVCProjBuildRule.
-  // (this could be avoided with per-target source files)
-  std::string no_main_dependency = "";
-  std::vector<std::string> no_byproducts;
-  if(cmSourceFile* file =
-     mf->AddCustomCommandToOutput(
-       stamps, no_byproducts, listFiles,
-       no_main_dependency, commandLines, "Checking Build System",
-       no_working_directory, true))
-    {
-    gt->AddSource(file->GetFullPath());
+    // Collect the input files used to generate all targets in this
+    // project.
+    std::vector<std::string> listFiles;
+    for (unsigned int j = 0; j < generators.size(); ++j) {
+      cmMakefile* lmf = generators[j]->GetMakefile();
+      listFiles.insert(listFiles.end(), lmf->GetListFiles().begin(),
+                       lmf->GetListFiles().end());
     }
-  else
-    {
-    cmSystemTools::Error("Error adding rule for ", stamps[0].c_str());
+    // Sort the list of input files and remove duplicates.
+    std::sort(listFiles.begin(), listFiles.end(), std::less<std::string>());
+    std::vector<std::string>::iterator new_end =
+      std::unique(listFiles.begin(), listFiles.end());
+    listFiles.erase(new_end, listFiles.end());
+
+    // Create a rule to re-run CMake.
+    std::string stampName = cmake::GetCMakeFilesDirectoryPostSlash();
+    stampName += "generate.stamp";
+    cmCustomCommandLine commandLine;
+    commandLine.push_back(cmSystemTools::GetCMakeCommand());
+    std::string argH = "-H";
+    argH += lg->GetSourceDirectory();
+    commandLine.push_back(argH);
+    std::string argB = "-B";
+    argB += lg->GetBinaryDirectory();
+    commandLine.push_back(argB);
+    commandLine.push_back("--check-stamp-list");
+    commandLine.push_back(stampList.c_str());
+    commandLine.push_back("--vs-solution-file");
+    commandLine.push_back("\"$(SolutionPath)\"");
+    cmCustomCommandLines commandLines;
+    commandLines.push_back(commandLine);
+
+    // Add the rule.  Note that we cannot use the CMakeLists.txt
+    // file as the main dependency because it would get
+    // overwritten by the CreateVCProjBuildRule.
+    // (this could be avoided with per-target source files)
+    std::string no_main_dependency = "";
+    std::vector<std::string> no_byproducts;
+    if (cmSourceFile* file = mf->AddCustomCommandToOutput(
+          stamps, no_byproducts, listFiles, no_main_dependency, commandLines,
+          "Checking Build System", no_working_directory, true)) {
+      gt->AddSource(file->GetFullPath());
+    } else {
+      cmSystemTools::Error("Error adding rule for ", stamps[0].c_str());
     }
   }
 
@@ -351,83 +326,71 @@ bool cmGlobalVisualStudio8Generator::AddCheckTarget()
 void cmGlobalVisualStudio8Generator::AddExtraIDETargets()
 {
   cmGlobalVisualStudio7Generator::AddExtraIDETargets();
-  if(this->AddCheckTarget())
-    {
-    for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-      {
+  if (this->AddCheckTarget()) {
+    for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
       std::vector<cmGeneratorTarget*> tgts =
-          this->LocalGenerators[i]->GetGeneratorTargets();
+        this->LocalGenerators[i]->GetGeneratorTargets();
       // All targets depend on the build-system check target.
-      for(std::vector<cmGeneratorTarget*>::iterator ti = tgts.begin();
-          ti != tgts.end(); ++ti)
-        {
-        if((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
-          {
+      for (std::vector<cmGeneratorTarget*>::iterator ti = tgts.begin();
+           ti != tgts.end(); ++ti) {
+        if ((*ti)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
           (*ti)->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
-          }
         }
       }
     }
+  }
 }
 
-void
-cmGlobalVisualStudio8Generator
-::WriteSolutionConfigurations(std::ostream& fout,
-                              std::vector<std::string> const& configs)
+void cmGlobalVisualStudio8Generator::WriteSolutionConfigurations(
+  std::ostream& fout, std::vector<std::string> const& configs)
 {
   fout << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n";
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
-    fout << "\t\t" << *i << "|" << this->GetPlatformName()
-         << " = "  << *i << "|" << this->GetPlatformName() << "\n";
-    }
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
+    fout << "\t\t" << *i << "|" << this->GetPlatformName() << " = " << *i
+         << "|" << this->GetPlatformName() << "\n";
+  }
   fout << "\tEndGlobalSection\n";
 }
 
-void
-cmGlobalVisualStudio8Generator
-::WriteProjectConfigurations(
+void cmGlobalVisualStudio8Generator::WriteProjectConfigurations(
   std::ostream& fout, const std::string& name, cmState::TargetType type,
   std::vector<std::string> const& configs,
   const std::set<std::string>& configsPartOfDefaultBuild,
   std::string const& platformMapping)
 {
   std::string guid = this->GetGUID(name);
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
-    fout << "\t\t{" << guid << "}." << *i
-         << "|" << this->GetPlatformName() << ".ActiveCfg = " << *i << "|"
-         << (!platformMapping.empty()?
-             platformMapping : this->GetPlatformName())
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
+    fout << "\t\t{" << guid << "}." << *i << "|" << this->GetPlatformName()
+         << ".ActiveCfg = " << *i << "|"
+         << (!platformMapping.empty() ? platformMapping
+                                      : this->GetPlatformName())
          << "\n";
-      std::set<std::string>::const_iterator
-        ci = configsPartOfDefaultBuild.find(*i);
-      if(!(ci == configsPartOfDefaultBuild.end()))
-      {
-      fout << "\t\t{" << guid << "}." << *i
-           << "|" << this->GetPlatformName() << ".Build.0 = " << *i << "|"
-           << (!platformMapping.empty()?
-               platformMapping : this->GetPlatformName())
+    std::set<std::string>::const_iterator ci =
+      configsPartOfDefaultBuild.find(*i);
+    if (!(ci == configsPartOfDefaultBuild.end())) {
+      fout << "\t\t{" << guid << "}." << *i << "|" << this->GetPlatformName()
+           << ".Build.0 = " << *i << "|"
+           << (!platformMapping.empty() ? platformMapping
+                                        : this->GetPlatformName())
            << "\n";
-      }
-    if(this->NeedsDeploy(type))
-      {
-      fout << "\t\t{" << guid << "}." << *i
-           << "|" << this->GetPlatformName() << ".Deploy.0 = " << *i << "|"
-           << (!platformMapping.empty()?
-               platformMapping : this->GetPlatformName())
+    }
+    if (this->NeedsDeploy(type)) {
+      fout << "\t\t{" << guid << "}." << *i << "|" << this->GetPlatformName()
+           << ".Deploy.0 = " << *i << "|"
+           << (!platformMapping.empty() ? platformMapping
+                                        : this->GetPlatformName())
            << "\n";
-      }
     }
+  }
 }
 
-bool
-cmGlobalVisualStudio8Generator::NeedsDeploy(cmState::TargetType type) const
+bool cmGlobalVisualStudio8Generator::NeedsDeploy(
+  cmState::TargetType type) const
 {
-  bool needsDeploy = (type == cmState::EXECUTABLE ||
-                      type == cmState::SHARED_LIBRARY);
+  bool needsDeploy =
+    (type == cmState::EXECUTABLE || type == cmState::SHARED_LIBRARY);
   return this->TargetsWindowsCE() && needsDeploy;
 }
 
@@ -440,80 +403,74 @@ bool cmGlobalVisualStudio8Generator::ComputeTargetDepends()
 
 void cmGlobalVisualStudio8Generator::WriteProjectDepends(
   std::ostream& fout, const std::string&, const char*,
-        cmGeneratorTarget const* gt)
+  cmGeneratorTarget const* gt)
 {
   TargetDependSet const& unordered = this->GetTargetDirectDepends(gt);
   OrderedTargetDependSet depends(unordered, std::string());
-  for(OrderedTargetDependSet::const_iterator i = depends.begin();
-      i != depends.end(); ++i)
-    {
-    if((*i)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (OrderedTargetDependSet::const_iterator i = depends.begin();
+       i != depends.end(); ++i) {
+    if ((*i)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     std::string guid = this->GetGUID((*i)->GetName().c_str());
     fout << "\t\t{" << guid << "} = {" << guid << "}\n";
-    }
+  }
 }
 
 bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies(
-        cmGeneratorTarget *target)
+  cmGeneratorTarget* target)
 {
   // Look for utility dependencies that magically link.
-  for(std::set<std::string>::const_iterator ui =
-        target->GetUtilities().begin();
-      ui != target->GetUtilities().end(); ++ui)
-    {
-    if(cmGeneratorTarget* depTarget =
-        target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str()))
-      {
-      if(depTarget->GetType() != cmState::INTERFACE_LIBRARY
-          && depTarget->GetProperty("EXTERNAL_MSPROJECT"))
-        {
+  for (std::set<std::string>::const_iterator ui =
+         target->GetUtilities().begin();
+       ui != target->GetUtilities().end(); ++ui) {
+    if (cmGeneratorTarget* depTarget =
+          target->GetLocalGenerator()->FindGeneratorTargetToUse(ui->c_str())) {
+      if (depTarget->GetType() != cmState::INTERFACE_LIBRARY &&
+          depTarget->GetProperty("EXTERNAL_MSPROJECT")) {
         // This utility dependency names an external .vcproj target.
         // We use LinkLibraryDependencies="true" to link to it without
         // predicting the .lib file location or name.
         return true;
-        }
       }
     }
+  }
   return false;
 }
 
-static cmVS7FlagTable cmVS8ExtraFlagTable[] =
-{
-  {"CallingConvention", "Gd", "cdecl", "0", 0 },
-  {"CallingConvention", "Gr", "fastcall", "1", 0 },
-  {"CallingConvention", "Gz", "stdcall", "2", 0 },
-
-  {"Detect64BitPortabilityProblems", "Wp64",
-   "Detect 64Bit Portability Problems", "true", 0 },
-  {"ErrorReporting", "errorReport:prompt", "Report immediately", "1", 0 },
-  {"ErrorReporting", "errorReport:queue", "Queue for next login", "2", 0 },
+static cmVS7FlagTable cmVS8ExtraFlagTable[] = {
+  { "CallingConvention", "Gd", "cdecl", "0", 0 },
+  { "CallingConvention", "Gr", "fastcall", "1", 0 },
+  { "CallingConvention", "Gz", "stdcall", "2", 0 },
+
+  { "Detect64BitPortabilityProblems", "Wp64",
+    "Detect 64Bit Portability Problems", "true", 0 },
+  { "ErrorReporting", "errorReport:prompt", "Report immediately", "1", 0 },
+  { "ErrorReporting", "errorReport:queue", "Queue for next login", "2", 0 },
   // Precompiled header and related options.  Note that the
   // UsePrecompiledHeader entries are marked as "Continue" so that the
   // corresponding PrecompiledHeaderThrough entry can be found.
-  {"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "2",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
-   cmVS7FlagTable::UserValueRequired},
+  { "UsePrecompiledHeader", "Yu", "Use Precompiled Header", "2",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
   // There is no YX option in the VS8 IDE.
 
   // Exception handling mode.  If no entries match, it will be FALSE.
-  {"ExceptionHandling", "GX", "enable c++ exceptions", "1", 0},
-  {"ExceptionHandling", "EHsc", "enable c++ exceptions", "1", 0},
-  {"ExceptionHandling", "EHa", "enable SEH exceptions", "2", 0},
+  { "ExceptionHandling", "GX", "enable c++ exceptions", "1", 0 },
+  { "ExceptionHandling", "EHsc", "enable c++ exceptions", "1", 0 },
+  { "ExceptionHandling", "EHa", "enable SEH exceptions", "2", 0 },
 
-  {"EnablePREfast", "analyze", "", "true", 0},
-  {"EnablePREfast", "analyze-", "", "false", 0},
+  { "EnablePREfast", "analyze", "", "true", 0 },
+  { "EnablePREfast", "analyze-", "", "false", 0 },
 
   // Language options
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t",
-   "wchar_t is a built-in type", "true", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
-   "wchar_t is not a built-in type", "false", 0},
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "wchar_t is a built-in type",
+    "true", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
+    "wchar_t is not a built-in type", "false", 0 },
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
 cmIDEFlagTable const* cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8()
 {
diff --git a/Source/cmGlobalVisualStudio8Generator.h b/Source/cmGlobalVisualStudio8Generator.h
index 6eb8450..b29106f 100644
--- a/Source/cmGlobalVisualStudio8Generator.h
+++ b/Source/cmGlobalVisualStudio8Generator.h
@@ -14,7 +14,6 @@
 
 #include "cmGlobalVisualStudio71Generator.h"
 
-
 /** \class cmGlobalVisualStudio8Generator
  * \brief Write a Unix makefiles.
  *
@@ -24,17 +23,17 @@ class cmGlobalVisualStudio8Generator : public cmGlobalVisualStudio71Generator
 {
 public:
   cmGlobalVisualStudio8Generator(cmake* cm, const std::string& name,
-    const std::string& platformName);
+                                 const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const {return this->Name;}
+  virtual std::string GetName() const { return this->Name; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
   virtual void AddPlatformDefinitions(cmMakefile* mf);
 
   virtual bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf);
@@ -63,8 +62,10 @@ public:
   virtual bool NeedLinkLibraryDependencies(cmGeneratorTarget* target);
 
   /** Return true if building for Windows CE */
-  virtual bool TargetsWindowsCE() const {
-    return !this->WindowsCEVersion.empty(); }
+  virtual bool TargetsWindowsCE() const
+  {
+    return !this->WindowsCEVersion.empty();
+  }
 
   /** Is the installed VS an Express edition?  */
   bool IsExpressEdition() const { return this->ExpressEdition; }
@@ -92,10 +93,9 @@ protected:
     const std::set<std::string>& configsPartOfDefaultBuild,
     const std::string& platformMapping = "");
   virtual bool ComputeTargetDepends();
-  virtual void WriteProjectDepends(std::ostream& fout,
-                                   const std::string& name,
+  virtual void WriteProjectDepends(std::ostream& fout, const std::string& name,
                                    const char* path,
-                                   const cmGeneratorTarget *t);
+                                   const cmGeneratorTarget* t);
 
   bool UseFolderProperty();
 
diff --git a/Source/cmGlobalVisualStudio9Generator.cxx b/Source/cmGlobalVisualStudio9Generator.cxx
index 6052856..a47f4fc 100644
--- a/Source/cmGlobalVisualStudio9Generator.cxx
+++ b/Source/cmGlobalVisualStudio9Generator.cxx
@@ -20,63 +20,57 @@
 
 static const char vs9generatorName[] = "Visual Studio 9 2008";
 
-class cmGlobalVisualStudio9Generator::Factory
-  : public cmGlobalGeneratorFactory
+class cmGlobalVisualStudio9Generator::Factory : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const {
-    if(strncmp(name.c_str(), vs9generatorName,
-               sizeof(vs9generatorName) - 1) != 0)
-      {
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
+    if (strncmp(name.c_str(), vs9generatorName,
+                sizeof(vs9generatorName) - 1) != 0) {
       return 0;
-      }
+    }
 
     const char* p = name.c_str() + sizeof(vs9generatorName) - 1;
-    if(p[0] == '\0')
-      {
+    if (p[0] == '\0') {
       return new cmGlobalVisualStudio9Generator(cm, name, "");
-      }
+    }
 
-    if(p[0] != ' ')
-      {
+    if (p[0] != ' ') {
       return 0;
-      }
+    }
 
     ++p;
 
-    if(!strcmp(p, "IA64"))
-      {
+    if (!strcmp(p, "IA64")) {
       return new cmGlobalVisualStudio9Generator(cm, name, "Itanium");
-      }
+    }
 
-    if(!strcmp(p, "Win64"))
-      {
+    if (!strcmp(p, "Win64")) {
       return new cmGlobalVisualStudio9Generator(cm, name, "x64");
-      }
+    }
 
     cmVisualStudioWCEPlatformParser parser(p);
     parser.ParseVersion("9.0");
-    if (!parser.Found())
-      {
+    if (!parser.Found()) {
       return 0;
-      }
+    }
 
     cmGlobalVisualStudio9Generator* ret =
-        new cmGlobalVisualStudio9Generator(cm, name, p);
+      new cmGlobalVisualStudio9Generator(cm, name, p);
     ret->WindowsCEVersion = parser.GetOSVersion();
     return ret;
   }
 
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const {
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
     entry.Name = std::string(vs9generatorName) + " [arch]";
-    entry.Brief =
-      "Generates Visual Studio 2008 project files.  "
-      "Optional [arch] can be \"Win64\" or \"IA64\"."
-      ;
+    entry.Brief = "Generates Visual Studio 2008 project files.  "
+                  "Optional [arch] can be \"Win64\" or \"IA64\".";
   }
 
-  virtual void GetGenerators(std::vector<std::string>& names) const {
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
     names.push_back(vs9generatorName);
     names.push_back(vs9generatorName + std::string(" Win64"));
     names.push_back(vs9generatorName + std::string(" IA64"));
@@ -84,11 +78,11 @@ public:
     parser.ParseVersion("9.0");
     const std::vector<std::string>& availablePlatforms =
       parser.GetAvailablePlatforms();
-    for(std::vector<std::string>::const_iterator i =
-        availablePlatforms.begin(); i != availablePlatforms.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i =
+           availablePlatforms.begin();
+         i != availablePlatforms.end(); ++i) {
       names.push_back("Visual Studio 9 2008 " + *i);
-      }
+    }
   }
 
   virtual bool SupportsToolset() const { return false; }
@@ -99,15 +93,16 @@ cmGlobalGeneratorFactory* cmGlobalVisualStudio9Generator::NewFactory()
   return new Factory;
 }
 
-cmGlobalVisualStudio9Generator::cmGlobalVisualStudio9Generator(cmake* cm,
-  const std::string& name, const std::string& platformName)
+cmGlobalVisualStudio9Generator::cmGlobalVisualStudio9Generator(
+  cmake* cm, const std::string& name, const std::string& platformName)
   : cmGlobalVisualStudio8Generator(cm, name, platformName)
 {
   this->Version = VS9;
   std::string vc9Express;
   this->ExpressEdition = cmSystemTools::ReadRegistryValue(
     "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\9.0\\Setup\\VC;"
-    "ProductDir", vc9Express, cmSystemTools::KeyWOW64_32);
+    "ProductDir",
+    vc9Express, cmSystemTools::KeyWOW64_32);
 }
 
 void cmGlobalVisualStudio9Generator::WriteSLNHeader(std::ostream& fout)
@@ -123,19 +118,18 @@ std::string cmGlobalVisualStudio9Generator::GetUserMacrosDirectory()
 
   // base begins with the VisualStudioProjectsLocation reg value...
   if (cmSystemTools::ReadRegistryValue(
-    "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\9.0;"
-    "VisualStudioProjectsLocation",
-    base))
-    {
+        "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\9.0;"
+        "VisualStudioProjectsLocation",
+        base)) {
     cmSystemTools::ConvertToUnixSlashes(base);
 
     // 9.0 macros folder:
     path = base + "/VSMacros80";
-      // *NOT* a typo; right now in Visual Studio 2008 beta the macros
-      // folder is VSMacros80... They may change it to 90 before final
-      // release of 2008 or they may not... we'll have to keep our eyes
-      // on it
-    }
+    // *NOT* a typo; right now in Visual Studio 2008 beta the macros
+    // folder is VSMacros80... They may change it to 90 before final
+    // release of 2008 or they may not... we'll have to keep our eyes
+    // on it
+  }
 
   // path is (correctly) still empty if we did not read the base value from
   // the Registry value
diff --git a/Source/cmGlobalVisualStudio9Generator.h b/Source/cmGlobalVisualStudio9Generator.h
index e25a4be..2c82c3a 100644
--- a/Source/cmGlobalVisualStudio9Generator.h
+++ b/Source/cmGlobalVisualStudio9Generator.h
@@ -14,18 +14,16 @@
 
 #include "cmGlobalVisualStudio8Generator.h"
 
-
 /** \class cmGlobalVisualStudio9Generator
  * \brief Write a Unix makefiles.
  *
  * cmGlobalVisualStudio9Generator manages UNIX build process for a tree
  */
-class cmGlobalVisualStudio9Generator :
-  public cmGlobalVisualStudio8Generator
+class cmGlobalVisualStudio9Generator : public cmGlobalVisualStudio8Generator
 {
 public:
   cmGlobalVisualStudio9Generator(cmake* cm, const std::string& name,
-    const std::string& platformName);
+                                 const std::string& platformName);
   static cmGlobalGeneratorFactory* NewFactory();
 
   /**
@@ -46,6 +44,7 @@ public:
    * Studio?
    */
   virtual std::string GetUserMacrosRegKeyBase();
+
 protected:
   virtual const char* GetIDEVersion() { return "9.0"; }
 private:
diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx
index 4f6aa20..8066201 100644
--- a/Source/cmGlobalVisualStudioGenerator.cxx
+++ b/Source/cmGlobalVisualStudioGenerator.cxx
@@ -46,12 +46,10 @@ void cmGlobalVisualStudioGenerator::SetVersion(VSVersion v)
 
 std::string cmGlobalVisualStudioGenerator::GetRegistryBase()
 {
-  return cmGlobalVisualStudioGenerator::GetRegistryBase(
-    this->GetIDEVersion());
+  return cmGlobalVisualStudioGenerator::GetRegistryBase(this->GetIDEVersion());
 }
 
-std::string cmGlobalVisualStudioGenerator::GetRegistryBase(
-  const char* version)
+std::string cmGlobalVisualStudioGenerator::GetRegistryBase(const char* version)
 {
   std::string key = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\";
   return key + version;
@@ -65,19 +63,15 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
   std::vector<std::string> no_depends;
   cmCustomCommandLines no_commands;
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     std::vector<cmLocalGenerator*>& gen = it->second;
     // add the ALL_BUILD to the first local generator of each project
-    if(!gen.empty())
-      {
+    if (!gen.empty()) {
       // Use no actual command lines so that the target itself is not
       // considered always out of date.
-      cmTarget* allBuild =
-        gen[0]->GetMakefile()->
-        AddUtilityCommand("ALL_BUILD", true, no_working_dir,
-                          no_depends, no_commands, false,
-                          "Build all projects");
+      cmTarget* allBuild = gen[0]->GetMakefile()->AddUtilityCommand(
+        "ALL_BUILD", true, no_working_dir, no_depends, no_commands, false,
+        "Build all projects");
 
       cmGeneratorTarget* gt = new cmGeneratorTarget(allBuild, gen[0]);
       gen[0]->AddGeneratorTarget(gt);
@@ -85,92 +79,79 @@ void cmGlobalVisualStudioGenerator::AddExtraIDETargets()
       //
       // Organize in the "predefined targets" folder:
       //
-      if (this->UseFolderProperty())
-        {
+      if (this->UseFolderProperty()) {
         allBuild->SetProperty("FOLDER", this->GetPredefinedTargetsFolder());
-        }
+      }
 
       // Now make all targets depend on the ALL_BUILD target
-      for(std::vector<cmLocalGenerator*>::iterator i = gen.begin();
-          i != gen.end(); ++i)
-        {
-        std::vector<cmGeneratorTarget*> targets =
-            (*i)->GetGeneratorTargets();
-        for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-            t != targets.end(); ++t)
-          {
+      for (std::vector<cmLocalGenerator*>::iterator i = gen.begin();
+           i != gen.end(); ++i) {
+        std::vector<cmGeneratorTarget*> targets = (*i)->GetGeneratorTargets();
+        for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+             t != targets.end(); ++t) {
           cmGeneratorTarget* tgt = *t;
-          if (tgt->GetType() == cmState::GLOBAL_TARGET
-              || tgt->IsImported())
-            {
+          if (tgt->GetType() == cmState::GLOBAL_TARGET || tgt->IsImported()) {
             continue;
-            }
-          if(!this->IsExcluded(gen[0], tgt))
-            {
+          }
+          if (!this->IsExcluded(gen[0], tgt)) {
             allBuild->AddUtility(tgt->GetName());
-            }
           }
         }
       }
     }
+  }
 
   // Configure CMake Visual Studio macros, for this user on this version
   // of Visual Studio.
   this->ConfigureCMakeVisualStudioMacros();
 
   // Add CMakeLists.txt with custom command to rerun CMake.
-  for(std::vector<cmLocalGenerator*>::const_iterator
-        lgi = this->LocalGenerators.begin();
-      lgi != this->LocalGenerators.end(); ++lgi)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator lgi =
+         this->LocalGenerators.begin();
+       lgi != this->LocalGenerators.end(); ++lgi) {
     cmLocalVisualStudioGenerator* lg =
       static_cast<cmLocalVisualStudioGenerator*>(*lgi);
     lg->AddCMakeListsRules();
-    }
+  }
 }
 
-void cmGlobalVisualStudioGenerator
-::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
+void cmGlobalVisualStudioGenerator::ComputeTargetObjectDirectory(
+  cmGeneratorTarget* gt) const
 {
   std::string dir = gt->LocalGenerator->GetCurrentBinaryDirectory();
   dir += "/";
   std::string tgtDir = gt->LocalGenerator->GetTargetDirectory(gt);
-  if(!tgtDir.empty())
-    {
+  if (!tgtDir.empty()) {
     dir += tgtDir;
     dir += "/";
-    }
+  }
   const char* cd = this->GetCMakeCFGIntDir();
-  if(cd && *cd)
-    {
+  if (cd && *cd) {
     dir += cd;
     dir += "/";
-    }
+  }
   gt->ObjectDirectory = dir;
 }
 
 bool IsVisualStudioMacrosFileRegistered(const std::string& macrosFile,
-  const std::string& regKeyBase,
-  std::string& nextAvailableSubKeyName);
+                                        const std::string& regKeyBase,
+                                        std::string& nextAvailableSubKeyName);
 
 void RegisterVisualStudioMacros(const std::string& macrosFile,
-  const std::string& regKeyBase);
+                                const std::string& regKeyBase);
 
-#define CMAKE_VSMACROS_FILENAME \
-  "CMakeVSMacros2.vsmacros"
+#define CMAKE_VSMACROS_FILENAME "CMakeVSMacros2.vsmacros"
 
-#define CMAKE_VSMACROS_RELOAD_MACRONAME \
+#define CMAKE_VSMACROS_RELOAD_MACRONAME                                       \
   "Macros.CMakeVSMacros2.Macros.ReloadProjects"
 
-#define CMAKE_VSMACROS_STOP_MACRONAME \
-  "Macros.CMakeVSMacros2.Macros.StopBuild"
+#define CMAKE_VSMACROS_STOP_MACRONAME "Macros.CMakeVSMacros2.Macros.StopBuild"
 
 void cmGlobalVisualStudioGenerator::ConfigureCMakeVisualStudioMacros()
 {
   std::string dir = this->GetUserMacrosDirectory();
 
-  if (dir != "")
-    {
+  if (dir != "") {
     std::string src = cmSystemTools::GetCMakeRoot();
     src += "/Templates/" CMAKE_VSMACROS_FILENAME;
 
@@ -182,26 +163,22 @@ void cmGlobalVisualStudioGenerator::ConfigureCMakeVisualStudioMacros()
     // purposes but newer versions distributed with CMake will replace
     // older versions in user directories.
     int res;
-    if(!cmSystemTools::FileTimeCompare(src.c_str(), dst.c_str(), &res) ||
-       res > 0)
-      {
-      if (!cmSystemTools::CopyFileAlways(src.c_str(), dst.c_str()))
-        {
+    if (!cmSystemTools::FileTimeCompare(src.c_str(), dst.c_str(), &res) ||
+        res > 0) {
+      if (!cmSystemTools::CopyFileAlways(src.c_str(), dst.c_str())) {
         std::ostringstream oss;
         oss << "Could not copy from: " << src << std::endl;
         oss << "                 to: " << dst << std::endl;
         cmSystemTools::Message(oss.str().c_str(), "Warning");
-        }
       }
+    }
 
     RegisterVisualStudioMacros(dst, this->GetUserMacrosRegKeyBase());
-    }
+  }
 }
 
-void
-cmGlobalVisualStudioGenerator
-::CallVisualStudioMacro(MacroName m,
-                        const char* vsSolutionFile)
+void cmGlobalVisualStudioGenerator::CallVisualStudioMacro(
+  MacroName m, const char* vsSolutionFile)
 {
   // If any solution or project files changed during the generation,
   // tell Visual Studio to reload them...
@@ -214,60 +191,48 @@ cmGlobalVisualStudioGenerator
   //  - the CMake vsmacros file is registered
   //  - there were .sln/.vcproj files changed during generation
   //
-  if (dir != "")
-    {
+  if (dir != "") {
     std::string macrosFile = dir + "/CMakeMacros/" CMAKE_VSMACROS_FILENAME;
     std::string nextSubkeyName;
     if (cmSystemTools::FileExists(macrosFile.c_str()) &&
-      IsVisualStudioMacrosFileRegistered(macrosFile,
-        this->GetUserMacrosRegKeyBase(), nextSubkeyName)
-      )
-      {
+        IsVisualStudioMacrosFileRegistered(
+          macrosFile, this->GetUserMacrosRegKeyBase(), nextSubkeyName)) {
       std::string topLevelSlnName;
-      if(vsSolutionFile)
-        {
+      if (vsSolutionFile) {
         topLevelSlnName = vsSolutionFile;
-        }
-      else
-        {
+      } else {
         topLevelSlnName = mf->GetCurrentBinaryDirectory();
         topLevelSlnName += "/";
         topLevelSlnName += this->LocalGenerators[0]->GetProjectName();
         topLevelSlnName += ".sln";
-        }
+      }
 
-      if(m == MacroReload)
-        {
+      if (m == MacroReload) {
         std::vector<std::string> filenames;
         this->GetFilesReplacedDuringGenerate(filenames);
-        if (!filenames.empty())
-          {
+        if (!filenames.empty()) {
           // Convert vector to semi-colon delimited string of filenames:
           std::string projects;
           std::vector<std::string>::iterator it = filenames.begin();
-          if (it != filenames.end())
-            {
+          if (it != filenames.end()) {
             projects = *it;
             ++it;
-            }
-          for (; it != filenames.end(); ++it)
-            {
+          }
+          for (; it != filenames.end(); ++it) {
             projects += ";";
             projects += *it;
-            }
-          cmCallVisualStudioMacro::CallMacro(topLevelSlnName,
-            CMAKE_VSMACROS_RELOAD_MACRONAME, projects,
-            this->GetCMakeInstance()->GetDebugOutput());
           }
+          cmCallVisualStudioMacro::CallMacro(
+            topLevelSlnName, CMAKE_VSMACROS_RELOAD_MACRONAME, projects,
+            this->GetCMakeInstance()->GetDebugOutput());
         }
-      else if(m == MacroStop)
-        {
-        cmCallVisualStudioMacro::CallMacro(topLevelSlnName,
-          CMAKE_VSMACROS_STOP_MACRONAME, "",
+      } else if (m == MacroStop) {
+        cmCallVisualStudioMacro::CallMacro(
+          topLevelSlnName, CMAKE_VSMACROS_STOP_MACRONAME, "",
           this->GetCMakeInstance()->GetDebugOutput());
-        }
       }
     }
+  }
 }
 
 std::string cmGlobalVisualStudioGenerator::GetUserMacrosDirectory()
@@ -281,83 +246,68 @@ std::string cmGlobalVisualStudioGenerator::GetUserMacrosRegKeyBase()
 }
 
 void cmGlobalVisualStudioGenerator::FillLinkClosure(
-        const cmGeneratorTarget *target,
-        TargetSet& linked)
+  const cmGeneratorTarget* target, TargetSet& linked)
 {
-  if(linked.insert(target).second)
-    {
-    TargetDependSet const& depends =
-            this->GetTargetDirectDepends(target);
-    for(TargetDependSet::const_iterator di = depends.begin();
-        di != depends.end(); ++di)
-      {
-      if(di->IsLink())
-        {
+  if (linked.insert(target).second) {
+    TargetDependSet const& depends = this->GetTargetDirectDepends(target);
+    for (TargetDependSet::const_iterator di = depends.begin();
+         di != depends.end(); ++di) {
+      if (di->IsLink()) {
         this->FillLinkClosure(*di, linked);
-        }
       }
     }
+  }
 }
 
 cmGlobalVisualStudioGenerator::TargetSet const&
 cmGlobalVisualStudioGenerator::GetTargetLinkClosure(cmGeneratorTarget* target)
 {
   TargetSetMap::iterator i = this->TargetLinkClosure.find(target);
-  if(i == this->TargetLinkClosure.end())
-    {
+  if (i == this->TargetLinkClosure.end()) {
     TargetSetMap::value_type entry(target, TargetSet());
     i = this->TargetLinkClosure.insert(entry).first;
     this->FillLinkClosure(target, i->second);
-    }
+  }
   return i->second;
 }
 
 void cmGlobalVisualStudioGenerator::FollowLinkDepends(
-        const cmGeneratorTarget *target,
-        std::set<const cmGeneratorTarget *> &linked)
+  const cmGeneratorTarget* target, std::set<const cmGeneratorTarget*>& linked)
 {
-  if(target->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (target->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
-  if(linked.insert(target).second &&
-     target->GetType() == cmState::STATIC_LIBRARY)
-    {
+  }
+  if (linked.insert(target).second &&
+      target->GetType() == cmState::STATIC_LIBRARY) {
     // Static library targets do not list their link dependencies so
     // we must follow them transitively now.
     TargetDependSet const& depends = this->GetTargetDirectDepends(target);
-    for(TargetDependSet::const_iterator di = depends.begin();
-        di != depends.end(); ++di)
-      {
-      if(di->IsLink())
-        {
+    for (TargetDependSet::const_iterator di = depends.begin();
+         di != depends.end(); ++di) {
+      if (di->IsLink()) {
         this->FollowLinkDepends(*di, linked);
-        }
       }
     }
+  }
 }
 
 bool cmGlobalVisualStudioGenerator::ComputeTargetDepends()
 {
-  if(!this->cmGlobalGenerator::ComputeTargetDepends())
-    {
+  if (!this->cmGlobalGenerator::ComputeTargetDepends()) {
     return false;
-    }
+  }
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     std::vector<cmLocalGenerator*>& gen = it->second;
-    for(std::vector<cmLocalGenerator*>::iterator i = gen.begin();
-        i != gen.end(); ++i)
-      {
+    for (std::vector<cmLocalGenerator*>::iterator i = gen.begin();
+         i != gen.end(); ++i) {
       std::vector<cmGeneratorTarget*> targets = (*i)->GetGeneratorTargets();
-      for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-          ti != targets.end(); ++ti)
-        {
+      for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
+           ti != targets.end(); ++ti) {
         this->ComputeVSTargetDepends(*ti);
-        }
       }
     }
+  }
   return true;
 }
 
@@ -367,12 +317,11 @@ static bool VSLinkable(cmGeneratorTarget const* t)
 }
 
 void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(
-        cmGeneratorTarget* target)
+  cmGeneratorTarget* target)
 {
-  if(this->VSTargetDepends.find(target) != this->VSTargetDepends.end())
-    {
+  if (this->VSTargetDepends.find(target) != this->VSTargetDepends.end()) {
     return;
-    }
+  }
   VSDependSet& vsTargetDepend = this->VSTargetDepends[target];
   // VS <= 7.1 has two behaviors that affect solution dependencies.
   //
@@ -404,64 +353,53 @@ void cmGlobalVisualStudioGenerator::ComputeVSTargetDepends(
   // Static libraries cannot depend on their link implementation
   // due to behavior (2), but they do not really need to.
   std::set<cmGeneratorTarget const*> linkDepends;
-  if(target->GetType() != cmState::STATIC_LIBRARY)
-    {
-    for(TargetDependSet::const_iterator di = depends.begin();
-        di != depends.end(); ++di)
-      {
+  if (target->GetType() != cmState::STATIC_LIBRARY) {
+    for (TargetDependSet::const_iterator di = depends.begin();
+         di != depends.end(); ++di) {
       cmTargetDepend dep = *di;
-      if(dep.IsLink())
-        {
+      if (dep.IsLink()) {
         this->FollowLinkDepends(*di, linkDepends);
-        }
       }
     }
+  }
 
   // Collect explicit util dependencies (add_dependencies).
   std::set<cmGeneratorTarget const*> utilDepends;
-  for(TargetDependSet::const_iterator di = depends.begin();
-      di != depends.end(); ++di)
-    {
+  for (TargetDependSet::const_iterator di = depends.begin();
+       di != depends.end(); ++di) {
     cmTargetDepend dep = *di;
-    if(dep.IsUtil())
-      {
+    if (dep.IsUtil()) {
       this->FollowLinkDepends(*di, utilDepends);
-      }
     }
+  }
 
   // Collect all targets linked by this target so we can avoid
   // intermediate targets below.
   TargetSet linked;
-  if(target->GetType() != cmState::STATIC_LIBRARY)
-    {
+  if (target->GetType() != cmState::STATIC_LIBRARY) {
     linked = this->GetTargetLinkClosure(target);
-    }
+  }
 
   // Emit link dependencies.
-  for(std::set<cmGeneratorTarget const*>::iterator di = linkDepends.begin();
-      di != linkDepends.end(); ++di)
-    {
+  for (std::set<cmGeneratorTarget const*>::iterator di = linkDepends.begin();
+       di != linkDepends.end(); ++di) {
     cmGeneratorTarget const* dep = *di;
     vsTargetDepend.insert(dep->GetName());
-    }
+  }
 
   // Emit util dependencies.  Possibly use intermediate targets.
-  for(std::set<cmGeneratorTarget const*>::iterator di = utilDepends.begin();
-      di != utilDepends.end(); ++di)
-    {
+  for (std::set<cmGeneratorTarget const*>::iterator di = utilDepends.begin();
+       di != utilDepends.end(); ++di) {
     cmGeneratorTarget const* dgt = *di;
-    if(allowLinkable || !VSLinkable(dgt) || linked.count(dgt))
-      {
+    if (allowLinkable || !VSLinkable(dgt) || linked.count(dgt)) {
       // Direct dependency allowed.
       vsTargetDepend.insert(dgt->GetName());
-      }
-    else
-      {
+    } else {
       // Direct dependency on linkable target not allowed.
       // Use an intermediate utility target.
       vsTargetDepend.insert(this->GetUtilityDepend(dgt));
-      }
     }
+  }
 }
 
 void cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf)
@@ -469,47 +407,39 @@ void cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf)
   // Visual Studio generators know how to lookup their build tool
   // directly instead of needing a helper module to do it, so we
   // do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
-  if(cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
-    {
-    mf->AddDefinition("CMAKE_MAKE_PROGRAM",
-                      this->GetVSMakeProgram().c_str());
-    }
+  if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
+    mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetVSMakeProgram().c_str());
+  }
 }
 
-std::string
-cmGlobalVisualStudioGenerator::GetUtilityDepend(
-        cmGeneratorTarget const* target)
+std::string cmGlobalVisualStudioGenerator::GetUtilityDepend(
+  cmGeneratorTarget const* target)
 {
   UtilityDependsMap::iterator i = this->UtilityDepends.find(target);
-  if(i == this->UtilityDepends.end())
-    {
+  if (i == this->UtilityDepends.end()) {
     std::string name = this->WriteUtilityDepend(target);
     UtilityDependsMap::value_type entry(target, name);
     i = this->UtilityDepends.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
-std::string
-cmGlobalVisualStudioGenerator::GetStartupProjectName(
+std::string cmGlobalVisualStudioGenerator::GetStartupProjectName(
   cmLocalGenerator const* root) const
 {
   const char* n = root->GetMakefile()->GetProperty("VS_STARTUP_PROJECT");
-  if (n && *n)
-    {
+  if (n && *n) {
     std::string startup = n;
-    if (this->FindTarget(startup))
-      {
+    if (this->FindTarget(startup)) {
       return startup;
-      }
-    else
-      {
+    } else {
       root->GetMakefile()->IssueMessage(
         cmake::AUTHOR_WARNING,
         "Directory property VS_STARTUP_PROJECT specifies target "
-        "'" + startup + "' that does not exist.  Ignoring.");
-      }
+        "'" +
+          startup + "' that does not exist.  Ignoring.");
     }
+  }
 
   // default, if not specified
   return this->GetAllTargetName();
@@ -518,8 +448,8 @@ cmGlobalVisualStudioGenerator::GetStartupProjectName(
 #include <windows.h>
 
 bool IsVisualStudioMacrosFileRegistered(const std::string& macrosFile,
-  const std::string& regKeyBase,
-  std::string& nextAvailableSubKeyName)
+                                        const std::string& regKeyBase,
+                                        std::string& nextAvailableSubKeyName)
 {
   bool macrosRegistered = false;
 
@@ -538,98 +468,88 @@ bool IsVisualStudioMacrosFileRegistered(const std::string& macrosFile,
 
   keyname = regKeyBase + "\\OtherProjects7";
   hkey = NULL;
-  result = RegOpenKeyExW(HKEY_CURRENT_USER,
-                         cmsys::Encoding::ToWide(keyname).c_str(),
-                         0, KEY_READ, &hkey);
-  if (ERROR_SUCCESS == result)
-    {
+  result =
+    RegOpenKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(keyname).c_str(),
+                  0, KEY_READ, &hkey);
+  if (ERROR_SUCCESS == result) {
     // Iterate the subkeys and look for the values of interest in each subkey:
     wchar_t subkeyname[256];
-    DWORD cch_subkeyname = sizeof(subkeyname)*sizeof(subkeyname[0]);
+    DWORD cch_subkeyname = sizeof(subkeyname) * sizeof(subkeyname[0]);
     wchar_t keyclass[256];
-    DWORD cch_keyclass = sizeof(keyclass)*sizeof(keyclass[0]);
+    DWORD cch_keyclass = sizeof(keyclass) * sizeof(keyclass[0]);
     FILETIME lastWriteTime;
     lastWriteTime.dwHighDateTime = 0;
     lastWriteTime.dwLowDateTime = 0;
 
     while (ERROR_SUCCESS == RegEnumKeyExW(hkey, index, subkeyname,
-                                         &cch_subkeyname,
-      0, keyclass, &cch_keyclass, &lastWriteTime))
-      {
+                                          &cch_subkeyname, 0, keyclass,
+                                          &cch_keyclass, &lastWriteTime)) {
       // Open the subkey and query the values of interest:
       HKEY hsubkey = NULL;
       result = RegOpenKeyExW(hkey, subkeyname, 0, KEY_READ, &hsubkey);
-      if (ERROR_SUCCESS == result)
-        {
+      if (ERROR_SUCCESS == result) {
         DWORD valueType = REG_SZ;
         wchar_t data1[256];
-        DWORD cch_data1 = sizeof(data1)*sizeof(data1[0]);
-        RegQueryValueExW(hsubkey, L"Path", 0, &valueType,
-                        (LPBYTE) &data1[0], &cch_data1);
+        DWORD cch_data1 = sizeof(data1) * sizeof(data1[0]);
+        RegQueryValueExW(hsubkey, L"Path", 0, &valueType, (LPBYTE)&data1[0],
+                         &cch_data1);
 
         DWORD data2 = 0;
         DWORD cch_data2 = sizeof(data2);
-        RegQueryValueExW(hsubkey, L"Security", 0, &valueType,
-                        (LPBYTE) &data2, &cch_data2);
+        RegQueryValueExW(hsubkey, L"Security", 0, &valueType, (LPBYTE)&data2,
+                         &cch_data2);
 
         DWORD data3 = 0;
         DWORD cch_data3 = sizeof(data3);
         RegQueryValueExW(hsubkey, L"StorageFormat", 0, &valueType,
-                        (LPBYTE) &data3, &cch_data3);
+                         (LPBYTE)&data3, &cch_data3);
 
         s2 = cmSystemTools::LowerCase(cmsys::Encoding::ToNarrow(data1));
         cmSystemTools::ConvertToUnixSlashes(s2);
-        if (s2 == s1)
-          {
+        if (s2 == s1) {
           macrosRegistered = true;
-          }
+        }
 
         std::string fullname = cmsys::Encoding::ToNarrow(data1);
         std::string filename;
         std::string filepath;
         std::string filepathname;
         std::string filepathpath;
-        if (cmSystemTools::FileExists(fullname.c_str()))
-          {
+        if (cmSystemTools::FileExists(fullname.c_str())) {
           filename = cmSystemTools::GetFilenameName(fullname);
           filepath = cmSystemTools::GetFilenamePath(fullname);
           filepathname = cmSystemTools::GetFilenameName(filepath);
           filepathpath = cmSystemTools::GetFilenamePath(filepath);
-          }
+        }
 
-        //std::cout << keyname << "\\" << subkeyname << ":" << std::endl;
-        //std::cout << "  Path: " << data1 << std::endl;
-        //std::cout << "  Security: " << data2 << std::endl;
-        //std::cout << "  StorageFormat: " << data3 << std::endl;
-        //std::cout << "  filename: " << filename << std::endl;
-        //std::cout << "  filepath: " << filepath << std::endl;
-        //std::cout << "  filepathname: " << filepathname << std::endl;
-        //std::cout << "  filepathpath: " << filepathpath << std::endl;
-        //std::cout << std::endl;
+        // std::cout << keyname << "\\" << subkeyname << ":" << std::endl;
+        // std::cout << "  Path: " << data1 << std::endl;
+        // std::cout << "  Security: " << data2 << std::endl;
+        // std::cout << "  StorageFormat: " << data3 << std::endl;
+        // std::cout << "  filename: " << filename << std::endl;
+        // std::cout << "  filepath: " << filepath << std::endl;
+        // std::cout << "  filepathname: " << filepathname << std::endl;
+        // std::cout << "  filepathpath: " << filepathpath << std::endl;
+        // std::cout << std::endl;
 
         RegCloseKey(hsubkey);
-        }
-      else
-        {
+      } else {
         std::cout << "error opening subkey: " << subkeyname << std::endl;
         std::cout << std::endl;
-        }
+      }
 
       ++index;
-      cch_subkeyname = sizeof(subkeyname)*sizeof(subkeyname[0]);
-      cch_keyclass = sizeof(keyclass)*sizeof(keyclass[0]);
+      cch_subkeyname = sizeof(subkeyname) * sizeof(subkeyname[0]);
+      cch_keyclass = sizeof(keyclass) * sizeof(keyclass[0]);
       lastWriteTime.dwHighDateTime = 0;
       lastWriteTime.dwLowDateTime = 0;
-      }
+    }
 
     RegCloseKey(hkey);
-    }
-  else
-    {
+  } else {
     std::cout << "error opening key: " << keyname << std::endl;
     std::cout << std::endl;
-    }
-
+  }
 
   // Pass back next available sub key name, assuming sub keys always
   // follow the expected naming scheme. Expected naming scheme is that
@@ -639,139 +559,124 @@ bool IsVisualStudioMacrosFileRegistered(const std::string& macrosFile,
   ossNext << index;
   nextAvailableSubKeyName = ossNext.str();
 
-
   keyname = regKeyBase + "\\RecordingProject7";
   hkey = NULL;
-  result = RegOpenKeyExW(HKEY_CURRENT_USER,
-                         cmsys::Encoding::ToWide(keyname).c_str(),
-                         0, KEY_READ, &hkey);
-  if (ERROR_SUCCESS == result)
-    {
+  result =
+    RegOpenKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(keyname).c_str(),
+                  0, KEY_READ, &hkey);
+  if (ERROR_SUCCESS == result) {
     DWORD valueType = REG_SZ;
     wchar_t data1[256];
-    DWORD cch_data1 = sizeof(data1)*sizeof(data1[0]);
-    RegQueryValueExW(hkey, L"Path", 0, &valueType,
-                    (LPBYTE) &data1[0], &cch_data1);
+    DWORD cch_data1 = sizeof(data1) * sizeof(data1[0]);
+    RegQueryValueExW(hkey, L"Path", 0, &valueType, (LPBYTE)&data1[0],
+                     &cch_data1);
 
     DWORD data2 = 0;
     DWORD cch_data2 = sizeof(data2);
-    RegQueryValueExW(hkey, L"Security", 0, &valueType,
-                    (LPBYTE) &data2, &cch_data2);
+    RegQueryValueExW(hkey, L"Security", 0, &valueType, (LPBYTE)&data2,
+                     &cch_data2);
 
     DWORD data3 = 0;
     DWORD cch_data3 = sizeof(data3);
-    RegQueryValueExW(hkey, L"StorageFormat", 0, &valueType,
-                    (LPBYTE) &data3, &cch_data3);
+    RegQueryValueExW(hkey, L"StorageFormat", 0, &valueType, (LPBYTE)&data3,
+                     &cch_data3);
 
     s2 = cmSystemTools::LowerCase(cmsys::Encoding::ToNarrow(data1));
     cmSystemTools::ConvertToUnixSlashes(s2);
-    if (s2 == s1)
-      {
+    if (s2 == s1) {
       macrosRegistered = true;
-      }
+    }
 
-    //std::cout << keyname << ":" << std::endl;
-    //std::cout << "  Path: " << data1 << std::endl;
-    //std::cout << "  Security: " << data2 << std::endl;
-    //std::cout << "  StorageFormat: " << data3 << std::endl;
-    //std::cout << std::endl;
+    // std::cout << keyname << ":" << std::endl;
+    // std::cout << "  Path: " << data1 << std::endl;
+    // std::cout << "  Security: " << data2 << std::endl;
+    // std::cout << "  StorageFormat: " << data3 << std::endl;
+    // std::cout << std::endl;
 
     RegCloseKey(hkey);
-    }
-  else
-    {
+  } else {
     std::cout << "error opening key: " << keyname << std::endl;
     std::cout << std::endl;
-    }
+  }
 
   return macrosRegistered;
 }
 
-void WriteVSMacrosFileRegistryEntry(
-  const std::string& nextAvailableSubKeyName,
-  const std::string& macrosFile,
-  const std::string& regKeyBase)
+void WriteVSMacrosFileRegistryEntry(const std::string& nextAvailableSubKeyName,
+                                    const std::string& macrosFile,
+                                    const std::string& regKeyBase)
 {
   std::string keyname = regKeyBase + "\\OtherProjects7";
   HKEY hkey = NULL;
-  LONG result = RegOpenKeyExW(HKEY_CURRENT_USER,
-    cmsys::Encoding::ToWide(keyname).c_str(), 0,
-    KEY_READ|KEY_WRITE, &hkey);
-  if (ERROR_SUCCESS == result)
-    {
+  LONG result =
+    RegOpenKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(keyname).c_str(),
+                  0, KEY_READ | KEY_WRITE, &hkey);
+  if (ERROR_SUCCESS == result) {
     // Create the subkey and set the values of interest:
     HKEY hsubkey = NULL;
     wchar_t lpClass[] = L"";
-    result = RegCreateKeyExW(hkey,
-      cmsys::Encoding::ToWide(nextAvailableSubKeyName).c_str(), 0,
-      lpClass, 0, KEY_READ|KEY_WRITE, 0, &hsubkey, 0);
-    if (ERROR_SUCCESS == result)
-      {
+    result = RegCreateKeyExW(
+      hkey, cmsys::Encoding::ToWide(nextAvailableSubKeyName).c_str(), 0,
+      lpClass, 0, KEY_READ | KEY_WRITE, 0, &hsubkey, 0);
+    if (ERROR_SUCCESS == result) {
       DWORD dw = 0;
 
       std::string s(macrosFile);
       cmSystemTools::ReplaceString(s, "/", "\\");
       std::wstring ws = cmsys::Encoding::ToWide(s);
 
-      result = RegSetValueExW(hsubkey, L"Path", 0, REG_SZ, (LPBYTE)ws.c_str(),
-        static_cast<DWORD>(ws.size() + 1)*sizeof(wchar_t));
-      if (ERROR_SUCCESS != result)
-        {
+      result =
+        RegSetValueExW(hsubkey, L"Path", 0, REG_SZ, (LPBYTE)ws.c_str(),
+                       static_cast<DWORD>(ws.size() + 1) * sizeof(wchar_t));
+      if (ERROR_SUCCESS != result) {
         std::cout << "error result 1: " << result << std::endl;
         std::cout << std::endl;
-        }
+      }
 
       // Security value is always "1" for sample macros files (seems to be "2"
       // if you put the file somewhere outside the standard VSMacros folder)
       dw = 1;
-      result = RegSetValueExW(hsubkey, L"Security",
-                             0, REG_DWORD, (LPBYTE) &dw, sizeof(DWORD));
-      if (ERROR_SUCCESS != result)
-        {
+      result = RegSetValueExW(hsubkey, L"Security", 0, REG_DWORD, (LPBYTE)&dw,
+                              sizeof(DWORD));
+      if (ERROR_SUCCESS != result) {
         std::cout << "error result 2: " << result << std::endl;
         std::cout << std::endl;
-        }
+      }
 
       // StorageFormat value is always "0" for sample macros files
       dw = 0;
-      result = RegSetValueExW(hsubkey, L"StorageFormat",
-                             0, REG_DWORD, (LPBYTE) &dw, sizeof(DWORD));
-      if (ERROR_SUCCESS != result)
-        {
+      result = RegSetValueExW(hsubkey, L"StorageFormat", 0, REG_DWORD,
+                              (LPBYTE)&dw, sizeof(DWORD));
+      if (ERROR_SUCCESS != result) {
         std::cout << "error result 3: " << result << std::endl;
         std::cout << std::endl;
-        }
+      }
 
       RegCloseKey(hsubkey);
-      }
-    else
-      {
-      std::cout << "error creating subkey: "
-                << nextAvailableSubKeyName << std::endl;
+    } else {
+      std::cout << "error creating subkey: " << nextAvailableSubKeyName
+                << std::endl;
       std::cout << std::endl;
-      }
-    RegCloseKey(hkey);
     }
-  else
-    {
+    RegCloseKey(hkey);
+  } else {
     std::cout << "error opening key: " << keyname << std::endl;
     std::cout << std::endl;
-    }
+  }
 }
 
 void RegisterVisualStudioMacros(const std::string& macrosFile,
-  const std::string& regKeyBase)
+                                const std::string& regKeyBase)
 {
   bool macrosRegistered;
   std::string nextAvailableSubKeyName;
 
-  macrosRegistered = IsVisualStudioMacrosFileRegistered(macrosFile,
-    regKeyBase, nextAvailableSubKeyName);
+  macrosRegistered = IsVisualStudioMacrosFileRegistered(
+    macrosFile, regKeyBase, nextAvailableSubKeyName);
 
-  if (!macrosRegistered)
-    {
-    int count = cmCallVisualStudioMacro::
-      GetNumberOfRunningVisualStudioInstances("ALL");
+  if (!macrosRegistered) {
+    int count =
+      cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances("ALL");
 
     // Only register the macros file if there are *no* instances of Visual
     // Studio running. If we register it while one is running, first, it has
@@ -780,18 +685,16 @@ void RegisterVisualStudioMacros(const std::string& macrosFile,
     // emit a warning asking the user to exit all running Visual Studio
     // instances...
     //
-    if (0 != count)
-      {
+    if (0 != count) {
       std::ostringstream oss;
       oss << "Could not register CMake's Visual Studio macros file '"
-        << CMAKE_VSMACROS_FILENAME "' while Visual Studio is running."
-        << " Please exit all running instances of Visual Studio before"
-        << " continuing." << std::endl
-        << std::endl
-        << "CMake needs to register Visual Studio macros when its macros"
-        << " file is updated or when it detects that its current macros file"
-        << " is no longer registered with Visual Studio."
-        << std::endl;
+          << CMAKE_VSMACROS_FILENAME "' while Visual Studio is running."
+          << " Please exit all running instances of Visual Studio before"
+          << " continuing." << std::endl
+          << std::endl
+          << "CMake needs to register Visual Studio macros when its macros"
+          << " file is updated or when it detects that its current macros file"
+          << " is no longer registered with Visual Studio." << std::endl;
       cmSystemTools::Message(oss.str().c_str(), "Warning");
 
       // Count them again now that the warning is over. In the case of a GUI
@@ -799,104 +702,90 @@ void RegisterVisualStudioMacros(const std::string& macrosFile,
       // back to the CMake GUI and clicked ok on the above warning. If so,
       // then register the macros *now* if the count is *now* 0...
       //
-      count = cmCallVisualStudioMacro::
-        GetNumberOfRunningVisualStudioInstances("ALL");
+      count = cmCallVisualStudioMacro::GetNumberOfRunningVisualStudioInstances(
+        "ALL");
 
       // Also re-get the nextAvailableSubKeyName in case Visual Studio
       // wrote out new registered macros information as it was exiting:
       //
-      if (0 == count)
-        {
+      if (0 == count) {
         IsVisualStudioMacrosFileRegistered(macrosFile, regKeyBase,
-          nextAvailableSubKeyName);
-        }
+                                           nextAvailableSubKeyName);
       }
+    }
 
     // Do another if check - 'count' may have changed inside the above if:
     //
-    if (0 == count)
-      {
+    if (0 == count) {
       WriteVSMacrosFileRegistryEntry(nextAvailableSubKeyName, macrosFile,
-        regKeyBase);
-      }
+                                     regKeyBase);
     }
+  }
 }
-bool
-cmGlobalVisualStudioGenerator::TargetIsFortranOnly(cmGeneratorTarget const* gt)
+bool cmGlobalVisualStudioGenerator::TargetIsFortranOnly(
+  cmGeneratorTarget const* gt)
 {
   // check to see if this is a fortran build
   std::set<std::string> languages;
   {
-  // Issue diagnostic if the source files depend on the config.
-  std::vector<cmSourceFile*> sources;
-  if (!gt->GetConfigCommonSourceFiles(sources))
-    {
-    return false;
+    // Issue diagnostic if the source files depend on the config.
+    std::vector<cmSourceFile*> sources;
+    if (!gt->GetConfigCommonSourceFiles(sources)) {
+      return false;
     }
   }
   gt->GetLanguages(languages, "");
-  if(languages.size() == 1)
-    {
-    if(*languages.begin() == "Fortran")
-      {
+  if (languages.size() == 1) {
+    if (*languages.begin() == "Fortran") {
       return true;
-      }
     }
+  }
   return false;
 }
 
-bool
-cmGlobalVisualStudioGenerator::TargetCompare
-::operator()(cmGeneratorTarget const* l, cmGeneratorTarget const* r) const
+bool cmGlobalVisualStudioGenerator::TargetCompare::operator()(
+  cmGeneratorTarget const* l, cmGeneratorTarget const* r) const
 {
   // Make sure a given named target is ordered first,
   // e.g. to set ALL_BUILD as the default active project.
   // When the empty string is named this is a no-op.
-  if (r->GetName() == this->First)
-    {
+  if (r->GetName() == this->First) {
     return false;
-    }
-  if (l->GetName() == this->First)
-    {
+  }
+  if (l->GetName() == this->First) {
     return true;
-    }
+  }
   return l->GetName() < r->GetName();
 }
 
-cmGlobalVisualStudioGenerator::OrderedTargetDependSet
-::OrderedTargetDependSet(TargetDependSet const& targets,
-                         std::string const& first):
-  derived(TargetCompare(first))
+cmGlobalVisualStudioGenerator::OrderedTargetDependSet::OrderedTargetDependSet(
+  TargetDependSet const& targets, std::string const& first)
+  : derived(TargetCompare(first))
 {
   this->insert(targets.begin(), targets.end());
 }
 
-cmGlobalVisualStudioGenerator::OrderedTargetDependSet
-::OrderedTargetDependSet(TargetSet const& targets,
-                         std::string const& first):
-  derived(TargetCompare(first))
+cmGlobalVisualStudioGenerator::OrderedTargetDependSet::OrderedTargetDependSet(
+  TargetSet const& targets, std::string const& first)
+  : derived(TargetCompare(first))
 {
-  for (TargetSet::const_iterator it = targets.begin();
-       it != targets.end(); ++it)
-    {
+  for (TargetSet::const_iterator it = targets.begin(); it != targets.end();
+       ++it) {
     this->insert(*it);
-    }
+  }
 }
 
 std::string cmGlobalVisualStudioGenerator::ExpandCFGIntDir(
-  const std::string& str,
-  const std::string& config) const
+  const std::string& str, const std::string& config) const
 {
   std::string replace = GetCMakeCFGIntDir();
 
   std::string tmp = str;
-  for(std::string::size_type i = tmp.find(replace);
-      i != std::string::npos;
-      i = tmp.find(replace, i))
-    {
+  for (std::string::size_type i = tmp.find(replace); i != std::string::npos;
+       i = tmp.find(replace, i)) {
     tmp.replace(i, replace.size(), config);
     i += config.size();
-    }
+  }
   return tmp;
 }
 
@@ -912,13 +801,12 @@ void cmGlobalVisualStudioGenerator::AddSymbolExportCommand(
   std::vector<cmSourceFile const*> objectSources;
   gt->GetObjectSources(objectSources, configName);
   std::map<cmSourceFile const*, std::string> mapping;
-  for(std::vector<cmSourceFile const*>::const_iterator it
-        = objectSources.begin(); it != objectSources.end(); ++it)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator it =
+         objectSources.begin();
+       it != objectSources.end(); ++it) {
     mapping[*it];
-    }
-  gt->LocalGenerator->
-    ComputeObjectFilenames(mapping, gt);
+  }
+  gt->LocalGenerator->ComputeObjectFilenames(mapping, gt);
   std::string obj_dir = gt->ObjectDirectory;
   std::string cmakeCommand = cmSystemTools::GetCMakeCommand();
   cmSystemTools::ConvertToWindowsExtendedPath(cmakeCommand);
@@ -928,42 +816,36 @@ void cmGlobalVisualStudioGenerator::AddSymbolExportCommand(
   cmdl.push_back("__create_def");
   cmdl.push_back(deffile);
   std::string obj_dir_expanded = obj_dir;
-  cmSystemTools::ReplaceString(obj_dir_expanded,
-                               this->GetCMakeCFGIntDir(),
+  cmSystemTools::ReplaceString(obj_dir_expanded, this->GetCMakeCFGIntDir(),
                                configName.c_str());
   std::string objs_file = obj_dir_expanded;
   cmSystemTools::MakeDirectory(objs_file.c_str());
   objs_file += "/objects.txt";
   cmdl.push_back(objs_file);
   cmGeneratedFileStream fout(objs_file.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("could not open ", objs_file.c_str());
     return;
-    }
-  for(std::vector<cmSourceFile const*>::const_iterator it
-        = objectSources.begin(); it != objectSources.end(); ++it)
-    {
+  }
+  for (std::vector<cmSourceFile const*>::const_iterator it =
+         objectSources.begin();
+       it != objectSources.end(); ++it) {
     // Find the object file name corresponding to this source file.
-    std::map<cmSourceFile const*, std::string>::const_iterator
-      map_it = mapping.find(*it);
+    std::map<cmSourceFile const*, std::string>::const_iterator map_it =
+      mapping.find(*it);
     // It must exist because we populated the mapping just above.
     assert(!map_it->second.empty());
     std::string objFile = obj_dir + map_it->second;
     // replace $(ConfigurationName) in the object names
     cmSystemTools::ReplaceString(objFile, this->GetCMakeCFGIntDir(),
                                  configName.c_str());
-    if(cmHasLiteralSuffix(objFile, ".obj"))
-      {
+    if (cmHasLiteralSuffix(objFile, ".obj")) {
       fout << objFile << "\n";
-      }
     }
+  }
   cmCustomCommandLines commandLines;
   commandLines.push_back(cmdl);
-  cmCustomCommand command(gt->Target->GetMakefile(),
-                          outputs, empty, empty,
-                          commandLines,
-                          "Auto build dll exports",
-                          ".");
+  cmCustomCommand command(gt->Target->GetMakefile(), outputs, empty, empty,
+                          commandLines, "Auto build dll exports", ".");
   commands.push_back(command);
 }
diff --git a/Source/cmGlobalVisualStudioGenerator.h b/Source/cmGlobalVisualStudioGenerator.h
index 723a75f..fb2cdbd 100644
--- a/Source/cmGlobalVisualStudioGenerator.h
+++ b/Source/cmGlobalVisualStudioGenerator.h
@@ -62,17 +62,20 @@ public:
    */
   virtual std::string GetUserMacrosRegKeyBase();
 
-  enum MacroName {MacroReload, MacroStop};
+  enum MacroName
+  {
+    MacroReload,
+    MacroStop
+  };
 
   /**
    * Call the ReloadProjects macro if necessary based on
    * GetFilesReplacedDuringGenerate results.
    */
-  void CallVisualStudioMacro(MacroName m,
-                             const char* vsSolutionFile = 0);
+  void CallVisualStudioMacro(MacroName m, const char* vsSolutionFile = 0);
 
   // return true if target is fortran only
-  bool TargetIsFortranOnly(const cmGeneratorTarget *gt);
+  bool TargetIsFortranOnly(const cmGeneratorTarget* gt);
 
   /** Get the top-level registry key for this VS version.  */
   std::string GetRegistryBase();
@@ -87,12 +90,18 @@ public:
   /** Return true if building for Windows CE */
   virtual bool TargetsWindowsCE() const { return false; }
 
-  class TargetSet: public std::set<cmGeneratorTarget const*> {};
+  class TargetSet : public std::set<cmGeneratorTarget const*>
+  {
+  };
   class TargetCompare
   {
     std::string First;
+
   public:
-    TargetCompare(std::string const& first): First(first) {}
+    TargetCompare(std::string const& first)
+      : First(first)
+    {
+    }
     bool operator()(cmGeneratorTarget const* l,
                     cmGeneratorTarget const* r) const;
   };
@@ -100,7 +109,6 @@ public:
 
   virtual void FindMakeProgram(cmMakefile*);
 
-
   virtual std::string ExpandCFGIntDir(const std::string& str,
                                       const std::string& config) const;
 
@@ -108,9 +116,10 @@ public:
 
   std::string GetStartupProjectName(cmLocalGenerator const* root) const;
 
-  void AddSymbolExportCommand(
-    cmGeneratorTarget*, std::vector<cmCustomCommand>& commands,
-    std::string const& configName);
+  void AddSymbolExportCommand(cmGeneratorTarget*,
+                              std::vector<cmCustomCommand>& commands,
+                              std::string const& configName);
+
 protected:
   virtual void AddExtraIDETargets();
 
@@ -122,16 +131,20 @@ protected:
   virtual const char* GetIDEVersion() = 0;
 
   virtual bool ComputeTargetDepends();
-  class VSDependSet: public std::set<std::string> {};
-  class VSDependMap: public std::map<cmGeneratorTarget const*, VSDependSet> {};
+  class VSDependSet : public std::set<std::string>
+  {
+  };
+  class VSDependMap : public std::map<cmGeneratorTarget const*, VSDependSet>
+  {
+  };
   VSDependMap VSTargetDepends;
-  void ComputeVSTargetDepends(cmGeneratorTarget *);
+  void ComputeVSTargetDepends(cmGeneratorTarget*);
 
   bool CheckTargetLinks(cmGeneratorTarget& target, const std::string& name);
   std::string GetUtilityForTarget(cmGeneratorTarget& target,
                                   const std::string&);
   virtual std::string WriteUtilityDepend(cmGeneratorTarget const*) = 0;
-  std::string GetUtilityDepend(const cmGeneratorTarget *target);
+  std::string GetUtilityDepend(const cmGeneratorTarget* target);
   typedef std::map<cmGeneratorTarget const*, std::string> UtilityDependsMap;
   UtilityDependsMap UtilityDepends;
 
@@ -141,25 +154,29 @@ protected:
 private:
   virtual std::string GetVSMakeProgram() = 0;
   void PrintCompilerAdvice(std::ostream&, std::string const&,
-                           const char*) const {}
+                           const char*) const
+  {
+  }
 
   void FollowLinkDepends(cmGeneratorTarget const* target,
                          std::set<cmGeneratorTarget const*>& linked);
 
-  class TargetSetMap: public std::map<cmGeneratorTarget*, TargetSet> {};
+  class TargetSetMap : public std::map<cmGeneratorTarget*, TargetSet>
+  {
+  };
   TargetSetMap TargetLinkClosure;
-  void FillLinkClosure(const cmGeneratorTarget *target,
-                       TargetSet& linked);
+  void FillLinkClosure(const cmGeneratorTarget* target, TargetSet& linked);
   TargetSet const& GetTargetLinkClosure(cmGeneratorTarget* target);
 };
 
-class cmGlobalVisualStudioGenerator::OrderedTargetDependSet:
-  public std::multiset<cmTargetDepend,
-                       cmGlobalVisualStudioGenerator::TargetCompare>
+class cmGlobalVisualStudioGenerator::OrderedTargetDependSet
+  : public std::multiset<cmTargetDepend,
+                         cmGlobalVisualStudioGenerator::TargetCompare>
 {
   typedef std::multiset<cmTargetDepend,
                         cmGlobalVisualStudioGenerator::TargetCompare>
     derived;
+
 public:
   typedef cmGlobalGenerator::TargetDependSet TargetDependSet;
   typedef cmGlobalVisualStudioGenerator::TargetSet TargetSet;
diff --git a/Source/cmGlobalWatcomWMakeGenerator.cxx b/Source/cmGlobalWatcomWMakeGenerator.cxx
index 461b9b1..86fe6f2 100644
--- a/Source/cmGlobalWatcomWMakeGenerator.cxx
+++ b/Source/cmGlobalWatcomWMakeGenerator.cxx
@@ -34,10 +34,8 @@ cmGlobalWatcomWMakeGenerator::cmGlobalWatcomWMakeGenerator(cmake* cm)
   this->MakeSilentFlag = "-h";
 }
 
-void cmGlobalWatcomWMakeGenerator
-::EnableLanguage(std::vector<std::string>const& l,
-                 cmMakefile *mf,
-                 bool optional)
+void cmGlobalWatcomWMakeGenerator::EnableLanguage(
+  std::vector<std::string> const& l, cmMakefile* mf, bool optional)
 {
   // pick a default
   mf->AddDefinition("WATCOM", "1");
@@ -50,8 +48,8 @@ void cmGlobalWatcomWMakeGenerator
   this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
 }
 
-void cmGlobalWatcomWMakeGenerator
-::GetDocumentation(cmDocumentationEntry& entry)
+void cmGlobalWatcomWMakeGenerator::GetDocumentation(
+  cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalWatcomWMakeGenerator::GetActualName();
   entry.Brief = "Generates Watcom WMake makefiles.";
diff --git a/Source/cmGlobalWatcomWMakeGenerator.h b/Source/cmGlobalWatcomWMakeGenerator.h
index 4bfcf06..3954907 100644
--- a/Source/cmGlobalWatcomWMakeGenerator.h
+++ b/Source/cmGlobalWatcomWMakeGenerator.h
@@ -23,13 +23,16 @@ class cmGlobalWatcomWMakeGenerator : public cmGlobalUnixMakefileGenerator3
 {
 public:
   cmGlobalWatcomWMakeGenerator(cmake* cm);
-  static cmGlobalGeneratorFactory* NewFactory() {
-    return new cmGlobalGeneratorSimpleFactory
-      <cmGlobalWatcomWMakeGenerator>(); }
+  static cmGlobalGeneratorFactory* NewFactory()
+  {
+    return new cmGlobalGeneratorSimpleFactory<cmGlobalWatcomWMakeGenerator>();
+  }
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalWatcomWMakeGenerator::GetActualName();}
-  static std::string GetActualName() {return "Watcom WMake";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalWatcomWMakeGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "Watcom WMake"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
@@ -38,8 +41,8 @@ public:
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
 
   virtual bool AllowNotParallel() const { return false; }
   virtual bool AllowDeleteOnError() const { return false; }
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 022b802..efc239e 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -34,29 +34,25 @@
 class cmXcodeVersionParser : public cmXMLParser
 {
 public:
-  cmXcodeVersionParser(): Version("1.5") {}
-  void StartElement(const std::string&, const char**)
-    {
-      this->Data = "";
-    }
+  cmXcodeVersionParser()
+    : Version("1.5")
+  {
+  }
+  void StartElement(const std::string&, const char**) { this->Data = ""; }
   void EndElement(const std::string& name)
-    {
-      if(name == "key")
-        {
-        this->Key = this->Data;
-        }
-      else if(name == "string")
-        {
-        if(this->Key == "CFBundleShortVersionString")
-          {
-          this->Version = this->Data;
-          }
-        }
+  {
+    if (name == "key") {
+      this->Key = this->Data;
+    } else if (name == "string") {
+      if (this->Key == "CFBundleShortVersionString") {
+        this->Version = this->Data;
+      }
     }
+  }
   void CharacterDataHandler(const char* data, int length)
-    {
-      this->Data.append(data, length);
-    }
+  {
+    this->Data.append(data, length);
+  }
   std::string Version;
   std::string Key;
   std::string Data;
@@ -67,64 +63,63 @@ public:
 // given inputs.
 class cmGlobalXCodeGenerator::BuildObjectListOrString
 {
-  cmGlobalXCodeGenerator *Generator;
-  cmXCodeObject *Group;
+  cmGlobalXCodeGenerator* Generator;
+  cmXCodeObject* Group;
   bool Empty;
   std::string String;
 
 public:
-  BuildObjectListOrString(cmGlobalXCodeGenerator *gen, bool buildObjectList)
-    : Generator(gen), Group(0), Empty(true)
-    {
-    if (buildObjectList)
-      {
+  BuildObjectListOrString(cmGlobalXCodeGenerator* gen, bool buildObjectList)
+    : Generator(gen)
+    , Group(0)
+    , Empty(true)
+  {
+    if (buildObjectList) {
       this->Group = this->Generator->CreateObject(cmXCodeObject::OBJECT_LIST);
-      }
     }
+  }
 
   bool IsEmpty() const { return this->Empty; }
 
   void Add(const std::string& newString)
-    {
+  {
     this->Empty = false;
 
-    if (this->Group)
-      {
+    if (this->Group) {
       this->Group->AddObject(this->Generator->CreateString(newString));
-      }
-    else
-      {
+    } else {
       this->String += newString;
       this->String += ' ';
-      }
     }
+  }
 
-  const std::string &GetString() const { return this->String; }
+  const std::string& GetString() const { return this->String; }
 
-  cmXCodeObject *CreateList()
-    {
-    if (this->Group)
-      {
+  cmXCodeObject* CreateList()
+  {
+    if (this->Group) {
       return this->Group;
-      }
-    else
-      {
+    } else {
       return this->Generator->CreateString(this->String);
-      }
     }
+  }
 };
 
 class cmGlobalXCodeGenerator::Factory : public cmGlobalGeneratorFactory
 {
 public:
-  virtual cmGlobalGenerator*
-  CreateGlobalGenerator(const std::string& name, cmake* cm) const;
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const;
 
-  virtual void GetDocumentation(cmDocumentationEntry& entry) const {
-    cmGlobalXCodeGenerator::GetDocumentation(entry); }
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
+    cmGlobalXCodeGenerator::GetDocumentation(entry);
+  }
 
-  virtual void GetGenerators(std::vector<std::string>& names) const {
-    names.push_back(cmGlobalXCodeGenerator::GetActualName()); }
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
+    names.push_back(cmGlobalXCodeGenerator::GetActualName());
+  }
 
   virtual bool SupportsToolset() const { return true; }
 };
@@ -136,9 +131,9 @@ cmGlobalXCodeGenerator::cmGlobalXCodeGenerator(cmake* cm,
   this->VersionString = version;
 
   // Compute an integer form of the version number.
-  unsigned int v[2] = {0,0};
+  unsigned int v[2] = { 0, 0 };
   sscanf(this->VersionString.c_str(), "%u.%u", &v[0], &v[1]);
-  this->XcodeVersion = 10*v[0] + v[1];
+  this->XcodeVersion = 10 * v[0] + v[1];
 
   this->RootObject = 0;
   this->MainGroupChildren = 0;
@@ -154,8 +149,8 @@ cmGlobalGeneratorFactory* cmGlobalXCodeGenerator::NewFactory()
   return new Factory;
 }
 
-cmGlobalGenerator* cmGlobalXCodeGenerator::Factory
-::CreateGlobalGenerator(const std::string& name, cmake* cm) const
+cmGlobalGenerator* cmGlobalXCodeGenerator::Factory::CreateGlobalGenerator(
+  const std::string& name, cmake* cm) const
 {
   if (name != GetActualName())
     return 0;
@@ -163,42 +158,34 @@ cmGlobalGenerator* cmGlobalXCodeGenerator::Factory
   cmXcodeVersionParser parser;
   std::string versionFile;
   {
-  std::string out;
-  std::string::size_type pos;
-  if(cmSystemTools::RunSingleCommand("xcode-select --print-path", &out, 0,
-                                     0, 0, cmSystemTools::OUTPUT_NONE) &&
-     (pos = out.find(".app/"), pos != out.npos))
-    {
-    versionFile = out.substr(0, pos+5)+"Contents/version.plist";
+    std::string out;
+    std::string::size_type pos;
+    if (cmSystemTools::RunSingleCommand("xcode-select --print-path", &out, 0,
+                                        0, 0, cmSystemTools::OUTPUT_NONE) &&
+        (pos = out.find(".app/"), pos != out.npos)) {
+      versionFile = out.substr(0, pos + 5) + "Contents/version.plist";
     }
   }
-  if(!versionFile.empty() && cmSystemTools::FileExists(versionFile.c_str()))
-    {
+  if (!versionFile.empty() && cmSystemTools::FileExists(versionFile.c_str())) {
     parser.ParseFile(versionFile.c_str());
-    }
-  else if (cmSystemTools::FileExists(
-             "/Applications/Xcode.app/Contents/version.plist"))
-    {
-    parser.ParseFile
-      ("/Applications/Xcode.app/Contents/version.plist");
-    }
-  else
-    {
-    parser.ParseFile
-      ("/Developer/Applications/Xcode.app/Contents/version.plist");
-    }
-  cmsys::auto_ptr<cmGlobalXCodeGenerator>
-    gg(new cmGlobalXCodeGenerator(cm, parser.Version));
-  if (gg->XcodeVersion == 20)
-    {
+  } else if (cmSystemTools::FileExists(
+               "/Applications/Xcode.app/Contents/version.plist")) {
+    parser.ParseFile("/Applications/Xcode.app/Contents/version.plist");
+  } else {
+    parser.ParseFile(
+      "/Developer/Applications/Xcode.app/Contents/version.plist");
+  }
+  cmsys::auto_ptr<cmGlobalXCodeGenerator> gg(
+    new cmGlobalXCodeGenerator(cm, parser.Version));
+  if (gg->XcodeVersion == 20) {
     cmSystemTools::Message("Xcode 2.0 not really supported by cmake, "
                            "using Xcode 15 generator\n");
     gg->XcodeVersion = 15;
-    }
+  }
   return gg.release();
 #else
   std::cerr << "CMake should be built with cmake to use Xcode, "
-    "default to Xcode 1.5\n";
+               "default to Xcode 1.5\n";
   return new cmGlobalXCodeGenerator(cm);
 #endif
 }
@@ -208,162 +195,125 @@ void cmGlobalXCodeGenerator::FindMakeProgram(cmMakefile* mf)
   // The Xcode generator knows how to lookup its build tool
   // directly instead of needing a helper module to do it, so we
   // do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
-  if(cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
-    {
+  if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
     mf->AddDefinition("CMAKE_MAKE_PROGRAM",
                       this->GetXcodeBuildCommand().c_str());
-    }
+  }
 }
 
 std::string const& cmGlobalXCodeGenerator::GetXcodeBuildCommand()
 {
-  if(!this->XcodeBuildCommandInitialized)
-    {
+  if (!this->XcodeBuildCommandInitialized) {
     this->XcodeBuildCommandInitialized = true;
     this->XcodeBuildCommand = this->FindXcodeBuildCommand();
-    }
+  }
   return this->XcodeBuildCommand;
 }
 
 std::string cmGlobalXCodeGenerator::FindXcodeBuildCommand()
 {
-  if (this->XcodeVersion >= 40)
-    {
+  if (this->XcodeVersion >= 40) {
     std::string makeProgram = cmSystemTools::FindProgram("xcodebuild");
-    if (makeProgram.empty())
-      {
+    if (makeProgram.empty()) {
       makeProgram = "xcodebuild";
-      }
-    return makeProgram;
     }
-  else
-    {
+    return makeProgram;
+  } else {
     // Use cmakexbuild wrapper to suppress environment dump from output.
     return cmSystemTools::GetCMakeCommand() + "xbuild";
-    }
+  }
 }
 
 bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts,
                                                  cmMakefile* mf)
 {
-  if(this->XcodeVersion >= 30)
-    {
+  if (this->XcodeVersion >= 30) {
     this->GeneratorToolset = ts;
-    if(!this->GeneratorToolset.empty())
-      {
+    if (!this->GeneratorToolset.empty()) {
       mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET",
                         this->GeneratorToolset.c_str());
-      }
-    return true;
     }
-  else
-    {
+    return true;
+  } else {
     return cmGlobalGenerator::SetGeneratorToolset(ts, mf);
-    }
+  }
 }
 
-void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
-                                            lang,
-                                            cmMakefile * mf, bool optional)
+void cmGlobalXCodeGenerator::EnableLanguage(
+  std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
 {
-  mf->AddDefinition("XCODE","1");
+  mf->AddDefinition("XCODE", "1");
   mf->AddDefinition("XCODE_VERSION", this->VersionString.c_str());
-  if(this->XcodeVersion == 15)
-    {
-    }
-  else
-    {
-    if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
-      {
+  if (this->XcodeVersion == 15) {
+  } else {
+    if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) {
       mf->AddCacheDefinition(
-        "CMAKE_CONFIGURATION_TYPES",
-        "Debug;Release;MinSizeRel;RelWithDebInfo",
+        "CMAKE_CONFIGURATION_TYPES", "Debug;Release;MinSizeRel;RelWithDebInfo",
         "Semicolon separated list of supported configuration types, "
         "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
         "anything else will be ignored.",
         cmState::STRING);
-      }
     }
+  }
   mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
   this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
-    const char* osxArch =
-      mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
-  const char* sysroot =
-      mf->GetDefinition("CMAKE_OSX_SYSROOT");
-  if(osxArch && sysroot)
-    {
+  const char* osxArch = mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
+  const char* sysroot = mf->GetDefinition("CMAKE_OSX_SYSROOT");
+  if (osxArch && sysroot) {
     this->Architectures.clear();
     cmSystemTools::ExpandListArgument(std::string(osxArch),
                                       this->Architectures);
-    }
+  }
 }
 
-void
-cmGlobalXCodeGenerator::GenerateBuildCommand(
-  std::vector<std::string>& makeCommand,
-  const std::string& makeProgram,
-  const std::string& projectName,
-  const std::string& /*projectDir*/,
-  const std::string& targetName,
-  const std::string& config,
-  bool /*fast*/, bool /*verbose*/,
-  std::vector<std::string> const& makeOptions)
+void cmGlobalXCodeGenerator::GenerateBuildCommand(
+  std::vector<std::string>& makeCommand, const std::string& makeProgram,
+  const std::string& projectName, const std::string& /*projectDir*/,
+  const std::string& targetName, const std::string& config, bool /*fast*/,
+  bool /*verbose*/, std::vector<std::string> const& makeOptions)
 {
   // now build the test
   makeCommand.push_back(
-    this->SelectMakeProgram(makeProgram, this->GetXcodeBuildCommand())
-    );
+    this->SelectMakeProgram(makeProgram, this->GetXcodeBuildCommand()));
 
   makeCommand.push_back("-project");
   std::string projectArg = projectName;
   projectArg += ".xcode";
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     projectArg += "proj";
-    }
+  }
   makeCommand.push_back(projectArg);
 
   bool clean = false;
   std::string realTarget = targetName;
-  if ( realTarget == "clean" )
-    {
+  if (realTarget == "clean") {
     clean = true;
     realTarget = "ALL_BUILD";
-    }
-  if(clean)
-    {
+  }
+  if (clean) {
     makeCommand.push_back("clean");
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("build");
-    }
+  }
   makeCommand.push_back("-target");
-  if (!realTarget.empty())
-    {
+  if (!realTarget.empty()) {
     makeCommand.push_back(realTarget);
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("ALL_BUILD");
-    }
-  if(this->XcodeVersion == 15)
-    {
+  }
+  if (this->XcodeVersion == 15) {
     makeCommand.push_back("-buildstyle");
     makeCommand.push_back("Development");
-    }
-  else
-    {
+  } else {
     makeCommand.push_back("-configuration");
-    makeCommand.push_back(!config.empty()?config:"Debug");
-    }
-  makeCommand.insert(makeCommand.end(),
-                     makeOptions.begin(), makeOptions.end());
+    makeCommand.push_back(!config.empty() ? config : "Debug");
+  }
+  makeCommand.insert(makeCommand.end(), makeOptions.begin(),
+                     makeOptions.end());
 }
 
 ///! Create a local generator appropriate to this Global Generator
-cmLocalGenerator *
-cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf)
+cmLocalGenerator* cmGlobalXCodeGenerator::CreateLocalGenerator(cmMakefile* mf)
 {
   return new cmLocalXCodeGenerator(this, mf);
 }
@@ -373,30 +323,27 @@ void cmGlobalXCodeGenerator::AddExtraIDETargets()
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
   // make sure extra targets are added before calling
   // the parent generate which will call trace depends
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     cmLocalGenerator* root = it->second[0];
     this->SetGenerationRoot(root);
     // add ALL_BUILD, INSTALL, etc
     this->AddExtraTargets(root, it->second);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::Generate()
 {
   this->cmGlobalGenerator::Generate();
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return;
-    }
+  }
   std::map<std::string, std::vector<cmLocalGenerator*> >::iterator it;
-  for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
-    {
+  for (it = this->ProjectMap.begin(); it != this->ProjectMap.end(); ++it) {
     cmLocalGenerator* root = it->second[0];
     this->SetGenerationRoot(root);
     // now create the project
     this->OutputXCodeProject(root, it->second);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root)
@@ -404,47 +351,43 @@ void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root)
   this->CurrentProject = root->GetProjectName();
   this->SetCurrentLocalGenerator(root);
   cmSystemTools::SplitPath(
-        this->CurrentLocalGenerator->GetCurrentSourceDirectory(),
-        this->ProjectSourceDirectoryComponents);
+    this->CurrentLocalGenerator->GetCurrentSourceDirectory(),
+    this->ProjectSourceDirectoryComponents);
   cmSystemTools::SplitPath(
-        this->CurrentLocalGenerator->GetCurrentBinaryDirectory(),
-        this->ProjectOutputDirectoryComponents);
+    this->CurrentLocalGenerator->GetCurrentBinaryDirectory(),
+    this->ProjectOutputDirectoryComponents);
 
-  this->CurrentXCodeHackMakefile =
-    root->GetCurrentBinaryDirectory();
+  this->CurrentXCodeHackMakefile = root->GetCurrentBinaryDirectory();
   this->CurrentXCodeHackMakefile += "/CMakeScripts";
   cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str());
   this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make";
 }
 
-std::string
-cmGlobalXCodeGenerator::PostBuildMakeTarget(std::string const& tName,
-                                            std::string const& configName)
+std::string cmGlobalXCodeGenerator::PostBuildMakeTarget(
+  std::string const& tName, std::string const& configName)
 {
   std::string target = tName;
   cmSystemTools::ReplaceString(target, " ", "_");
   std::string out = "PostBuild." + target;
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     out += "." + configName;
-    }
+  }
   return out;
 }
 
 #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK"
 
-void
-cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
-                                        std::vector<cmLocalGenerator*>& gens)
+void cmGlobalXCodeGenerator::AddExtraTargets(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& gens)
 {
   cmMakefile* mf = root->GetMakefile();
 
   // Add ALL_BUILD
   const char* no_working_directory = 0;
   std::vector<std::string> no_depends;
-  cmTarget* allbuild = mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
-                        no_working_directory,
-                        "echo", "Build all projects");
+  cmTarget* allbuild =
+    mf->AddUtilityCommand("ALL_BUILD", true, no_depends, no_working_directory,
+                          "echo", "Build all projects");
 
   cmGeneratorTarget* allBuildGt = new cmGeneratorTarget(allbuild, root);
   root->AddGeneratorTarget(allBuildGt);
@@ -458,113 +401,98 @@ cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
   // Add XCODE depend helper
   std::string dir = root->GetCurrentBinaryDirectory();
   cmCustomCommandLine makeHelper;
-  if(this->XcodeVersion < 50)
-    {
+  if (this->XcodeVersion < 50) {
     makeHelper.push_back("make");
     makeHelper.push_back("-C");
     makeHelper.push_back(dir.c_str());
     makeHelper.push_back("-f");
     makeHelper.push_back(this->CurrentXCodeHackMakefile.c_str());
     makeHelper.push_back(""); // placeholder, see below
-    }
+  }
 
   // Add ZERO_CHECK
   bool regenerate = !mf->IsOn("CMAKE_SUPPRESS_REGENERATION");
-  if (regenerate)
-    {
+  if (regenerate) {
     this->CreateReRunCMakeFile(root, gens);
-    std::string file = this->ConvertToRelativeForMake(
-      this->CurrentReRunCMakeMakefile.c_str());
+    std::string file =
+      this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile.c_str());
     cmSystemTools::ReplaceString(file, "\\ ", " ");
-    cmTarget* check = mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET,
-                          true, no_depends,
-                          no_working_directory,
-                          "make", "-f", file.c_str());
+    cmTarget* check =
+      mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, true, no_depends,
+                            no_working_directory, "make", "-f", file.c_str());
 
     cmGeneratorTarget* checkGt = new cmGeneratorTarget(check, root);
     root->AddGeneratorTarget(checkGt);
-    }
+  }
 
   // now make the allbuild depend on all the non-utility targets
   // in the project
-  for(std::vector<cmLocalGenerator*>::iterator i = gens.begin();
-      i != gens.end(); ++i)
-    {
+  for (std::vector<cmLocalGenerator*>::iterator i = gens.begin();
+       i != gens.end(); ++i) {
     cmLocalGenerator* lg = *i;
-    if(this->IsExcluded(root, *i))
-      {
+    if (this->IsExcluded(root, *i)) {
       continue;
-      }
+    }
 
     std::vector<cmGeneratorTarget*> tgts = lg->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-        l != tgts.end(); l++)
-      {
+    for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+         l != tgts.end(); l++) {
       cmGeneratorTarget* target = *l;
 
-      if (target->GetType() == cmState::GLOBAL_TARGET)
-        {
+      if (target->GetType() == cmState::GLOBAL_TARGET) {
         continue;
-        }
+      }
 
       std::string targetName = target->GetName();
 
-      if (regenerate && (targetName != CMAKE_CHECK_BUILD_SYSTEM_TARGET))
-        {
+      if (regenerate && (targetName != CMAKE_CHECK_BUILD_SYSTEM_TARGET)) {
         target->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
-        }
+      }
 
       // make all exe, shared libs and modules
       // run the depend check makefile as a post build rule
       // this will make sure that when the next target is built
       // things are up-to-date
-      if(!makeHelper.empty() &&
-         (target->GetType() == cmState::EXECUTABLE ||
-// Nope - no post-build for OBJECT_LIRBRARY
-//          target->GetType() == cmState::OBJECT_LIBRARY ||
-          target->GetType() == cmState::STATIC_LIBRARY ||
-          target->GetType() == cmState::SHARED_LIBRARY ||
-          target->GetType() == cmState::MODULE_LIBRARY))
-        {
-        makeHelper[makeHelper.size()-1] = // fill placeholder
+      if (!makeHelper.empty() &&
+          (target->GetType() == cmState::EXECUTABLE ||
+           // Nope - no post-build for OBJECT_LIRBRARY
+           //          target->GetType() == cmState::OBJECT_LIBRARY ||
+           target->GetType() == cmState::STATIC_LIBRARY ||
+           target->GetType() == cmState::SHARED_LIBRARY ||
+           target->GetType() == cmState::MODULE_LIBRARY)) {
+        makeHelper[makeHelper.size() - 1] = // fill placeholder
           this->PostBuildMakeTarget(target->GetName(), "$(CONFIGURATION)");
         cmCustomCommandLines commandLines;
         commandLines.push_back(makeHelper);
         std::vector<std::string> no_byproducts;
-        lg->GetMakefile()->AddCustomCommandToTarget(target->GetName(),
-                                                    no_byproducts,
-                                                    no_depends,
-                                                    commandLines,
-                                                    cmTarget::POST_BUILD,
-                                                    "Depend check for xcode",
-                                                    dir.c_str());
-        }
+        lg->GetMakefile()->AddCustomCommandToTarget(
+          target->GetName(), no_byproducts, no_depends, commandLines,
+          cmTarget::POST_BUILD, "Depend check for xcode", dir.c_str());
+      }
 
-      if(target->GetType() != cmState::INTERFACE_LIBRARY
-          && !target->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-        {
+      if (target->GetType() != cmState::INTERFACE_LIBRARY &&
+          !target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
         allbuild->AddUtility(target->GetName());
-        }
+      }
 
       // Refer to the build configuration file for easy editing.
       listfile = lg->GetCurrentSourceDirectory();
       listfile += "/";
       listfile += "CMakeLists.txt";
       target->AddSource(listfile.c_str());
-      }
     }
+  }
 }
 
 void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens)
 {
   std::vector<std::string> lfiles;
-  for(std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin();
-      gi != gens.end(); ++gi)
-    {
+  for (std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin();
+       gi != gens.end(); ++gi) {
     std::vector<std::string> const& lf = (*gi)->GetMakefile()->GetListFiles();
     lfiles.insert(lfiles.end(), lf.begin(), lf.end());
-    }
+  }
 
   // sort the array
   std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
@@ -575,8 +503,8 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   this->CurrentReRunCMakeMakefile += "/CMakeScripts";
   cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
   this->CurrentReRunCMakeMakefile += "/ReRunCMake.make";
-  cmGeneratedFileStream makefileStream
-    (this->CurrentReRunCMakeMakefile.c_str());
+  cmGeneratedFileStream makefileStream(
+    this->CurrentReRunCMakeMakefile.c_str());
   makefileStream.SetCopyIfDifferent(true);
   makefileStream << "# Generated by CMake, DO NOT EDIT\n\n";
 
@@ -584,30 +512,30 @@ void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
   makefileStream << "space:= $(empty) $(empty)\n";
   makefileStream << "spaceplus:= $(empty)\\ $(empty)\n\n";
 
-  for(std::vector<std::string>::const_iterator i = lfiles.begin();
-      i !=  lfiles.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = lfiles.begin();
+       i != lfiles.end(); ++i) {
     makefileStream << "TARGETS += $(subst $(space),$(spaceplus),$(wildcard "
-                   << this->ConvertToRelativeForMake(i->c_str())
-                   << "))\n";
-    }
+                   << this->ConvertToRelativeForMake(i->c_str()) << "))\n";
+  }
 
   std::string checkCache = root->GetBinaryDirectory();
   checkCache += "/";
   checkCache += cmake::GetCMakeFilesDirectoryPostSlash();
   checkCache += "cmake.check_cache";
 
-  makefileStream << "\n" << this->ConvertToRelativeForMake(checkCache.c_str())
+  makefileStream << "\n"
+                 << this->ConvertToRelativeForMake(checkCache.c_str())
                  << ": $(TARGETS)\n";
-  makefileStream << "\t" <<
-    this->ConvertToRelativeForMake(cmSystemTools::GetCMakeCommand().c_str())
-                 << " -H" << this->ConvertToRelativeForMake(
-                   root->GetSourceDirectory())
-                 << " -B" << this->ConvertToRelativeForMake(
-                   root->GetBinaryDirectory()) << "\n";
+  makefileStream << "\t"
+                 << this->ConvertToRelativeForMake(
+                      cmSystemTools::GetCMakeCommand().c_str())
+                 << " -H"
+                 << this->ConvertToRelativeForMake(root->GetSourceDirectory())
+                 << " -B"
+                 << this->ConvertToRelativeForMake(root->GetBinaryDirectory())
+                 << "\n";
 }
 
-
 static bool objectIdLessThan(cmXCodeObject* l, cmXCodeObject* r)
 {
   return l->GetId() < r->GetId();
@@ -622,10 +550,9 @@ void cmGlobalXCodeGenerator::SortXCodeObjects()
 void cmGlobalXCodeGenerator::ClearXCodeObjects()
 {
   this->TargetDoneSet.clear();
-  for(unsigned int i = 0; i < this->XCodeObjects.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->XCodeObjects.size(); ++i) {
     delete this->XCodeObjects[i];
-    }
+  }
   this->XCodeObjects.clear();
   this->XCodeObjectIDs.clear();
   this->XCodeObjectMap.clear();
@@ -635,76 +562,68 @@ void cmGlobalXCodeGenerator::ClearXCodeObjects()
   this->FileRefs.clear();
 }
 
-void cmGlobalXCodeGenerator::addObject(cmXCodeObject *obj)
+void cmGlobalXCodeGenerator::addObject(cmXCodeObject* obj)
 {
-  if(obj->GetType() == cmXCodeObject::OBJECT)
-    {
+  if (obj->GetType() == cmXCodeObject::OBJECT) {
     std::string id = obj->GetId();
 
     // If this is a duplicate id, it's an error:
     //
-    if(this->XCodeObjectIDs.count(id))
-      {
+    if (this->XCodeObjectIDs.count(id)) {
       cmSystemTools::Error(
         "Xcode generator: duplicate object ids not allowed");
-      }
+    }
 
     this->XCodeObjectIDs.insert(id);
-    }
+  }
 
   this->XCodeObjects.push_back(obj);
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateObject(
+  cmXCodeObject::PBXType ptype)
 {
   cmXCodeObject* obj;
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
-    }
-  else
-    {
+  } else {
     obj = new cmXCode21Object(ptype, cmXCodeObject::OBJECT);
-    }
+  }
   this->addObject(obj);
   return obj;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
 {
   cmXCodeObject* obj = new cmXCodeObject(cmXCodeObject::None, type);
   this->addObject(obj);
   return obj;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateString(const std::string& s)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateString(const std::string& s)
 {
   cmXCodeObject* obj = this->CreateObject(cmXCodeObject::STRING);
   obj->SetString(s);
   return obj;
 }
 
-cmXCodeObject* cmGlobalXCodeGenerator
-::CreateObjectReference(cmXCodeObject* ref)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateObjectReference(
+  cmXCodeObject* ref)
 {
   cmXCodeObject* obj = this->CreateObject(cmXCodeObject::OBJECT_REF);
   obj->SetObject(ref);
   return obj;
 }
 
-cmXCodeObject* cmGlobalXCodeGenerator
-::CreateFlatClone(cmXCodeObject* orig)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateFlatClone(cmXCodeObject* orig)
 {
   cmXCodeObject* obj = this->CreateObject(orig->GetType());
   obj->CopyAttributes(orig);
   return obj;
 }
 
-std::string
-GetGroupMapKeyFromPath(cmGeneratorTarget* target, const std::string& fullpath)
+std::string GetGroupMapKeyFromPath(cmGeneratorTarget* target,
+                                   const std::string& fullpath)
 {
   std::string key(target->GetName());
   key += "-";
@@ -712,18 +631,14 @@ GetGroupMapKeyFromPath(cmGeneratorTarget* target, const std::string& fullpath)
   return key;
 }
 
-std::string
-GetGroupMapKey(cmGeneratorTarget* target, cmSourceFile* sf)
+std::string GetGroupMapKey(cmGeneratorTarget* target, cmSourceFile* sf)
 {
   return GetGroupMapKeyFromPath(target, sf->GetFullPath());
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
-  const std::string &fullpath,
-  cmGeneratorTarget* target,
-  const std::string &lang,
-  cmSourceFile* sf)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
+  const std::string& fullpath, cmGeneratorTarget* target,
+  const std::string& lang, cmSourceFile* sf)
 {
   // Using a map and the full path guarantees that we will always get the same
   // fileRef object for any given full path.
@@ -738,168 +653,127 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
   return buildFile;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
-                                              cmSourceFile* sf,
-                                              cmGeneratorTarget* gtgt)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeSourceFile(
+  cmLocalGenerator* lg, cmSourceFile* sf, cmGeneratorTarget* gtgt)
 {
   // Add flags from target and source file properties.
   std::string flags;
   const char* srcfmt = sf->GetProperty("Fortran_FORMAT");
-  switch(this->CurrentLocalGenerator->GetFortranFormat(srcfmt))
-    {
-    case cmLocalGenerator::FortranFormatFixed: flags="-fixed "+flags; break;
-    case cmLocalGenerator::FortranFormatFree: flags="-free "+flags; break;
-    default: break;
-    }
+  switch (this->CurrentLocalGenerator->GetFortranFormat(srcfmt)) {
+    case cmLocalGenerator::FortranFormatFixed:
+      flags = "-fixed " + flags;
+      break;
+    case cmLocalGenerator::FortranFormatFree:
+      flags = "-free " + flags;
+      break;
+    default:
+      break;
+  }
   lg->AppendFlags(flags, sf->GetProperty("COMPILE_FLAGS"));
 
   // Add per-source definitions.
   BuildObjectListOrString flagsBuild(this, false);
-  this->AppendDefines(flagsBuild,
-                      sf->GetProperty("COMPILE_DEFINITIONS"), true);
-  if (!flagsBuild.IsEmpty())
-    {
-    if (!flags.empty())
-      {
+  this->AppendDefines(flagsBuild, sf->GetProperty("COMPILE_DEFINITIONS"),
+                      true);
+  if (!flagsBuild.IsEmpty()) {
+    if (!flags.empty()) {
       flags += ' ';
-      }
-    flags += flagsBuild.GetString();
     }
+    flags += flagsBuild.GetString();
+  }
 
-  std::string lang =
-    this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
+  std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
 
   cmXCodeObject* buildFile =
     this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), gtgt, lang, sf);
   cmXCodeObject* fileRef = buildFile->GetObject("fileRef")->GetObject();
 
-  cmXCodeObject* settings =
-    this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+  cmXCodeObject* settings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   settings->AddAttribute("COMPILER_FLAGS", this->CreateString(flags));
 
   // Is this a resource file in this target? Add it to the resources group...
   //
 
   cmGeneratorTarget::SourceFileFlags tsFlags =
-      gtgt->GetTargetSourceFileFlags(sf);
+    gtgt->GetTargetSourceFileFlags(sf);
   bool isResource = tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource;
 
   // Is this a "private" or "public" framework header file?
   // Set the ATTRIBUTES attribute appropriately...
   //
-  if(gtgt->IsFrameworkOnApple())
-    {
-    if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader)
-      {
+  if (gtgt->IsFrameworkOnApple()) {
+    if (tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) {
       cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
       attrs->AddObject(this->CreateString("Private"));
       settings->AddAttribute("ATTRIBUTES", attrs);
       isResource = true;
-      }
-    else if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader)
-      {
+    } else if (tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader) {
       cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
       attrs->AddObject(this->CreateString("Public"));
       settings->AddAttribute("ATTRIBUTES", attrs);
       isResource = true;
-      }
     }
+  }
 
   // Add the fileRef to the top level Resources group/folder if it is not
   // already there.
   //
-  if(isResource && this->ResourcesGroupChildren &&
-    !this->ResourcesGroupChildren->HasObject(fileRef))
-    {
+  if (isResource && this->ResourcesGroupChildren &&
+      !this->ResourcesGroupChildren->HasObject(fileRef)) {
     this->ResourcesGroupChildren->AddObject(fileRef);
-    }
+  }
 
   buildFile->AddAttribute("settings", settings);
   return buildFile;
 }
 
-std::string
-GetSourcecodeValueFromFileExtension(const std::string& _ext,
-                                    const std::string& lang,
-                                    bool& keepLastKnownFileType)
+std::string GetSourcecodeValueFromFileExtension(const std::string& _ext,
+                                                const std::string& lang,
+                                                bool& keepLastKnownFileType)
 {
   std::string ext = cmSystemTools::LowerCase(_ext);
   std::string sourcecode = "sourcecode";
 
-  if(ext == "o")
-    {
+  if (ext == "o") {
     sourcecode = "compiled.mach-o.objfile";
-    }
-  else if(ext == "xctest")
-    {
+  } else if (ext == "xctest") {
     sourcecode = "wrapper.cfbundle";
-    }
-  else if(ext == "xib")
-    {
+  } else if (ext == "xib") {
     keepLastKnownFileType = true;
     sourcecode = "file.xib";
-    }
-  else if(ext == "storyboard")
-    {
+  } else if (ext == "storyboard") {
     keepLastKnownFileType = true;
     sourcecode = "file.storyboard";
-    }
-  else if(ext == "mm")
-    {
+  } else if (ext == "mm") {
     sourcecode += ".cpp.objcpp";
-    }
-  else if(ext == "m")
-    {
+  } else if (ext == "m") {
     sourcecode += ".c.objc";
-    }
-  else if (ext == "swift")
-    {
+  } else if (ext == "swift") {
     sourcecode += ".swift";
-    }
-  else if(ext == "plist")
-    {
+  } else if (ext == "plist") {
     sourcecode += ".text.plist";
-    }
-  else if(ext == "h")
-    {
+  } else if (ext == "h") {
     sourcecode += ".c.h";
-    }
-  else if(ext == "hxx" || ext == "hpp" || ext == "txx"
-    || ext == "pch" || ext == "hh")
-    {
+  } else if (ext == "hxx" || ext == "hpp" || ext == "txx" || ext == "pch" ||
+             ext == "hh") {
     sourcecode += ".cpp.h";
-    }
-  else if(ext == "png" || ext == "gif" || ext == "jpg")
-    {
+  } else if (ext == "png" || ext == "gif" || ext == "jpg") {
     keepLastKnownFileType = true;
     sourcecode = "image";
-    }
-  else if(ext == "txt")
-    {
+  } else if (ext == "txt") {
     sourcecode += ".text";
-    }
-  else if(lang == "CXX")
-    {
+  } else if (lang == "CXX") {
     sourcecode += ".cpp.cpp";
-    }
-  else if(lang == "C")
-    {
+  } else if (lang == "C") {
     sourcecode += ".c.c";
-    }
-  else if(lang == "Fortran")
-    {
+  } else if (lang == "Fortran") {
     sourcecode += ".fortran.f90";
-    }
-  else if(lang == "ASM")
-    {
+  } else if (lang == "ASM") {
     sourcecode += ".asm";
-    }
-  else if (ext == "metal")
-    {
+  } else if (ext == "metal") {
     sourcecode += ".metal";
-    }
-  //else
+  }
+  // else
   //  {
   //  // Already specialized above or we leave sourcecode == "sourcecode"
   //  // which is probably the most correct choice. Extensionless headers,
@@ -910,111 +784,93 @@ GetSourcecodeValueFromFileExtension(const std::string& _ext,
   return sourcecode;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
-  const std::string &fullpath,
-  cmGeneratorTarget* target,
-  const std::string &lang,
-  cmSourceFile* sf)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
+  const std::string& fullpath, cmGeneratorTarget* target,
+  const std::string& lang, cmSourceFile* sf)
 {
   std::string key = GetGroupMapKeyFromPath(target, fullpath);
   cmXCodeObject* fileRef = this->FileRefs[key];
-  if(!fileRef)
-    {
+  if (!fileRef) {
     fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
     fileRef->SetComment(fullpath);
     this->FileRefs[key] = fileRef;
-    }
+  }
   cmXCodeObject* group = this->GroupMap[key];
   cmXCodeObject* children = group->GetObject("children");
-  if (!children->HasObject(fileRef))
-    {
+  if (!children->HasObject(fileRef)) {
     children->AddObject(fileRef);
-    }
+  }
   fileRef->AddAttribute("fileEncoding", this->CreateString("4"));
 
   bool useLastKnownFileType = false;
   std::string fileType;
-  if(sf)
-    {
-    if(const char* e = sf->GetProperty("XCODE_EXPLICIT_FILE_TYPE"))
-      {
+  if (sf) {
+    if (const char* e = sf->GetProperty("XCODE_EXPLICIT_FILE_TYPE")) {
       fileType = e;
-      }
-    else if(const char* l = sf->GetProperty("XCODE_LAST_KNOWN_FILE_TYPE"))
-      {
+    } else if (const char* l = sf->GetProperty("XCODE_LAST_KNOWN_FILE_TYPE")) {
       useLastKnownFileType = true;
       fileType = l;
-      }
     }
-  if(fileType.empty())
-    {
+  }
+  if (fileType.empty()) {
     // Compute the extension without leading '.'.
     std::string ext = cmSystemTools::GetFilenameLastExtension(fullpath);
-    if(!ext.empty())
-      {
+    if (!ext.empty()) {
       ext = ext.substr(1);
-      }
+    }
 
     // If fullpath references a directory, then we need to specify
     // lastKnownFileType as folder in order for Xcode to be able to
     // open the contents of the folder.
     // (Xcode 4.6 does not like explicitFileType=folder).
-    if(cmSystemTools::FileIsDirectory(fullpath.c_str()))
-      {
-      fileType = (ext == "xcassets"? "folder.assetcatalog" : "folder");
+    if (cmSystemTools::FileIsDirectory(fullpath.c_str())) {
+      fileType = (ext == "xcassets" ? "folder.assetcatalog" : "folder");
       useLastKnownFileType = true;
-      }
-    else
-      {
-      fileType = GetSourcecodeValueFromFileExtension(
-        ext, lang, useLastKnownFileType);
-      }
+    } else {
+      fileType =
+        GetSourcecodeValueFromFileExtension(ext, lang, useLastKnownFileType);
     }
+  }
 
-  fileRef->AddAttribute(useLastKnownFileType? "lastKnownFileType"
-                                            : "explicitFileType",
+  fileRef->AddAttribute(useLastKnownFileType ? "lastKnownFileType"
+                                             : "explicitFileType",
                         this->CreateString(fileType));
 
   // Store the file path relative to the top of the source tree.
   std::string path = this->RelativeToSource(fullpath.c_str());
   std::string name = cmSystemTools::GetFilenameName(path.c_str());
-  const char* sourceTree = (cmSystemTools::FileIsFullPath(path.c_str())?
-                            "<absolute>" : "SOURCE_ROOT");
+  const char* sourceTree =
+    (cmSystemTools::FileIsFullPath(path.c_str()) ? "<absolute>"
+                                                 : "SOURCE_ROOT");
   fileRef->AddAttribute("name", this->CreateString(name));
   fileRef->AddAttribute("path", this->CreateString(path));
   fileRef->AddAttribute("sourceTree", this->CreateString(sourceTree));
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     fileRef->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   return fileRef;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf,
-                                                 cmGeneratorTarget* target)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeFileReference(
+  cmSourceFile* sf, cmGeneratorTarget* target)
 {
-  std::string lang =
-    this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
+  std::string lang = this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
 
-  return this->CreateXCodeFileReferenceFromPath(
-    sf->GetFullPath(), target, lang, sf);
+  return this->CreateXCodeFileReferenceFromPath(sf->GetFullPath(), target,
+                                                lang, sf);
 }
 
 bool cmGlobalXCodeGenerator::SpecialTargetEmitted(std::string const& tname)
 {
-  if(tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
-     tname == "install" || tname == "package" || tname == "RUN_TESTS" ||
-     tname == CMAKE_CHECK_BUILD_SYSTEM_TARGET )
-    {
-    if(this->TargetDoneSet.find(tname) != this->TargetDoneSet.end())
-      {
+  if (tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
+      tname == "install" || tname == "package" || tname == "RUN_TESTS" ||
+      tname == CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
+    if (this->TargetDoneSet.find(tname) != this->TargetDoneSet.end()) {
       return true;
-      }
+    }
     this->TargetDoneSet.insert(tname);
     return false;
-    }
+  }
   return false;
 }
 
@@ -1022,19 +878,17 @@ void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen)
 {
   this->CurrentLocalGenerator = gen;
   this->CurrentMakefile = gen->GetMakefile();
-  std::string outdir =
-    cmSystemTools::CollapseFullPath(this->CurrentLocalGenerator->
-                                    GetCurrentBinaryDirectory());
+  std::string outdir = cmSystemTools::CollapseFullPath(
+    this->CurrentLocalGenerator->GetCurrentBinaryDirectory());
   cmSystemTools::SplitPath(outdir.c_str(),
                            this->CurrentOutputDirectoryComponents);
 
   // Select the current set of configuration types.
   this->CurrentConfigurationTypes.clear();
   this->CurrentMakefile->GetConfigurations(this->CurrentConfigurationTypes);
-  if(this->CurrentConfigurationTypes.empty())
-    {
+  if (this->CurrentConfigurationTypes.empty()) {
     this->CurrentConfigurationTypes.push_back("");
-    }
+  }
 }
 
 struct cmSourceFilePathCompare
@@ -1047,72 +901,61 @@ struct cmSourceFilePathCompare
 
 struct cmCompareTargets
 {
-  bool operator () (std::string const& a, std::string const& b) const
+  bool operator()(std::string const& a, std::string const& b) const
   {
-    if (a == "ALL_BUILD")
-      {
+    if (a == "ALL_BUILD") {
       return true;
-      }
-    if (b == "ALL_BUILD")
-      {
+    }
+    if (b == "ALL_BUILD") {
       return false;
-      }
+    }
     return strcmp(a.c_str(), b.c_str()) < 0;
   }
 };
 
-bool
-cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
-                                           std::vector<cmXCodeObject*>&
-                                           targets)
+bool cmGlobalXCodeGenerator::CreateXCodeTargets(
+  cmLocalGenerator* gen, std::vector<cmXCodeObject*>& targets)
 {
   this->SetCurrentLocalGenerator(gen);
   std::vector<cmGeneratorTarget*> tgts =
-      this->CurrentLocalGenerator->GetGeneratorTargets();
+    this->CurrentLocalGenerator->GetGeneratorTargets();
   typedef std::map<std::string, cmGeneratorTarget*, cmCompareTargets>
-      cmSortedTargets;
+    cmSortedTargets;
   cmSortedTargets sortedTargets;
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); l++)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); l++) {
     sortedTargets[(*l)->GetName()] = *l;
-    }
-  for(cmSortedTargets::iterator l = sortedTargets.begin();
-      l != sortedTargets.end(); l++)
-    {
+  }
+  for (cmSortedTargets::iterator l = sortedTargets.begin();
+       l != sortedTargets.end(); l++) {
     cmGeneratorTarget* gtgt = l->second;
 
     std::string targetName = gtgt->GetName();
 
     // make sure ALL_BUILD, INSTALL, etc are only done once
-    if(this->SpecialTargetEmitted(targetName.c_str()))
-      {
+    if (this->SpecialTargetEmitted(targetName.c_str())) {
       continue;
-      }
+    }
 
-    if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
 
-    if(gtgt->GetType() == cmState::UTILITY ||
-       gtgt->GetType() == cmState::GLOBAL_TARGET)
-      {
+    if (gtgt->GetType() == cmState::UTILITY ||
+        gtgt->GetType() == cmState::GLOBAL_TARGET) {
       cmXCodeObject* t = this->CreateUtilityTarget(gtgt);
-      if (!t)
-        {
+      if (!t) {
         return false;
-        }
+      }
       targets.push_back(t);
       continue;
-      }
+    }
 
     // organize the sources
     std::vector<cmSourceFile*> classes;
-    if (!gtgt->GetConfigCommonSourceFiles(classes))
-      {
+    if (!gtgt->GetConfigCommonSourceFiles(classes)) {
       return false;
-      }
+    }
     std::sort(classes.begin(), classes.end(), cmSourceFilePathCompare());
 
     gtgt->ComputeObjectMapping();
@@ -1121,66 +964,53 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
     std::vector<cmXCodeObject*> headerFiles;
     std::vector<cmXCodeObject*> resourceFiles;
     std::vector<cmXCodeObject*> sourceFiles;
-    for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-        i != classes.end(); ++i)
-      {
+    for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+         i != classes.end(); ++i) {
       cmXCodeObject* xsf =
-        this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
-                                    *i, gtgt);
+        this->CreateXCodeSourceFile(this->CurrentLocalGenerator, *i, gtgt);
       cmXCodeObject* fr = xsf->GetObject("fileRef");
-      cmXCodeObject* filetype =
-        fr->GetObject()->GetObject("explicitFileType");
+      cmXCodeObject* filetype = fr->GetObject()->GetObject("explicitFileType");
 
       cmGeneratorTarget::SourceFileFlags tsFlags =
         gtgt->GetTargetSourceFileFlags(*i);
 
-      if(filetype &&
-         filetype->GetString() == "compiled.mach-o.objfile")
-        {
-        if ((*i)->GetObjectLibrary().empty())
-          {
+      if (filetype && filetype->GetString() == "compiled.mach-o.objfile") {
+        if ((*i)->GetObjectLibrary().empty()) {
           externalObjFiles.push_back(xsf);
-          }
         }
-      else if(this->IsHeaderFile(*i) ||
-        (tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) ||
-        (tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader))
-        {
+      } else if (this->IsHeaderFile(*i) ||
+                 (tsFlags.Type ==
+                  cmGeneratorTarget::SourceFileTypePrivateHeader) ||
+                 (tsFlags.Type ==
+                  cmGeneratorTarget::SourceFileTypePublicHeader)) {
         headerFiles.push_back(xsf);
-        }
-      else if(tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource)
-        {
+      } else if (tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource) {
         resourceFiles.push_back(xsf);
-        }
-      else if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY"))
-        {
+      } else if (!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY")) {
         // Include this file in the build if it has a known language
         // and has not been listed as an ignored extension for this
         // generator.
-        if(!this->CurrentLocalGenerator->GetSourceFileLanguage(**i).empty() &&
-           !this->IgnoreFile((*i)->GetExtension().c_str()))
-          {
+        if (!this->CurrentLocalGenerator->GetSourceFileLanguage(**i).empty() &&
+            !this->IgnoreFile((*i)->GetExtension().c_str())) {
           sourceFiles.push_back(xsf);
-          }
         }
       }
+    }
 
-    if(this->XcodeVersion < 50)
-      {
+    if (this->XcodeVersion < 50) {
       // Add object library contents as external objects. (Equivalent to
       // the externalObjFiles above, except each one is not a cmSourceFile
       // within the target.)
       std::vector<std::string> objs;
       gtgt->UseObjectLibraries(objs, "");
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         std::string obj = *oi;
         cmXCodeObject* xsf =
           this->CreateXCodeSourceFileFromPath(obj, gtgt, "", 0);
         externalObjFiles.push_back(xsf);
-        }
       }
+    }
 
     // some build phases only apply to bundles and/or frameworks
     bool isFrameworkTarget = gtgt->IsFrameworkOnApple();
@@ -1191,126 +1021,110 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
 
     // create source build phase
     cmXCodeObject* sourceBuildPhase = 0;
-    if (!sourceFiles.empty())
-      {
+    if (!sourceFiles.empty()) {
       sourceBuildPhase =
         this->CreateObject(cmXCodeObject::PBXSourcesBuildPhase);
       sourceBuildPhase->SetComment("Sources");
       sourceBuildPhase->AddAttribute("buildActionMask",
                                      this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<cmXCodeObject*>::iterator i = sourceFiles.begin();
-          i != sourceFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = sourceFiles.begin();
+           i != sourceFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       sourceBuildPhase->AddAttribute("files", buildFiles);
       sourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                      this->CreateString("0"));
-      }
+    }
 
     // create header build phase - only for framework targets
     cmXCodeObject* headerBuildPhase = 0;
-    if (!headerFiles.empty() && isFrameworkTarget)
-      {
+    if (!headerFiles.empty() && isFrameworkTarget) {
       headerBuildPhase =
         this->CreateObject(cmXCodeObject::PBXHeadersBuildPhase);
       headerBuildPhase->SetComment("Headers");
       headerBuildPhase->AddAttribute("buildActionMask",
                                      this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<cmXCodeObject*>::iterator i = headerFiles.begin();
-          i != headerFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = headerFiles.begin();
+           i != headerFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       headerBuildPhase->AddAttribute("files", buildFiles);
       headerBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                      this->CreateString("0"));
-      }
+    }
 
     // create resource build phase - only for framework or bundle targets
     cmXCodeObject* resourceBuildPhase = 0;
     if (!resourceFiles.empty() &&
-        (isFrameworkTarget || isBundleTarget || isCFBundleTarget))
-      {
+        (isFrameworkTarget || isBundleTarget || isCFBundleTarget)) {
       resourceBuildPhase =
         this->CreateObject(cmXCodeObject::PBXResourcesBuildPhase);
       resourceBuildPhase->SetComment("Resources");
       resourceBuildPhase->AddAttribute("buildActionMask",
                                        this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<cmXCodeObject*>::iterator i = resourceFiles.begin();
-          i != resourceFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = resourceFiles.begin();
+           i != resourceFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       resourceBuildPhase->AddAttribute("files", buildFiles);
       resourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
-                                     this->CreateString("0"));
-      }
+                                       this->CreateString("0"));
+    }
 
     // create vector of "non-resource content file" build phases - only for
     // framework or bundle targets
     std::vector<cmXCodeObject*> contentBuildPhases;
-    if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
-      {
+    if (isFrameworkTarget || isBundleTarget || isCFBundleTarget) {
       typedef std::map<std::string, std::vector<cmSourceFile*> >
         mapOfVectorOfSourceFiles;
       mapOfVectorOfSourceFiles bundleFiles;
-      for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-          i != classes.end(); ++i)
-        {
+      for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+           i != classes.end(); ++i) {
         cmGeneratorTarget::SourceFileFlags tsFlags =
           gtgt->GetTargetSourceFileFlags(*i);
-        if(tsFlags.Type == cmGeneratorTarget::SourceFileTypeMacContent)
-          {
+        if (tsFlags.Type == cmGeneratorTarget::SourceFileTypeMacContent) {
           bundleFiles[tsFlags.MacFolder].push_back(*i);
-          }
         }
+      }
       mapOfVectorOfSourceFiles::iterator mit;
-      for ( mit = bundleFiles.begin(); mit != bundleFiles.end(); ++ mit )
-        {
+      for (mit = bundleFiles.begin(); mit != bundleFiles.end(); ++mit) {
         cmXCodeObject* copyFilesBuildPhase =
           this->CreateObject(cmXCodeObject::PBXCopyFilesBuildPhase);
         copyFilesBuildPhase->SetComment("Copy files");
         copyFilesBuildPhase->AddAttribute("buildActionMask",
-          this->CreateString("2147483647"));
+                                          this->CreateString("2147483647"));
         copyFilesBuildPhase->AddAttribute("dstSubfolderSpec",
-          this->CreateString("6"));
+                                          this->CreateString("6"));
         std::ostringstream ostr;
-        if (gtgt->IsFrameworkOnApple())
-          {
+        if (gtgt->IsFrameworkOnApple()) {
           // dstPath in frameworks is relative to Versions/<version>
           ostr << mit->first;
-          }
-        else if ( mit->first != "MacOS" )
-          {
+        } else if (mit->first != "MacOS") {
           // dstPath in bundles is relative to Contents/MacOS
           ostr << "../" << mit->first.c_str();
-          }
+        }
         copyFilesBuildPhase->AddAttribute("dstPath",
-          this->CreateString(ostr.str()));
-        copyFilesBuildPhase->AddAttribute(
-          "runOnlyForDeploymentPostprocessing", this->CreateString("0"));
+                                          this->CreateString(ostr.str()));
+        copyFilesBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+                                          this->CreateString("0"));
         buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
         copyFilesBuildPhase->AddAttribute("files", buildFiles);
         std::vector<cmSourceFile*>::iterator sfIt;
-        for ( sfIt = mit->second.begin(); sfIt != mit->second.end(); ++ sfIt )
-          {
-          cmXCodeObject* xsf =
-            this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
-                                        *sfIt, gtgt);
+        for (sfIt = mit->second.begin(); sfIt != mit->second.end(); ++sfIt) {
+          cmXCodeObject* xsf = this->CreateXCodeSourceFile(
+            this->CurrentLocalGenerator, *sfIt, gtgt);
           buildFiles->AddObject(xsf);
-          }
-        contentBuildPhases.push_back(copyFilesBuildPhase);
         }
+        contentBuildPhases.push_back(copyFilesBuildPhase);
       }
+    }
 
     // create framework build phase
     cmXCodeObject* frameworkBuildPhase = 0;
-    if (!externalObjFiles.empty())
-      {
+    if (!externalObjFiles.empty()) {
       frameworkBuildPhase =
         this->CreateObject(cmXCodeObject::PBXFrameworksBuildPhase);
       frameworkBuildPhase->SetComment("Frameworks");
@@ -1318,66 +1132,63 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
                                         this->CreateString("2147483647"));
       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
       frameworkBuildPhase->AddAttribute("files", buildFiles);
-      for(std::vector<cmXCodeObject*>::iterator i =  externalObjFiles.begin();
-          i != externalObjFiles.end(); ++i)
-        {
+      for (std::vector<cmXCodeObject*>::iterator i = externalObjFiles.begin();
+           i != externalObjFiles.end(); ++i) {
         buildFiles->AddObject(*i);
-        }
+      }
       frameworkBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                         this->CreateString("0"));
-      }
+    }
 
     // create list of build phases and create the Xcode target
     cmXCodeObject* buildPhases =
       this->CreateObject(cmXCodeObject::OBJECT_LIST);
 
-    this->CreateCustomCommands(buildPhases, sourceBuildPhase,
-                               headerBuildPhase, resourceBuildPhase,
-                               contentBuildPhases,
+    this->CreateCustomCommands(buildPhases, sourceBuildPhase, headerBuildPhase,
+                               resourceBuildPhase, contentBuildPhases,
                                frameworkBuildPhase, gtgt);
 
     targets.push_back(this->CreateXCodeTarget(gtgt, buildPhases));
-    }
+  }
   return true;
 }
 
 void cmGlobalXCodeGenerator::ForceLinkerLanguages()
 {
-  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();
     // All targets depend on the build-system check target.
-    for(std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin();
-        ti != tgts.end(); ++ti)
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator ti = tgts.begin();
+         ti != tgts.end(); ++ti) {
       // This makes sure all targets link using the proper language.
       this->ForceLinkerLanguage(*ti);
-      }
     }
+  }
 }
 
 void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt)
 {
   // This matters only for targets that link.
-  if(gtgt->GetType() != cmState::EXECUTABLE &&
-     gtgt->GetType() != cmState::SHARED_LIBRARY &&
-     gtgt->GetType() != cmState::MODULE_LIBRARY)
-    {
+  if (gtgt->GetType() != cmState::EXECUTABLE &&
+      gtgt->GetType() != cmState::SHARED_LIBRARY &&
+      gtgt->GetType() != cmState::MODULE_LIBRARY) {
     return;
-    }
+  }
 
   std::string llang = gtgt->GetLinkerLanguage("NOCONFIG");
-  if(llang.empty()) { return; }
+  if (llang.empty()) {
+    return;
+  }
 
   // If the language is compiled as a source trust Xcode to link with it.
-  cmLinkImplementation const* impl =
-    gtgt->GetLinkImplementation("NOCONFIG");
-  for(std::vector<std::string>::const_iterator li = impl->Languages.begin();
-      li != impl->Languages.end(); ++li)
-    {
-    if(*li == llang) { return; }
+  cmLinkImplementation const* impl = gtgt->GetLinkImplementation("NOCONFIG");
+  for (std::vector<std::string>::const_iterator li = impl->Languages.begin();
+       li != impl->Languages.end(); ++li) {
+    if (*li == llang) {
+      return;
     }
+  }
 
   // Add an empty source file to the target that compiles with the
   // linker language.  This should convince Xcode to choose the proper
@@ -1391,14 +1202,13 @@ void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmGeneratorTarget* gtgt)
   fname += ".";
   fname += cmSystemTools::LowerCase(llang);
   {
-  cmGeneratedFileStream fout(fname.c_str());
-  fout << "\n";
+    cmGeneratedFileStream fout(fname.c_str());
+    fout << "\n";
   }
-  if(cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str()))
-    {
+  if (cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str())) {
     sf->SetProperty("LANGUAGE", llang.c_str());
     gtgt->AddSource(fname);
-    }
+  }
 }
 
 bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf)
@@ -1409,57 +1219,39 @@ bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf)
           hdrExts.end());
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateBuildPhase(const char* name,
-                                         const char* name2,
-                                         cmGeneratorTarget* target,
-                                         const std::vector<cmCustomCommand>&
-                                         commands)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateBuildPhase(
+  const char* name, const char* name2, cmGeneratorTarget* target,
+  const std::vector<cmCustomCommand>& commands)
 {
-  if(commands.size() == 0 && strcmp(name, "CMake ReRun") != 0)
-    {
+  if (commands.size() == 0 && strcmp(name, "CMake ReRun") != 0) {
     return 0;
-    }
+  }
   cmXCodeObject* buildPhase =
     this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
   buildPhase->AddAttribute("buildActionMask",
                            this->CreateString("2147483647"));
   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   buildPhase->AddAttribute("files", buildFiles);
-  buildPhase->AddAttribute("name",
-                           this->CreateString(name));
+  buildPhase->AddAttribute("name", this->CreateString(name));
   buildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                            this->CreateString("0"));
-  buildPhase->AddAttribute("shellPath",
-                           this->CreateString("/bin/sh"));
-  this->AddCommandsToBuildPhase(buildPhase, target, commands,
-                                name2);
+  buildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
+  this->AddCommandsToBuildPhase(buildPhase, target, commands, name2);
   return buildPhase;
 }
 
-void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
-                                                  cmXCodeObject*
-                                                  sourceBuildPhase,
-                                                  cmXCodeObject*
-                                                  headerBuildPhase,
-                                                  cmXCodeObject*
-                                                  resourceBuildPhase,
-                                                  std::vector<cmXCodeObject*>
-                                                  contentBuildPhases,
-                                                  cmXCodeObject*
-                                                  frameworkBuildPhase,
-                                                  cmGeneratorTarget* gtgt)
-{
-  std::vector<cmCustomCommand> const & prebuild
-    = gtgt->GetPreBuildCommands();
-  std::vector<cmCustomCommand> const & prelink
-    = gtgt->GetPreLinkCommands();
-  std::vector<cmCustomCommand> postbuild
-    = gtgt->GetPostBuildCommands();
-
-  if(gtgt->GetType() == cmState::SHARED_LIBRARY &&
-    !gtgt->IsFrameworkOnApple())
-    {
+void cmGlobalXCodeGenerator::CreateCustomCommands(
+  cmXCodeObject* buildPhases, cmXCodeObject* sourceBuildPhase,
+  cmXCodeObject* headerBuildPhase, cmXCodeObject* resourceBuildPhase,
+  std::vector<cmXCodeObject*> contentBuildPhases,
+  cmXCodeObject* frameworkBuildPhase, cmGeneratorTarget* gtgt)
+{
+  std::vector<cmCustomCommand> const& prebuild = gtgt->GetPreBuildCommands();
+  std::vector<cmCustomCommand> const& prelink = gtgt->GetPreLinkCommands();
+  std::vector<cmCustomCommand> postbuild = gtgt->GetPostBuildCommands();
+
+  if (gtgt->GetType() == cmState::SHARED_LIBRARY &&
+      !gtgt->IsFrameworkOnApple()) {
     cmCustomCommandLines cmd;
     cmd.resize(1);
     cmd[0].push_back(cmSystemTools::GetCMakeCommand());
@@ -1478,92 +1270,72 @@ void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
     cmd[0].push_back(str_so_file);
     cmd[0].push_back(str_link_file);
 
-    cmCustomCommand command(this->CurrentMakefile,
-      std::vector<std::string>(),
-      std::vector<std::string>(),
-      std::vector<std::string>(),
-      cmd,
-      "Creating symlinks",
-      "");
+    cmCustomCommand command(this->CurrentMakefile, std::vector<std::string>(),
+                            std::vector<std::string>(),
+                            std::vector<std::string>(), cmd,
+                            "Creating symlinks", "");
 
     postbuild.push_back(command);
-    }
+  }
 
   std::vector<cmSourceFile*> classes;
-  if (!gtgt->GetConfigCommonSourceFiles(classes))
-    {
+  if (!gtgt->GetConfigCommonSourceFiles(classes)) {
     return;
-    }
+  }
   // add all the sources
   std::vector<cmCustomCommand> commands;
-  for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-      i != classes.end(); ++i)
-    {
-    if((*i)->GetCustomCommand())
-      {
+  for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+       i != classes.end(); ++i) {
+    if ((*i)->GetCustomCommand()) {
       commands.push_back(*(*i)->GetCustomCommand());
-      }
     }
+  }
   // create prebuild phase
-  cmXCodeObject* cmakeRulesBuildPhase =
-    this->CreateBuildPhase("CMake Rules",
-                           "cmakeRulesBuildPhase",
-                           gtgt, commands);
+  cmXCodeObject* cmakeRulesBuildPhase = this->CreateBuildPhase(
+    "CMake Rules", "cmakeRulesBuildPhase", gtgt, commands);
   // create prebuild phase
-  cmXCodeObject* preBuildPhase =
-    this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands",
-                           gtgt, prebuild);
+  cmXCodeObject* preBuildPhase = this->CreateBuildPhase(
+    "CMake PreBuild Rules", "preBuildCommands", gtgt, prebuild);
   // create prelink phase
-  cmXCodeObject* preLinkPhase =
-    this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands",
-                           gtgt, prelink);
+  cmXCodeObject* preLinkPhase = this->CreateBuildPhase(
+    "CMake PreLink Rules", "preLinkCommands", gtgt, prelink);
   // create postbuild phase
-  cmXCodeObject* postBuildPhase =
-    this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase",
-                           gtgt, postbuild);
+  cmXCodeObject* postBuildPhase = this->CreateBuildPhase(
+    "CMake PostBuild Rules", "postBuildPhase", gtgt, postbuild);
 
   // The order here is the order they will be built in.
   // The order "headers, resources, sources" mimics a native project generated
   // from an xcode template...
   //
-  if(preBuildPhase)
-    {
+  if (preBuildPhase) {
     buildPhases->AddObject(preBuildPhase);
-    }
-  if(cmakeRulesBuildPhase)
-    {
+  }
+  if (cmakeRulesBuildPhase) {
     buildPhases->AddObject(cmakeRulesBuildPhase);
-    }
-  if(headerBuildPhase)
-    {
+  }
+  if (headerBuildPhase) {
     buildPhases->AddObject(headerBuildPhase);
-    }
-  if(resourceBuildPhase)
-    {
+  }
+  if (resourceBuildPhase) {
     buildPhases->AddObject(resourceBuildPhase);
-    }
+  }
   std::vector<cmXCodeObject*>::iterator cit;
   for (cit = contentBuildPhases.begin(); cit != contentBuildPhases.end();
-       ++cit)
-    {
+       ++cit) {
     buildPhases->AddObject(*cit);
-    }
-  if(sourceBuildPhase)
-    {
+  }
+  if (sourceBuildPhase) {
     buildPhases->AddObject(sourceBuildPhase);
-    }
-  if(preLinkPhase)
-    {
+  }
+  if (preLinkPhase) {
     buildPhases->AddObject(preLinkPhase);
-    }
-  if(frameworkBuildPhase)
-    {
+  }
+  if (frameworkBuildPhase) {
     buildPhases->AddObject(frameworkBuildPhase);
-    }
-  if(postBuildPhase)
-    {
+  }
+  if (postBuildPhase) {
     buildPhases->AddObject(postBuildPhase);
-    }
+  }
 }
 
 // This function removes each occurrence of the flag and returns the last one
@@ -1574,28 +1346,25 @@ std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag,
   std::string retFlag;
   std::string::size_type lastOccurancePos = flags.rfind(flag);
   bool saved = false;
-  while(lastOccurancePos != flags.npos)
-    {
-    //increment pos, we use lastOccurancePos to reduce search space on next inc
+  while (lastOccurancePos != flags.npos) {
+    // increment pos, we use lastOccurancePos to reduce search space on next
+    // inc
     std::string::size_type pos = lastOccurancePos;
-    if(pos == 0 || flags[pos-1]==' ')
-      {
-      while(pos < flags.size() && flags[pos] != ' ')
-        {
-        if(!saved)
-          {
+    if (pos == 0 || flags[pos - 1] == ' ') {
+      while (pos < flags.size() && flags[pos] != ' ') {
+        if (!saved) {
           retFlag += flags[pos];
-          }
+        }
         flags[pos] = ' ';
         pos++;
-        }
-      saved = true;
       }
-    //decrement lastOccurancePos while making sure we don't loop around
-    //and become a very large positive number since size_type is unsigned
-    lastOccurancePos = lastOccurancePos == 0 ? 0 : lastOccurancePos-1;
-    lastOccurancePos = flags.rfind(flag,lastOccurancePos);
+      saved = true;
     }
+    // decrement lastOccurancePos while making sure we don't loop around
+    // and become a very large positive number since size_type is unsigned
+    lastOccurancePos = lastOccurancePos == 0 ? 0 : lastOccurancePos - 1;
+    lastOccurancePos = flags.rfind(flag, lastOccurancePos);
+  }
   return retFlag;
 }
 
@@ -1609,15 +1378,13 @@ std::string cmGlobalXCodeGenerator::ExtractFlagRegex(const char* exp,
 
   cmsys::RegularExpression regex(exp);
   assert(regex.is_valid());
-  if(!regex.is_valid())
-    {
+  if (!regex.is_valid()) {
     return retFlag;
-    }
+  }
 
   std::string::size_type offset = 0;
 
-  while(regex.find(flags.c_str() + offset))
-    {
+  while (regex.find(flags.c_str() + offset)) {
     const std::string::size_type startPos = offset + regex.start(matchIndex);
     const std::string::size_type endPos = offset + regex.end(matchIndex);
     const std::string::size_type size = endPos - startPos;
@@ -1626,57 +1393,47 @@ std::string cmGlobalXCodeGenerator::ExtractFlagRegex(const char* exp,
 
     retFlag.assign(flags, startPos, size);
     flags.replace(startPos, size, size, ' ');
-    }
+  }
 
   return retFlag;
 }
 
- //----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
 // This function strips off Xcode attributes that do not target the current
 // configuration
-void
-cmGlobalXCodeGenerator
-::FilterConfigurationAttribute(std::string const& configName,
-                               std::string& attribute)
+void cmGlobalXCodeGenerator::FilterConfigurationAttribute(
+  std::string const& configName, std::string& attribute)
 {
   // Handle [variant=<config>] condition explicitly here.
   std::string::size_type beginVariant = attribute.find("[variant=");
-  if (beginVariant == std::string::npos)
-    {
+  if (beginVariant == std::string::npos) {
     // There is no variant in this attribute.
     return;
-    }
+  }
 
-  std::string::size_type endVariant = attribute.find("]", beginVariant+9);
-  if (endVariant == std::string::npos)
-    {
+  std::string::size_type endVariant = attribute.find("]", beginVariant + 9);
+  if (endVariant == std::string::npos) {
     // There is no terminating bracket.
     return;
-    }
+  }
 
   // Compare the variant to the configuration.
   std::string variant =
-    attribute.substr(beginVariant+9, endVariant-beginVariant-9);
-  if (variant == configName)
-    {
+    attribute.substr(beginVariant + 9, endVariant - beginVariant - 9);
+  if (variant == configName) {
     // The variant matches the configuration so use this
     // attribute but drop the [variant=<config>] condition.
-    attribute.erase(beginVariant, endVariant-beginVariant+1);
-    }
-  else
-    {
+    attribute.erase(beginVariant, endVariant - beginVariant + 1);
+  } else {
     // The variant does not match the configuration so
     // do not use this attribute.
     attribute.clear();
-    }
+  }
 }
 
-void
-cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
-                                                cmGeneratorTarget* target,
-                                                std::vector<cmCustomCommand>
-                                                const & commands,
-                                                const char* name)
+void cmGlobalXCodeGenerator::AddCommandsToBuildPhase(
+  cmXCodeObject* buildphase, cmGeneratorTarget* target,
+  std::vector<cmCustomCommand> const& commands, const char* name)
 {
   std::string dir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
   dir += "/CMakeScripts";
@@ -1688,180 +1445,150 @@ cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
   makefile += name;
   makefile += ".make";
 
-  for (std::vector<std::string>::const_iterator currentConfig=
-            this->CurrentConfigurationTypes.begin();
-       currentConfig!=this->CurrentConfigurationTypes.end();
-       currentConfig++ )
-    {
-    this->CreateCustomRulesMakefile(makefile.c_str(),
-                                    target,
-                                    commands,
+  for (std::vector<std::string>::const_iterator currentConfig =
+         this->CurrentConfigurationTypes.begin();
+       currentConfig != this->CurrentConfigurationTypes.end();
+       currentConfig++) {
+    this->CreateCustomRulesMakefile(makefile.c_str(), target, commands,
                                     currentConfig->c_str());
-    }
+  }
 
   std::string cdir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
   cdir = this->ConvertToRelativeForMake(cdir.c_str());
   std::string makecmd = "make -C ";
   makecmd += cdir;
   makecmd += " -f ";
-  makecmd += this->ConvertToRelativeForMake(
-                                          (makefile+"$CONFIGURATION").c_str());
+  makecmd +=
+    this->ConvertToRelativeForMake((makefile + "$CONFIGURATION").c_str());
   makecmd += " all";
-  buildphase->AddAttribute("shellScript",
-                           this->CreateString(makecmd));
-  buildphase->AddAttribute("showEnvVarsInLog",
-                           this->CreateString("0"));
+  buildphase->AddAttribute("shellScript", this->CreateString(makecmd));
+  buildphase->AddAttribute("showEnvVarsInLog", this->CreateString("0"));
 }
 
-void  cmGlobalXCodeGenerator
-::CreateCustomRulesMakefile(const char* makefileBasename,
-                            cmGeneratorTarget* target,
-                            std::vector<cmCustomCommand>
-                            const & commands,
-                            const std::string& configName)
+void cmGlobalXCodeGenerator::CreateCustomRulesMakefile(
+  const char* makefileBasename, cmGeneratorTarget* target,
+  std::vector<cmCustomCommand> const& commands, const std::string& configName)
 {
-  std::string makefileName=makefileBasename;
-  if(this->XcodeVersion > 20)
-    {
-    makefileName+=configName;
-    }
+  std::string makefileName = makefileBasename;
+  if (this->XcodeVersion > 20) {
+    makefileName += configName;
+  }
   cmGeneratedFileStream makefileStream(makefileName.c_str());
-  if(!makefileStream)
-    {
+  if (!makefileStream) {
     return;
-    }
+  }
   makefileStream.SetCopyIfDifferent(true);
   makefileStream << "# Generated by CMake, DO NOT EDIT\n";
   makefileStream << "# Custom rules for " << target->GetName() << "\n";
 
   // disable the implicit rules
-  makefileStream << ".SUFFIXES: " << "\n";
+  makefileStream << ".SUFFIXES: "
+                 << "\n";
 
   // have all depend on all outputs
   makefileStream << "all: ";
   std::map<const cmCustomCommand*, std::string> tname;
   int count = 0;
-  for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+       i != commands.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, configName, this->CurrentLocalGenerator);
-    if(ccg.GetNumberOfCommands() > 0)
-      {
+    if (ccg.GetNumberOfCommands() > 0) {
       const std::vector<std::string>& outputs = ccg.GetOutputs();
-      if(!outputs.empty())
-        {
-        for(std::vector<std::string>::const_iterator o = outputs.begin();
-            o != outputs.end(); ++o)
-          {
-          makefileStream
-              << "\\\n\t" << this->ConvertToRelativeForMake(o->c_str());
-          }
+      if (!outputs.empty()) {
+        for (std::vector<std::string>::const_iterator o = outputs.begin();
+             o != outputs.end(); ++o) {
+          makefileStream << "\\\n\t"
+                         << this->ConvertToRelativeForMake(o->c_str());
         }
-      else
-        {
+      } else {
         std::ostringstream str;
-        str << "_buildpart_" << count++ ;
+        str << "_buildpart_" << count++;
         tname[&ccg.GetCC()] = std::string(target->GetName()) + str.str();
         makefileStream << "\\\n\t" << tname[&ccg.GetCC()];
-        }
       }
     }
+  }
   makefileStream << "\n\n";
-  for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+       i != commands.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, configName, this->CurrentLocalGenerator);
-    if(ccg.GetNumberOfCommands() > 0)
-      {
+    if (ccg.GetNumberOfCommands() > 0) {
       makefileStream << "\n";
       const std::vector<std::string>& outputs = ccg.GetOutputs();
-      if(!outputs.empty())
-        {
+      if (!outputs.empty()) {
         // There is at least one output, start the rule for it
         const char* sep = "";
-        for(std::vector<std::string>::const_iterator oi = outputs.begin();
-            oi != outputs.end(); ++oi)
-          {
-          makefileStream << sep <<
-            this->ConvertToRelativeForMake(oi->c_str());
+        for (std::vector<std::string>::const_iterator oi = outputs.begin();
+             oi != outputs.end(); ++oi) {
+          makefileStream << sep << this->ConvertToRelativeForMake(oi->c_str());
           sep = " ";
-          }
-        makefileStream << ": ";
         }
-      else
-        {
+        makefileStream << ": ";
+      } else {
         // There are no outputs.  Use the generated force rule name.
         makefileStream << tname[&ccg.GetCC()] << ": ";
-        }
-      for(std::vector<std::string>::const_iterator d =
-          ccg.GetDepends().begin();
-          d != ccg.GetDepends().end(); ++d)
-        {
+      }
+      for (std::vector<std::string>::const_iterator d =
+             ccg.GetDepends().begin();
+           d != ccg.GetDepends().end(); ++d) {
         std::string dep;
-        if(this->CurrentLocalGenerator
-           ->GetRealDependency(d->c_str(), configName, dep))
-          {
-          makefileStream << "\\\n" <<
-            this->ConvertToRelativeForMake(dep.c_str());
-          }
+        if (this->CurrentLocalGenerator->GetRealDependency(d->c_str(),
+                                                           configName, dep)) {
+          makefileStream << "\\\n"
+                         << this->ConvertToRelativeForMake(dep.c_str());
         }
+      }
       makefileStream << "\n";
 
-      if(const char* comment = ccg.GetComment())
-        {
+      if (const char* comment = ccg.GetComment()) {
         std::string echo_cmd = "echo ";
-        echo_cmd += (this->CurrentLocalGenerator->
-          EscapeForShell(comment, ccg.GetCC().GetEscapeAllowMakeVars()));
+        echo_cmd += (this->CurrentLocalGenerator->EscapeForShell(
+          comment, ccg.GetCC().GetEscapeAllowMakeVars()));
         makefileStream << "\t" << echo_cmd.c_str() << "\n";
-        }
+      }
 
       // Add each command line to the set of commands.
-      for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-        {
+      for (unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) {
         // Build the command line in a single string.
         std::string cmd2 = ccg.GetCommand(c);
         cmSystemTools::ReplaceString(cmd2, "/./", "/");
         cmd2 = this->ConvertToRelativeForMake(cmd2.c_str());
         std::string cmd;
         std::string wd = ccg.GetWorkingDirectory();
-        if(!wd.empty())
-          {
+        if (!wd.empty()) {
           cmd += "cd ";
           cmd += this->ConvertToRelativeForMake(wd.c_str());
           cmd += " && ";
-          }
+        }
         cmd += cmd2;
         ccg.AppendArguments(c, cmd);
         makefileStream << "\t" << cmd.c_str() << "\n";
-        }
       }
     }
+  }
 }
 
 void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
-                                                cmXCodeObject* buildSettings,
-                                                const std::string& configName)
+                                                 cmXCodeObject* buildSettings,
+                                                 const std::string& configName)
 {
-  if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
+  }
 
   std::string defFlags;
   bool shared = ((gtgt->GetType() == cmState::SHARED_LIBRARY) ||
                  (gtgt->GetType() == cmState::MODULE_LIBRARY));
   bool binary = ((gtgt->GetType() == cmState::OBJECT_LIBRARY) ||
                  (gtgt->GetType() == cmState::STATIC_LIBRARY) ||
-                 (gtgt->GetType() == cmState::EXECUTABLE) ||
-                 shared);
+                 (gtgt->GetType() == cmState::EXECUTABLE) || shared);
 
   // Compute the compilation flags for each language.
   std::set<std::string> languages;
   gtgt->GetLanguages(languages, configName);
   std::map<std::string, std::string> cflags;
   for (std::set<std::string>::iterator li = languages.begin();
-       li != languages.end(); ++li)
-    {
+       li != languages.end(); ++li) {
     std::string const& lang = *li;
     std::string& flags = cflags[lang];
 
@@ -1869,126 +1596,97 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
 
     // Add shared-library flags if needed.
-    this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt,
-                                                 lang, configName);
+    this->CurrentLocalGenerator->AddCMP0018Flags(flags, gtgt, lang,
+                                                 configName);
 
-    this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt,
-                                                   lang);
+    this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, gtgt, lang);
 
-    this->CurrentLocalGenerator->
-      AddCompileOptions(flags, gtgt, lang, configName);
-    }
+    this->CurrentLocalGenerator->AddCompileOptions(flags, gtgt, lang,
+                                                   configName);
+  }
 
   std::string llang = gtgt->GetLinkerLanguage(configName);
-  if(binary && llang.empty())
-    {
-    cmSystemTools::Error
-      ("CMake can not determine linker language for target: ",
-       gtgt->GetName().c_str());
+  if (binary && llang.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      gtgt->GetName().c_str());
     return;
-    }
+  }
 
   // Add define flags
-  this->CurrentLocalGenerator->
-    AppendFlags(defFlags,
-                this->CurrentMakefile->GetDefineFlags());
+  this->CurrentLocalGenerator->AppendFlags(
+    defFlags, this->CurrentMakefile->GetDefineFlags());
 
   // Add preprocessor definitions for this target and configuration.
   BuildObjectListOrString ppDefs(this, this->XcodeVersion >= 30);
-  if(this->XcodeVersion > 15)
-    {
-    this->AppendDefines(ppDefs,
-      "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
-    }
-  if(const char* exportMacro = gtgt->GetExportMacro())
-    {
+  if (this->XcodeVersion > 15) {
+    this->AppendDefines(
+      ppDefs, "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
+  }
+  if (const char* exportMacro = gtgt->GetExportMacro()) {
     // Add the export symbol definition for shared library objects.
     this->AppendDefines(ppDefs, exportMacro);
-    }
+  }
   std::vector<std::string> targetDefines;
   gtgt->GetCompileDefinitions(targetDefines, configName, "C");
   this->AppendDefines(ppDefs, targetDefines);
-  buildSettings->AddAttribute
-    ("GCC_PREPROCESSOR_DEFINITIONS", ppDefs.CreateList());
+  buildSettings->AddAttribute("GCC_PREPROCESSOR_DEFINITIONS",
+                              ppDefs.CreateList());
 
   std::string extraLinkOptionsVar;
   std::string extraLinkOptions;
-  if(gtgt->GetType() == cmState::EXECUTABLE)
-    {
+  if (gtgt->GetType() == cmState::EXECUTABLE) {
     extraLinkOptionsVar = "CMAKE_EXE_LINKER_FLAGS";
-    }
-  else if(gtgt->GetType() == cmState::SHARED_LIBRARY)
-    {
+  } else if (gtgt->GetType() == cmState::SHARED_LIBRARY) {
     extraLinkOptionsVar = "CMAKE_SHARED_LINKER_FLAGS";
-    }
-  else if(gtgt->GetType() == cmState::MODULE_LIBRARY)
-    {
+  } else if (gtgt->GetType() == cmState::MODULE_LIBRARY) {
     extraLinkOptionsVar = "CMAKE_MODULE_LINKER_FLAGS";
-    }
-  if(!extraLinkOptionsVar.empty())
-    {
-    this->CurrentLocalGenerator
-      ->AddConfigVariableFlags(extraLinkOptions,
-                               extraLinkOptionsVar.c_str(),
-                               configName);
-    }
+  }
+  if (!extraLinkOptionsVar.empty()) {
+    this->CurrentLocalGenerator->AddConfigVariableFlags(
+      extraLinkOptions, extraLinkOptionsVar.c_str(), configName);
+  }
 
-  if(gtgt->GetType() == cmState::OBJECT_LIBRARY ||
-     gtgt->GetType() == cmState::STATIC_LIBRARY)
-    {
-    this->CurrentLocalGenerator
-      ->GetStaticLibraryFlags(extraLinkOptions,
-                              cmSystemTools::UpperCase(configName),
-                              gtgt);
-    }
-  else
-    {
+  if (gtgt->GetType() == cmState::OBJECT_LIBRARY ||
+      gtgt->GetType() == cmState::STATIC_LIBRARY) {
+    this->CurrentLocalGenerator->GetStaticLibraryFlags(
+      extraLinkOptions, cmSystemTools::UpperCase(configName), gtgt);
+  } else {
     const char* targetLinkFlags = gtgt->GetProperty("LINK_FLAGS");
-    if(targetLinkFlags)
-      {
-      this->CurrentLocalGenerator->
-        AppendFlags(extraLinkOptions, targetLinkFlags);
-      }
-    if(!configName.empty())
-      {
+    if (targetLinkFlags) {
+      this->CurrentLocalGenerator->AppendFlags(extraLinkOptions,
+                                               targetLinkFlags);
+    }
+    if (!configName.empty()) {
       std::string linkFlagsVar = "LINK_FLAGS_";
       linkFlagsVar += cmSystemTools::UpperCase(configName);
-      if(const char* linkFlags = gtgt->GetProperty(linkFlagsVar.c_str()))
-        {
-        this->CurrentLocalGenerator->
-          AppendFlags(extraLinkOptions, linkFlags);
-        }
+      if (const char* linkFlags = gtgt->GetProperty(linkFlagsVar.c_str())) {
+        this->CurrentLocalGenerator->AppendFlags(extraLinkOptions, linkFlags);
       }
     }
+  }
 
   // Set target-specific architectures.
   std::vector<std::string> archs;
   gtgt->GetAppleArchs(configName, archs);
 
-  if(!archs.empty())
-    {
+  if (!archs.empty()) {
     // Enable ARCHS attribute.
-    buildSettings->AddAttribute("ONLY_ACTIVE_ARCH",
-                                this->CreateString("NO"));
+    buildSettings->AddAttribute("ONLY_ACTIVE_ARCH", this->CreateString("NO"));
 
     // Store ARCHS value.
-    if(archs.size() == 1)
-      {
-      buildSettings->AddAttribute("ARCHS",
-                                  this->CreateString(archs[0]));
-      }
-    else
-      {
+    if (archs.size() == 1) {
+      buildSettings->AddAttribute("ARCHS", this->CreateString(archs[0]));
+    } else {
       cmXCodeObject* archObjects =
         this->CreateObject(cmXCodeObject::OBJECT_LIST);
-      for(std::vector<std::string>::iterator i = archs.begin();
-          i != archs.end(); i++)
-        {
+      for (std::vector<std::string>::iterator i = archs.begin();
+           i != archs.end(); i++) {
         archObjects->AddObject(this->CreateString(*i));
-        }
-      buildSettings->AddAttribute("ARCHS", archObjects);
       }
+      buildSettings->AddAttribute("ARCHS", archObjects);
     }
+  }
 
   // Get the product name components.
   std::string pnprefix;
@@ -1998,280 +1696,219 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
 
   const char* version = gtgt->GetProperty("VERSION");
   const char* soversion = gtgt->GetProperty("SOVERSION");
-  if(!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple())
-    {
+  if (!gtgt->HasSOName(configName) || gtgt->IsFrameworkOnApple()) {
     version = 0;
     soversion = 0;
-    }
-  if(version && !soversion)
-    {
+  }
+  if (version && !soversion) {
     soversion = version;
-    }
-  if(!version && soversion)
-    {
+  }
+  if (!version && soversion) {
     version = soversion;
-    }
+  }
 
   std::string realName = pnbase;
   std::string soName = pnbase;
-  if(version && soversion)
-    {
+  if (version && soversion) {
     realName += ".";
     realName += version;
     soName += ".";
     soName += soversion;
-    }
+  }
 
   // Set attributes to specify the proper name for the target.
   std::string pndir = this->CurrentLocalGenerator->GetCurrentBinaryDirectory();
-  if(gtgt->GetType() == cmState::STATIC_LIBRARY ||
-     gtgt->GetType() == cmState::SHARED_LIBRARY ||
-     gtgt->GetType() == cmState::MODULE_LIBRARY ||
-     gtgt->GetType() == cmState::EXECUTABLE)
-    {
-    if(this->XcodeVersion >= 21)
-      {
-      if(!gtgt->UsesDefaultOutputDir(configName, false))
-        {
+  if (gtgt->GetType() == cmState::STATIC_LIBRARY ||
+      gtgt->GetType() == cmState::SHARED_LIBRARY ||
+      gtgt->GetType() == cmState::MODULE_LIBRARY ||
+      gtgt->GetType() == cmState::EXECUTABLE) {
+    if (this->XcodeVersion >= 21) {
+      if (!gtgt->UsesDefaultOutputDir(configName, false)) {
         std::string pncdir = gtgt->GetDirectory(configName);
         buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
                                     this->CreateString(pncdir));
-        }
       }
-    else
-      {
-      buildSettings->AddAttribute("OBJROOT",
-                                  this->CreateString(pndir));
+    } else {
+      buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir));
       pndir = gtgt->GetDirectory(configName);
-      }
+    }
 
-    if(gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple())
-      {
+    if (gtgt->IsFrameworkOnApple() || gtgt->IsCFBundleOnApple()) {
       pnprefix = "";
-      }
+    }
 
     buildSettings->AddAttribute("EXECUTABLE_PREFIX",
                                 this->CreateString(pnprefix));
     buildSettings->AddAttribute("EXECUTABLE_SUFFIX",
                                 this->CreateString(pnsuffix));
-    }
-  else if(gtgt->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  } else if (gtgt->GetType() == cmState::OBJECT_LIBRARY) {
     pnprefix = "lib";
     pnbase = gtgt->GetName();
     pnsuffix = ".a";
 
-    if(this->XcodeVersion >= 21)
-      {
+    if (this->XcodeVersion >= 21) {
       std::string pncdir = this->GetObjectsNormalDirectory(
         this->CurrentProject, configName, gtgt);
       buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
                                   this->CreateString(pncdir));
-      }
-    else
-      {
-      buildSettings->AddAttribute("OBJROOT",
-                                  this->CreateString(pndir));
-      pndir = this->GetObjectsNormalDirectory(
-        this->CurrentProject, configName, gtgt);
-      }
+    } else {
+      buildSettings->AddAttribute("OBJROOT", this->CreateString(pndir));
+      pndir = this->GetObjectsNormalDirectory(this->CurrentProject, configName,
+                                              gtgt);
     }
+  }
 
   // Store the product name for all target types.
-  buildSettings->AddAttribute("PRODUCT_NAME",
-                              this->CreateString(realName));
-  buildSettings->AddAttribute("SYMROOT",
-                              this->CreateString(pndir));
+  buildSettings->AddAttribute("PRODUCT_NAME", this->CreateString(realName));
+  buildSettings->AddAttribute("SYMROOT", this->CreateString(pndir));
 
   // Handle settings for each target type.
-  switch(gtgt->GetType())
-    {
+  switch (gtgt->GetType()) {
     case cmState::OBJECT_LIBRARY:
-    case cmState::STATIC_LIBRARY:
-    {
-    buildSettings->AddAttribute("LIBRARY_STYLE",
-                                this->CreateString("STATIC"));
-    break;
+    case cmState::STATIC_LIBRARY: {
+      buildSettings->AddAttribute("LIBRARY_STYLE",
+                                  this->CreateString("STATIC"));
+      break;
     }
 
-    case cmState::MODULE_LIBRARY:
-    {
-    buildSettings->AddAttribute("LIBRARY_STYLE",
-                                this->CreateString("BUNDLE"));
-    if (gtgt->IsCFBundleOnApple())
-      {
-      // It turns out that a BUNDLE is basically the same
-      // in many ways as an application bundle, as far as
-      // link flags go
-      std::string createFlags =
-        this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS",
-                          "-bundle");
-      if(!createFlags.empty())
-        {
-        extraLinkOptions += " ";
-        extraLinkOptions += createFlags;
-        }
-      std::string plist = this->ComputeInfoPListLocation(gtgt);
-      // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the cfbundle name. This avoids creating
-      // a per-configuration Info.plist file. The cfbundle plist
-      // is very similar to the application bundle plist
-      this->CurrentLocalGenerator
-        ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)",
-                                 plist.c_str());
-      buildSettings->AddAttribute("INFOPLIST_FILE",
-                                  this->CreateString(plist));
-      }
-    else if(this->XcodeVersion >= 22)
-      {
-      buildSettings->AddAttribute("MACH_O_TYPE",
-                                  this->CreateString("mh_bundle"));
-      buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
-                                  this->CreateString("NO"));
-      // Add the flags to create an executable.
-      std::string createFlags =
-        this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
-      if(!createFlags.empty())
-        {
-        extraLinkOptions += " ";
-        extraLinkOptions += createFlags;
+    case cmState::MODULE_LIBRARY: {
+      buildSettings->AddAttribute("LIBRARY_STYLE",
+                                  this->CreateString("BUNDLE"));
+      if (gtgt->IsCFBundleOnApple()) {
+        // It turns out that a BUNDLE is basically the same
+        // in many ways as an application bundle, as far as
+        // link flags go
+        std::string createFlags = this->LookupFlags(
+          "CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS", "-bundle");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
         }
-      }
-    else
-      {
-      // Add the flags to create a module.
-      std::string createFlags =
-        this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS",
-                          "-bundle");
-      if(!createFlags.empty())
-        {
-        extraLinkOptions += " ";
-        extraLinkOptions += createFlags;
+        std::string plist = this->ComputeInfoPListLocation(gtgt);
+        // Xcode will create the final version of Info.plist at build time,
+        // so let it replace the cfbundle name. This avoids creating
+        // a per-configuration Info.plist file. The cfbundle plist
+        // is very similar to the application bundle plist
+        this->CurrentLocalGenerator->GenerateAppleInfoPList(
+          gtgt, "$(EXECUTABLE_NAME)", plist.c_str());
+        buildSettings->AddAttribute("INFOPLIST_FILE",
+                                    this->CreateString(plist));
+      } else if (this->XcodeVersion >= 22) {
+        buildSettings->AddAttribute("MACH_O_TYPE",
+                                    this->CreateString("mh_bundle"));
+        buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
+                                    this->CreateString("NO"));
+        // Add the flags to create an executable.
+        std::string createFlags =
+          this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
+        }
+      } else {
+        // Add the flags to create a module.
+        std::string createFlags = this->LookupFlags(
+          "CMAKE_SHARED_MODULE_CREATE_", llang, "_FLAGS", "-bundle");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
         }
       }
-    break;
+      break;
     }
-    case cmState::SHARED_LIBRARY:
-    {
-    if(gtgt->GetPropertyAsBool("FRAMEWORK"))
-      {
-      std::string fw_version = gtgt->GetFrameworkVersion();
-      buildSettings->AddAttribute("FRAMEWORK_VERSION",
-                                  this->CreateString(fw_version));
-
-      std::string plist = this->ComputeInfoPListLocation(gtgt);
-      // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the framework name. This avoids creating
-      // a per-configuration Info.plist file.
-      this->CurrentLocalGenerator
-        ->GenerateFrameworkInfoPList(gtgt, "$(EXECUTABLE_NAME)",
-                                     plist.c_str());
-      buildSettings->AddAttribute("INFOPLIST_FILE",
-                                  this->CreateString(plist));
-      }
-    else
-      {
-      // Add the flags to create a shared library.
+    case cmState::SHARED_LIBRARY: {
+      if (gtgt->GetPropertyAsBool("FRAMEWORK")) {
+        std::string fw_version = gtgt->GetFrameworkVersion();
+        buildSettings->AddAttribute("FRAMEWORK_VERSION",
+                                    this->CreateString(fw_version));
+
+        std::string plist = this->ComputeInfoPListLocation(gtgt);
+        // Xcode will create the final version of Info.plist at build time,
+        // so let it replace the framework name. This avoids creating
+        // a per-configuration Info.plist file.
+        this->CurrentLocalGenerator->GenerateFrameworkInfoPList(
+          gtgt, "$(EXECUTABLE_NAME)", plist.c_str());
+        buildSettings->AddAttribute("INFOPLIST_FILE",
+                                    this->CreateString(plist));
+      } else {
+        // Add the flags to create a shared library.
+        std::string createFlags = this->LookupFlags(
+          "CMAKE_SHARED_LIBRARY_CREATE_", llang, "_FLAGS", "-dynamiclib");
+        if (!createFlags.empty()) {
+          extraLinkOptions += " ";
+          extraLinkOptions += createFlags;
+        }
+      }
+
+      buildSettings->AddAttribute("LIBRARY_STYLE",
+                                  this->CreateString("DYNAMIC"));
+      break;
+    }
+    case cmState::EXECUTABLE: {
+      // Add the flags to create an executable.
       std::string createFlags =
-        this->LookupFlags("CMAKE_SHARED_LIBRARY_CREATE_", llang, "_FLAGS",
-                          "-dynamiclib");
-      if(!createFlags.empty())
-        {
+        this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
+      if (!createFlags.empty()) {
         extraLinkOptions += " ";
         extraLinkOptions += createFlags;
-        }
-      }
-
-    buildSettings->AddAttribute("LIBRARY_STYLE",
-                                this->CreateString("DYNAMIC"));
-    break;
-    }
-    case cmState::EXECUTABLE:
-    {
-    // Add the flags to create an executable.
-    std::string createFlags =
-      this->LookupFlags("CMAKE_", llang, "_LINK_FLAGS", "");
-    if(!createFlags.empty())
-      {
-      extraLinkOptions += " ";
-      extraLinkOptions += createFlags;
       }
 
-    // Handle bundles and normal executables separately.
-    if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE"))
-      {
-      std::string plist = this->ComputeInfoPListLocation(gtgt);
-      // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the executable name.  This avoids creating
-      // a per-configuration Info.plist file.
-      this->CurrentLocalGenerator
-        ->GenerateAppleInfoPList(gtgt, "$(EXECUTABLE_NAME)",
-                                 plist.c_str());
-      buildSettings->AddAttribute("INFOPLIST_FILE",
-                                  this->CreateString(plist));
-
-      }
-    }
-    break;
+      // Handle bundles and normal executables separately.
+      if (gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) {
+        std::string plist = this->ComputeInfoPListLocation(gtgt);
+        // Xcode will create the final version of Info.plist at build time,
+        // so let it replace the executable name.  This avoids creating
+        // a per-configuration Info.plist file.
+        this->CurrentLocalGenerator->GenerateAppleInfoPList(
+          gtgt, "$(EXECUTABLE_NAME)", plist.c_str());
+        buildSettings->AddAttribute("INFOPLIST_FILE",
+                                    this->CreateString(plist));
+      }
+    } break;
     default:
       break;
-    }
-  if(this->XcodeVersion >= 22 && this->XcodeVersion < 40)
-    {
-    buildSettings->AddAttribute("PREBINDING",
-                                this->CreateString("NO"));
-    }
+  }
+  if (this->XcodeVersion >= 22 && this->XcodeVersion < 40) {
+    buildSettings->AddAttribute("PREBINDING", this->CreateString("NO"));
+  }
 
   BuildObjectListOrString dirs(this, this->XcodeVersion >= 30);
   BuildObjectListOrString fdirs(this, this->XcodeVersion >= 30);
   std::vector<std::string> includes;
-  this->CurrentLocalGenerator->GetIncludeDirectories(includes, gtgt,
-                                                     "C", configName);
+  this->CurrentLocalGenerator->GetIncludeDirectories(includes, gtgt, "C",
+                                                     configName);
   std::set<std::string> emitted;
   emitted.insert("/System/Library/Frameworks");
-  for(std::vector<std::string>::iterator i = includes.begin();
-      i != includes.end(); ++i)
-    {
-    if(this->NameResolvesToFramework(i->c_str()))
-      {
+  for (std::vector<std::string>::iterator i = includes.begin();
+       i != includes.end(); ++i) {
+    if (this->NameResolvesToFramework(i->c_str())) {
       std::string frameworkDir = *i;
       frameworkDir += "/../";
       frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
-      if(emitted.insert(frameworkDir).second)
-        {
+      if (emitted.insert(frameworkDir).second) {
         fdirs.Add(this->XCodeEscapePath(frameworkDir));
-        }
       }
-    else
-      {
-      std::string incpath =
-        this->XCodeEscapePath(*i);
+    } else {
+      std::string incpath = this->XCodeEscapePath(*i);
       dirs.Add(incpath);
-      }
     }
+  }
   // Add framework search paths needed for linking.
-  if(cmComputeLinkInformation* cli = gtgt->GetLinkInformation(configName))
-    {
+  if (cmComputeLinkInformation* cli = gtgt->GetLinkInformation(configName)) {
     std::vector<std::string> const& fwDirs = cli->GetFrameworkPaths();
-    for(std::vector<std::string>::const_iterator fdi = fwDirs.begin();
-        fdi != fwDirs.end(); ++fdi)
-      {
-      if(emitted.insert(*fdi).second)
-        {
+    for (std::vector<std::string>::const_iterator fdi = fwDirs.begin();
+         fdi != fwDirs.end(); ++fdi) {
+      if (emitted.insert(*fdi).second) {
         fdirs.Add(this->XCodeEscapePath(*fdi));
-        }
       }
     }
-  if(!fdirs.IsEmpty())
-    {
-    buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS",
-                                fdirs.CreateList());
-    }
-  if(!dirs.IsEmpty())
-    {
-    buildSettings->AddAttribute("HEADER_SEARCH_PATHS",
-                                dirs.CreateList());
-    }
+  }
+  if (!fdirs.IsEmpty()) {
+    buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS", fdirs.CreateList());
+  }
+  if (!dirs.IsEmpty()) {
+    buildSettings->AddAttribute("HEADER_SEARCH_PATHS", dirs.CreateList());
+  }
 
   bool same_gflags = true;
   std::map<std::string, std::string> gflags;
@@ -2280,52 +1917,42 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
 
   // Minimal map of flags to build settings.
   for (std::set<std::string>::iterator li = languages.begin();
-       li != languages.end(); ++li)
-    {
+       li != languages.end(); ++li) {
     std::string& flags = cflags[*li];
     std::string& gflag = gflags[*li];
     std::string oflag =
       this->ExtractFlagRegex("(^| )(-Ofast|-Os|-O[0-9]*)( |$)", 2, flags);
-    if(oflag.size() == 2)
-      {
+    if (oflag.size() == 2) {
       optLevel = "1";
-      }
-    else if(oflag.size() > 2)
-      {
+    } else if (oflag.size() > 2) {
       optLevel = oflag.substr(2);
-      }
+    }
     gflag = this->ExtractFlag("-g", flags);
     // put back gdwarf-2 if used since there is no way
     // to represent it in the gui, but we still want debug yes
-    if(gflag == "-gdwarf-2")
-      {
+    if (gflag == "-gdwarf-2") {
       flags += " ";
       flags += gflag;
-      }
-    if (last_gflag && *last_gflag != gflag)
-      {
+    }
+    if (last_gflag && *last_gflag != gflag) {
       same_gflags = false;
-      }
-    last_gflag = &gflag;
     }
+    last_gflag = &gflag;
+  }
 
   const char* debugStr = "YES";
-  if (!same_gflags)
-    {
+  if (!same_gflags) {
     // We can't set the Xcode flag differently depending on the language,
     // so put them back in this case.
     for (std::set<std::string>::iterator li = languages.begin();
-         li != languages.end(); ++li)
-      {
+         li != languages.end(); ++li) {
       cflags[*li] += " ";
       cflags[*li] += gflags[*li];
-      }
-    debugStr = "NO";
     }
-  else if (last_gflag && (last_gflag->empty() || *last_gflag == "-g0"))
-    {
     debugStr = "NO";
-    }
+  } else if (last_gflag && (last_gflag->empty() || *last_gflag == "-g0")) {
+    debugStr = "NO";
+  }
 
   buildSettings->AddAttribute("COMBINE_HIDPI_IMAGES",
                               this->CreateString("YES"));
@@ -2338,45 +1965,40 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
   buildSettings->AddAttribute("GCC_INLINES_ARE_PRIVATE_EXTERN",
                               this->CreateString("NO"));
   for (std::set<std::string>::iterator li = languages.begin();
-       li != languages.end(); ++li)
-    {
+       li != languages.end(); ++li) {
     std::string flags = cflags[*li] + " " + defFlags;
-    if (*li == "CXX")
-      {
+    if (*li == "CXX") {
       buildSettings->AddAttribute("OTHER_CPLUSPLUSFLAGS",
                                   this->CreateString(flags));
-      }
-    else if (*li == "Fortran")
-      {
+    } else if (*li == "Fortran") {
       buildSettings->AddAttribute("IFORT_OTHER_FLAGS",
                                   this->CreateString(flags));
-      }
-    else if (*li == "C")
-      {
-      buildSettings->AddAttribute("OTHER_CFLAGS",
-                                  this->CreateString(flags));
-      }
+    } else if (*li == "C") {
+      buildSettings->AddAttribute("OTHER_CFLAGS", this->CreateString(flags));
     }
+  }
 
   // Add Fortran source format attribute if property is set.
   const char* format = 0;
   const char* tgtfmt = gtgt->GetProperty("Fortran_FORMAT");
-  switch(this->CurrentLocalGenerator->GetFortranFormat(tgtfmt))
-    {
-    case cmLocalGenerator::FortranFormatFixed: format = "fixed"; break;
-    case cmLocalGenerator::FortranFormatFree: format = "free"; break;
-    default: break;
-    }
-  if(format)
-    {
+  switch (this->CurrentLocalGenerator->GetFortranFormat(tgtfmt)) {
+    case cmLocalGenerator::FortranFormatFixed:
+      format = "fixed";
+      break;
+    case cmLocalGenerator::FortranFormatFree:
+      format = "free";
+      break;
+    default:
+      break;
+  }
+  if (format) {
     buildSettings->AddAttribute("IFORT_LANG_SRCFMT",
                                 this->CreateString(format));
-    }
+  }
 
   // Create the INSTALL_PATH attribute.
   std::string install_name_dir;
-  if(gtgt->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::SHARED_LIBRARY) {
     // Get the install_name directory for the build tree.
     install_name_dir = gtgt->GetInstallNameDirForBuildTree(configName);
     // Xcode doesn't create the correct install_name in some cases.
@@ -2385,86 +2007,71 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     // This is done by adding a link flag to create an install_name
     // with just the library soname.
     std::string install_name;
-    if(!install_name_dir.empty())
-      {
+    if (!install_name_dir.empty()) {
       // Convert to a path for the native build tool.
       cmSystemTools::ConvertToUnixSlashes(install_name_dir);
       install_name += install_name_dir;
       install_name += "/";
-      }
+    }
     install_name += gtgt->GetSOName(configName);
 
-    if((realName != soName) || install_name_dir.empty())
-      {
+    if ((realName != soName) || install_name_dir.empty()) {
       install_name_dir = "";
       extraLinkOptions += " -install_name ";
       extraLinkOptions += XCodeEscapePath(install_name);
-      }
     }
+  }
   buildSettings->AddAttribute("INSTALL_PATH",
                               this->CreateString(install_name_dir));
 
   // Create the LD_RUNPATH_SEARCH_PATHS
   cmComputeLinkInformation* pcli = gtgt->GetLinkInformation(configName);
-  if(pcli)
-    {
+  if (pcli) {
     std::string search_paths;
     std::vector<std::string> runtimeDirs;
     pcli->GetRPath(runtimeDirs, false);
     // runpath dirs needs to be unique to prevent corruption
     std::set<std::string> unique_dirs;
 
-    for(std::vector<std::string>::const_iterator i = runtimeDirs.begin();
-        i != runtimeDirs.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = runtimeDirs.begin();
+         i != runtimeDirs.end(); ++i) {
       std::string runpath = *i;
       runpath = this->ExpandCFGIntDir(runpath, configName);
 
-      if(unique_dirs.find(runpath) == unique_dirs.end())
-        {
+      if (unique_dirs.find(runpath) == unique_dirs.end()) {
         unique_dirs.insert(runpath);
-        if(!search_paths.empty())
-          {
+        if (!search_paths.empty()) {
           search_paths += " ";
-          }
-        search_paths += this->XCodeEscapePath(runpath);
         }
+        search_paths += this->XCodeEscapePath(runpath);
       }
-    if(!search_paths.empty())
-      {
+    }
+    if (!search_paths.empty()) {
       buildSettings->AddAttribute("LD_RUNPATH_SEARCH_PATHS",
                                   this->CreateString(search_paths));
-      }
     }
+  }
 
   buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(gtgt),
                               this->CreateString(extraLinkOptions));
-  buildSettings->AddAttribute("OTHER_REZFLAGS",
-                              this->CreateString(""));
-  buildSettings->AddAttribute("SECTORDER_FLAGS",
-                              this->CreateString(""));
-  buildSettings->AddAttribute("USE_HEADERMAP",
-                              this->CreateString("NO"));
-  if (this->XcodeVersion >= 30)
-    {
-    cmXCodeObject *group = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  buildSettings->AddAttribute("OTHER_REZFLAGS", this->CreateString(""));
+  buildSettings->AddAttribute("SECTORDER_FLAGS", this->CreateString(""));
+  buildSettings->AddAttribute("USE_HEADERMAP", this->CreateString("NO"));
+  if (this->XcodeVersion >= 30) {
+    cmXCodeObject* group = this->CreateObject(cmXCodeObject::OBJECT_LIST);
     group->AddObject(this->CreateString("-Wmost"));
     group->AddObject(this->CreateString("-Wno-four-char-constants"));
     group->AddObject(this->CreateString("-Wno-unknown-pragmas"));
     group->AddObject(this->CreateString("$(inherited)"));
     buildSettings->AddAttribute("WARNING_CFLAGS", group);
-    }
-  else
-    {
-    buildSettings->AddAttribute("WARNING_CFLAGS",
-                                this->CreateString(
-                                  "-Wmost -Wno-four-char-constants"
-                                  " -Wno-unknown-pragmas"));
-    }
+  } else {
+    buildSettings->AddAttribute(
+      "WARNING_CFLAGS", this->CreateString("-Wmost -Wno-four-char-constants"
+                                           " -Wno-unknown-pragmas"));
+  }
 
   // Runtime version information.
-  if(gtgt->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::SHARED_LIBRARY) {
     int major;
     int minor;
     int patch;
@@ -2474,10 +2081,9 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     std::ostringstream v;
 
     // Xcode always wants at least 1.0.0 or nothing
-    if(!(major == 0 && minor == 0 && patch == 0))
-      {
+    if (!(major == 0 && minor == 0 && patch == 0)) {
       v << major << "." << minor << "." << patch;
-      }
+    }
     buildSettings->AddAttribute("DYLIB_CURRENT_VERSION",
                                 this->CreateString(v.str()));
 
@@ -2486,39 +2092,36 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmGeneratorTarget* gtgt,
     std::ostringstream vso;
 
     // Xcode always wants at least 1.0.0 or nothing
-    if(!(major == 0 && minor == 0 && patch == 0))
-      {
+    if (!(major == 0 && minor == 0 && patch == 0)) {
       vso << major << "." << minor << "." << patch;
-      }
+    }
     buildSettings->AddAttribute("DYLIB_COMPATIBILITY_VERSION",
                                 this->CreateString(vso.str()));
-    }
+  }
   // put this last so it can override existing settings
   // Convert "XCODE_ATTRIBUTE_*" properties directly.
   {
-  std::vector<std::string> const& props = gtgt->GetPropertyKeys();
-  for(std::vector<std::string>::const_iterator i = props.begin();
-      i != props.end(); ++i)
-    {
-    if(i->find("XCODE_ATTRIBUTE_") == 0)
-      {
-      std::string attribute = i->substr(16);
-      this->FilterConfigurationAttribute(configName, attribute);
-      if (!attribute.empty())
-        {
-        cmGeneratorExpression ge;
-        std::string processed = ge.Parse(gtgt->GetProperty(*i))
-          ->Evaluate(this->CurrentLocalGenerator, configName);
-        buildSettings->AddAttribute(attribute.c_str(),
-                                    this->CreateString(processed));
+    std::vector<std::string> const& props = gtgt->GetPropertyKeys();
+    for (std::vector<std::string>::const_iterator i = props.begin();
+         i != props.end(); ++i) {
+      if (i->find("XCODE_ATTRIBUTE_") == 0) {
+        std::string attribute = i->substr(16);
+        this->FilterConfigurationAttribute(configName, attribute);
+        if (!attribute.empty()) {
+          cmGeneratorExpression ge;
+          std::string processed =
+            ge.Parse(gtgt->GetProperty(*i))
+              ->Evaluate(this->CurrentLocalGenerator, configName);
+          buildSettings->AddAttribute(attribute.c_str(),
+                                      this->CreateString(processed));
         }
       }
     }
   }
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateUtilityTarget(cmGeneratorTarget* gtgt)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateUtilityTarget(
+  cmGeneratorTarget* gtgt)
 {
   cmXCodeObject* shellBuildPhase =
     this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
@@ -2532,65 +2135,52 @@ cmGlobalXCodeGenerator::CreateUtilityTarget(cmGeneratorTarget* gtgt)
   shellBuildPhase->AddAttribute("outputPaths", outputPaths);
   shellBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
                                 this->CreateString("0"));
-  shellBuildPhase->AddAttribute("shellPath",
-                                this->CreateString("/bin/sh"));
-  shellBuildPhase->AddAttribute("shellScript",
-                                this->CreateString(
-                                  "# shell script goes here\nexit 0"));
-  shellBuildPhase->AddAttribute("showEnvVarsInLog",
-                                this->CreateString("0"));
+  shellBuildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
+  shellBuildPhase->AddAttribute(
+    "shellScript", this->CreateString("# shell script goes here\nexit 0"));
+  shellBuildPhase->AddAttribute("showEnvVarsInLog", this->CreateString("0"));
 
   cmXCodeObject* target =
     this->CreateObject(cmXCodeObject::PBXAggregateTarget);
   target->SetComment(gtgt->GetName().c_str());
-  cmXCodeObject* buildPhases =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  cmXCodeObject* buildPhases = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   std::vector<cmXCodeObject*> emptyContentVector;
   this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0,
                              gtgt);
   target->AddAttribute("buildPhases", buildPhases);
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     this->AddConfigurations(target, gtgt);
-    }
-  else
-    {
+  } else {
     std::string theConfig =
       this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
     cmXCodeObject* buildSettings =
       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     this->CreateBuildSettings(gtgt, buildSettings, theConfig);
     target->AddAttribute("buildSettings", buildSettings);
-    }
-  cmXCodeObject* dependencies =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  }
+  cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   target->AddAttribute("dependencies", dependencies);
   target->AddAttribute("name", this->CreateString(gtgt->GetName()));
-  target->AddAttribute("productName",this->CreateString(gtgt->GetName()));
+  target->AddAttribute("productName", this->CreateString(gtgt->GetName()));
   target->SetTarget(gtgt);
   this->XCodeObjectMap[gtgt] = target;
 
   // Add source files without build rules for editing convenience.
-  if(gtgt->GetType() == cmState::UTILITY)
-    {
+  if (gtgt->GetType() == cmState::UTILITY) {
     std::vector<cmSourceFile*> sources;
-    if (!gtgt->GetConfigCommonSourceFiles(sources))
-      {
+    if (!gtgt->GetConfigCommonSourceFiles(sources)) {
       return 0;
-      }
+    }
 
-    for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
-        i != sources.end(); ++i)
-      {
-      if(!(*i)->GetPropertyAsBool("GENERATED"))
-        {
+    for (std::vector<cmSourceFile*>::const_iterator i = sources.begin();
+         i != sources.end(); ++i) {
+      if (!(*i)->GetPropertyAsBool("GENERATED")) {
         this->CreateXCodeFileReference(*i, gtgt);
-        }
       }
     }
+  }
 
-  target->SetId(this->GetOrCreateId(
-    gtgt->GetName(), target->GetId()).c_str());
+  target->SetId(this->GetOrCreateId(gtgt->GetName(), target->GetId()).c_str());
 
   return target;
 }
@@ -2617,50 +2207,43 @@ std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target,
   configlist->SetComment(comment.c_str());
   target->AddAttribute("buildConfigurationList",
                        this->CreateObjectReference(configlist));
-  for(unsigned int i = 0; i < configVector.size(); ++i)
-    {
+  for (unsigned int i = 0; i < configVector.size(); ++i) {
     cmXCodeObject* config =
       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
     buildConfigurations->AddObject(config);
     cmXCodeObject* buildSettings =
       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
-    this->CreateBuildSettings(gtgt, buildSettings,
-                              configVector[i].c_str());
+    this->CreateBuildSettings(gtgt, buildSettings, configVector[i].c_str());
     config->AddAttribute("name", this->CreateString(configVector[i]));
     config->SetComment(configVector[i].c_str());
     config->AddAttribute("buildSettings", buildSettings);
-    }
-  if(!configVector.empty())
-    {
+  }
+  if (!configVector.empty()) {
     configlist->AddAttribute("defaultConfigurationName",
                              this->CreateString(configVector[0]));
     configlist->AddAttribute("defaultConfigurationIsVisible",
                              this->CreateString("0"));
     return configVector[0];
-    }
+  }
   return "";
 }
 
 const char* cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(
-    cmGeneratorTarget const* target) const
+  cmGeneratorTarget const* target) const
 {
-  if(this->XcodeVersion >= 60 &&
-     (target->GetType() == cmState::STATIC_LIBRARY ||
-      target->GetType() == cmState::OBJECT_LIBRARY))
-    {
+  if (this->XcodeVersion >= 60 &&
+      (target->GetType() == cmState::STATIC_LIBRARY ||
+       target->GetType() == cmState::OBJECT_LIBRARY)) {
     return "OTHER_LIBTOOLFLAGS";
-    }
-  else
-    {
+  } else {
     return "OTHER_LDFLAGS";
-    }
+  }
 }
 
 const char* cmGlobalXCodeGenerator::GetTargetFileType(
-    cmGeneratorTarget* target)
+  cmGeneratorTarget* target)
 {
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::OBJECT_LIBRARY:
     case cmState::STATIC_LIBRARY:
       return "archive.ar";
@@ -2670,23 +2253,24 @@ const char* cmGlobalXCodeGenerator::GetTargetFileType(
       else if (target->IsCFBundleOnApple())
         return "wrapper.plug-in";
       else
-        return ((this->XcodeVersion >= 22)?
-              "compiled.mach-o.executable" : "compiled.mach-o.dylib");
+        return ((this->XcodeVersion >= 22) ? "compiled.mach-o.executable"
+                                           : "compiled.mach-o.dylib");
     case cmState::SHARED_LIBRARY:
-      return (target->GetPropertyAsBool("FRAMEWORK")?
-              "wrapper.framework" : "compiled.mach-o.dylib");
+      return (target->GetPropertyAsBool("FRAMEWORK")
+                ? "wrapper.framework"
+                : "compiled.mach-o.dylib");
     case cmState::EXECUTABLE:
       return "compiled.mach-o.executable";
-    default: break;
-    }
+    default:
+      break;
+  }
   return 0;
 }
 
 const char* cmGlobalXCodeGenerator::GetTargetProductType(
-    cmGeneratorTarget* target)
+  cmGeneratorTarget* target)
 {
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::OBJECT_LIBRARY:
     case cmState::STATIC_LIBRARY:
       return "com.apple.product-type.library.static";
@@ -2696,106 +2280,90 @@ const char* cmGlobalXCodeGenerator::GetTargetProductType(
       else if (target->IsCFBundleOnApple())
         return "com.apple.product-type.bundle";
       else
-        return ((this->XcodeVersion >= 22)?
-                "com.apple.product-type.tool" :
-                "com.apple.product-type.library.dynamic");
+        return ((this->XcodeVersion >= 22)
+                  ? "com.apple.product-type.tool"
+                  : "com.apple.product-type.library.dynamic");
     case cmState::SHARED_LIBRARY:
-      return (target->GetPropertyAsBool("FRAMEWORK")?
-              "com.apple.product-type.framework" :
-              "com.apple.product-type.library.dynamic");
+      return (target->GetPropertyAsBool("FRAMEWORK")
+                ? "com.apple.product-type.framework"
+                : "com.apple.product-type.library.dynamic");
     case cmState::EXECUTABLE:
-      return (target->GetPropertyAsBool("MACOSX_BUNDLE")?
-              "com.apple.product-type.application" :
-              "com.apple.product-type.tool");
-    default: break;
-    }
+      return (target->GetPropertyAsBool("MACOSX_BUNDLE")
+                ? "com.apple.product-type.application"
+                : "com.apple.product-type.tool");
+    default:
+      break;
+  }
   return 0;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::CreateXCodeTarget(cmGeneratorTarget* gtgt,
-                                          cmXCodeObject* buildPhases)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateXCodeTarget(
+  cmGeneratorTarget* gtgt, cmXCodeObject* buildPhases)
 {
-  if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
     return 0;
-    }
-  cmXCodeObject* target =
-    this->CreateObject(cmXCodeObject::PBXNativeTarget);
+  }
+  cmXCodeObject* target = this->CreateObject(cmXCodeObject::PBXNativeTarget);
   target->AddAttribute("buildPhases", buildPhases);
   cmXCodeObject* buildRules = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   target->AddAttribute("buildRules", buildRules);
   std::string defConfig;
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     defConfig = this->AddConfigurations(target, gtgt);
-    }
-  else
-    {
+  } else {
     cmXCodeObject* buildSettings =
       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     defConfig = this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
     this->CreateBuildSettings(gtgt, buildSettings, defConfig.c_str());
     target->AddAttribute("buildSettings", buildSettings);
-    }
-  cmXCodeObject* dependencies =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  }
+  cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   target->AddAttribute("dependencies", dependencies);
   target->AddAttribute("name", this->CreateString(gtgt->GetName()));
-  target->AddAttribute("productName",this->CreateString(gtgt->GetName()));
+  target->AddAttribute("productName", this->CreateString(gtgt->GetName()));
 
-  cmXCodeObject* fileRef =
-    this->CreateObject(cmXCodeObject::PBXFileReference);
-  if(const char* fileType = this->GetTargetFileType(gtgt))
-    {
+  cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
+  if (const char* fileType = this->GetTargetFileType(gtgt)) {
     fileRef->AddAttribute("explicitFileType", this->CreateString(fileType));
-    }
+  }
   std::string fullName;
-  if(gtgt->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  if (gtgt->GetType() == cmState::OBJECT_LIBRARY) {
     fullName = "lib";
     fullName += gtgt->GetName();
     fullName += ".a";
-    }
-  else
-    {
+  } else {
     fullName = gtgt->GetFullName(defConfig.c_str());
-    }
+  }
   fileRef->AddAttribute("path", this->CreateString(fullName));
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     fileRef->AddAttribute("refType", this->CreateString("0"));
-    }
+  }
   fileRef->AddAttribute("sourceTree",
                         this->CreateString("BUILT_PRODUCTS_DIR"));
   fileRef->SetComment(gtgt->GetName().c_str());
   target->AddAttribute("productReference",
                        this->CreateObjectReference(fileRef));
-  if(const char* productType = this->GetTargetProductType(gtgt))
-    {
+  if (const char* productType = this->GetTargetProductType(gtgt)) {
     target->AddAttribute("productType", this->CreateString(productType));
-    }
+  }
   target->SetTarget(gtgt);
   this->XCodeObjectMap[gtgt] = target;
-  target->SetId(this->GetOrCreateId(
-    gtgt->GetName(), target->GetId()).c_str());
+  target->SetId(this->GetOrCreateId(gtgt->GetName(), target->GetId()).c_str());
   return target;
 }
 
-cmXCodeObject*
-cmGlobalXCodeGenerator::FindXCodeTarget(cmGeneratorTarget const* t)
+cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(
+  cmGeneratorTarget const* t)
 {
-  if(!t)
-    {
+  if (!t) {
     return 0;
-    }
+  }
 
   std::map<cmGeneratorTarget const*, cmXCodeObject*>::const_iterator const i =
     this->XCodeObjectMap.find(t);
-  if (i == this->XCodeObjectMap.end())
-    {
+  if (i == this->XCodeObjectMap.end()) {
     return 0;
-    }
+  }
   return i->second;
 }
 
@@ -2807,13 +2375,13 @@ std::string cmGlobalXCodeGenerator::GetOrCreateId(const std::string& name,
   const char* storedGUID =
     this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
 
-  if(storedGUID)
-    {
+  if (storedGUID) {
     return storedGUID;
-    }
+  }
 
-  this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
-    id.c_str(), "Stored Xcode object GUID", cmState::INTERNAL);
+  this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(), id.c_str(),
+                                     "Stored Xcode object GUID",
+                                     cmState::INTERNAL);
 
   return id;
 }
@@ -2830,66 +2398,52 @@ void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
   container->AddAttribute("proxyType", this->CreateString("1"));
   container->AddAttribute("remoteGlobalIDString",
                           this->CreateObjectReference(dependTarget));
-  container->AddAttribute("remoteInfo",
-                          this->CreateString(
-                            dependTarget->GetTarget()->GetName()));
+  container->AddAttribute(
+    "remoteInfo", this->CreateString(dependTarget->GetTarget()->GetName()));
   cmXCodeObject* targetdep =
     this->CreateObject(cmXCodeObject::PBXTargetDependency);
   targetdep->SetComment("PBXTargetDependency");
-  targetdep->AddAttribute("target",
-                          this->CreateObjectReference(dependTarget));
+  targetdep->AddAttribute("target", this->CreateObjectReference(dependTarget));
   targetdep->AddAttribute("targetProxy",
                           this->CreateObjectReference(container));
 
   cmXCodeObject* depends = target->GetObject("dependencies");
-  if(!depends)
-    {
-    cmSystemTools::
-      Error("target does not have dependencies attribute error..");
+  if (!depends) {
+    cmSystemTools::Error(
+      "target does not have dependencies attribute error..");
 
-    }
-  else
-    {
+  } else {
     depends->AddUniqueObject(targetdep);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::AppendOrAddBuildSetting(cmXCodeObject* settings,
                                                      const char* attribute,
                                                      const char* value)
 {
-  if(settings)
-    {
+  if (settings) {
     cmXCodeObject* attr = settings->GetObject(attribute);
-    if(!attr)
-      {
+    if (!attr) {
       settings->AddAttribute(attribute, this->CreateString(value));
-      }
-    else
-      {
+    } else {
       std::string oldValue = attr->GetString();
       oldValue += " ";
       oldValue += value;
       attr->SetString(oldValue.c_str());
-      }
     }
+  }
 }
 
-void cmGlobalXCodeGenerator
-::AppendBuildSettingAttribute(cmXCodeObject* target,
-                              const char* attribute,
-                              const char* value,
-                              const std::string& configName)
+void cmGlobalXCodeGenerator::AppendBuildSettingAttribute(
+  cmXCodeObject* target, const char* attribute, const char* value,
+  const std::string& configName)
 {
-  if(this->XcodeVersion < 21)
-    {
+  if (this->XcodeVersion < 21) {
     // There is only one configuration.  Add the setting to the buildSettings
     // of the target.
     this->AppendOrAddBuildSetting(target->GetObject("buildSettings"),
                                   attribute, value);
-    }
-  else
-    {
+  } else {
     // There are multiple configurations.  Add the setting to the
     // buildSettings of the configuration name given.
     cmXCodeObject* configurationList =
@@ -2898,360 +2452,307 @@ void cmGlobalXCodeGenerator
       configurationList->GetObject("buildConfigurations");
     std::vector<cmXCodeObject*> list = buildConfigs->GetObjectList();
     // each configuration and the target itself has a buildSettings in it
-    //list.push_back(target);
-    for(std::vector<cmXCodeObject*>::iterator i = list.begin();
-        i != list.end(); ++i)
-      {
-      if(!configName.empty())
-        {
-        if((*i)->GetObject("name")->GetString() == configName)
-          {
+    // list.push_back(target);
+    for (std::vector<cmXCodeObject*>::iterator i = list.begin();
+         i != list.end(); ++i) {
+      if (!configName.empty()) {
+        if ((*i)->GetObject("name")->GetString() == configName) {
           cmXCodeObject* settings = (*i)->GetObject("buildSettings");
           this->AppendOrAddBuildSetting(settings, attribute, value);
-          }
         }
-      else
-        {
+      } else {
         cmXCodeObject* settings = (*i)->GetObject("buildSettings");
         this->AppendOrAddBuildSetting(settings, attribute, value);
-        }
       }
     }
+  }
 }
 
-void cmGlobalXCodeGenerator
-::AddDependAndLinkInformation(cmXCodeObject* target)
+void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
 {
   cmGeneratorTarget* gt = target->GetTarget();
-  if(!gt)
-    {
+  if (!gt) {
     cmSystemTools::Error("Error no target on xobject\n");
     return;
-    }
-  if(gt->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  }
+  if (gt->GetType() == cmState::INTERFACE_LIBRARY) {
     return;
-    }
+  }
 
   // Add dependencies on other CMake targets.
   TargetDependSet const& deps = this->GetTargetDirectDepends(gt);
-  for(TargetDependSet::const_iterator i = deps.begin(); i != deps.end(); ++i)
-    {
-    if(cmXCodeObject* dptarget = this->FindXCodeTarget(*i))
-      {
+  for (TargetDependSet::const_iterator i = deps.begin(); i != deps.end();
+       ++i) {
+    if (cmXCodeObject* dptarget = this->FindXCodeTarget(*i)) {
       this->AddDependTarget(target, dptarget);
-      }
     }
+  }
 
   // Loop over configuration types and set per-configuration info.
-  for(std::vector<std::string>::iterator i =
-        this->CurrentConfigurationTypes.begin();
-      i != this->CurrentConfigurationTypes.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i =
+         this->CurrentConfigurationTypes.begin();
+       i != this->CurrentConfigurationTypes.end(); ++i) {
     // Get the current configuration name.
     std::string configName = *i;
 
-    if(this->XcodeVersion >= 50)
-      {
+    if (this->XcodeVersion >= 50) {
       // Add object library contents as link flags.
       std::string linkObjs;
       const char* sep = "";
       std::vector<std::string> objs;
       gt->UseObjectLibraries(objs, "");
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         linkObjs += sep;
         sep = " ";
         linkObjs += this->XCodeEscapePath(*oi);
-        }
-      this->AppendBuildSettingAttribute(
-        target, this->GetTargetLinkFlagsVar(gt),
-        linkObjs.c_str(), configName);
       }
+      this->AppendBuildSettingAttribute(
+        target, this->GetTargetLinkFlagsVar(gt), linkObjs.c_str(), configName);
+    }
 
     // Skip link information for object libraries.
-    if(gt->GetType() == cmState::OBJECT_LIBRARY ||
-       gt->GetType() == cmState::STATIC_LIBRARY)
-      {
+    if (gt->GetType() == cmState::OBJECT_LIBRARY ||
+        gt->GetType() == cmState::STATIC_LIBRARY) {
       continue;
-      }
+    }
 
     // Compute the link library and directory information.
     cmComputeLinkInformation* pcli = gt->GetLinkInformation(configName);
-    if(!pcli)
-      {
+    if (!pcli) {
       continue;
-      }
+    }
     cmComputeLinkInformation& cli = *pcli;
 
     // Add dependencies directly on library files.
     {
-    std::vector<std::string> const& libDeps = cli.GetDepends();
-    for(std::vector<std::string>::const_iterator j = libDeps.begin();
-        j != libDeps.end(); ++j)
-      {
-      target->AddDependLibrary(configName, j->c_str());
+      std::vector<std::string> const& libDeps = cli.GetDepends();
+      for (std::vector<std::string>::const_iterator j = libDeps.begin();
+           j != libDeps.end(); ++j) {
+        target->AddDependLibrary(configName, j->c_str());
       }
     }
 
     // add the library search paths
     {
-    std::vector<std::string> const& libDirs = cli.GetDirectories();
-    std::string linkDirs;
-    for(std::vector<std::string>::const_iterator libDir = libDirs.begin();
-        libDir != libDirs.end(); ++libDir)
-      {
-      if(libDir->size() && *libDir != "/usr/lib")
-        {
-        if(this->XcodeVersion > 15)
-          {
-          // Now add the same one but append
-          // $(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME) to it:
-          linkDirs += " ";
-          linkDirs += this->XCodeEscapePath(
-            *libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)");
+      std::vector<std::string> const& libDirs = cli.GetDirectories();
+      std::string linkDirs;
+      for (std::vector<std::string>::const_iterator libDir = libDirs.begin();
+           libDir != libDirs.end(); ++libDir) {
+        if (libDir->size() && *libDir != "/usr/lib") {
+          if (this->XcodeVersion > 15) {
+            // Now add the same one but append
+            // $(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME) to it:
+            linkDirs += " ";
+            linkDirs += this->XCodeEscapePath(
+              *libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)");
           }
-        linkDirs += " ";
-        linkDirs += this->XCodeEscapePath(*libDir);
+          linkDirs += " ";
+          linkDirs += this->XCodeEscapePath(*libDir);
         }
       }
-    this->AppendBuildSettingAttribute(target, "LIBRARY_SEARCH_PATHS",
-                                      linkDirs.c_str(), configName);
+      this->AppendBuildSettingAttribute(target, "LIBRARY_SEARCH_PATHS",
+                                        linkDirs.c_str(), configName);
     }
 
     // now add the link libraries
     {
-    std::string linkLibs;
-    const char* sep = "";
-    typedef cmComputeLinkInformation::ItemVector ItemVector;
-    ItemVector const& libNames = cli.GetItems();
-    for(ItemVector::const_iterator li = libNames.begin();
-        li != libNames.end(); ++li)
-      {
-      linkLibs += sep;
-      sep = " ";
-      if(li->IsPath)
-        {
-        linkLibs += this->XCodeEscapePath(li->Value);
-        }
-      else if (!li->Target
-          || li->Target->GetType() != cmState::INTERFACE_LIBRARY)
-        {
-        linkLibs += li->Value;
+      std::string linkLibs;
+      const char* sep = "";
+      typedef cmComputeLinkInformation::ItemVector ItemVector;
+      ItemVector const& libNames = cli.GetItems();
+      for (ItemVector::const_iterator li = libNames.begin();
+           li != libNames.end(); ++li) {
+        linkLibs += sep;
+        sep = " ";
+        if (li->IsPath) {
+          linkLibs += this->XCodeEscapePath(li->Value);
+        } else if (!li->Target ||
+                   li->Target->GetType() != cmState::INTERFACE_LIBRARY) {
+          linkLibs += li->Value;
         }
-      if(li->Target && !li->Target->IsImported())
-        {
-        target->AddDependTarget(configName, li->Target->GetName());
+        if (li->Target && !li->Target->IsImported()) {
+          target->AddDependTarget(configName, li->Target->GetName());
         }
       }
-    this->AppendBuildSettingAttribute(
-      target, this->GetTargetLinkFlagsVar(gt),
-      linkLibs.c_str(), configName);
-    }
+      this->AppendBuildSettingAttribute(
+        target, this->GetTargetLinkFlagsVar(gt), linkLibs.c_str(), configName);
     }
+  }
 }
 
-bool cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
-                                          std::vector<cmLocalGenerator*>&
-                                          generators)
+bool cmGlobalXCodeGenerator::CreateGroups(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
-  for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
-      i != generators.end(); ++i)
-    {
-    if(this->IsExcluded(root, *i))
-      {
+  for (std::vector<cmLocalGenerator*>::iterator i = generators.begin();
+       i != generators.end(); ++i) {
+    if (this->IsExcluded(root, *i)) {
       continue;
-      }
+    }
     cmMakefile* mf = (*i)->GetMakefile();
     std::vector<cmSourceGroup> sourceGroups = mf->GetSourceGroups();
     std::vector<cmGeneratorTarget*> tgts = (*i)->GetGeneratorTargets();
-    for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-        l != tgts.end(); l++)
-      {
+    for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+         l != tgts.end(); l++) {
       cmGeneratorTarget* gtgt = *l;
 
       // Same skipping logic here as in CreateXCodeTargets so that we do not
       // end up with (empty anyhow) ALL_BUILD and XCODE_DEPEND_HELPER source
       // groups:
       //
-      if(gtgt->GetType() == cmState::GLOBAL_TARGET)
-        {
+      if (gtgt->GetType() == cmState::GLOBAL_TARGET) {
         continue;
-        }
-      if(gtgt->GetType() == cmState::INTERFACE_LIBRARY)
-        {
+      }
+      if (gtgt->GetType() == cmState::INTERFACE_LIBRARY) {
         continue;
-        }
+      }
 
       // add the soon to be generated Info.plist file as a source for a
       // MACOSX_BUNDLE file
-      if(gtgt->GetPropertyAsBool("MACOSX_BUNDLE"))
-        {
+      if (gtgt->GetPropertyAsBool("MACOSX_BUNDLE")) {
         std::string plist = this->ComputeInfoPListLocation(gtgt);
         mf->GetOrCreateSource(plist, true);
         gtgt->AddSource(plist);
-        }
+      }
 
       std::vector<cmSourceFile*> classes;
-      if (!gtgt->GetConfigCommonSourceFiles(classes))
-        {
+      if (!gtgt->GetConfigCommonSourceFiles(classes)) {
         return false;
-        }
+      }
       // Put cmSourceFile instances in proper groups:
-      for(std::vector<cmSourceFile*>::const_iterator s = classes.begin();
-          s != classes.end(); s++)
-        {
+      for (std::vector<cmSourceFile*>::const_iterator s = classes.begin();
+           s != classes.end(); s++) {
         cmSourceFile* sf = *s;
         // Add the file to the list of sources.
         std::string const& source = sf->GetFullPath();
         cmSourceGroup* sourceGroup =
           mf->FindSourceGroup(source.c_str(), sourceGroups);
-        cmXCodeObject* pbxgroup =
-          this->CreateOrGetPBXGroup(gtgt, sourceGroup);
+        cmXCodeObject* pbxgroup = this->CreateOrGetPBXGroup(gtgt, sourceGroup);
         std::string key = GetGroupMapKey(gtgt, sf);
         this->GroupMap[key] = pbxgroup;
-        }
+      }
 
       // Put OBJECT_LIBRARY objects in proper groups:
       std::vector<std::string> objs;
       gtgt->UseObjectLibraries(objs, "");
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         std::string const& source = *oi;
         cmSourceGroup* sourceGroup =
           mf->FindSourceGroup(source.c_str(), sourceGroups);
-        cmXCodeObject* pbxgroup =
-          this->CreateOrGetPBXGroup(gtgt, sourceGroup);
+        cmXCodeObject* pbxgroup = this->CreateOrGetPBXGroup(gtgt, sourceGroup);
         std::string key = GetGroupMapKeyFromPath(gtgt, source);
         this->GroupMap[key] = pbxgroup;
-        }
       }
     }
+  }
   return true;
 }
 
-cmXCodeObject *cmGlobalXCodeGenerator
-::CreatePBXGroup(cmXCodeObject *parent, std::string name)
+cmXCodeObject* cmGlobalXCodeGenerator::CreatePBXGroup(cmXCodeObject* parent,
+                                                      std::string name)
 {
   cmXCodeObject* parentChildren = NULL;
-  if(parent)
+  if (parent)
     parentChildren = parent->GetObject("children");
   cmXCodeObject* group = this->CreateObject(cmXCodeObject::PBXGroup);
   cmXCodeObject* groupChildren =
-  this->CreateObject(cmXCodeObject::OBJECT_LIST);
+    this->CreateObject(cmXCodeObject::OBJECT_LIST);
   group->AddAttribute("name", this->CreateString(name));
   group->AddAttribute("children", groupChildren);
-  if(this->XcodeVersion == 15)
-  {
+  if (this->XcodeVersion == 15) {
     group->AddAttribute("refType", this->CreateString("4"));
   }
   group->AddAttribute("sourceTree", this->CreateString("<group>"));
-  if(parentChildren)
+  if (parentChildren)
     parentChildren->AddObject(group);
   return group;
 }
 
-cmXCodeObject* cmGlobalXCodeGenerator
-::CreateOrGetPBXGroup(cmGeneratorTarget* gtgt, cmSourceGroup* sg)
+cmXCodeObject* cmGlobalXCodeGenerator::CreateOrGetPBXGroup(
+  cmGeneratorTarget* gtgt, cmSourceGroup* sg)
 {
   std::string s;
   std::string target;
-  const char *targetFolder= gtgt->GetProperty("FOLDER");
-  if(targetFolder) {
+  const char* targetFolder = gtgt->GetProperty("FOLDER");
+  if (targetFolder) {
     target = targetFolder;
     target += "/";
   }
   target += gtgt->GetName();
   s = target + "/";
   s += sg->GetFullName();
-  std::map<std::string, cmXCodeObject* >::iterator it =
+  std::map<std::string, cmXCodeObject*>::iterator it =
     this->GroupNameMap.find(s);
-  if(it != this->GroupNameMap.end())
-    {
+  if (it != this->GroupNameMap.end()) {
     return it->second;
-    }
+  }
 
   it = this->TargetGroup.find(target);
   cmXCodeObject* tgroup = 0;
-  if(it != this->TargetGroup.end())
-    {
+  if (it != this->TargetGroup.end()) {
     tgroup = it->second;
-    }
-  else
-    {
+  } else {
     std::vector<std::string> tgt_folders =
       cmSystemTools::tokenize(target, "/");
     std::string curr_tgt_folder;
-    for(std::vector<std::string>::size_type i = 0; i < tgt_folders.size();i++)
-      {
-      if (i != 0)
-        {
+    for (std::vector<std::string>::size_type i = 0; i < tgt_folders.size();
+         i++) {
+      if (i != 0) {
         curr_tgt_folder += "/";
-        }
+      }
       curr_tgt_folder += tgt_folders[i];
       it = this->TargetGroup.find(curr_tgt_folder);
-      if(it != this->TargetGroup.end())
-        {
+      if (it != this->TargetGroup.end()) {
         tgroup = it->second;
         continue;
-        }
-      tgroup = this->CreatePBXGroup(tgroup,tgt_folders[i]);
+      }
+      tgroup = this->CreatePBXGroup(tgroup, tgt_folders[i]);
       this->TargetGroup[curr_tgt_folder] = tgroup;
-      if(i == 0)
-        {
+      if (i == 0) {
         this->SourcesGroupChildren->AddObject(tgroup);
-        }
       }
     }
+  }
   this->TargetGroup[target] = tgroup;
 
   // If it's the default source group (empty name) then put the source file
   // directly in the tgroup...
   //
-  if (std::string(sg->GetFullName()) == "")
-    {
+  if (std::string(sg->GetFullName()) == "") {
     this->GroupNameMap[s] = tgroup;
     return tgroup;
-    }
+  }
 
-  //It's a recursive folder structure, let's find the real parent group
-  if(std::string(sg->GetFullName()) != std::string(sg->GetName()))
-    {
+  // It's a recursive folder structure, let's find the real parent group
+  if (std::string(sg->GetFullName()) != std::string(sg->GetName())) {
     std::vector<std::string> folders =
       cmSystemTools::tokenize(sg->GetFullName(), "\\");
     std::string curr_folder = target;
     curr_folder += "/";
-    for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
-      {
+    for (std::vector<std::string>::size_type i = 0; i < folders.size(); i++) {
       curr_folder += folders[i];
-      std::map<std::string, cmXCodeObject* >::iterator i_folder =
+      std::map<std::string, cmXCodeObject*>::iterator i_folder =
         this->GroupNameMap.find(curr_folder);
-      //Create new folder
-      if(i_folder == this->GroupNameMap.end())
-        {
-        cmXCodeObject *group = this->CreatePBXGroup(tgroup,folders[i]);
+      // Create new folder
+      if (i_folder == this->GroupNameMap.end()) {
+        cmXCodeObject* group = this->CreatePBXGroup(tgroup, folders[i]);
         this->GroupNameMap[curr_folder] = group;
         tgroup = group;
-        }
-      else
-        {
+      } else {
         tgroup = i_folder->second;
-        }
-      curr_folder = curr_folder + "\\";
       }
-    return tgroup;
+      curr_folder = curr_folder + "\\";
     }
-  cmXCodeObject *group = this->CreatePBXGroup(tgroup,sg->GetName());
+    return tgroup;
+  }
+  cmXCodeObject* group = this->CreatePBXGroup(tgroup, sg->GetName());
   this->GroupNameMap[s] = group;
   return group;
 }
 
-bool cmGlobalXCodeGenerator
-::CreateXCodeObjects(cmLocalGenerator* root,
-                     std::vector<cmLocalGenerator*>&
-                     generators)
+bool cmGlobalXCodeGenerator::CreateXCodeObjects(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
   this->ClearXCodeObjects();
   this->RootObject = 0;
@@ -3263,24 +2764,19 @@ bool cmGlobalXCodeGenerator
   cmXCodeObject* developBuildStyle =
     this->CreateObject(cmXCodeObject::PBXBuildStyle);
   cmXCodeObject* listObjs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-  if(this->XcodeVersion == 15)
-    {
-    developBuildStyle->AddAttribute("name",
-                                    this->CreateString("Development"));
+  if (this->XcodeVersion == 15) {
+    developBuildStyle->AddAttribute("name", this->CreateString("Development"));
     developBuildStyle->AddAttribute("buildSettings", group);
     listObjs->AddObject(developBuildStyle);
     group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
     cmXCodeObject* deployBuildStyle =
-    this->CreateObject(cmXCodeObject::PBXBuildStyle);
+      this->CreateObject(cmXCodeObject::PBXBuildStyle);
     deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
     deployBuildStyle->AddAttribute("buildSettings", group);
     listObjs->AddObject(deployBuildStyle);
-    }
-  else
-    {
-    for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
-      {
+  } else {
+    for (unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i) {
       cmXCodeObject* buildStyle =
         this->CreateObject(cmXCodeObject::PBXBuildStyle);
       const char* name = this->CurrentConfigurationTypes[i].c_str();
@@ -3291,28 +2787,24 @@ bool cmGlobalXCodeGenerator
       sgroup->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
       buildStyle->AddAttribute("buildSettings", sgroup);
       listObjs->AddObject(buildStyle);
-      }
     }
+  }
 
   cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
-  this->MainGroupChildren =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  this->MainGroupChildren = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   mainGroup->AddAttribute("children", this->MainGroupChildren);
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     mainGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   mainGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
 
   cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
-  this->SourcesGroupChildren =
-    this->CreateObject(cmXCodeObject::OBJECT_LIST);
+  this->SourcesGroupChildren = this->CreateObject(cmXCodeObject::OBJECT_LIST);
   sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
   sourcesGroup->AddAttribute("children", this->SourcesGroupChildren);
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     sourcesGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
   this->MainGroupChildren->AddObject(sourcesGroup);
 
@@ -3321,49 +2813,45 @@ bool cmGlobalXCodeGenerator
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   resourcesGroup->AddAttribute("name", this->CreateString("Resources"));
   resourcesGroup->AddAttribute("children", this->ResourcesGroupChildren);
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     resourcesGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   resourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
   this->MainGroupChildren->AddObject(resourcesGroup);
 
   // now create the cmake groups
-  if (!this->CreateGroups(root, generators))
-    {
+  if (!this->CreateGroups(root, generators)) {
     return false;
-    }
+  }
 
   cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
   productGroup->AddAttribute("name", this->CreateString("Products"));
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     productGroup->AddAttribute("refType", this->CreateString("4"));
-    }
+  }
   productGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
   cmXCodeObject* productGroupChildren =
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   productGroup->AddAttribute("children", productGroupChildren);
   this->MainGroupChildren->AddObject(productGroup);
 
-
   this->RootObject = this->CreateObject(cmXCodeObject::PBXProject);
   this->RootObject->SetComment("Project object");
 
   std::string project_id = "PROJECT_";
   project_id += root->GetProjectName();
-  this->RootObject->SetId(this->GetOrCreateId(
-    project_id.c_str(), this->RootObject->GetId()).c_str());
+  this->RootObject->SetId(
+    this->GetOrCreateId(project_id.c_str(), this->RootObject->GetId())
+      .c_str());
 
   group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   this->RootObject->AddAttribute("mainGroup",
-                             this->CreateObjectReference(mainGroup));
+                                 this->CreateObjectReference(mainGroup));
   this->RootObject->AddAttribute("buildSettings", group);
   this->RootObject->AddAttribute("buildStyles", listObjs);
   this->RootObject->AddAttribute("hasScannedForEncodings",
-                             this->CreateString("0"));
-  if (this->XcodeVersion >= 30)
-    {
+                                 this->CreateString("0"));
+  if (this->XcodeVersion >= 30) {
     group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
     group->AddAttribute("BuildIndependentTargetsInParallel",
                         this->CreateString("YES"));
@@ -3380,14 +2868,13 @@ bool cmGlobalXCodeGenerator
     else
       this->RootObject->AddAttribute("compatibilityVersion",
                                      this->CreateString("Xcode 3.0"));
-    }
+  }
   // Point Xcode at the top of the source tree.
   {
-  std::string pdir =
-    this->RelativeToBinary(root->GetCurrentSourceDirectory());
-  this->RootObject->AddAttribute("projectDirPath",
-                                 this->CreateString(pdir));
-  this->RootObject->AddAttribute("projectRoot", this->CreateString(""));
+    std::string pdir =
+      this->RelativeToBinary(root->GetCurrentSourceDirectory());
+    this->RootObject->AddAttribute("projectDirPath", this->CreateString(pdir));
+    this->RootObject->AddAttribute("projectRoot", this->CreateString(""));
   }
   cmXCodeObject* configlist =
     this->CreateObject(cmXCodeObject::XCConfigurationList);
@@ -3395,9 +2882,8 @@ bool cmGlobalXCodeGenerator
     this->CreateObject(cmXCodeObject::OBJECT_LIST);
   typedef std::vector<std::pair<std::string, cmXCodeObject*> > Configs;
   Configs configs;
-  const char *defaultConfigName = "Debug";
-  if(this->XcodeVersion == 15)
-    {
+  const char* defaultConfigName = "Debug";
+  if (this->XcodeVersion == 15) {
     cmXCodeObject* configDebug =
       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
     configDebug->AddAttribute("name", this->CreateString("Debug"));
@@ -3406,26 +2892,21 @@ bool cmGlobalXCodeGenerator
       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
     configRelease->AddAttribute("name", this->CreateString("Release"));
     configs.push_back(std::make_pair("Release", configRelease));
-    }
-  else
-    {
-    for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
-      {
+  } else {
+    for (unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i) {
       const char* name = this->CurrentConfigurationTypes[i].c_str();
-      if (0 == i)
-        {
+      if (0 == i) {
         defaultConfigName = name;
-        }
+      }
       cmXCodeObject* config =
         this->CreateObject(cmXCodeObject::XCBuildConfiguration);
       config->AddAttribute("name", this->CreateString(name));
       configs.push_back(std::make_pair(name, config));
-      }
     }
-  for(Configs::iterator c = configs.begin(); c != configs.end(); ++c)
-    {
+  }
+  for (Configs::iterator c = configs.begin(); c != configs.end(); ++c) {
     buildConfigurations->AddObject(c->second);
-    }
+  }
   configlist->AddAttribute("buildConfigurations", buildConfigurations);
 
   std::string comment = "Build configuration list for PBXProject";
@@ -3438,133 +2919,111 @@ bool cmGlobalXCodeGenerator
   configlist->AddAttribute("defaultConfigurationName",
                            this->CreateString(defaultConfigName));
   cmXCodeObject* buildSettings =
-      this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+    this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
   const char* osxArch =
-      this->CurrentMakefile->GetDefinition("CMAKE_OSX_ARCHITECTURES");
+    this->CurrentMakefile->GetDefinition("CMAKE_OSX_ARCHITECTURES");
   const char* sysroot =
-      this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
+    this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
   const char* deploymentTarget =
     this->CurrentMakefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
   std::string archs;
-  if(sysroot)
-    {
-    if(osxArch)
-      {
+  if (sysroot) {
+    if (osxArch) {
       // recompute this as it may have been changed since enable language
       this->Architectures.clear();
       cmSystemTools::ExpandListArgument(std::string(osxArch),
                                         this->Architectures);
       archs = cmJoin(this->Architectures, " ");
-      }
-    buildSettings->AddAttribute("SDKROOT",
-                                this->CreateString(sysroot));
     }
-  if (archs.empty())
-    {
+    buildSettings->AddAttribute("SDKROOT", this->CreateString(sysroot));
+  }
+  if (archs.empty()) {
     // Tell Xcode to use NATIVE_ARCH instead of ARCHS.
     buildSettings->AddAttribute("ONLY_ACTIVE_ARCH", this->CreateString("YES"));
-    }
-  else
-    {
+  } else {
     // Tell Xcode to use ARCHS (ONLY_ACTIVE_ARCH defaults to NO).
     buildSettings->AddAttribute("ARCHS", this->CreateString(archs));
-    }
-  if(deploymentTarget && *deploymentTarget)
-    {
+  }
+  if (deploymentTarget && *deploymentTarget) {
     buildSettings->AddAttribute("MACOSX_DEPLOYMENT_TARGET",
                                 this->CreateString(deploymentTarget));
-    }
-  if(!this->GeneratorToolset.empty())
-    {
+  }
+  if (!this->GeneratorToolset.empty()) {
     buildSettings->AddAttribute("GCC_VERSION",
-      this->CreateString(this->GeneratorToolset));
-    }
+                                this->CreateString(this->GeneratorToolset));
+  }
 
   std::string symroot = root->GetCurrentBinaryDirectory();
   symroot += "/build";
   buildSettings->AddAttribute("SYMROOT", this->CreateString(symroot));
 
-  for(Configs::iterator i = configs.begin(); i != configs.end(); ++i)
-    {
+  for (Configs::iterator i = configs.begin(); i != configs.end(); ++i) {
     cmXCodeObject* buildSettingsForCfg = this->CreateFlatClone(buildSettings);
 
     // Put this last so it can override existing settings
     // Convert "CMAKE_XCODE_ATTRIBUTE_*" variables directly.
     std::vector<std::string> vars = this->CurrentMakefile->GetDefinitions();
-    for(std::vector<std::string>::const_iterator d = vars.begin();
-        d != vars.end(); ++d)
-      {
-      if(d->find("CMAKE_XCODE_ATTRIBUTE_") == 0)
-        {
+    for (std::vector<std::string>::const_iterator d = vars.begin();
+         d != vars.end(); ++d) {
+      if (d->find("CMAKE_XCODE_ATTRIBUTE_") == 0) {
         std::string attribute = d->substr(22);
         this->FilterConfigurationAttribute(i->first, attribute);
-        if(!attribute.empty())
-          {
+        if (!attribute.empty()) {
           cmGeneratorExpression ge;
           std::string processed =
             ge.Parse(this->CurrentMakefile->GetDefinition(*d))
               ->Evaluate(this->CurrentLocalGenerator, i->first);
           buildSettingsForCfg->AddAttribute(attribute,
-            this->CreateString(processed));
-          }
+                                            this->CreateString(processed));
         }
       }
+    }
     // store per-config buildSettings into configuration object
     i->second->AddAttribute("buildSettings", buildSettingsForCfg);
-    }
+  }
 
   this->RootObject->AddAttribute("buildConfigurationList",
-                             this->CreateObjectReference(configlist));
+                                 this->CreateObjectReference(configlist));
 
   std::vector<cmXCodeObject*> targets;
-  for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
-      i != generators.end(); ++i)
-    {
-    if(!this->IsExcluded(root, *i))
-      {
-      if (!this->CreateXCodeTargets(*i, targets))
-        {
+  for (std::vector<cmLocalGenerator*>::iterator i = generators.begin();
+       i != generators.end(); ++i) {
+    if (!this->IsExcluded(root, *i)) {
+      if (!this->CreateXCodeTargets(*i, targets)) {
         return false;
-        }
       }
     }
+  }
   // loop over all targets and add link and depend info
-  for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-      i != targets.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+       i != targets.end(); ++i) {
     cmXCodeObject* t = *i;
     this->AddDependAndLinkInformation(t);
-    }
-  if(this->XcodeVersion < 50)
-    {
+  }
+  if (this->XcodeVersion < 50) {
     // now create xcode depend hack makefile
     this->CreateXCodeDependHackTarget(targets);
-    }
+  }
   // now add all targets to the root object
   cmXCodeObject* allTargets = this->CreateObject(cmXCodeObject::OBJECT_LIST);
-  for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-      i != targets.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+       i != targets.end(); ++i) {
     cmXCodeObject* t = *i;
     allTargets->AddObject(t);
     cmXCodeObject* productRef = t->GetObject("productReference");
-    if(productRef)
-      {
+    if (productRef) {
       productGroupChildren->AddObject(productRef->GetObject());
-      }
     }
+  }
   this->RootObject->AddAttribute("targets", allTargets);
   return true;
 }
 
-std::string
-cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
-  const std::string &projName,
-  const std::string &configName,
-  const cmGeneratorTarget *t) const
+std::string cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
+  const std::string& projName, const std::string& configName,
+  const cmGeneratorTarget* t) const
 {
-  std::string dir =
-    t->GetLocalGenerator()->GetCurrentBinaryDirectory();
+  std::string dir = t->GetLocalGenerator()->GetCurrentBinaryDirectory();
   dir += "/";
   dir += projName;
   dir += ".build/";
@@ -3576,18 +3035,15 @@ cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
   return dir;
 }
 
-void
-cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
+void cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
   std::vector<cmXCodeObject*>& targets)
 {
-  cmGeneratedFileStream
-    makefileStream(this->CurrentXCodeHackMakefile.c_str());
-  if(!makefileStream)
-    {
+  cmGeneratedFileStream makefileStream(this->CurrentXCodeHackMakefile.c_str());
+  if (!makefileStream) {
     cmSystemTools::Error("Could not create",
                          this->CurrentXCodeHackMakefile.c_str());
     return;
-    }
+  }
   makefileStream.SetCopyIfDifferent(true);
   // one more pass for external depend information not handled
   // correctly by xcode
@@ -3603,26 +3059,23 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
     "so the target does not have to exist\n";
   /* clang-format on */
   std::set<std::string> emitted;
-  for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-      i != targets.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+       i != targets.end(); ++i) {
     cmXCodeObject* target = *i;
     std::map<std::string, cmXCodeObject::StringVec> const& deplibs =
       target->GetDependLibraries();
-    for(std::map<std::string, cmXCodeObject::StringVec>::const_iterator ci
-          = deplibs.begin(); ci != deplibs.end(); ++ci)
-      {
-      for(cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
-          d != ci->second.end(); ++d)
-        {
-        if(emitted.insert(*d).second)
-          {
-          makefileStream <<
-            this->ConvertToRelativeForMake(d->c_str()) << ":\n";
-          }
+    for (std::map<std::string, cmXCodeObject::StringVec>::const_iterator ci =
+           deplibs.begin();
+         ci != deplibs.end(); ++ci) {
+      for (cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
+           d != ci->second.end(); ++d) {
+        if (emitted.insert(*d).second) {
+          makefileStream << this->ConvertToRelativeForMake(d->c_str())
+                         << ":\n";
         }
       }
     }
+  }
   makefileStream << "\n\n";
 
   // Write rules to help Xcode relink things at the right time.
@@ -3632,66 +3085,58 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
     "# link.  This forces Xcode to relink the targets from scratch.  It\n"
     "# does not seem to check these dependencies itself.\n";
   /* clang-format on */
-  for(std::vector<std::string>::const_iterator
-        ct = this->CurrentConfigurationTypes.begin();
-      ct != this->CurrentConfigurationTypes.end(); ++ct)
-    {
+  for (std::vector<std::string>::const_iterator ct =
+         this->CurrentConfigurationTypes.begin();
+       ct != this->CurrentConfigurationTypes.end(); ++ct) {
     std::string configName = *ct;
-    for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
-        i != targets.end(); ++i)
-      {
+    for (std::vector<cmXCodeObject*>::iterator i = targets.begin();
+         i != targets.end(); ++i) {
       cmXCodeObject* target = *i;
-      cmGeneratorTarget* gt =target->GetTarget();
-
-      if(gt->GetType() == cmState::EXECUTABLE ||
-// Nope - no post-build for OBJECT_LIRBRARY
-//         gt->GetType() == cmState::OBJECT_LIBRARY ||
-         gt->GetType() == cmState::STATIC_LIBRARY ||
-         gt->GetType() == cmState::SHARED_LIBRARY ||
-         gt->GetType() == cmState::MODULE_LIBRARY)
-        {
+      cmGeneratorTarget* gt = target->GetTarget();
+
+      if (gt->GetType() == cmState::EXECUTABLE ||
+          // Nope - no post-build for OBJECT_LIRBRARY
+          //         gt->GetType() == cmState::OBJECT_LIBRARY ||
+          gt->GetType() == cmState::STATIC_LIBRARY ||
+          gt->GetType() == cmState::SHARED_LIBRARY ||
+          gt->GetType() == cmState::MODULE_LIBRARY) {
         // Declare an entry point for the target post-build phase.
         makefileStream << this->PostBuildMakeTarget(gt->GetName(), *ct)
                        << ":\n";
-        }
+      }
 
-      if(gt->GetType() == cmState::EXECUTABLE ||
-         gt->GetType() == cmState::SHARED_LIBRARY ||
-         gt->GetType() == cmState::MODULE_LIBRARY)
-        {
+      if (gt->GetType() == cmState::EXECUTABLE ||
+          gt->GetType() == cmState::SHARED_LIBRARY ||
+          gt->GetType() == cmState::MODULE_LIBRARY) {
         std::string tfull = gt->GetFullPath(configName);
         std::string trel = this->ConvertToRelativeForMake(tfull.c_str());
 
         // Add this target to the post-build phases of its dependencies.
-        std::map<std::string, cmXCodeObject::StringVec>::const_iterator
-          y = target->GetDependTargets().find(*ct);
-        if(y != target->GetDependTargets().end())
-          {
+        std::map<std::string, cmXCodeObject::StringVec>::const_iterator y =
+          target->GetDependTargets().find(*ct);
+        if (y != target->GetDependTargets().end()) {
           std::vector<std::string> const& deptgts = y->second;
-          for(std::vector<std::string>::const_iterator d = deptgts.begin();
-              d != deptgts.end(); ++d)
-            {
+          for (std::vector<std::string>::const_iterator d = deptgts.begin();
+               d != deptgts.end(); ++d) {
             makefileStream << this->PostBuildMakeTarget(*d, *ct) << ": "
                            << trel << "\n";
-            }
           }
+        }
 
         // Create a rule for this target.
         makefileStream << trel << ":";
 
         // List dependencies if any exist.
-        std::map<std::string, cmXCodeObject::StringVec>::const_iterator
-          x = target->GetDependLibraries().find(*ct);
-        if(x != target->GetDependLibraries().end())
-          {
+        std::map<std::string, cmXCodeObject::StringVec>::const_iterator x =
+          target->GetDependLibraries().find(*ct);
+        if (x != target->GetDependLibraries().end()) {
           std::vector<std::string> const& deplibs = x->second;
-          for(std::vector<std::string>::const_iterator d = deplibs.begin();
-              d != deplibs.end(); ++d)
-            {
-            makefileStream << "\\\n\t" <<
-              this->ConvertToRelativeForMake(d->c_str());
-            }
+          for (std::vector<std::string>::const_iterator d = deplibs.begin();
+               d != deplibs.end(); ++d) {
+            makefileStream << "\\\n\t"
+                           << this->ConvertToRelativeForMake(d->c_str());
           }
+        }
         // Write the action to remove the target if it is out of date.
         makefileStream << "\n";
         makefileStream << "\t/bin/rm -f "
@@ -3699,69 +3144,59 @@ cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
                        << "\n";
         // if building for more than one architecture
         // then remove those exectuables as well
-        if(this->Architectures.size() > 1)
-          {
+        if (this->Architectures.size() > 1) {
           std::string universal = this->GetObjectsNormalDirectory(
             this->CurrentProject, configName, gt);
-          for( std::vector<std::string>::iterator arch =
+          for (std::vector<std::string>::iterator arch =
                  this->Architectures.begin();
-               arch != this->Architectures.end(); ++arch)
-            {
+               arch != this->Architectures.end(); ++arch) {
             std::string universalFile = universal;
             universalFile += *arch;
             universalFile += "/";
             universalFile += gt->GetFullName(configName);
             makefileStream << "\t/bin/rm -f "
-                           <<
-              this->ConvertToRelativeForMake(universalFile.c_str())
+                           << this->ConvertToRelativeForMake(
+                                universalFile.c_str())
                            << "\n";
-            }
           }
-        makefileStream << "\n\n";
         }
+        makefileStream << "\n\n";
       }
     }
+  }
 }
 
-void
-cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
-                                           std::vector<cmLocalGenerator*>&
-                                           generators)
+void cmGlobalXCodeGenerator::OutputXCodeProject(
+  cmLocalGenerator* root, std::vector<cmLocalGenerator*>& generators)
 {
-  if(generators.size() == 0)
-    {
+  if (generators.size() == 0) {
     return;
-    }
+  }
   // Skip local generators that are excluded from this project.
-  for(std::vector<cmLocalGenerator*>::iterator g = generators.begin();
-      g != generators.end(); ++g)
-    {
-    if(this->IsExcluded(root, *g))
-      {
+  for (std::vector<cmLocalGenerator*>::iterator g = generators.begin();
+       g != generators.end(); ++g) {
+    if (this->IsExcluded(root, *g)) {
       continue;
-      }
     }
+  }
 
-  if (!this->CreateXCodeObjects(root, generators))
-    {
+  if (!this->CreateXCodeObjects(root, generators)) {
     return;
-    }
+  }
   std::string xcodeDir = root->GetCurrentBinaryDirectory();
   xcodeDir += "/";
   xcodeDir += root->GetProjectName();
   xcodeDir += ".xcode";
-  if(this->XcodeVersion > 20)
-    {
+  if (this->XcodeVersion > 20) {
     xcodeDir += "proj";
-    }
+  }
   cmSystemTools::MakeDirectory(xcodeDir.c_str());
   std::string xcodeProjFile = xcodeDir + "/project.pbxproj";
   cmGeneratedFileStream fout(xcodeProjFile.c_str());
   fout.SetCopyIfDifferent(true);
-  if(!fout)
-    {
+  if (!fout) {
     return;
-    }
+  }
   this->WriteXCodePBXProj(fout, root, generators);
   this->ClearXCodeObjects();
 
@@ -3771,10 +3206,9 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
     root->GetBinaryDirectory());
 }
 
-void
-cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
-                                          cmLocalGenerator* ,
-                                          std::vector<cmLocalGenerator*>& )
+void cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
+                                               cmLocalGenerator*,
+                                               std::vector<cmLocalGenerator*>&)
 {
   SortXCodeObjects();
 
@@ -3787,8 +3221,7 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
   cmXCodeObject::Indent(1, fout);
   fout << "};\n";
   cmXCodeObject::Indent(1, fout);
-  if(this->XcodeVersion >= 21)
-    {
+  if (this->XcodeVersion >= 21) {
     if (this->XcodeVersion >= 32)
       fout << "objectVersion = 46;\n";
     else if (this->XcodeVersion >= 31)
@@ -3798,12 +3231,10 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
     else
       fout << "objectVersion = 42;\n";
     cmXCode21Object::PrintList(this->XCodeObjects, fout);
-    }
-  else
-    {
+  } else {
     fout << "objectVersion = 39;\n";
     cmXCodeObject::PrintList(this->XCodeObjects, fout);
-    }
+  }
   cmXCodeObject::Indent(1, fout);
   fout << "rootObject = " << this->RootObject->GetId()
        << " /* Project object */;\n";
@@ -3812,31 +3243,28 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
 
 const char* cmGlobalXCodeGenerator::GetCMakeCFGIntDir() const
 {
-  return this->XcodeVersion >= 21 ?
-    "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" : ".";
+  return this->XcodeVersion >= 21
+    ? "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)"
+    : ".";
 }
 
-std::string cmGlobalXCodeGenerator::ExpandCFGIntDir(const std::string& str,
-                                        const std::string& config) const
+std::string cmGlobalXCodeGenerator::ExpandCFGIntDir(
+  const std::string& str, const std::string& config) const
 {
   std::string replace1 = "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)";
   std::string replace2 = "$(CONFIGURATION)";
 
   std::string tmp = str;
-  for(std::string::size_type i = tmp.find(replace1);
-      i != std::string::npos;
-      i = tmp.find(replace1, i))
-    {
+  for (std::string::size_type i = tmp.find(replace1); i != std::string::npos;
+       i = tmp.find(replace1, i)) {
     tmp.replace(i, replace1.size(), config);
     i += config.size();
-    }
-  for(std::string::size_type i = tmp.find(replace2);
-      i != std::string::npos;
-      i = tmp.find(replace2, i))
-    {
+  }
+  for (std::string::size_type i = tmp.find(replace2); i != std::string::npos;
+       i = tmp.find(replace2, i)) {
     tmp.replace(i, replace2.size(), config);
     i += config.size();
-    }
+  }
   return tmp;
 }
 
@@ -3855,66 +3283,55 @@ std::string cmGlobalXCodeGenerator::RelativeToSource(const char* p)
 {
   // We force conversion because Xcode breakpoints do not work unless
   // they are in a file named relative to the source tree.
-  return this->CurrentLocalGenerator->
-    ConvertToRelativePath(this->ProjectSourceDirectoryComponents, p, true);
+  return this->CurrentLocalGenerator->ConvertToRelativePath(
+    this->ProjectSourceDirectoryComponents, p, true);
 }
 
 std::string cmGlobalXCodeGenerator::RelativeToBinary(const char* p)
 {
-  return this->CurrentLocalGenerator->
-    ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
+  return this->CurrentLocalGenerator->ConvertToRelativePath(
+    this->ProjectOutputDirectoryComponents, p);
 }
 
 std::string cmGlobalXCodeGenerator::XCodeEscapePath(const std::string& p)
 {
-  if(p.find(' ') != p.npos)
-    {
+  if (p.find(' ') != p.npos) {
     std::string t = "\"";
     t += p;
     t += "\"";
     return t;
-    }
+  }
   return p;
 }
 
-void
-cmGlobalXCodeGenerator
-::AppendDirectoryForConfig(const std::string& prefix,
-                           const std::string& config,
-                           const std::string& suffix,
-                           std::string& dir)
+void cmGlobalXCodeGenerator::AppendDirectoryForConfig(
+  const std::string& prefix, const std::string& config,
+  const std::string& suffix, std::string& dir)
 {
-  if(this->XcodeVersion > 20)
-    {
-    if(!config.empty())
-      {
+  if (this->XcodeVersion > 20) {
+    if (!config.empty()) {
       dir += prefix;
       dir += config;
       dir += suffix;
-      }
     }
+  }
 }
 
 std::string cmGlobalXCodeGenerator::LookupFlags(
-                                              const std::string& varNamePrefix,
-                                              const std::string& varNameLang,
-                                              const std::string& varNameSuffix,
-                                              const std::string& default_flags)
+  const std::string& varNamePrefix, const std::string& varNameLang,
+  const std::string& varNameSuffix, const std::string& default_flags)
 {
-  if(!varNameLang.empty())
-    {
+  if (!varNameLang.empty()) {
     std::string varName = varNamePrefix;
     varName += varNameLang;
     varName += varNameSuffix;
-    if(const char* varValue =
-       this->CurrentMakefile->GetDefinition(varName.c_str()))
-      {
-      if(*varValue)
-        {
+    if (const char* varValue =
+          this->CurrentMakefile->GetDefinition(varName.c_str())) {
+      if (*varValue) {
         return varValue;
-        }
       }
     }
+  }
   return default_flags;
 }
 
@@ -3923,10 +3340,9 @@ void cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
                                            bool dflag)
 {
   // Skip this if there are no definitions.
-  if(!defines_list)
-    {
+  if (!defines_list) {
     return;
-    }
+  }
 
   // Expand the list of definitions.
   std::vector<std::string> defines;
@@ -3936,41 +3352,37 @@ void cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
   this->AppendDefines(defs, defines, dflag);
 }
 
-void
-cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
-                                      std::vector<std::string> const& defines,
-                                      bool dflag)
+void cmGlobalXCodeGenerator::AppendDefines(
+  BuildObjectListOrString& defs, std::vector<std::string> const& defines,
+  bool dflag)
 {
   // GCC_PREPROCESSOR_DEFINITIONS is a space-separated list of definitions.
   std::string def;
-  for(std::vector<std::string>::const_iterator di = defines.begin();
-      di != defines.end(); ++di)
-    {
+  for (std::vector<std::string>::const_iterator di = defines.begin();
+       di != defines.end(); ++di) {
     // Start with -D if requested.
-    def = dflag? "-D": "";
+    def = dflag ? "-D" : "";
     def += *di;
 
     // Append the flag with needed escapes.
     std::string tmp;
     this->AppendFlag(tmp, def);
     defs.Add(tmp);
-    }
+  }
 }
 
 void cmGlobalXCodeGenerator::AppendFlag(std::string& flags,
                                         std::string const& flag)
 {
   // Short-circuit for an empty flag.
-  if(flag.empty())
-    {
+  if (flag.empty()) {
     return;
-    }
+  }
 
   // Separate from previous flags.
-  if(!flags.empty())
-    {
+  if (!flags.empty()) {
     flags += " ";
-    }
+  }
 
   // Check if the flag needs quoting.
   bool quoteFlag =
@@ -3986,48 +3398,36 @@ void cmGlobalXCodeGenerator::AppendFlag(std::string& flags,
   // The final level of escaping is done when the string is stored
   // into the project file by cmXCodeObject::PrintString.
 
-  if(quoteFlag)
-    {
+  if (quoteFlag) {
     // Open single quote.
     flags += "'";
-    }
+  }
 
   // Flag value with escaped quotes and backslashes.
-  for(const char* c = flag.c_str(); *c; ++c)
-    {
-    if(*c == '\'')
-      {
-      if (this->XcodeVersion >= 40)
-        {
+  for (const char* c = flag.c_str(); *c; ++c) {
+    if (*c == '\'') {
+      if (this->XcodeVersion >= 40) {
         flags += "'\\''";
-        }
-      else
-        {
+      } else {
         flags += "\\'";
-        }
       }
-    else if(*c == '\\')
-      {
+    } else if (*c == '\\') {
       flags += "\\\\";
-      }
-    else
-      {
+    } else {
       flags += *c;
-      }
     }
+  }
 
-  if(quoteFlag)
-    {
+  if (quoteFlag) {
     // Close single quote.
     flags += "'";
-    }
+  }
 }
 
-std::string
-cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmGeneratorTarget* target)
+std::string cmGlobalXCodeGenerator::ComputeInfoPListLocation(
+  cmGeneratorTarget* target)
 {
-  std::string plist =
-      target->GetLocalGenerator()->GetCurrentBinaryDirectory();
+  std::string plist = target->GetLocalGenerator()->GetCurrentBinaryDirectory();
   plist += cmake::GetCMakeFilesDirectory();
   plist += "/";
   plist += target->GetName();
@@ -4040,33 +3440,29 @@ cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmGeneratorTarget* target)
 bool cmGlobalXCodeGenerator::IsMultiConfig()
 {
   // Old Xcode 1.5 is single config:
-  if(this->XcodeVersion == 15)
-    {
+  if (this->XcodeVersion == 15) {
     return false;
-    }
+  }
 
   // Newer Xcode versions are multi config:
   return true;
 }
 
-void cmGlobalXCodeGenerator
-::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
+void cmGlobalXCodeGenerator::ComputeTargetObjectDirectory(
+  cmGeneratorTarget* gt) const
 {
   std::string configName = this->GetCMakeCFGIntDir();
-  std::string dir = this->GetObjectsNormalDirectory(
-    "$(PROJECT_NAME)", configName, gt);
-  if(this->XcodeVersion >= 21)
-    {
+  std::string dir =
+    this->GetObjectsNormalDirectory("$(PROJECT_NAME)", configName, gt);
+  if (this->XcodeVersion >= 21) {
     dir += "$(CURRENT_ARCH)/";
-    }
-  else
-    {
+  } else {
 #ifdef __ppc__
     dir += "ppc/";
 #endif
 #ifdef __i386
     dir += "i386/";
 #endif
-    }
+  }
   gt->ObjectDirectory = dir;
 }
diff --git a/Source/cmGlobalXCodeGenerator.h b/Source/cmGlobalXCodeGenerator.h
index c3b3613..2ca4c19 100644
--- a/Source/cmGlobalXCodeGenerator.h
+++ b/Source/cmGlobalXCodeGenerator.h
@@ -20,7 +20,6 @@ class cmGlobalGeneratorFactory;
 class cmSourceFile;
 class cmSourceGroup;
 
-
 /** \class cmGlobalXCodeGenerator
  * \brief Write a Unix makefiles.
  *
@@ -33,36 +32,34 @@ public:
   static cmGlobalGeneratorFactory* NewFactory();
 
   ///! Get the name for the generator.
-  virtual std::string GetName() const {
-    return cmGlobalXCodeGenerator::GetActualName();}
-  static std::string GetActualName() {return "Xcode";}
+  virtual std::string GetName() const
+  {
+    return cmGlobalXCodeGenerator::GetActualName();
+  }
+  static std::string GetActualName() { return "Xcode"; }
 
   /** Get the documentation entry for this generator.  */
   static void GetDocumentation(cmDocumentationEntry& entry);
 
   ///! Create a local generator appropriate to this Global Generator
-  virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile *mf);
+  virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf);
 
   /**
    * Try to determine system information such as shared library
    * extension, pthreads, byte order etc.
    */
-  virtual void EnableLanguage(std::vector<std::string>const& languages,
-                              cmMakefile *, bool optional);
+  virtual void EnableLanguage(std::vector<std::string> const& languages,
+                              cmMakefile*, bool optional);
   /**
    * Try running cmake and building a file. This is used for dynalically
    * loaded commands, not as part of the usual build process.
    */
   virtual void GenerateBuildCommand(
-    std::vector<std::string>& makeCommand,
-    const std::string& makeProgram,
-    const std::string& projectName,
-    const std::string& projectDir,
-    const std::string& targetName,
-    const std::string& config,
-    bool fast, bool verbose,
-    std::vector<std::string> const& makeOptions = std::vector<std::string>()
-    );
+    std::vector<std::string>& makeCommand, const std::string& makeProgram,
+    const std::string& projectName, const std::string& projectDir,
+    const std::string& targetName, const std::string& config, bool fast,
+    bool verbose,
+    std::vector<std::string> const& makeOptions = std::vector<std::string>());
 
   /** Append the subdirectory for the given configuration.  */
   virtual void AppendDirectoryForConfig(const std::string& prefix,
@@ -86,17 +83,17 @@ public:
 
   virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
   void AppendFlag(std::string& flags, std::string const& flag);
+
 protected:
   virtual void AddExtraIDETargets();
   virtual void Generate();
+
 private:
   cmXCodeObject* CreateOrGetPBXGroup(cmGeneratorTarget* gtgt,
                                      cmSourceGroup* sg);
-  cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
-                                std::string name);
+  cmXCodeObject* CreatePBXGroup(cmXCodeObject* parent, std::string name);
   bool CreateGroups(cmLocalGenerator* root,
-                    std::vector<cmLocalGenerator*>&
-                    generators);
+                    std::vector<cmLocalGenerator*>& generators);
   std::string XCodeEscapePath(const std::string& p);
   std::string RelativeToSource(const char* p);
   std::string RelativeToBinary(const char* p);
@@ -107,22 +104,21 @@ private:
                             cmXCodeObject* resourceBuildPhase,
                             std::vector<cmXCodeObject*> contentBuildPhases,
                             cmXCodeObject* frameworkBuildPhase,
-                            cmGeneratorTarget *gtgt);
+                            cmGeneratorTarget* gtgt);
 
-  std::string ComputeInfoPListLocation(cmGeneratorTarget *target);
+  std::string ComputeInfoPListLocation(cmGeneratorTarget* target);
 
   void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
-                               cmGeneratorTarget *target,
-                               std::vector<cmCustomCommand>
-                               const & commands,
+                               cmGeneratorTarget* target,
+                               std::vector<cmCustomCommand> const& commands,
                                const char* commandFileName);
 
   void CreateCustomRulesMakefile(const char* makefileBasename,
                                  cmGeneratorTarget* target,
-                                 std::vector<cmCustomCommand> const & commands,
+                                 std::vector<cmCustomCommand> const& commands,
                                  const std::string& configName);
 
-  cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget *);
+  cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget*);
   std::string GetOrCreateId(const std::string& name, const std::string& id);
 
   // create cmXCodeObject from these functions so that memory can be managed
@@ -132,23 +128,23 @@ private:
   cmXCodeObject* CreateString(const std::string& s);
   cmXCodeObject* CreateObjectReference(cmXCodeObject*);
   cmXCodeObject* CreateFlatClone(cmXCodeObject*);
-  cmXCodeObject* CreateXCodeTarget(cmGeneratorTarget *gtgt,
+  cmXCodeObject* CreateXCodeTarget(cmGeneratorTarget* gtgt,
                                    cmXCodeObject* buildPhases);
   void ForceLinkerLanguages();
   void ForceLinkerLanguage(cmGeneratorTarget* gtgt);
-  const char* GetTargetLinkFlagsVar(const cmGeneratorTarget *target) const;
+  const char* GetTargetLinkFlagsVar(const cmGeneratorTarget* target) const;
   const char* GetTargetFileType(cmGeneratorTarget* target);
   const char* GetTargetProductType(cmGeneratorTarget* target);
   std::string AddConfigurations(cmXCodeObject* target,
-                                cmGeneratorTarget *gtgt);
+                                cmGeneratorTarget* gtgt);
   void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
                                const char* value);
   void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
                                    const char* value,
                                    const std::string& configName);
-  cmXCodeObject* CreateUtilityTarget(cmGeneratorTarget *gtgt);
+  cmXCodeObject* CreateUtilityTarget(cmGeneratorTarget* gtgt);
   void AddDependAndLinkInformation(cmXCodeObject* target);
-  void CreateBuildSettings(cmGeneratorTarget *gtgt,
+  void CreateBuildSettings(cmGeneratorTarget* gtgt,
                            cmXCodeObject* buildSettings,
                            const std::string& buildType);
   std::string ExtractFlag(const char* flag, std::string& flags);
@@ -165,32 +161,28 @@ private:
                           std::vector<cmLocalGenerator*>& generators);
   void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
                          std::vector<cmLocalGenerator*>& generators);
-  cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath,
-                                                  cmGeneratorTarget *target,
-                                                  const std::string &lang,
+  cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string& fullpath,
+                                                  cmGeneratorTarget* target,
+                                                  const std::string& lang,
                                                   cmSourceFile* sf);
-  cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
-                                               cmGeneratorTarget *target,
-                                               const std::string &lang,
+  cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string& fullpath,
+                                               cmGeneratorTarget* target,
+                                               const std::string& lang,
                                                cmSourceFile* sf);
   cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
-                                          cmGeneratorTarget *target);
-  cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
-                                       cmSourceFile* sf,
-                                       cmGeneratorTarget *gtgt);
-  bool CreateXCodeTargets(cmLocalGenerator* gen,
-                          std::vector<cmXCodeObject*>&);
+                                          cmGeneratorTarget* target);
+  cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen, cmSourceFile* sf,
+                                       cmGeneratorTarget* gtgt);
+  bool CreateXCodeTargets(cmLocalGenerator* gen, std::vector<cmXCodeObject*>&);
   bool IsHeaderFile(cmSourceFile*);
-  void AddDependTarget(cmXCodeObject* target,
-                       cmXCodeObject* dependTarget);
+  void AddDependTarget(cmXCodeObject* target, cmXCodeObject* dependTarget);
   void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
   bool SpecialTargetEmitted(std::string const& tname);
   void SetGenerationRoot(cmLocalGenerator* root);
   void AddExtraTargets(cmLocalGenerator* root,
                        std::vector<cmLocalGenerator*>& gens);
-  cmXCodeObject* CreateBuildPhase(const char* name,
-                                  const char* name2,
-                                  cmGeneratorTarget *target,
+  cmXCodeObject* CreateBuildPhase(const char* name, const char* name2,
+                                  cmGeneratorTarget* target,
                                   const std::vector<cmCustomCommand>&);
   void CreateReRunCMakeFile(cmLocalGenerator* root,
                             std::vector<cmLocalGenerator*> const& gens);
@@ -211,6 +203,7 @@ private:
                      bool dflag = false);
 
   void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
+
 protected:
   virtual const char* GetInstallTargetName() const { return "install"; }
   virtual const char* GetPackageTargetName() const { return "package"; }
@@ -220,6 +213,7 @@ protected:
   std::set<std::string> XCodeObjectIDs;
   std::vector<cmXCodeObject*> XCodeObjects;
   cmXCodeObject* RootObject;
+
 private:
   std::string const& GetXcodeBuildCommand();
   std::string FindXcodeBuildCommand();
@@ -227,13 +221,15 @@ private:
   bool XcodeBuildCommandInitialized;
 
   void PrintCompilerAdvice(std::ostream&, std::string const&,
-                           const char*) const {}
+                           const char*) const
+  {
+  }
 
-  std::string GetObjectsNormalDirectory(const std::string &projName,
-    const std::string &configName,
-    const cmGeneratorTarget *t) const;
+  std::string GetObjectsNormalDirectory(const std::string& projName,
+                                        const std::string& configName,
+                                        const cmGeneratorTarget* t) const;
 
-  void addObject(cmXCodeObject *obj);
+  void addObject(cmXCodeObject* obj);
   std::string PostBuildMakeTarget(std::string const& tName,
                                   std::string const& configName);
   cmXCodeObject* MainGroupChildren;
@@ -249,11 +245,11 @@ private:
   std::vector<std::string> CurrentOutputDirectoryComponents;
   std::vector<std::string> ProjectSourceDirectoryComponents;
   std::vector<std::string> ProjectOutputDirectoryComponents;
-  std::map<std::string, cmXCodeObject* > GroupMap;
-  std::map<std::string, cmXCodeObject* > GroupNameMap;
-  std::map<std::string, cmXCodeObject* > TargetGroup;
-  std::map<std::string, cmXCodeObject* > FileRefs;
-  std::map<cmGeneratorTarget const*, cmXCodeObject* > XCodeObjectMap;
+  std::map<std::string, cmXCodeObject*> GroupMap;
+  std::map<std::string, cmXCodeObject*> GroupNameMap;
+  std::map<std::string, cmXCodeObject*> TargetGroup;
+  std::map<std::string, cmXCodeObject*> FileRefs;
+  std::map<cmGeneratorTarget const*, cmXCodeObject*> XCodeObjectMap;
   std::vector<std::string> Architectures;
   std::string GeneratorToolset;
 };
diff --git a/Source/cmGraphAdjacencyList.h b/Source/cmGraphAdjacencyList.h
index 0149d33..5666d48 100644
--- a/Source/cmGraphAdjacencyList.h
+++ b/Source/cmGraphAdjacencyList.h
@@ -22,10 +22,26 @@
 class cmGraphEdge
 {
 public:
-  cmGraphEdge(): Dest(0), Strong(true) {}
-  cmGraphEdge(int n): Dest(n), Strong(true) {}
-  cmGraphEdge(int n, bool s): Dest(n), Strong(s) {}
-  cmGraphEdge(cmGraphEdge const& r): Dest(r.Dest), Strong(r.Strong) {}
+  cmGraphEdge()
+    : Dest(0)
+    , Strong(true)
+  {
+  }
+  cmGraphEdge(int n)
+    : Dest(n)
+    , Strong(true)
+  {
+  }
+  cmGraphEdge(int n, bool s)
+    : Dest(n)
+    , Strong(s)
+  {
+  }
+  cmGraphEdge(cmGraphEdge const& r)
+    : Dest(r.Dest)
+    , Strong(r.Strong)
+  {
+  }
   operator int() const { return this->Dest; }
 
   bool IsStrong() const { return this->Strong; }
@@ -33,8 +49,14 @@ private:
   int Dest;
   bool Strong;
 };
-struct cmGraphEdgeList: public std::vector<cmGraphEdge> {};
-struct cmGraphNodeList: public std::vector<int> {};
-struct cmGraphAdjacencyList: public std::vector<cmGraphEdgeList> {};
+struct cmGraphEdgeList : public std::vector<cmGraphEdge>
+{
+};
+struct cmGraphNodeList : public std::vector<int>
+{
+};
+struct cmGraphAdjacencyList : public std::vector<cmGraphEdgeList>
+{
+};
 
 #endif
diff --git a/Source/cmGraphVizWriter.cxx b/Source/cmGraphVizWriter.cxx
index 76b6430..20cd171 100644
--- a/Source/cmGraphVizWriter.cxx
+++ b/Source/cmGraphVizWriter.cxx
@@ -16,17 +16,13 @@
 #include "cmLocalGenerator.h"
 #include "cmMakefile.h"
 
-
-
 static const char* getShapeForTarget(const cmGeneratorTarget* target)
 {
-  if (!target)
-    {
+  if (!target) {
     return "ellipse";
-    }
+  }
 
-  switch ( target->GetType() )
-    {
+  switch (target->GetType()) {
     case cmState::EXECUTABLE:
       return "house";
     case cmState::STATIC_LIBRARY:
@@ -37,31 +33,29 @@ static const char* getShapeForTarget(const cmGeneratorTarget* target)
       return "octagon";
     default:
       break;
-    }
+  }
 
   return "box";
 }
 
-
-cmGraphVizWriter::cmGraphVizWriter(const std::vector<cmLocalGenerator*>&
-                                                               localGenerators)
-:GraphType("digraph")
-,GraphName("GG")
-,GraphHeader("node [\n  fontsize = \"12\"\n];")
-,GraphNodePrefix("node")
-,LocalGenerators(localGenerators)
-,GenerateForExecutables(true)
-,GenerateForStaticLibs(true)
-,GenerateForSharedLibs(true)
-,GenerateForModuleLibs(true)
-,GenerateForExternals(true)
-,GeneratePerTarget(true)
-,GenerateDependers(true)
-,HaveTargetsAndLibs(false)
+cmGraphVizWriter::cmGraphVizWriter(
+  const std::vector<cmLocalGenerator*>& localGenerators)
+  : GraphType("digraph")
+  , GraphName("GG")
+  , GraphHeader("node [\n  fontsize = \"12\"\n];")
+  , GraphNodePrefix("node")
+  , LocalGenerators(localGenerators)
+  , GenerateForExecutables(true)
+  , GenerateForStaticLibs(true)
+  , GenerateForSharedLibs(true)
+  , GenerateForModuleLibs(true)
+  , GenerateForExternals(true)
+  , GeneratePerTarget(true)
+  , GenerateDependers(true)
+  , HaveTargetsAndLibs(false)
 {
 }
 
-
 void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
                                     const char* fallbackSettingsFileName)
 {
@@ -71,36 +65,32 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
   cm.GetCurrentSnapshot().SetDefaultDefinitions();
   cmGlobalGenerator ggi(&cm);
   cmsys::auto_ptr<cmMakefile> mf(
-        new cmMakefile(&ggi, cm.GetCurrentSnapshot()));
+    new cmMakefile(&ggi, cm.GetCurrentSnapshot()));
   cmsys::auto_ptr<cmLocalGenerator> lg(ggi.CreateLocalGenerator(mf.get()));
 
   const char* inFileName = settingsFileName;
 
-  if ( !cmSystemTools::FileExists(inFileName) )
-    {
+  if (!cmSystemTools::FileExists(inFileName)) {
     inFileName = fallbackSettingsFileName;
-    if ( !cmSystemTools::FileExists(inFileName) )
-      {
+    if (!cmSystemTools::FileExists(inFileName)) {
       return;
-      }
     }
+  }
 
-  if ( !mf->ReadListFile(inFileName) )
-    {
+  if (!mf->ReadListFile(inFileName)) {
     cmSystemTools::Error("Problem opening GraphViz options file: ",
                          inFileName);
     return;
-    }
+  }
 
   std::cout << "Reading GraphViz options file: " << inFileName << std::endl;
 
-#define __set_if_set(var, cmakeDefinition) \
-  { \
-  const char* value = mf->GetDefinition(cmakeDefinition); \
-  if ( value ) \
-    { \
-    var = value; \
-    } \
+#define __set_if_set(var, cmakeDefinition)                                    \
+  {                                                                           \
+    const char* value = mf->GetDefinition(cmakeDefinition);                   \
+    if (value) {                                                              \
+      var = value;                                                            \
+    }                                                                         \
   }
 
   __set_if_set(this->GraphType, "GRAPHVIZ_GRAPH_TYPE");
@@ -108,13 +98,12 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
   __set_if_set(this->GraphHeader, "GRAPHVIZ_GRAPH_HEADER");
   __set_if_set(this->GraphNodePrefix, "GRAPHVIZ_NODE_PREFIX");
 
-#define __set_bool_if_set(var, cmakeDefinition) \
-  { \
-  const char* value = mf->GetDefinition(cmakeDefinition); \
-  if ( value ) \
-    { \
-    var = mf->IsOn(cmakeDefinition); \
-    } \
+#define __set_bool_if_set(var, cmakeDefinition)                               \
+  {                                                                           \
+    const char* value = mf->GetDefinition(cmakeDefinition);                   \
+    if (value) {                                                              \
+      var = mf->IsOn(cmakeDefinition);                                        \
+    }                                                                         \
   }
 
   __set_bool_if_set(this->GenerateForExecutables, "GRAPHVIZ_EXECUTABLES");
@@ -129,55 +118,44 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
   __set_if_set(ignoreTargetsRegexes, "GRAPHVIZ_IGNORE_TARGETS");
 
   this->TargetsToIgnoreRegex.clear();
-  if (!ignoreTargetsRegexes.empty())
-    {
+  if (!ignoreTargetsRegexes.empty()) {
     std::vector<std::string> ignoreTargetsRegExVector;
     cmSystemTools::ExpandListArgument(ignoreTargetsRegexes,
                                       ignoreTargetsRegExVector);
-    for(std::vector<std::string>::const_iterator itvIt
-                                            = ignoreTargetsRegExVector.begin();
-        itvIt != ignoreTargetsRegExVector.end();
-        ++ itvIt )
-      {
+    for (std::vector<std::string>::const_iterator itvIt =
+           ignoreTargetsRegExVector.begin();
+         itvIt != ignoreTargetsRegExVector.end(); ++itvIt) {
       std::string currentRegexString(*itvIt);
       cmsys::RegularExpression currentRegex;
-      if (!currentRegex.compile(currentRegexString.c_str()))
-        {
+      if (!currentRegex.compile(currentRegexString.c_str())) {
         std::cerr << "Could not compile bad regex \"" << currentRegexString
                   << "\"" << std::endl;
-        }
-      this->TargetsToIgnoreRegex.push_back(currentRegex);
       }
+      this->TargetsToIgnoreRegex.push_back(currentRegex);
     }
-
+  }
 }
 
-
 // Iterate over all targets and write for each one a graph which shows
 // which other targets depend on it.
 void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
 {
-  if(this->GenerateDependers == false)
-    {
+  if (this->GenerateDependers == false) {
     return;
-    }
+  }
 
   this->CollectTargetsAndLibs();
 
-  for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
-                                                      this->TargetPtrs.begin();
-      ptrIt != this->TargetPtrs.end();
-      ++ptrIt)
-    {
-    if (ptrIt->second == NULL)
-      {
+  for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
+         this->TargetPtrs.begin();
+       ptrIt != this->TargetPtrs.end(); ++ptrIt) {
+    if (ptrIt->second == NULL) {
       continue;
-      }
+    }
 
-    if (this->GenerateForTargetType(ptrIt->second->GetType()) == false)
-      {
+    if (this->GenerateForTargetType(ptrIt->second->GetType()) == false) {
       continue;
-      }
+    }
 
     std::string currentFilename = fileName;
     currentFilename += ".";
@@ -185,10 +163,9 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
     currentFilename += ".dependers";
 
     cmGeneratedFileStream str(currentFilename.c_str());
-    if ( !str )
-      {
+    if (!str) {
       return;
-      }
+    }
 
     std::set<std::string> insertedConnections;
     std::set<std::string> insertedNodes;
@@ -196,39 +173,33 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName)
     std::cout << "Writing " << currentFilename << "..." << std::endl;
     this->WriteHeader(str);
 
-    this->WriteDependerConnections(ptrIt->first,
-                                   insertedNodes, insertedConnections, str);
+    this->WriteDependerConnections(ptrIt->first, insertedNodes,
+                                   insertedConnections, str);
 
     this->WriteFooter(str);
-    }
+  }
 }
 
-
 // Iterate over all targets and write for each one a graph which shows
 // on which targets it depends.
 void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
 {
-  if(this->GeneratePerTarget == false)
-    {
+  if (this->GeneratePerTarget == false) {
     return;
-    }
+  }
 
   this->CollectTargetsAndLibs();
 
-  for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
-                                                      this->TargetPtrs.begin();
-      ptrIt != this->TargetPtrs.end();
-      ++ptrIt)
-    {
-    if (ptrIt->second == NULL)
-      {
+  for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
+         this->TargetPtrs.begin();
+       ptrIt != this->TargetPtrs.end(); ++ptrIt) {
+    if (ptrIt->second == NULL) {
       continue;
-      }
+    }
 
-    if (this->GenerateForTargetType(ptrIt->second->GetType()) == false)
-      {
+    if (this->GenerateForTargetType(ptrIt->second->GetType()) == false) {
       continue;
-      }
+    }
 
     std::set<std::string> insertedConnections;
     std::set<std::string> insertedNodes;
@@ -237,31 +208,27 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName)
     currentFilename += ".";
     currentFilename += ptrIt->first;
     cmGeneratedFileStream str(currentFilename.c_str());
-    if ( !str )
-      {
+    if (!str) {
       return;
-      }
+    }
 
     std::cout << "Writing " << currentFilename << "..." << std::endl;
     this->WriteHeader(str);
 
-    this->WriteConnections(ptrIt->first,
-                              insertedNodes, insertedConnections, str);
+    this->WriteConnections(ptrIt->first, insertedNodes, insertedConnections,
+                           str);
     this->WriteFooter(str);
-    }
-
+  }
 }
 
-
 void cmGraphVizWriter::WriteGlobalFile(const char* fileName)
 {
   this->CollectTargetsAndLibs();
 
   cmGeneratedFileStream str(fileName);
-  if ( !str )
-    {
+  if (!str) {
     return;
-    }
+  }
   this->WriteHeader(str);
 
   std::cout << "Writing " << fileName << "..." << std::endl;
@@ -269,323 +236,268 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName)
   std::set<std::string> insertedConnections;
   std::set<std::string> insertedNodes;
 
-  for(std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
-                                                      this->TargetPtrs.begin();
-      ptrIt != this->TargetPtrs.end();
-      ++ptrIt)
-    {
-    if (ptrIt->second == NULL)
-      {
+  for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt =
+         this->TargetPtrs.begin();
+       ptrIt != this->TargetPtrs.end(); ++ptrIt) {
+    if (ptrIt->second == NULL) {
       continue;
-      }
+    }
 
-    if (this->GenerateForTargetType(ptrIt->second->GetType()) == false)
-      {
+    if (this->GenerateForTargetType(ptrIt->second->GetType()) == false) {
       continue;
-      }
-
-    this->WriteConnections(ptrIt->first,
-                              insertedNodes, insertedConnections, str);
     }
+
+    this->WriteConnections(ptrIt->first, insertedNodes, insertedConnections,
+                           str);
+  }
   this->WriteFooter(str);
 }
 
-
 void cmGraphVizWriter::WriteHeader(cmGeneratedFileStream& str) const
 {
   str << this->GraphType << " \"" << this->GraphName << "\" {" << std::endl;
   str << this->GraphHeader << std::endl;
 }
 
-
 void cmGraphVizWriter::WriteFooter(cmGeneratedFileStream& str) const
 {
   str << "}" << std::endl;
 }
 
-
-void cmGraphVizWriter::WriteConnections(const std::string& targetName,
-                                    std::set<std::string>& insertedNodes,
-                                    std::set<std::string>& insertedConnections,
-                                    cmGeneratedFileStream& str) const
+void cmGraphVizWriter::WriteConnections(
+  const std::string& targetName, std::set<std::string>& insertedNodes,
+  std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const
 {
-  std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt
-      = this->TargetPtrs.find(targetName);
+  std::map<std::string, const cmGeneratorTarget*>::const_iterator targetPtrIt =
+    this->TargetPtrs.find(targetName);
 
-  if (targetPtrIt == this->TargetPtrs.end())  // not found at all
-    {
+  if (targetPtrIt == this->TargetPtrs.end()) // not found at all
+  {
     return;
-    }
+  }
 
   this->WriteNode(targetName, targetPtrIt->second, insertedNodes, str);
 
   if (targetPtrIt->second == NULL) // it's an external library
-    {
+  {
     return;
-    }
-
+  }
 
   std::string myNodeName = this->TargetNamesNodes.find(targetName)->second;
 
   const cmTarget::LinkLibraryVectorType* ll =
-      &(targetPtrIt->second->Target->GetOriginalLinkLibraries());
+    &(targetPtrIt->second->Target->GetOriginalLinkLibraries());
 
   for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
-       llit != ll->end();
-       ++ llit )
-    {
+       llit != ll->end(); ++llit) {
     const char* libName = llit->first.c_str();
     std::map<std::string, std::string>::const_iterator libNameIt =
-                                          this->TargetNamesNodes.find(libName);
+      this->TargetNamesNodes.find(libName);
 
     // can happen e.g. if GRAPHVIZ_TARGET_IGNORE_REGEX is used
-    if(libNameIt == this->TargetNamesNodes.end())
-      {
+    if (libNameIt == this->TargetNamesNodes.end()) {
       continue;
-      }
+    }
 
     std::string connectionName = myNodeName;
     connectionName += "-";
     connectionName += libNameIt->second;
-    if (insertedConnections.find(connectionName) == insertedConnections.end())
-      {
+    if (insertedConnections.find(connectionName) ==
+        insertedConnections.end()) {
       insertedConnections.insert(connectionName);
       this->WriteNode(libName, this->TargetPtrs.find(libName)->second,
                       insertedNodes, str);
 
-      str << "    \"" << myNodeName << "\" -> \""
-          << libNameIt->second << "\"";
+      str << "    \"" << myNodeName << "\" -> \"" << libNameIt->second << "\"";
       str << " // " << targetName << " -> " << libName << std::endl;
       this->WriteConnections(libName, insertedNodes, insertedConnections, str);
-      }
     }
-
+  }
 }
 
-
-void cmGraphVizWriter::WriteDependerConnections(const std::string& targetName,
-                                    std::set<std::string>& insertedNodes,
-                                    std::set<std::string>& insertedConnections,
-                                    cmGeneratedFileStream& str) const
+void cmGraphVizWriter::WriteDependerConnections(
+  const std::string& targetName, std::set<std::string>& insertedNodes,
+  std::set<std::string>& insertedConnections, cmGeneratedFileStream& str) const
 {
-  std::map<std::string, const cmGeneratorTarget* >::const_iterator targetPtrIt
-      = this->TargetPtrs.find(targetName);
+  std::map<std::string, const cmGeneratorTarget*>::const_iterator targetPtrIt =
+    this->TargetPtrs.find(targetName);
 
-  if (targetPtrIt == this->TargetPtrs.end())  // not found at all
-    {
+  if (targetPtrIt == this->TargetPtrs.end()) // not found at all
+  {
     return;
-    }
+  }
 
   this->WriteNode(targetName, targetPtrIt->second, insertedNodes, str);
 
   if (targetPtrIt->second == NULL) // it's an external library
-    {
+  {
     return;
-    }
-
+  }
 
   std::string myNodeName = this->TargetNamesNodes.find(targetName)->second;
 
   // now search who links against me
-  for(std::map<std::string, const cmGeneratorTarget*>::const_iterator
-      dependerIt = this->TargetPtrs.begin();
-      dependerIt != this->TargetPtrs.end();
-      ++dependerIt)
-    {
-    if (dependerIt->second == NULL)
-      {
+  for (std::map<std::string, const cmGeneratorTarget*>::const_iterator
+         dependerIt = this->TargetPtrs.begin();
+       dependerIt != this->TargetPtrs.end(); ++dependerIt) {
+    if (dependerIt->second == NULL) {
       continue;
-      }
+    }
 
-    if (this->GenerateForTargetType(dependerIt->second->GetType()) == false)
-      {
+    if (this->GenerateForTargetType(dependerIt->second->GetType()) == false) {
       continue;
-      }
+    }
 
     // Now we have a target, check whether it links against targetName.
     // If so, draw a connection, and then continue with dependers on that one.
     const cmTarget::LinkLibraryVectorType* ll =
-        &(dependerIt->second->Target->GetOriginalLinkLibraries());
+      &(dependerIt->second->Target->GetOriginalLinkLibraries());
 
     for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
-         llit != ll->end();
-         ++ llit )
-      {
+         llit != ll->end(); ++llit) {
       std::string libName = llit->first;
-      if (libName == targetName)
-        {
+      if (libName == targetName) {
         // So this target links against targetName.
         std::map<std::string, std::string>::const_iterator dependerNodeNameIt =
-                                this->TargetNamesNodes.find(dependerIt->first);
+          this->TargetNamesNodes.find(dependerIt->first);
 
-        if(dependerNodeNameIt != this->TargetNamesNodes.end())
-          {
+        if (dependerNodeNameIt != this->TargetNamesNodes.end()) {
           std::string connectionName = dependerNodeNameIt->second;
           connectionName += "-";
           connectionName += myNodeName;
 
           if (insertedConnections.find(connectionName) ==
-                                                     insertedConnections.end())
-            {
+              insertedConnections.end()) {
             insertedConnections.insert(connectionName);
             this->WriteNode(dependerIt->first, dependerIt->second,
                             insertedNodes, str);
 
             str << "    \"" << dependerNodeNameIt->second << "\" -> \""
                 << myNodeName << "\"";
-            str << " // " <<targetName<< " -> " <<dependerIt->first<<std::endl;
-            this->WriteDependerConnections(dependerIt->first,
-                                      insertedNodes, insertedConnections, str);
-            }
-
-
+            str << " // " << targetName << " -> " << dependerIt->first
+                << std::endl;
+            this->WriteDependerConnections(dependerIt->first, insertedNodes,
+                                           insertedConnections, str);
           }
-        break;
         }
+        break;
       }
     }
-
+  }
 }
 
-
 void cmGraphVizWriter::WriteNode(const std::string& targetName,
                                  const cmGeneratorTarget* target,
                                  std::set<std::string>& insertedNodes,
                                  cmGeneratedFileStream& str) const
 {
-  if (insertedNodes.find(targetName) == insertedNodes.end())
-  {
+  if (insertedNodes.find(targetName) == insertedNodes.end()) {
     insertedNodes.insert(targetName);
     std::map<std::string, std::string>::const_iterator nameIt =
-                                       this->TargetNamesNodes.find(targetName);
+      this->TargetNamesNodes.find(targetName);
 
-    str << "    \"" << nameIt->second << "\" [ label=\""
-        << targetName <<  "\" shape=\"" << getShapeForTarget(target)
-        << "\"];" << std::endl;
+    str << "    \"" << nameIt->second << "\" [ label=\"" << targetName
+        << "\" shape=\"" << getShapeForTarget(target) << "\"];" << std::endl;
   }
 }
 
-
 void cmGraphVizWriter::CollectTargetsAndLibs()
 {
-  if (this->HaveTargetsAndLibs == false)
-    {
+  if (this->HaveTargetsAndLibs == false) {
     this->HaveTargetsAndLibs = true;
     int cnt = this->CollectAllTargets();
-    if (this->GenerateForExternals)
-      {
+    if (this->GenerateForExternals) {
       this->CollectAllExternalLibs(cnt);
-      }
     }
+  }
 }
 
-
 int cmGraphVizWriter::CollectAllTargets()
 {
   int cnt = 0;
   // First pass get the list of all cmake targets
   for (std::vector<cmLocalGenerator*>::const_iterator lit =
-                                                 this->LocalGenerators.begin();
-       lit != this->LocalGenerators.end();
-       ++ lit )
-    {
+         this->LocalGenerators.begin();
+       lit != this->LocalGenerators.end(); ++lit) {
     std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets();
-    for ( std::vector<cmGeneratorTarget*>::const_iterator it =
-          targets.begin(); it != targets.end(); ++it )
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator it = targets.begin();
+         it != targets.end(); ++it) {
       const char* realTargetName = (*it)->GetName().c_str();
-      if(this->IgnoreThisTarget(realTargetName))
-        {
+      if (this->IgnoreThisTarget(realTargetName)) {
         // Skip ignored targets
         continue;
-        }
-      //std::cout << "Found target: " << tit->first.c_str() << std::endl;
+      }
+      // std::cout << "Found target: " << tit->first.c_str() << std::endl;
       std::ostringstream ostr;
       ostr << this->GraphNodePrefix << cnt++;
       this->TargetNamesNodes[realTargetName] = ostr.str();
       this->TargetPtrs[realTargetName] = *it;
-      }
     }
+  }
 
   return cnt;
 }
 
-
 int cmGraphVizWriter::CollectAllExternalLibs(int cnt)
 {
   // Ok, now find all the stuff we link to that is not in cmake
   for (std::vector<cmLocalGenerator*>::const_iterator lit =
-                                                 this->LocalGenerators.begin();
-       lit != this->LocalGenerators.end();
-       ++ lit )
-    {
+         this->LocalGenerators.begin();
+       lit != this->LocalGenerators.end(); ++lit) {
     std::vector<cmGeneratorTarget*> targets = (*lit)->GetGeneratorTargets();
-    for ( std::vector<cmGeneratorTarget*>::const_iterator it =
-          targets.begin(); it != targets.end(); ++it )
-      {
+    for (std::vector<cmGeneratorTarget*>::const_iterator it = targets.begin();
+         it != targets.end(); ++it) {
       const char* realTargetName = (*it)->GetName().c_str();
-      if (this->IgnoreThisTarget(realTargetName))
-        {
+      if (this->IgnoreThisTarget(realTargetName)) {
         // Skip ignored targets
         continue;
-        }
+      }
       const cmTarget::LinkLibraryVectorType* ll =
-          &((*it)->Target->GetOriginalLinkLibraries());
+        &((*it)->Target->GetOriginalLinkLibraries());
       for (cmTarget::LinkLibraryVectorType::const_iterator llit = ll->begin();
-           llit != ll->end();
-           ++ llit )
-        {
+           llit != ll->end(); ++llit) {
         const char* libName = llit->first.c_str();
-        if (this->IgnoreThisTarget(libName))
-          {
+        if (this->IgnoreThisTarget(libName)) {
           // Skip ignored targets
           continue;
-          }
+        }
 
-        std::map<std::string, const cmGeneratorTarget*>::const_iterator tarIt
-            = this->TargetPtrs.find(libName);
-        if ( tarIt == this->TargetPtrs.end() )
-          {
+        std::map<std::string, const cmGeneratorTarget*>::const_iterator tarIt =
+          this->TargetPtrs.find(libName);
+        if (tarIt == this->TargetPtrs.end()) {
           std::ostringstream ostr;
           ostr << this->GraphNodePrefix << cnt++;
           this->TargetNamesNodes[libName] = ostr.str();
           this->TargetPtrs[libName] = NULL;
           // str << "    \"" << ostr.c_str() << "\" [ label=\"" << libName
           // <<  "\" shape=\"ellipse\"];" << std::endl;
-          }
         }
       }
     }
-   return cnt;
+  }
+  return cnt;
 }
 
-
 bool cmGraphVizWriter::IgnoreThisTarget(const std::string& name)
 {
-  for(std::vector<cmsys::RegularExpression>::iterator itvIt
-                                          = this->TargetsToIgnoreRegex.begin();
-      itvIt != this->TargetsToIgnoreRegex.end();
-      ++ itvIt )
-    {
+  for (std::vector<cmsys::RegularExpression>::iterator itvIt =
+         this->TargetsToIgnoreRegex.begin();
+       itvIt != this->TargetsToIgnoreRegex.end(); ++itvIt) {
     cmsys::RegularExpression& regEx = *itvIt;
-    if (regEx.is_valid())
-      {
-      if (regEx.find(name))
-        {
+    if (regEx.is_valid()) {
+      if (regEx.find(name)) {
         return true;
-        }
       }
     }
+  }
 
   return false;
 }
 
-
-bool cmGraphVizWriter::GenerateForTargetType(cmState::TargetType targetType)
-                                                                          const
+bool cmGraphVizWriter::GenerateForTargetType(
+  cmState::TargetType targetType) const
 {
-  switch (targetType)
-  {
+  switch (targetType) {
     case cmState::EXECUTABLE:
       return this->GenerateForExecutables;
     case cmState::STATIC_LIBRARY:
diff --git a/Source/cmGraphVizWriter.h b/Source/cmGraphVizWriter.h
index 7914ca3..c73d82d 100644
--- a/Source/cmGraphVizWriter.h
+++ b/Source/cmGraphVizWriter.h
@@ -25,7 +25,6 @@ class cmGeneratorTarget;
 class cmGraphVizWriter
 {
 public:
-
   cmGraphVizWriter(const std::vector<cmLocalGenerator*>& localGenerators);
 
   void ReadSettings(const char* settingsFileName,
@@ -37,7 +36,6 @@ public:
   void WriteGlobalFile(const char* fileName);
 
 protected:
-
   void CollectTargetsAndLibs();
 
   int CollectAllTargets();
diff --git a/Source/cmHexFileConverter.cxx b/Source/cmHexFileConverter.cxx
index 6ea597e..9609e95 100644
--- a/Source/cmHexFileConverter.cxx
+++ b/Source/cmHexFileConverter.cxx
@@ -14,62 +14,55 @@
 #include <stdio.h>
 #include <string.h>
 
-#define INTEL_HEX_MIN_LINE_LENGTH     (1+8        +2)
-#define INTEL_HEX_MAX_LINE_LENGTH     (1+8+(256*2)+2)
-#define MOTOROLA_SREC_MIN_LINE_LENGTH (2+2+4        +2)
-#define MOTOROLA_SREC_MAX_LINE_LENGTH (2+2+8+(256*2)+2)
+#define INTEL_HEX_MIN_LINE_LENGTH (1 + 8 + 2)
+#define INTEL_HEX_MAX_LINE_LENGTH (1 + 8 + (256 * 2) + 2)
+#define MOTOROLA_SREC_MIN_LINE_LENGTH (2 + 2 + 4 + 2)
+#define MOTOROLA_SREC_MAX_LINE_LENGTH (2 + 2 + 8 + (256 * 2) + 2)
 
 // might go to SystemTools ?
 static bool cm_IsHexChar(char c)
 {
-  return (((c >= '0') && (c <= '9'))
-         || ((c >= 'a') && (c <= 'f'))
-         || ((c >= 'A') && (c <= 'F')));
+  return (((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) ||
+          ((c >= 'A') && (c <= 'F')));
 }
 
 static unsigned int ChompStrlen(const char* line)
 {
-  if (line == 0)
-    {
+  if (line == 0) {
     return 0;
-    }
-  unsigned int  length = static_cast<unsigned int>(strlen(line));
-  if ((line[length-1] == '\n') || (line[length-1] == '\r'))
-    {
+  }
+  unsigned int length = static_cast<unsigned int>(strlen(line));
+  if ((line[length - 1] == '\n') || (line[length - 1] == '\r')) {
     length--;
-    }
-  if ((line[length-1] == '\n') || (line[length-1] == '\r'))
-    {
+  }
+  if ((line[length - 1] == '\n') || (line[length - 1] == '\r')) {
     length--;
-    }
+  }
   return length;
 }
 
-static bool OutputBin(FILE* file, const char * buf,
-                      unsigned int startIndex, unsigned int stopIndex)
+static bool OutputBin(FILE* file, const char* buf, unsigned int startIndex,
+                      unsigned int stopIndex)
 {
   bool success = true;
   char hexNumber[3];
   hexNumber[2] = '\0';
   char outBuf[256];
   unsigned int outBufCount = 0;
-  for (unsigned int i = startIndex; i < stopIndex; i += 2)
-    {
+  for (unsigned int i = startIndex; i < stopIndex; i += 2) {
     hexNumber[0] = buf[i];
-    hexNumber[1] = buf[i+1];
+    hexNumber[1] = buf[i + 1];
     unsigned int convertedByte = 0;
-    if (sscanf(hexNumber, "%x", &convertedByte) != 1)
-      {
+    if (sscanf(hexNumber, "%x", &convertedByte) != 1) {
       success = false;
       break;
-      }
+    }
     outBuf[outBufCount] = static_cast<char>(convertedByte & 0xff);
     outBufCount++;
-    }
-  if (success)
-    {
-    success = (fwrite(outBuf, 1, outBufCount, file)==outBufCount);
-    }
+  }
+  if (success) {
+    success = (fwrite(outBuf, 1, outBufCount, file) == outBufCount);
+  }
   return success;
 }
 
@@ -77,45 +70,35 @@ static bool OutputBin(FILE* file, const char * buf,
 static bool ConvertMotorolaSrecLine(const char* buf, FILE* outFile)
 {
   unsigned int slen = ChompStrlen(buf);
-  if ((slen < MOTOROLA_SREC_MIN_LINE_LENGTH)
-       || (slen > MOTOROLA_SREC_MAX_LINE_LENGTH))
-    {
+  if ((slen < MOTOROLA_SREC_MIN_LINE_LENGTH) ||
+      (slen > MOTOROLA_SREC_MAX_LINE_LENGTH)) {
     return false;
-    }
+  }
 
   // line length must be even
-  if (slen % 2 == 1)
-    {
+  if (slen % 2 == 1) {
     return false;
-    }
+  }
 
-  if (buf[0] != 'S')
-    {
+  if (buf[0] != 'S') {
     return false;
-    }
+  }
 
   unsigned int dataStart = 0;
   // ignore extra address records
-  if ((buf[1] == '5') || (buf[1] == '7') || (buf[1] == '8') || (buf[1] == '9'))
-    {
+  if ((buf[1] == '5') || (buf[1] == '7') || (buf[1] == '8') ||
+      (buf[1] == '9')) {
     return true;
-    }
-  else if (buf[1] == '1')
-    {
+  } else if (buf[1] == '1') {
     dataStart = 8;
-    }
-  else if (buf[1] == '2')
-    {
+  } else if (buf[1] == '2') {
     dataStart = 10;
-    }
-  else if (buf[1] == '3')
-    {
+  } else if (buf[1] == '3') {
     dataStart = 12;
-    }
-  else // unknown record type
-    {
+  } else // unknown record type
+  {
     return false;
-    }
+  }
 
   // ignore the last two bytes  (checksum)
   return OutputBin(outFile, buf, dataStart, slen - 2);
@@ -125,91 +108,77 @@ static bool ConvertMotorolaSrecLine(const char* buf, FILE* outFile)
 static bool ConvertIntelHexLine(const char* buf, FILE* outFile)
 {
   unsigned int slen = ChompStrlen(buf);
-  if ((slen < INTEL_HEX_MIN_LINE_LENGTH)
-       || (slen > INTEL_HEX_MAX_LINE_LENGTH))
-    {
+  if ((slen < INTEL_HEX_MIN_LINE_LENGTH) ||
+      (slen > INTEL_HEX_MAX_LINE_LENGTH)) {
     return false;
-    }
+  }
 
   // line length must be odd
-  if (slen % 2 == 0)
-    {
+  if (slen % 2 == 0) {
     return false;
-    }
+  }
 
-  if ((buf[0] != ':') || (buf[7] != '0'))
-    {
+  if ((buf[0] != ':') || (buf[7] != '0')) {
     return false;
-    }
+  }
 
   unsigned int dataStart = 0;
-  if ((buf[8] == '0') || (buf[8] == '1'))
-    {
+  if ((buf[8] == '0') || (buf[8] == '1')) {
     dataStart = 9;
-    }
+  }
   // ignore extra address records
-  else if ((buf[8] == '2') || (buf[8] == '3') || (buf[8] == '4')
-            || (buf[8] == '5'))
-    {
+  else if ((buf[8] == '2') || (buf[8] == '3') || (buf[8] == '4') ||
+           (buf[8] == '5')) {
     return true;
-    }
-  else  // unknown record type
-    {
+  } else // unknown record type
+  {
     return false;
-    }
+  }
 
-// ignore the last two bytes  (checksum)
+  // ignore the last two bytes  (checksum)
   return OutputBin(outFile, buf, dataStart, slen - 2);
 }
 
 cmHexFileConverter::FileType cmHexFileConverter::DetermineFileType(
-                                                        const char* inFileName)
+  const char* inFileName)
 {
   char buf[1024];
   FILE* inFile = cmsys::SystemTools::Fopen(inFileName, "rb");
-  if (inFile == 0)
-    {
+  if (inFile == 0) {
     return Binary;
-    }
+  }
 
-  if(!fgets(buf, 1024, inFile))
-    {
+  if (!fgets(buf, 1024, inFile)) {
     buf[0] = 0;
-    }
+  }
   fclose(inFile);
   FileType type = Binary;
   unsigned int minLineLength = 0;
   unsigned int maxLineLength = 0;
   if (buf[0] == ':') // might be an intel hex file
-    {
+  {
     type = IntelHex;
     minLineLength = INTEL_HEX_MIN_LINE_LENGTH;
     maxLineLength = INTEL_HEX_MAX_LINE_LENGTH;
-    }
-  else if (buf[0] == 'S') // might be a motorola srec file
-    {
+  } else if (buf[0] == 'S') // might be a motorola srec file
+  {
     type = MotorolaSrec;
     minLineLength = MOTOROLA_SREC_MIN_LINE_LENGTH;
     maxLineLength = MOTOROLA_SREC_MAX_LINE_LENGTH;
-    }
-  else
-    {
+  } else {
     return Binary;
-    }
+  }
 
   unsigned int slen = ChompStrlen(buf);
-  if ((slen < minLineLength) || (slen > maxLineLength))
-    {
+  if ((slen < minLineLength) || (slen > maxLineLength)) {
     return Binary;
-    }
+  }
 
-  for (unsigned int i = 1; i < slen; i++)
-    {
-    if (!cm_IsHexChar(buf[i]))
-      {
+  for (unsigned int i = 1; i < slen; i++) {
+    if (!cm_IsHexChar(buf[i])) {
       return Binary;
-      }
     }
+  }
   return type;
 }
 
@@ -217,49 +186,39 @@ bool cmHexFileConverter::TryConvert(const char* inFileName,
                                     const char* outFileName)
 {
   FileType type = DetermineFileType(inFileName);
-  if (type == Binary)
-    {
+  if (type == Binary) {
     return false;
-    }
+  }
 
   // try to open the file
   FILE* inFile = cmsys::SystemTools::Fopen(inFileName, "rb");
   FILE* outFile = cmsys::SystemTools::Fopen(outFileName, "wb");
-  if ((inFile == 0) || (outFile == 0))
-    {
-    if (inFile != 0)
-      {
+  if ((inFile == 0) || (outFile == 0)) {
+    if (inFile != 0) {
       fclose(inFile);
-      }
-    if (outFile != 0)
-      {
+    }
+    if (outFile != 0) {
       fclose(outFile);
-      }
-    return false;
     }
+    return false;
+  }
 
   // convert them line by line
   bool success = false;
   char buf[1024];
-  while (fgets(buf, 1024, inFile) != 0)
-    {
-    if (type == MotorolaSrec)
-      {
+  while (fgets(buf, 1024, inFile) != 0) {
+    if (type == MotorolaSrec) {
       success = ConvertMotorolaSrecLine(buf, outFile);
-      }
-    else if (type == IntelHex)
-      {
+    } else if (type == IntelHex) {
       success = ConvertIntelHexLine(buf, outFile);
-      }
-    if (success == false)
-      {
+    }
+    if (success == false) {
       break;
-      }
     }
+  }
 
   // close them again
   fclose(inFile);
   fclose(outFile);
   return success;
 }
-
diff --git a/Source/cmHexFileConverter.h b/Source/cmHexFileConverter.h
index 89b8533..56fa9b1 100644
--- a/Source/cmHexFileConverter.h
+++ b/Source/cmHexFileConverter.h
@@ -22,7 +22,12 @@
 class cmHexFileConverter
 {
 public:
-  enum FileType {Binary, IntelHex, MotorolaSrec};
+  enum FileType
+  {
+    Binary,
+    IntelHex,
+    MotorolaSrec
+  };
   static FileType DetermineFileType(const char* inFileName);
   static bool TryConvert(const char* inFileName, const char* outFileName);
 };
diff --git a/Source/cmIDEFlagTable.h b/Source/cmIDEFlagTable.h
index adc7763..e8a6e38 100644
--- a/Source/cmIDEFlagTable.h
+++ b/Source/cmIDEFlagTable.h
@@ -15,26 +15,26 @@
 // This is a table mapping XML tag IDE names to command line options
 struct cmIDEFlagTable
 {
-  const char* IDEName;  // name used in the IDE xml file
+  const char* IDEName;     // name used in the IDE xml file
   const char* commandFlag; // command line flag
   const char* comment;     // comment
-  const char* value; // string value
-  unsigned int special; // flags for special handling requests
+  const char* value;       // string value
+  unsigned int special;    // flags for special handling requests
   enum
   {
-    UserValue    = (1<<0), // flag contains a user-specified value
-    UserIgnored  = (1<<1), // ignore any user value
-    UserRequired = (1<<2), // match only when user value is non-empty
-    Continue     = (1<<3), // continue looking for matching entries
-    SemicolonAppendable = (1<<4), // a flag that if specified multiple times
-                                  // should have its value appended to the
-                                  // old value with semicolons (e.g.
-                                  // /NODEFAULTLIB: =>
-                                  // IgnoreDefaultLibraryNames)
-    UserFollowing = (1<<5), // expect value in following argument
-    CaseInsensitive = (1<<6), // flag may be any case
+    UserValue = (1 << 0),           // flag contains a user-specified value
+    UserIgnored = (1 << 1),         // ignore any user value
+    UserRequired = (1 << 2),        // match only when user value is non-empty
+    Continue = (1 << 3),            // continue looking for matching entries
+    SemicolonAppendable = (1 << 4), // a flag that if specified multiple times
+                                    // should have its value appended to the
+                                    // old value with semicolons (e.g.
+                                    // /NODEFAULTLIB: =>
+                                    // IgnoreDefaultLibraryNames)
+    UserFollowing = (1 << 5),       // expect value in following argument
+    CaseInsensitive = (1 << 6),     // flag may be any case
 
-    UserValueIgnored  = UserValue | UserIgnored,
+    UserValueIgnored = UserValue | UserIgnored,
     UserValueRequired = UserValue | UserRequired
   };
 };
diff --git a/Source/cmIDEOptions.cxx b/Source/cmIDEOptions.cxx
index 1c52519..9f4b537 100644
--- a/Source/cmIDEOptions.cxx
+++ b/Source/cmIDEOptions.cxx
@@ -21,10 +21,9 @@ cmIDEOptions::cmIDEOptions()
   this->AllowDefine = true;
   this->AllowSlash = false;
   this->DoingFollowing = 0;
-  for(int i=0; i < FlagTableCount; ++i)
-    {
+  for (int i = 0; i < FlagTableCount; ++i) {
     this->FlagTable[i] = 0;
-    }
+  }
 }
 
 cmIDEOptions::~cmIDEOptions()
@@ -34,56 +33,46 @@ cmIDEOptions::~cmIDEOptions()
 void cmIDEOptions::HandleFlag(const char* flag)
 {
   // If the last option was -D then this option is the definition.
-  if(this->DoingDefine)
-    {
+  if (this->DoingDefine) {
     this->DoingDefine = false;
     this->Defines.push_back(flag);
     return;
-    }
+  }
 
   // If the last option expected a following value, this is it.
-  if(this->DoingFollowing)
-    {
+  if (this->DoingFollowing) {
     this->FlagMapUpdate(this->DoingFollowing, flag);
     this->DoingFollowing = 0;
     return;
-    }
+  }
 
   // Look for known arguments.
-  if(flag[0] == '-' || (this->AllowSlash && flag[0] == '/'))
-    {
+  if (flag[0] == '-' || (this->AllowSlash && flag[0] == '/')) {
     // Look for preprocessor definitions.
-    if(this->AllowDefine && flag[1] == 'D')
-      {
-      if(flag[2] == '\0')
-        {
+    if (this->AllowDefine && flag[1] == 'D') {
+      if (flag[2] == '\0') {
         // The next argument will have the definition.
         this->DoingDefine = true;
-        }
-      else
-        {
+      } else {
         // Store this definition.
-        this->Defines.push_back(flag+2);
-        }
-      return;
+        this->Defines.push_back(flag + 2);
       }
+      return;
+    }
 
     // Look through the available flag tables.
     bool flag_handled = false;
-    for(int i=0; i < FlagTableCount && this->FlagTable[i]; ++i)
-      {
-      if(this->CheckFlagTable(this->FlagTable[i], flag, flag_handled))
-        {
+    for (int i = 0; i < FlagTableCount && this->FlagTable[i]; ++i) {
+      if (this->CheckFlagTable(this->FlagTable[i], flag, flag_handled)) {
         return;
-        }
       }
+    }
 
     // If any map entry handled the flag we are done.
-    if(flag_handled)
-      {
+    if (flag_handled) {
       return;
-      }
     }
+  }
 
   // This option is not known.  Store it in the output flags.
   this->StoreUnknownFlag(flag);
@@ -93,52 +82,43 @@ bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
                                   const char* flag, bool& flag_handled)
 {
   // Look for an entry in the flag table matching this flag.
-  for(cmIDEFlagTable const* entry = table; entry->IDEName; ++entry)
-    {
+  for (cmIDEFlagTable const* entry = table; entry->IDEName; ++entry) {
     bool entry_found = false;
-    if(entry->special & cmIDEFlagTable::UserValue)
-      {
+    if (entry->special & cmIDEFlagTable::UserValue) {
       // This flag table entry accepts a user-specified value.  If
       // the entry specifies UserRequired we must match only if a
       // non-empty value is given.
       int n = static_cast<int>(strlen(entry->commandFlag));
-      if((strncmp(flag+1, entry->commandFlag, n) == 0 ||
-          (entry->special & cmIDEFlagTable::CaseInsensitive &&
-           cmsysString_strncasecmp(flag+1, entry->commandFlag, n))) &&
-         (!(entry->special & cmIDEFlagTable::UserRequired) ||
-          static_cast<int>(strlen(flag+1)) > n))
-        {
-        this->FlagMapUpdate(entry, flag+n+1);
+      if ((strncmp(flag + 1, entry->commandFlag, n) == 0 ||
+           (entry->special & cmIDEFlagTable::CaseInsensitive &&
+            cmsysString_strncasecmp(flag + 1, entry->commandFlag, n))) &&
+          (!(entry->special & cmIDEFlagTable::UserRequired) ||
+           static_cast<int>(strlen(flag + 1)) > n)) {
+        this->FlagMapUpdate(entry, flag + n + 1);
         entry_found = true;
-        }
       }
-    else if(strcmp(flag+1, entry->commandFlag) == 0 ||
-            (entry->special & cmIDEFlagTable::CaseInsensitive &&
-             cmsysString_strcasecmp(flag+1, entry->commandFlag) == 0))
-      {
-      if(entry->special & cmIDEFlagTable::UserFollowing)
-        {
+    } else if (strcmp(flag + 1, entry->commandFlag) == 0 ||
+               (entry->special & cmIDEFlagTable::CaseInsensitive &&
+                cmsysString_strcasecmp(flag + 1, entry->commandFlag) == 0)) {
+      if (entry->special & cmIDEFlagTable::UserFollowing) {
         // This flag expects a value in the following argument.
         this->DoingFollowing = entry;
-        }
-      else
-        {
+      } else {
         // This flag table entry provides a fixed value.
         this->FlagMap[entry->IDEName] = entry->value;
-        }
-      entry_found = true;
       }
+      entry_found = true;
+    }
 
     // If the flag has been handled by an entry not requesting a
     // search continuation we are done.
-    if(entry_found && !(entry->special & cmIDEFlagTable::Continue))
-      {
+    if (entry_found && !(entry->special & cmIDEFlagTable::Continue)) {
       return true;
-      }
+    }
 
     // If the entry was found the flag has been handled.
     flag_handled = flag_handled || entry_found;
-    }
+  }
 
   return false;
 }
@@ -146,20 +126,15 @@ bool cmIDEOptions::CheckFlagTable(cmIDEFlagTable const* table,
 void cmIDEOptions::FlagMapUpdate(cmIDEFlagTable const* entry,
                                  const char* new_value)
 {
-  if(entry->special & cmIDEFlagTable::UserIgnored)
-    {
+  if (entry->special & cmIDEFlagTable::UserIgnored) {
     // Ignore the user-specified value.
     this->FlagMap[entry->IDEName] = entry->value;
-    }
-  else if(entry->special & cmIDEFlagTable::SemicolonAppendable)
-    {
+  } else if (entry->special & cmIDEFlagTable::SemicolonAppendable) {
     this->FlagMap[entry->IDEName].push_back(new_value);
-    }
-  else
-    {
+  } else {
     // Use the user-specified value.
     this->FlagMap[entry->IDEName] = new_value;
-    }
+  }
 }
 
 void cmIDEOptions::AddDefine(const std::string& def)
@@ -169,13 +144,12 @@ void cmIDEOptions::AddDefine(const std::string& def)
 
 void cmIDEOptions::AddDefines(const char* defines)
 {
-  if(defines)
-    {
+  if (defines) {
     // Expand the list of definitions.
     cmSystemTools::ExpandListArgument(defines, this->Defines);
-    }
+  }
 }
-void cmIDEOptions::AddDefines(const std::vector<std::string> &defines)
+void cmIDEOptions::AddDefines(const std::vector<std::string>& defines)
 {
   this->Defines.insert(this->Defines.end(), defines.begin(), defines.end());
 }
@@ -218,9 +192,8 @@ const char* cmIDEOptions::GetFlag(const char* flag)
 {
   // This method works only for single-valued flags!
   std::map<std::string, FlagValue>::iterator i = this->FlagMap.find(flag);
-  if(i != this->FlagMap.end() && i->second.size() == 1)
-    {
+  if (i != this->FlagMap.end() && i->second.size() == 1) {
     return i->second[0].c_str();
-    }
+  }
   return 0;
 }
diff --git a/Source/cmIDEOptions.h b/Source/cmIDEOptions.h
index 8c985c7..fac7d4e 100644
--- a/Source/cmIDEOptions.h
+++ b/Source/cmIDEOptions.h
@@ -28,7 +28,7 @@ public:
   // Store definitions and flags.
   void AddDefine(const std::string& define);
   void AddDefines(const char* defines);
-  void AddDefines(const std::vector<std::string> &defines);
+  void AddDefines(const std::vector<std::string>& defines);
   void AddFlag(const char* flag, const char* value);
   void AddFlag(const char* flag, std::vector<std::string> const& value);
   void AppendFlag(std::string const& flag, std::string const& value);
@@ -46,23 +46,24 @@ protected:
   // Then parse the command line flags specified in CMAKE_CXX_FLAGS
   // and CMAKE_C_FLAGS
   // and overwrite or add new values to this map
-  class FlagValue: public std::vector<std::string>
+  class FlagValue : public std::vector<std::string>
   {
     typedef std::vector<std::string> derived;
+
   public:
     FlagValue& operator=(std::string const& r)
-      {
+    {
       this->resize(1);
       this->operator[](0) = r;
       return *this;
-      }
+    }
     FlagValue& operator=(std::vector<std::string> const& r)
-      {
+    {
       this->derived::operator=(r);
       return *this;
-      }
+    }
   };
-  std::map<std::string, FlagValue > FlagMap;
+  std::map<std::string, FlagValue> FlagMap;
 
   // Preprocessor definitions.
   std::vector<std::string> Defines;
@@ -74,7 +75,10 @@ protected:
   bool AllowDefine;
   bool AllowSlash;
   cmIDEFlagTable const* DoingFollowing;
-  enum { FlagTableCount = 16 };
+  enum
+  {
+    FlagTableCount = 16
+  };
   cmIDEFlagTable const* FlagTable[FlagTableCount];
   void HandleFlag(const char* flag);
   bool CheckFlagTable(cmIDEFlagTable const* table, const char* flag,
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 37f03c5..45395d1 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -20,85 +20,71 @@
 #include <list>
 #include <stdlib.h> // required for atof
 
-
 static std::string cmIfCommandError(
   std::vector<cmExpandedCommandArgument> const& args)
 {
   std::string err = "given arguments:\n ";
-  for(std::vector<cmExpandedCommandArgument>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<cmExpandedCommandArgument>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
     err += " ";
     err += cmOutputConverter::EscapeForCMake(i->GetValue());
-    }
+  }
   err += "\n";
   return err;
 }
 
 //=========================================================================
-bool cmIfFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& lff,
-                  cmMakefile &mf,
-                  cmExecutionStatus &inStatus)
+bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
+                                            cmMakefile& mf,
+                                            cmExecutionStatus& inStatus)
 {
   // we start by recording all the functions
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(),"if"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "if")) {
     this->ScopeDepth++;
-    }
-  else if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endif"))
-    {
+  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endif")) {
     this->ScopeDepth--;
     // if this is the endif for this if statement, then start executing
-    if (!this->ScopeDepth)
-      {
+    if (!this->ScopeDepth) {
       // Remove the function blocker for this scope or bail.
-      cmsys::auto_ptr<cmFunctionBlocker>
-        fb(mf.RemoveFunctionBlocker(this, lff));
-      if(!fb.get()) { return false; }
+      cmsys::auto_ptr<cmFunctionBlocker> fb(
+        mf.RemoveFunctionBlocker(this, lff));
+      if (!fb.get()) {
+        return false;
+      }
 
       // execute the functions for the true parts of the if statement
       cmExecutionStatus status;
       int scopeDepth = 0;
-      for(unsigned int c = 0; c < this->Functions.size(); ++c)
-        {
+      for (unsigned int c = 0; c < this->Functions.size(); ++c) {
         // keep track of scope depth
-        if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),"if"))
-          {
+        if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(), "if")) {
           scopeDepth++;
-          }
-        if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),"endif"))
-          {
+        }
+        if (!cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),
+                                    "endif")) {
           scopeDepth--;
-          }
+        }
         // watch for our state change
         if (scopeDepth == 0 &&
-            !cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),"else"))
-          {
+            !cmSystemTools::Strucmp(this->Functions[c].Name.c_str(), "else")) {
           this->IsBlocking = this->HasRun;
           this->HasRun = true;
 
           // if trace is enabled, print a (trivially) evaluated "else"
           // statement
-          if(!this->IsBlocking && mf.GetCMakeInstance()->GetTrace())
-            {
+          if (!this->IsBlocking && mf.GetCMakeInstance()->GetTrace()) {
             mf.PrintCommandTrace(this->Functions[c]);
-            }
           }
-        else if (scopeDepth == 0 && !cmSystemTools::Strucmp
-                 (this->Functions[c].Name.c_str(),"elseif"))
-          {
-          if (this->HasRun)
-            {
+        } else if (scopeDepth == 0 &&
+                   !cmSystemTools::Strucmp(this->Functions[c].Name.c_str(),
+                                           "elseif")) {
+          if (this->HasRun) {
             this->IsBlocking = true;
-            }
-          else
-            {
+          } else {
             // if trace is enabled, print the evaluated "elseif" statement
-            if(mf.GetCMakeInstance()->GetTrace())
-              {
+            if (mf.GetCMakeInstance()->GetTrace()) {
               mf.PrintCommandTrace(this->Functions[c]);
-              }
+            }
 
             std::string errorString;
 
@@ -109,63 +95,54 @@ IsFunctionBlocked(const cmListFileFunction& lff,
             cmake::MessageType messType;
 
             cmListFileContext conditionContext =
-                cmListFileContext::FromCommandContext(
-                  this->Functions[c],
-                  this->GetStartingContext().FilePath);
+              cmListFileContext::FromCommandContext(
+                this->Functions[c], this->GetStartingContext().FilePath);
 
             cmConditionEvaluator conditionEvaluator(
-                  mf, conditionContext,
-                  mf.GetBacktrace(this->Functions[c]));
+              mf, conditionContext, mf.GetBacktrace(this->Functions[c]));
 
-            bool isTrue = conditionEvaluator.IsTrue(
-              expandedArguments, errorString, messType);
+            bool isTrue = conditionEvaluator.IsTrue(expandedArguments,
+                                                    errorString, messType);
 
-            if (!errorString.empty())
-              {
+            if (!errorString.empty()) {
               std::string err = cmIfCommandError(expandedArguments);
               err += errorString;
               cmListFileBacktrace bt = mf.GetBacktrace(this->Functions[c]);
               mf.GetCMakeInstance()->IssueMessage(messType, err, bt);
-              if (messType == cmake::FATAL_ERROR)
-                {
+              if (messType == cmake::FATAL_ERROR) {
                 cmSystemTools::SetFatalErrorOccured();
                 return true;
-                }
               }
+            }
 
-            if (isTrue)
-              {
+            if (isTrue) {
               this->IsBlocking = false;
               this->HasRun = true;
-              }
             }
           }
+        }
 
         // should we execute?
-        else if (!this->IsBlocking)
-          {
+        else if (!this->IsBlocking) {
           status.Clear();
-          mf.ExecuteCommand(this->Functions[c],status);
-          if (status.GetReturnInvoked())
-            {
+          mf.ExecuteCommand(this->Functions[c], status);
+          if (status.GetReturnInvoked()) {
             inStatus.SetReturnInvoked(true);
             return true;
-            }
-          if (status.GetBreakInvoked())
-            {
+          }
+          if (status.GetBreakInvoked()) {
             inStatus.SetBreakInvoked(true);
             return true;
-            }
-          if (status.GetContinueInvoked())
-            {
+          }
+          if (status.GetContinueInvoked()) {
             inStatus.SetContinueInvoked(true);
             return true;
-            }
           }
         }
-      return true;
       }
+      return true;
     }
+  }
 
   // record the command
   this->Functions.push_back(lff);
@@ -178,24 +155,20 @@ IsFunctionBlocked(const cmListFileFunction& lff,
 bool cmIfFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
                                        cmMakefile&)
 {
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endif"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endif")) {
     // if the endif has arguments, then make sure
     // they match the arguments of the matching if
-    if (lff.Arguments.empty() ||
-        lff.Arguments == this->Args)
-      {
+    if (lff.Arguments.empty() || lff.Arguments == this->Args) {
       return true;
-      }
     }
+  }
 
   return false;
 }
 
 //=========================================================================
-bool cmIfCommand
-::InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                    cmExecutionStatus &)
+bool cmIfCommand::InvokeInitialPass(
+  const std::vector<cmListFileArgument>& args, cmExecutionStatus&)
 {
   std::string errorString;
 
@@ -205,37 +178,31 @@ bool cmIfCommand
   cmake::MessageType status;
 
   cmConditionEvaluator conditionEvaluator(
-        *(this->Makefile),
-        this->Makefile->GetExecutionContext(),
-        this->Makefile->GetBacktrace());
+    *(this->Makefile), this->Makefile->GetExecutionContext(),
+    this->Makefile->GetBacktrace());
 
-  bool isTrue = conditionEvaluator.IsTrue(
-    expandedArguments, errorString, status);
+  bool isTrue =
+    conditionEvaluator.IsTrue(expandedArguments, errorString, status);
 
-  if (!errorString.empty())
-    {
+  if (!errorString.empty()) {
     std::string err = cmIfCommandError(expandedArguments);
     err += errorString;
-    if (status == cmake::FATAL_ERROR)
-      {
+    if (status == cmake::FATAL_ERROR) {
       this->SetError(err);
       cmSystemTools::SetFatalErrorOccured();
       return false;
-      }
-    else
-      {
+    } else {
       this->Makefile->IssueMessage(status, err);
-      }
     }
+  }
 
-  cmIfFunctionBlocker *f = new cmIfFunctionBlocker();
+  cmIfFunctionBlocker* f = new cmIfFunctionBlocker();
   // if is isn't true block the commands
   f->ScopeDepth = 1;
   f->IsBlocking = !isTrue;
-  if (isTrue)
-    {
+  if (isTrue) {
     f->HasRun = true;
-    }
+  }
   f->Args = args;
   this->Makefile->AddFunctionBlocker(f);
 
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index 9054a0b..54200df 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -19,14 +19,15 @@
 class cmIfFunctionBlocker : public cmFunctionBlocker
 {
 public:
-  cmIfFunctionBlocker() {
-    this->HasRun = false; this->ScopeDepth = 0; }
+  cmIfFunctionBlocker()
+  {
+    this->HasRun = false;
+    this->ScopeDepth = 0;
+  }
   virtual ~cmIfFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
-                                 cmMakefile &mf,
-                                 cmExecutionStatus &);
-  virtual bool ShouldRemove(const cmListFileFunction& lff,
-                            cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                                 cmExecutionStatus&);
+  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf);
 
   std::vector<cmListFileArgument> Args;
   std::vector<cmListFileFunction> Functions;
@@ -42,29 +43,28 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmIfCommand;
-    }
+  virtual cmCommand* Clone() { return new cmIfCommand; }
 
   /**
    * This overrides the default InvokeInitialPass implementation.
    * It records the arguments before expansion.
    */
   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) { return false;}
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "if";}
+  virtual std::string GetName() const { return "if"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -78,5 +78,4 @@ public:
   cmTypeMacro(cmIfCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmIncludeCommand.cxx b/Source/cmIncludeCommand.cxx
index 8890e2b..cb9b74d 100644
--- a/Source/cmIncludeCommand.cxx
+++ b/Source/cmIncludeCommand.cxx
@@ -11,97 +11,77 @@
 ============================================================================*/
 #include "cmIncludeCommand.h"
 
-
 // cmIncludeCommand
-bool cmIncludeCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmIncludeCommand::InitialPass(std::vector<std::string> const& args,
+                                   cmExecutionStatus&)
 {
-  if (args.size()< 1 || args.size() > 4)
-    {
-      this->SetError("called with wrong number of arguments.  "
-                     "include() only takes one file.");
-      return false;
-    }
+  if (args.size() < 1 || args.size() > 4) {
+    this->SetError("called with wrong number of arguments.  "
+                   "include() only takes one file.");
+    return false;
+  }
   bool optional = false;
   bool noPolicyScope = false;
   std::string fname = args[0];
   std::string resultVarName;
 
-  for (unsigned int i=1; i<args.size(); i++)
-    {
-    if (args[i] == "OPTIONAL")
-      {
-      if (optional)
-        {
+  for (unsigned int i = 1; i < args.size(); i++) {
+    if (args[i] == "OPTIONAL") {
+      if (optional) {
         this->SetError("called with invalid arguments: OPTIONAL used twice");
         return false;
-        }
-      optional = true;
       }
-    else if(args[i] == "RESULT_VARIABLE")
-      {
-      if (!resultVarName.empty())
-        {
+      optional = true;
+    } else if (args[i] == "RESULT_VARIABLE") {
+      if (!resultVarName.empty()) {
         this->SetError("called with invalid arguments: "
-            "only one result variable allowed");
+                       "only one result variable allowed");
         return false;
-        }
-      if(++i < args.size())
-        {
+      }
+      if (++i < args.size()) {
         resultVarName = args[i];
-        }
-      else
-        {
+      } else {
         this->SetError("called with no value for RESULT_VARIABLE.");
         return false;
-        }
       }
-    else if(args[i] == "NO_POLICY_SCOPE")
-      {
+    } else if (args[i] == "NO_POLICY_SCOPE") {
       noPolicyScope = true;
-      }
-      else if(i > 1)  // compat.: in previous cmake versions the second
+    } else if (i > 1) // compat.: in previous cmake versions the second
                       // parameter was ignored if it wasn't "OPTIONAL"
-        {
-        std::string errorText = "called with invalid argument: ";
-        errorText += args[i];
-        this->SetError(errorText);
-        return false;
-        }
+    {
+      std::string errorText = "called with invalid argument: ";
+      errorText += args[i];
+      this->SetError(errorText);
+      return false;
     }
+  }
 
-  if(fname.empty())
-    {
+  if (fname.empty()) {
     this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
                                  "include() given empty file name (ignored).");
     return true;
-    }
+  }
 
-  if(!cmSystemTools::FileIsFullPath(fname.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(fname.c_str())) {
     // Not a path. Maybe module.
     std::string module = fname;
     module += ".cmake";
     std::string mfile = this->Makefile->GetModulesFile(module.c_str());
-    if (!mfile.empty())
-      {
+    if (!mfile.empty()) {
       fname = mfile.c_str();
-      }
     }
+  }
 
-  std::string fname_abs =
-      cmSystemTools::CollapseFullPath(fname,
-                                 this->Makefile->GetCurrentSourceDirectory());
+  std::string fname_abs = cmSystemTools::CollapseFullPath(
+    fname, this->Makefile->GetCurrentSourceDirectory());
 
-  cmGlobalGenerator *gg = this->Makefile->GetGlobalGenerator();
-  if (gg->IsExportedTargetsFile(fname_abs))
-    {
-    const char *modal = 0;
+  cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
+  if (gg->IsExportedTargetsFile(fname_abs)) {
+    const char* modal = 0;
     std::ostringstream e;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
 
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0024))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0024)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0024) << "\n";
         modal = "should";
@@ -112,55 +92,47 @@ bool cmIncludeCommand
       case cmPolicies::NEW:
         modal = "may";
         messageType = cmake::FATAL_ERROR;
-      }
-    if (modal)
-      {
+    }
+    if (modal) {
       e << "The file\n  " << fname_abs << "\nwas generated by the export() "
-        "command.  It " << modal << " not be used as the argument to the "
-        "include() command.  Use ALIAS targets instead to refer to targets "
-        "by alternative names.\n";
+                                          "command.  It "
+        << modal
+        << " not be used as the argument to the "
+           "include() command.  Use ALIAS targets instead to refer to targets "
+           "by alternative names.\n";
       this->Makefile->IssueMessage(messageType, e.str());
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
+    }
     gg->CreateGenerationObjects();
     gg->GenerateImportFile(fname_abs);
-    }
+  }
 
-  std::string listFile =
-    cmSystemTools::CollapseFullPath(fname.c_str(),
-                                  this->Makefile->GetCurrentSourceDirectory());
-  if(optional && !cmSystemTools::FileExists(listFile.c_str()))
-    {
-    if (!resultVarName.empty())
-      {
+  std::string listFile = cmSystemTools::CollapseFullPath(
+    fname.c_str(), this->Makefile->GetCurrentSourceDirectory());
+  if (optional && !cmSystemTools::FileExists(listFile.c_str())) {
+    if (!resultVarName.empty()) {
       this->Makefile->AddDefinition(resultVarName, "NOTFOUND");
-      }
-    return true;
     }
+    return true;
+  }
 
   bool readit =
     this->Makefile->ReadDependentFile(listFile.c_str(), noPolicyScope);
 
   // add the location of the included file if a result variable was given
-  if (!resultVarName.empty())
-    {
-      this->Makefile->AddDefinition(resultVarName,
-                                    readit?fname_abs.c_str():"NOTFOUND");
-    }
-
-  if(!optional && !readit && !cmSystemTools::GetFatalErrorOccured())
-    {
-    std::string m =
-      "could not find load file:\n"
-      "  ";
+  if (!resultVarName.empty()) {
+    this->Makefile->AddDefinition(resultVarName,
+                                  readit ? fname_abs.c_str() : "NOTFOUND");
+  }
+
+  if (!optional && !readit && !cmSystemTools::GetFatalErrorOccured()) {
+    std::string m = "could not find load file:\n"
+                    "  ";
     m += fname;
     this->SetError(m);
     return false;
-    }
+  }
   return true;
 }
-
-
diff --git a/Source/cmIncludeCommand.h b/Source/cmIncludeCommand.h
index 0dcd7de..e319dbd 100644
--- a/Source/cmIncludeCommand.h
+++ b/Source/cmIncludeCommand.h
@@ -26,17 +26,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmIncludeCommand;
-    }
+  virtual cmCommand* Clone() { return new cmIncludeCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -46,11 +43,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "include";}
+  virtual std::string GetName() const { return "include"; }
 
   cmTypeMacro(cmIncludeCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmIncludeDirectoryCommand.cxx b/Source/cmIncludeDirectoryCommand.cxx
index 5c28cfd..cafdba7 100644
--- a/Source/cmIncludeDirectoryCommand.cxx
+++ b/Source/cmIncludeDirectoryCommand.cxx
@@ -12,68 +12,55 @@
 #include "cmIncludeDirectoryCommand.h"
 
 // cmIncludeDirectoryCommand
-bool cmIncludeDirectoryCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmIncludeDirectoryCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
 
   std::vector<std::string>::const_iterator i = args.begin();
 
   bool before = this->Makefile->IsOn("CMAKE_INCLUDE_DIRECTORIES_BEFORE");
   bool system = false;
 
-  if ((*i) == "BEFORE")
-    {
+  if ((*i) == "BEFORE") {
     before = true;
     ++i;
-    }
-  else if ((*i) == "AFTER")
-    {
+  } else if ((*i) == "AFTER") {
     before = false;
     ++i;
-    }
+  }
 
   std::vector<std::string> beforeIncludes;
   std::vector<std::string> afterIncludes;
   std::set<std::string> systemIncludes;
 
-  for(; i != args.end(); ++i)
-    {
-    if(*i == "SYSTEM")
-      {
+  for (; i != args.end(); ++i) {
+    if (*i == "SYSTEM") {
       system = true;
       continue;
-      }
-    if(i->empty())
-      {
+    }
+    if (i->empty()) {
       this->SetError("given empty-string as include directory.");
       return false;
-      }
+    }
 
     std::vector<std::string> includes;
 
     this->GetIncludes(*i, includes);
 
-    if (before)
-      {
-      beforeIncludes.insert(beforeIncludes.end(),
-                            includes.begin(),
+    if (before) {
+      beforeIncludes.insert(beforeIncludes.end(), includes.begin(),
                             includes.end());
-      }
-    else
-      {
-      afterIncludes.insert(afterIncludes.end(),
-                           includes.begin(),
+    } else {
+      afterIncludes.insert(afterIncludes.end(), includes.begin(),
                            includes.end());
-      }
-    if (system)
-      {
+    }
+    if (system) {
       systemIncludes.insert(includes.begin(), includes.end());
-      }
     }
+  }
   std::reverse(beforeIncludes.begin(), beforeIncludes.end());
 
   this->Makefile->AddIncludeDirectories(afterIncludes);
@@ -83,7 +70,7 @@ bool cmIncludeDirectoryCommand
   return true;
 }
 
-static bool StartsWithGeneratorExpression(const std::string &input)
+static bool StartsWithGeneratorExpression(const std::string& input)
 {
   return input[0] == '$' && input[1] == '<';
 }
@@ -100,60 +87,50 @@ static bool StartsWithGeneratorExpression(const std::string &input)
 // output from a program and passing it into a command the cleanup doesn't
 // always happen
 //
-void cmIncludeDirectoryCommand::GetIncludes(const std::string &arg,
-                                            std::vector<std::string> &incs)
+void cmIncludeDirectoryCommand::GetIncludes(const std::string& arg,
+                                            std::vector<std::string>& incs)
 {
   // break apart any line feed arguments
   std::string::size_type pos = 0;
   std::string::size_type lastPos = 0;
-  while((pos = arg.find('\n', lastPos)) != std::string::npos)
-    {
-    if (pos)
-      {
-      std::string inc = arg.substr(lastPos,pos);
+  while ((pos = arg.find('\n', lastPos)) != std::string::npos) {
+    if (pos) {
+      std::string inc = arg.substr(lastPos, pos);
       this->NormalizeInclude(inc);
-      if (!inc.empty())
-        {
+      if (!inc.empty()) {
         incs.push_back(inc);
-        }
       }
-    lastPos = pos + 1;
     }
+    lastPos = pos + 1;
+  }
   std::string inc = arg.substr(lastPos);
   this->NormalizeInclude(inc);
-  if (!inc.empty())
-    {
+  if (!inc.empty()) {
     incs.push_back(inc);
-    }
+  }
 }
 
-void cmIncludeDirectoryCommand::NormalizeInclude(std::string &inc)
+void cmIncludeDirectoryCommand::NormalizeInclude(std::string& inc)
 {
   std::string::size_type b = inc.find_first_not_of(" \r");
   std::string::size_type e = inc.find_last_not_of(" \r");
-  if ((b!=inc.npos) && (e!=inc.npos))
-    {
-    inc.assign(inc, b, 1+e-b);   // copy the remaining substring
-    }
-  else
-    {
+  if ((b != inc.npos) && (e != inc.npos)) {
+    inc.assign(inc, b, 1 + e - b); // copy the remaining substring
+  } else {
     inc = "";
     return;
-    }
+  }
 
-  if (!cmSystemTools::IsOff(inc.c_str()))
-    {
+  if (!cmSystemTools::IsOff(inc.c_str())) {
     cmSystemTools::ConvertToUnixSlashes(inc);
 
-    if(!cmSystemTools::FileIsFullPath(inc.c_str()))
-      {
-      if(!StartsWithGeneratorExpression(inc))
-        {
+    if (!cmSystemTools::FileIsFullPath(inc.c_str())) {
+      if (!StartsWithGeneratorExpression(inc)) {
         std::string tmp = this->Makefile->GetCurrentSourceDirectory();
         tmp += "/";
         tmp += inc;
         inc = tmp;
-        }
       }
     }
+  }
 }
diff --git a/Source/cmIncludeDirectoryCommand.h b/Source/cmIncludeDirectoryCommand.h
index 6cc2c83..952294b 100644
--- a/Source/cmIncludeDirectoryCommand.h
+++ b/Source/cmIncludeDirectoryCommand.h
@@ -26,31 +26,26 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmIncludeDirectoryCommand;
-    }
+  virtual cmCommand* Clone() { return new cmIncludeDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "include_directories";}
+  virtual std::string GetName() const { return "include_directories"; }
 
   cmTypeMacro(cmIncludeDirectoryCommand, cmCommand);
 
 protected:
   // used internally
-  void GetIncludes(const std::string &arg, std::vector<std::string> &incs);
-  void NormalizeInclude(std::string &inc);
+  void GetIncludes(const std::string& arg, std::vector<std::string>& incs);
+  void NormalizeInclude(std::string& inc);
 };
 
-
-
 #endif
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index c64d128..9720d63 100644
--- a/Source/cmIncludeExternalMSProjectCommand.cxx
+++ b/Source/cmIncludeExternalMSProjectCommand.cxx
@@ -12,20 +12,24 @@
 #include "cmIncludeExternalMSProjectCommand.h"
 
 // cmIncludeExternalMSProjectCommand
-bool cmIncludeExternalMSProjectCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmIncludeExternalMSProjectCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2)
-  {
-  this->SetError("INCLUDE_EXTERNAL_MSPROJECT called with incorrect "
-                 "number of arguments");
-  return false;
+  if (args.size() < 2) {
+    this->SetError("INCLUDE_EXTERNAL_MSPROJECT called with incorrect "
+                   "number of arguments");
+    return false;
   }
 // only compile this for win32 to avoid coverage errors
 #ifdef _WIN32
-  if(this->Makefile->GetDefinition("WIN32"))
+  if (this->Makefile->GetDefinition("WIN32")) {
+    enum Doing
     {
-    enum Doing { DoingNone, DoingType, DoingGuid, DoingPlatform };
+      DoingNone,
+      DoingType,
+      DoingGuid,
+      DoingPlatform
+    };
 
     Doing doing = DoingNone;
 
@@ -34,32 +38,31 @@ bool cmIncludeExternalMSProjectCommand
     std::string platformMapping;
 
     std::vector<std::string> depends;
-    for (unsigned int i=2; i<args.size(); ++i)
-      {
-      if (args[i] == "TYPE")
-        {
+    for (unsigned int i = 2; i < args.size(); ++i) {
+      if (args[i] == "TYPE") {
         doing = DoingType;
-        }
-      else if (args[i] == "GUID")
-        {
+      } else if (args[i] == "GUID") {
         doing = DoingGuid;
-        }
-      else if (args[i] == "PLATFORM")
-        {
+      } else if (args[i] == "PLATFORM") {
         doing = DoingPlatform;
+      } else {
+        switch (doing) {
+          case DoingNone:
+            depends.push_back(args[i]);
+            break;
+          case DoingType:
+            customType = args[i];
+            break;
+          case DoingGuid:
+            customGuid = args[i];
+            break;
+          case DoingPlatform:
+            platformMapping = args[i];
+            break;
         }
-      else
-        {
-        switch (doing)
-          {
-          case DoingNone: depends.push_back(args[i]);    break;
-          case DoingType: customType = args[i];          break;
-          case DoingGuid: customGuid = args[i];          break;
-          case DoingPlatform: platformMapping = args[i]; break;
-          }
         doing = DoingNone;
-        }
       }
+    }
 
     // Hack together a utility target storing enough information
     // to reproduce the target inclusion.
@@ -68,34 +71,31 @@ bool cmIncludeExternalMSProjectCommand
     std::string path = args[1];
     cmSystemTools::ConvertToUnixSlashes(path);
 
-    if (!customGuid.empty())
-      {
+    if (!customGuid.empty()) {
       std::string guidVariable = utility_name + "_GUID_CMAKE";
       this->Makefile->GetCMakeInstance()->AddCacheEntry(
-        guidVariable.c_str(), customGuid.c_str(),
-        "Stored GUID", cmState::INTERNAL);
-      }
+        guidVariable.c_str(), customGuid.c_str(), "Stored GUID",
+        cmState::INTERNAL);
+    }
 
     // Create a target instance for this utility.
-    cmTarget* target=this->Makefile->AddNewTarget(cmState::UTILITY,
-                                                  utility_name.c_str());
+    cmTarget* target =
+      this->Makefile->AddNewTarget(cmState::UTILITY, utility_name.c_str());
 
     target->SetProperty("GENERATOR_FILE_NAME", utility_name.c_str());
     target->SetProperty("EXTERNAL_MSPROJECT", path.c_str());
     target->SetProperty("EXCLUDE_FROM_ALL", "FALSE");
 
     if (!customType.empty())
-      target->SetProperty("VS_PROJECT_TYPE",customType.c_str());
+      target->SetProperty("VS_PROJECT_TYPE", customType.c_str());
     if (!platformMapping.empty())
-      target->SetProperty("VS_PLATFORM_MAPPING",platformMapping.c_str());
+      target->SetProperty("VS_PLATFORM_MAPPING", platformMapping.c_str());
 
     for (std::vector<std::string>::const_iterator it = depends.begin();
-         it != depends.end();
-         ++it)
-      {
+         it != depends.end(); ++it) {
       target->AddUtility(it->c_str());
-      }
     }
+  }
 #endif
   return true;
 }
diff --git a/Source/cmIncludeExternalMSProjectCommand.h b/Source/cmIncludeExternalMSProjectCommand.h
index 081f77a..999eb9e 100644
--- a/Source/cmIncludeExternalMSProjectCommand.h
+++ b/Source/cmIncludeExternalMSProjectCommand.h
@@ -27,26 +27,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmIncludeExternalMSProjectCommand;
-    }
+  virtual cmCommand* Clone() { return new cmIncludeExternalMSProjectCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "include_external_msproject";}
+  virtual std::string GetName() const { return "include_external_msproject"; }
 
   cmTypeMacro(cmIncludeExternalMSProjectCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmIncludeRegularExpressionCommand.cxx b/Source/cmIncludeRegularExpressionCommand.cxx
index d6dfdd2..2473dff 100644
--- a/Source/cmIncludeRegularExpressionCommand.cxx
+++ b/Source/cmIncludeRegularExpressionCommand.cxx
@@ -12,21 +12,18 @@
 #include "cmIncludeRegularExpressionCommand.h"
 
 // cmIncludeRegularExpressionCommand
-bool cmIncludeRegularExpressionCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmIncludeRegularExpressionCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if((args.size() < 1) || (args.size() > 2))
-    {
+  if ((args.size() < 1) || (args.size() > 2)) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   this->Makefile->SetIncludeRegularExpression(args[0].c_str());
 
-  if(args.size() > 1)
-    {
+  if (args.size() > 1) {
     this->Makefile->SetComplainRegularExpression(args[1]);
-    }
+  }
 
   return true;
 }
-
diff --git a/Source/cmIncludeRegularExpressionCommand.h b/Source/cmIncludeRegularExpressionCommand.h
index c58f018..1071a7a 100644
--- a/Source/cmIncludeRegularExpressionCommand.h
+++ b/Source/cmIncludeRegularExpressionCommand.h
@@ -26,26 +26,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmIncludeRegularExpressionCommand;
-    }
+  virtual cmCommand* Clone() { return new cmIncludeRegularExpressionCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "include_regular_expression";}
+  virtual std::string GetName() const { return "include_regular_expression"; }
 
   cmTypeMacro(cmIncludeRegularExpressionCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index c87b29b..e9de8df 100644
--- a/Source/cmInstallCommand.cxx
+++ b/Source/cmInstallCommand.cxx
@@ -22,88 +22,68 @@
 
 #include <cmsys/Glob.hxx>
 
-static cmInstallTargetGenerator* CreateInstallTargetGenerator(cmTarget& target,
-     const cmInstallCommandArguments& args, bool impLib, bool forceOpt = false)
+static cmInstallTargetGenerator* CreateInstallTargetGenerator(
+  cmTarget& target, const cmInstallCommandArguments& args, bool impLib,
+  bool forceOpt = false)
 {
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(target.GetMakefile());
   target.SetHaveInstallRule(true);
-  return new cmInstallTargetGenerator(target.GetName(),
-                        args.GetDestination().c_str(),
-                        impLib, args.GetPermissions().c_str(),
-                        args.GetConfigurations(), args.GetComponent().c_str(),
-                        message,
-                        args.GetExcludeFromAll(),
-                        args.GetOptional() || forceOpt);
+  return new cmInstallTargetGenerator(
+    target.GetName(), args.GetDestination().c_str(), impLib,
+    args.GetPermissions().c_str(), args.GetConfigurations(),
+    args.GetComponent().c_str(), message, args.GetExcludeFromAll(),
+    args.GetOptional() || forceOpt);
 }
 
 static cmInstallFilesGenerator* CreateInstallFilesGenerator(
-  cmMakefile* mf,
-    const std::vector<std::string>& absFiles,
-    const cmInstallCommandArguments& args, bool programs)
+  cmMakefile* mf, const std::vector<std::string>& absFiles,
+  const cmInstallCommandArguments& args, bool programs)
 {
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(mf);
   return new cmInstallFilesGenerator(
-                        absFiles, args.GetDestination().c_str(),
-                        programs, args.GetPermissions().c_str(),
-                        args.GetConfigurations(), args.GetComponent().c_str(),
-                        message,
-                        args.GetExcludeFromAll(), args.GetRename().c_str(),
-                        args.GetOptional());
+    absFiles, args.GetDestination().c_str(), programs,
+    args.GetPermissions().c_str(), args.GetConfigurations(),
+    args.GetComponent().c_str(), message, args.GetExcludeFromAll(),
+    args.GetRename().c_str(), args.GetOptional());
 }
 
-
 // cmInstallCommand
 bool cmInstallCommand::InitialPass(std::vector<std::string> const& args,
-                                   cmExecutionStatus &)
+                                   cmExecutionStatus&)
 {
   // Allow calling with no arguments so that arguments may be built up
   // using a variable that may be left empty.
-  if(args.empty())
-    {
+  if (args.empty()) {
     return true;
-    }
+  }
 
   // Enable the install target.
   this->Makefile->GetGlobalGenerator()->EnableInstallTarget();
 
-  this->DefaultComponentName = this->Makefile->GetSafeDefinition(
-                                       "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
-  if (this->DefaultComponentName.empty())
-    {
+  this->DefaultComponentName =
+    this->Makefile->GetSafeDefinition("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
+  if (this->DefaultComponentName.empty()) {
     this->DefaultComponentName = "Unspecified";
-    }
+  }
 
   // Switch among the command modes.
-  if(args[0] == "SCRIPT")
-    {
+  if (args[0] == "SCRIPT") {
     return this->HandleScriptMode(args);
-    }
-  else if(args[0] == "CODE")
-    {
+  } else if (args[0] == "CODE") {
     return this->HandleScriptMode(args);
-    }
-  else if(args[0] == "TARGETS")
-    {
+  } else if (args[0] == "TARGETS") {
     return this->HandleTargetsMode(args);
-    }
-  else if(args[0] == "FILES")
-    {
+  } else if (args[0] == "FILES") {
     return this->HandleFilesMode(args);
-    }
-  else if(args[0] == "PROGRAMS")
-    {
+  } else if (args[0] == "PROGRAMS") {
     return this->HandleFilesMode(args);
-    }
-  else if(args[0] == "DIRECTORY")
-    {
+  } else if (args[0] == "DIRECTORY") {
     return this->HandleDirectoryMode(args);
-    }
-  else if(args[0] == "EXPORT")
-    {
+  } else if (args[0] == "EXPORT") {
     return this->HandleExportMode(args);
-    }
+  }
 
   // Unknown mode.
   std::string e = "called with unknown mode ";
@@ -122,96 +102,75 @@ bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
 
   // Scan the args once for COMPONENT. Only allow one.
   //
-  for(size_t i=0; i < args.size(); ++i)
-    {
-    if(args[i] == "COMPONENT" && i+1 < args.size())
-        {
-        ++componentCount;
-        ++i;
-        component = args[i];
-        }
-    if(args[i] == "EXCLUDE_FROM_ALL")
-      {
+  for (size_t i = 0; i < args.size(); ++i) {
+    if (args[i] == "COMPONENT" && i + 1 < args.size()) {
+      ++componentCount;
+      ++i;
+      component = args[i];
+    }
+    if (args[i] == "EXCLUDE_FROM_ALL") {
       exclude_from_all = true;
-      }
     }
+  }
 
-  if(componentCount>1)
-    {
+  if (componentCount > 1) {
     this->SetError("given more than one COMPONENT for the SCRIPT or CODE "
-      "signature of the INSTALL command. "
-      "Use multiple INSTALL commands with one COMPONENT each.");
+                   "signature of the INSTALL command. "
+                   "Use multiple INSTALL commands with one COMPONENT each.");
     return false;
-    }
+  }
 
   // Scan the args again, this time adding install generators each time we
   // encounter a SCRIPT or CODE arg:
   //
-  for(size_t i=0; i < args.size(); ++i)
-    {
-    if(args[i] == "SCRIPT")
-      {
+  for (size_t i = 0; i < args.size(); ++i) {
+    if (args[i] == "SCRIPT") {
       doing_script = true;
       doing_code = false;
-      }
-    else if(args[i] == "CODE")
-      {
+    } else if (args[i] == "CODE") {
       doing_script = false;
       doing_code = true;
-      }
-    else if(args[i] == "COMPONENT")
-      {
+    } else if (args[i] == "COMPONENT") {
       doing_script = false;
       doing_code = false;
-      }
-    else if(doing_script)
-      {
+    } else if (doing_script) {
       doing_script = false;
       std::string script = args[i];
-      if(!cmSystemTools::FileIsFullPath(script.c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(script.c_str())) {
         script = this->Makefile->GetCurrentSourceDirectory();
         script += "/";
         script += args[i];
-        }
-      if(cmSystemTools::FileIsDirectory(script))
-        {
+      }
+      if (cmSystemTools::FileIsDirectory(script)) {
         this->SetError("given a directory as value of SCRIPT argument.");
         return false;
-        }
-      this->Makefile->AddInstallGenerator(
-        new cmInstallScriptGenerator(script.c_str(), false,
-                                     component.c_str(), exclude_from_all));
       }
-    else if(doing_code)
-      {
+      this->Makefile->AddInstallGenerator(new cmInstallScriptGenerator(
+        script.c_str(), false, component.c_str(), exclude_from_all));
+    } else if (doing_code) {
       doing_code = false;
       std::string code = args[i];
-      this->Makefile->AddInstallGenerator(
-        new cmInstallScriptGenerator(code.c_str(), true,
-                                     component.c_str(), exclude_from_all));
-      }
+      this->Makefile->AddInstallGenerator(new cmInstallScriptGenerator(
+        code.c_str(), true, component.c_str(), exclude_from_all));
     }
+  }
 
-  if(doing_script)
-    {
+  if (doing_script) {
     this->SetError("given no value for SCRIPT argument.");
     return false;
-    }
-  if(doing_code)
-    {
+  }
+  if (doing_code) {
     this->SetError("given no value for CODE argument.");
     return false;
-    }
+  }
 
-  //Tell the global generator about any installation component names specified.
-  this->Makefile->GetGlobalGenerator()
-                             ->AddInstallComponent(component.c_str());
+  // Tell the global generator about any installation component names
+  // specified.
+  this->Makefile->GetGlobalGenerator()->AddInstallComponent(component.c_str());
 
   return true;
 }
 
-
 /*struct InstallPart
 {
   InstallPart(cmCommandArgumentsHelper* helper, const char* key,
@@ -227,16 +186,17 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
 
   cmCommandArgumentsHelper argHelper;
   cmCommandArgumentGroup group;
-  cmCAStringVector genericArgVector      (&argHelper,0);
-  cmCAStringVector archiveArgVector      (&argHelper,"ARCHIVE",&group);
-  cmCAStringVector libraryArgVector      (&argHelper,"LIBRARY",&group);
-  cmCAStringVector runtimeArgVector      (&argHelper,"RUNTIME",&group);
-  cmCAStringVector frameworkArgVector    (&argHelper,"FRAMEWORK",&group);
-  cmCAStringVector bundleArgVector       (&argHelper,"BUNDLE",&group);
-  cmCAStringVector includesArgVector     (&argHelper,"INCLUDES",&group);
-  cmCAStringVector privateHeaderArgVector(&argHelper,"PRIVATE_HEADER",&group);
-  cmCAStringVector publicHeaderArgVector (&argHelper,"PUBLIC_HEADER",&group);
-  cmCAStringVector resourceArgVector     (&argHelper,"RESOURCE",&group);
+  cmCAStringVector genericArgVector(&argHelper, 0);
+  cmCAStringVector archiveArgVector(&argHelper, "ARCHIVE", &group);
+  cmCAStringVector libraryArgVector(&argHelper, "LIBRARY", &group);
+  cmCAStringVector runtimeArgVector(&argHelper, "RUNTIME", &group);
+  cmCAStringVector frameworkArgVector(&argHelper, "FRAMEWORK", &group);
+  cmCAStringVector bundleArgVector(&argHelper, "BUNDLE", &group);
+  cmCAStringVector includesArgVector(&argHelper, "INCLUDES", &group);
+  cmCAStringVector privateHeaderArgVector(&argHelper, "PRIVATE_HEADER",
+                                          &group);
+  cmCAStringVector publicHeaderArgVector(&argHelper, "PUBLIC_HEADER", &group);
+  cmCAStringVector resourceArgVector(&argHelper, "RESOURCE", &group);
   genericArgVector.Follows(0);
   group.Follows(&genericArgVector);
 
@@ -248,7 +208,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
   std::vector<std::string> unknownArgs;
   cmInstallCommandArguments genericArgs(this->DefaultComponentName);
   cmCAStringVector targetList(&genericArgs.Parser, "TARGETS");
-  cmCAString exports(&genericArgs.Parser,"EXPORT", &genericArgs.ArgumentGroup);
+  cmCAString exports(&genericArgs.Parser, "EXPORT",
+                     &genericArgs.ArgumentGroup);
   targetList.Follows(0);
   genericArgs.ArgumentGroup.Follows(&targetList);
   genericArgs.Parse(&genericArgVector.GetVector(), &unknownArgs);
@@ -266,24 +227,23 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
 
   // now parse the args for specific parts of the target (e.g. LIBRARY,
   // RUNTIME, ARCHIVE etc.
-  archiveArgs.Parse      (&archiveArgVector.GetVector(),       &unknownArgs);
-  libraryArgs.Parse      (&libraryArgVector.GetVector(),       &unknownArgs);
-  runtimeArgs.Parse      (&runtimeArgVector.GetVector(),       &unknownArgs);
-  frameworkArgs.Parse    (&frameworkArgVector.GetVector(),     &unknownArgs);
-  bundleArgs.Parse       (&bundleArgVector.GetVector(),        &unknownArgs);
+  archiveArgs.Parse(&archiveArgVector.GetVector(), &unknownArgs);
+  libraryArgs.Parse(&libraryArgVector.GetVector(), &unknownArgs);
+  runtimeArgs.Parse(&runtimeArgVector.GetVector(), &unknownArgs);
+  frameworkArgs.Parse(&frameworkArgVector.GetVector(), &unknownArgs);
+  bundleArgs.Parse(&bundleArgVector.GetVector(), &unknownArgs);
   privateHeaderArgs.Parse(&privateHeaderArgVector.GetVector(), &unknownArgs);
-  publicHeaderArgs.Parse (&publicHeaderArgVector.GetVector(),  &unknownArgs);
-  resourceArgs.Parse     (&resourceArgVector.GetVector(),      &unknownArgs);
-  includesArgs.Parse     (&includesArgVector.GetVector(),      &unknownArgs);
+  publicHeaderArgs.Parse(&publicHeaderArgVector.GetVector(), &unknownArgs);
+  resourceArgs.Parse(&resourceArgVector.GetVector(), &unknownArgs);
+  includesArgs.Parse(&includesArgVector.GetVector(), &unknownArgs);
 
-  if(!unknownArgs.empty())
-    {
+  if (!unknownArgs.empty()) {
     // Unknown argument.
     std::ostringstream e;
     e << "TARGETS given unknown argument \"" << unknownArgs[0] << "\".";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // apply generic args
   archiveArgs.SetGenericArguments(&genericArgs);
@@ -304,125 +264,98 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
   success = success && publicHeaderArgs.Finalize();
   success = success && resourceArgs.Finalize();
 
-  if(!success)
-    {
+  if (!success) {
     return false;
-    }
+  }
 
   // Enforce argument rules too complex to specify for the
   // general-purpose parser.
-  if(archiveArgs.GetNamelinkOnly() ||
-     runtimeArgs.GetNamelinkOnly() ||
-     frameworkArgs.GetNamelinkOnly() ||
-     bundleArgs.GetNamelinkOnly() ||
-     privateHeaderArgs.GetNamelinkOnly() ||
-     publicHeaderArgs.GetNamelinkOnly() ||
-     resourceArgs.GetNamelinkOnly())
-    {
+  if (archiveArgs.GetNamelinkOnly() || runtimeArgs.GetNamelinkOnly() ||
+      frameworkArgs.GetNamelinkOnly() || bundleArgs.GetNamelinkOnly() ||
+      privateHeaderArgs.GetNamelinkOnly() ||
+      publicHeaderArgs.GetNamelinkOnly() || resourceArgs.GetNamelinkOnly()) {
     this->SetError(
       "TARGETS given NAMELINK_ONLY option not in LIBRARY group.  "
-      "The NAMELINK_ONLY option may be specified only following LIBRARY."
-      );
+      "The NAMELINK_ONLY option may be specified only following LIBRARY.");
     return false;
-    }
-  if(archiveArgs.GetNamelinkSkip() ||
-     runtimeArgs.GetNamelinkSkip() ||
-     frameworkArgs.GetNamelinkSkip() ||
-     bundleArgs.GetNamelinkSkip() ||
-     privateHeaderArgs.GetNamelinkSkip() ||
-     publicHeaderArgs.GetNamelinkSkip() ||
-     resourceArgs.GetNamelinkSkip())
-    {
+  }
+  if (archiveArgs.GetNamelinkSkip() || runtimeArgs.GetNamelinkSkip() ||
+      frameworkArgs.GetNamelinkSkip() || bundleArgs.GetNamelinkSkip() ||
+      privateHeaderArgs.GetNamelinkSkip() ||
+      publicHeaderArgs.GetNamelinkSkip() || resourceArgs.GetNamelinkSkip()) {
     this->SetError(
       "TARGETS given NAMELINK_SKIP option not in LIBRARY group.  "
-      "The NAMELINK_SKIP option may be specified only following LIBRARY."
-      );
+      "The NAMELINK_SKIP option may be specified only following LIBRARY.");
     return false;
-    }
-  if(libraryArgs.GetNamelinkOnly() && libraryArgs.GetNamelinkSkip())
-    {
-    this->SetError(
-      "TARGETS given NAMELINK_ONLY and NAMELINK_SKIP.  "
-      "At most one of these two options may be specified."
-      );
+  }
+  if (libraryArgs.GetNamelinkOnly() && libraryArgs.GetNamelinkSkip()) {
+    this->SetError("TARGETS given NAMELINK_ONLY and NAMELINK_SKIP.  "
+                   "At most one of these two options may be specified.");
     return false;
-    }
+  }
 
   // Select the mode for installing symlinks to versioned shared libraries.
-  cmInstallTargetGenerator::NamelinkModeType
-    namelinkMode = cmInstallTargetGenerator::NamelinkModeNone;
-  if(libraryArgs.GetNamelinkOnly())
-    {
+  cmInstallTargetGenerator::NamelinkModeType namelinkMode =
+    cmInstallTargetGenerator::NamelinkModeNone;
+  if (libraryArgs.GetNamelinkOnly()) {
     namelinkMode = cmInstallTargetGenerator::NamelinkModeOnly;
-    }
-  else if(libraryArgs.GetNamelinkSkip())
-    {
+  } else if (libraryArgs.GetNamelinkSkip()) {
     namelinkMode = cmInstallTargetGenerator::NamelinkModeSkip;
-    }
+  }
 
   // Check if there is something to do.
-  if(targetList.GetVector().empty())
-    {
+  if (targetList.GetVector().empty()) {
     return true;
-    }
+  }
 
   // Check whether this is a DLL platform.
-  bool dll_platform = (this->Makefile->IsOn("WIN32") ||
-                       this->Makefile->IsOn("CYGWIN") ||
-                       this->Makefile->IsOn("MINGW"));
-
-  for(std::vector<std::string>::const_iterator
-      targetIt=targetList.GetVector().begin();
-      targetIt!=targetList.GetVector().end();
-      ++targetIt)
-    {
-
-    if (this->Makefile->IsAlias(*targetIt))
-      {
+  bool dll_platform =
+    (this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
+     this->Makefile->IsOn("MINGW"));
+
+  for (std::vector<std::string>::const_iterator targetIt =
+         targetList.GetVector().begin();
+       targetIt != targetList.GetVector().end(); ++targetIt) {
+
+    if (this->Makefile->IsAlias(*targetIt)) {
       std::ostringstream e;
-      e << "TARGETS given target \"" << (*targetIt)
-        << "\" which is an alias.";
+      e << "TARGETS given target \"" << (*targetIt) << "\" which is an alias.";
       this->SetError(e.str());
       return false;
-      }
+    }
     // Lookup this target in the current directory.
-    if(cmTarget* target=this->Makefile->FindLocalNonAliasTarget(*targetIt))
-      {
+    if (cmTarget* target =
+          this->Makefile->FindLocalNonAliasTarget(*targetIt)) {
       // Found the target.  Check its type.
-      if(target->GetType() != cmState::EXECUTABLE &&
-         target->GetType() != cmState::STATIC_LIBRARY &&
-         target->GetType() != cmState::SHARED_LIBRARY &&
-         target->GetType() != cmState::MODULE_LIBRARY &&
-         target->GetType() != cmState::OBJECT_LIBRARY &&
-         target->GetType() != cmState::INTERFACE_LIBRARY)
-        {
+      if (target->GetType() != cmState::EXECUTABLE &&
+          target->GetType() != cmState::STATIC_LIBRARY &&
+          target->GetType() != cmState::SHARED_LIBRARY &&
+          target->GetType() != cmState::MODULE_LIBRARY &&
+          target->GetType() != cmState::OBJECT_LIBRARY &&
+          target->GetType() != cmState::INTERFACE_LIBRARY) {
         std::ostringstream e;
         e << "TARGETS given target \"" << (*targetIt)
           << "\" which is not an executable, library, or module.";
         this->SetError(e.str());
         return false;
-        }
-      else if(target->GetType() == cmState::OBJECT_LIBRARY)
-        {
+      } else if (target->GetType() == cmState::OBJECT_LIBRARY) {
         std::ostringstream e;
         e << "TARGETS given OBJECT library \"" << (*targetIt)
           << "\" which may not be installed.";
         this->SetError(e.str());
         return false;
-        }
+      }
       // Store the target in the list to be installed.
       targets.push_back(target);
-      }
-    else
-      {
+    } else {
       // Did not find the target.
       std::ostringstream e;
       e << "TARGETS given target \"" << (*targetIt)
         << "\" which does not exist in this directory.";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Keep track of whether we will be performing an installation of
   // any files of the given type.
@@ -436,9 +369,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
   bool installsResource = false;
 
   // Generate install script code to install the given targets.
-  for(std::vector<cmTarget*>::iterator ti = targets.begin();
-      ti != targets.end(); ++ti)
-    {
+  for (std::vector<cmTarget*>::iterator ti = targets.begin();
+       ti != targets.end(); ++ti) {
     // Handle each target type.
     cmTarget& target = *(*ti);
     cmInstallTargetGenerator* archiveGenerator = 0;
@@ -453,204 +385,163 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     // Track whether this is a namelink-only rule.
     bool namelinkOnly = false;
 
-    switch(target.GetType())
-      {
-      case cmState::SHARED_LIBRARY:
-        {
+    switch (target.GetType()) {
+      case cmState::SHARED_LIBRARY: {
         // Shared libraries are handled differently on DLL and non-DLL
         // platforms.  All windows platforms are DLL platforms including
         // cygwin.  Currently no other platform is a DLL platform.
-        if(dll_platform)
-          {
+        if (dll_platform) {
           // When in namelink only mode skip all libraries on Windows.
-          if(namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly)
-            {
+          if (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly) {
             continue;
-            }
+          }
 
           // This is a DLL platform.
-          if(!archiveArgs.GetDestination().empty())
-            {
+          if (!archiveArgs.GetDestination().empty()) {
             // The import library uses the ARCHIVE properties.
-            archiveGenerator = CreateInstallTargetGenerator(target,
-                                                            archiveArgs, true);
-            }
-          if(!runtimeArgs.GetDestination().empty())
-            {
+            archiveGenerator =
+              CreateInstallTargetGenerator(target, archiveArgs, true);
+          }
+          if (!runtimeArgs.GetDestination().empty()) {
             // The DLL uses the RUNTIME properties.
-            runtimeGenerator = CreateInstallTargetGenerator(target,
-                                                           runtimeArgs, false);
-            }
-          if ((archiveGenerator==0) && (runtimeGenerator==0))
-            {
+            runtimeGenerator =
+              CreateInstallTargetGenerator(target, runtimeArgs, false);
+          }
+          if ((archiveGenerator == 0) && (runtimeGenerator == 0)) {
             this->SetError("Library TARGETS given no DESTINATION!");
             return false;
-            }
           }
-        else
-          {
+        } else {
           // This is a non-DLL platform.
           // If it is marked with FRAMEWORK property use the FRAMEWORK set of
           // INSTALL properties. Otherwise, use the LIBRARY properties.
-          if(target.IsFrameworkOnApple())
-            {
+          if (target.IsFrameworkOnApple()) {
             // When in namelink only mode skip frameworks.
-            if(namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly)
-              {
+            if (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly) {
               continue;
-              }
+            }
 
             // Use the FRAMEWORK properties.
-            if (!frameworkArgs.GetDestination().empty())
-              {
-              frameworkGenerator = CreateInstallTargetGenerator(target,
-                                                         frameworkArgs, false);
-              }
-            else
-              {
+            if (!frameworkArgs.GetDestination().empty()) {
+              frameworkGenerator =
+                CreateInstallTargetGenerator(target, frameworkArgs, false);
+            } else {
               std::ostringstream e;
               e << "TARGETS given no FRAMEWORK DESTINATION for shared library "
-                "FRAMEWORK target \"" << target.GetName() << "\".";
+                   "FRAMEWORK target \""
+                << target.GetName() << "\".";
               this->SetError(e.str());
               return false;
-              }
             }
-          else
-            {
+          } else {
             // The shared library uses the LIBRARY properties.
-            if (!libraryArgs.GetDestination().empty())
-              {
-              libraryGenerator = CreateInstallTargetGenerator(target,
-                                                           libraryArgs, false);
+            if (!libraryArgs.GetDestination().empty()) {
+              libraryGenerator =
+                CreateInstallTargetGenerator(target, libraryArgs, false);
               libraryGenerator->SetNamelinkMode(namelinkMode);
               namelinkOnly =
                 (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly);
-              }
-            else
-              {
+            } else {
               std::ostringstream e;
               e << "TARGETS given no LIBRARY DESTINATION for shared library "
-                "target \"" << target.GetName() << "\".";
+                   "target \""
+                << target.GetName() << "\".";
               this->SetError(e.str());
               return false;
-              }
             }
           }
         }
-        break;
-      case cmState::STATIC_LIBRARY:
-        {
+      } break;
+      case cmState::STATIC_LIBRARY: {
         // Static libraries use ARCHIVE properties.
-        if (!archiveArgs.GetDestination().empty())
-          {
-          archiveGenerator = CreateInstallTargetGenerator(target, archiveArgs,
-                                                          false);
-          }
-        else
-          {
+        if (!archiveArgs.GetDestination().empty()) {
+          archiveGenerator =
+            CreateInstallTargetGenerator(target, archiveArgs, false);
+        } else {
           std::ostringstream e;
           e << "TARGETS given no ARCHIVE DESTINATION for static library "
-            "target \"" << target.GetName() << "\".";
+               "target \""
+            << target.GetName() << "\".";
           this->SetError(e.str());
           return false;
-          }
         }
-        break;
-      case cmState::MODULE_LIBRARY:
-        {
+      } break;
+      case cmState::MODULE_LIBRARY: {
         // Modules use LIBRARY properties.
-        if (!libraryArgs.GetDestination().empty())
-          {
-          libraryGenerator = CreateInstallTargetGenerator(target, libraryArgs,
-                                                          false);
+        if (!libraryArgs.GetDestination().empty()) {
+          libraryGenerator =
+            CreateInstallTargetGenerator(target, libraryArgs, false);
           libraryGenerator->SetNamelinkMode(namelinkMode);
           namelinkOnly =
             (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly);
-          }
-        else
-          {
+        } else {
           std::ostringstream e;
           e << "TARGETS given no LIBRARY DESTINATION for module target \""
             << target.GetName() << "\".";
           this->SetError(e.str());
           return false;
-          }
         }
-        break;
-      case cmState::EXECUTABLE:
-        {
-        if(target.IsAppBundleOnApple())
-          {
+      } break;
+      case cmState::EXECUTABLE: {
+        if (target.IsAppBundleOnApple()) {
           // Application bundles use the BUNDLE properties.
-          if (!bundleArgs.GetDestination().empty())
-            {
-            bundleGenerator = CreateInstallTargetGenerator(target, bundleArgs,
-                                                           false);
-            }
-          else if(!runtimeArgs.GetDestination().empty())
-            {
+          if (!bundleArgs.GetDestination().empty()) {
+            bundleGenerator =
+              CreateInstallTargetGenerator(target, bundleArgs, false);
+          } else if (!runtimeArgs.GetDestination().empty()) {
             bool failure = false;
-            if(this->CheckCMP0006(failure))
-              {
+            if (this->CheckCMP0006(failure)) {
               // For CMake 2.4 compatibility fallback to the RUNTIME
               // properties.
               bundleGenerator =
                 CreateInstallTargetGenerator(target, runtimeArgs, false);
-              }
-            else if(failure)
-              {
+            } else if (failure) {
               return false;
-              }
             }
-          if(!bundleGenerator)
-            {
+          }
+          if (!bundleGenerator) {
             std::ostringstream e;
             e << "TARGETS given no BUNDLE DESTINATION for MACOSX_BUNDLE "
-                 "executable target \"" << target.GetName() << "\".";
+                 "executable target \""
+              << target.GetName() << "\".";
             this->SetError(e.str());
             return false;
-            }
           }
-        else
-          {
+        } else {
           // Executables use the RUNTIME properties.
-          if (!runtimeArgs.GetDestination().empty())
-            {
-            runtimeGenerator = CreateInstallTargetGenerator(target,
-                                                           runtimeArgs, false);
-            }
-          else
-            {
+          if (!runtimeArgs.GetDestination().empty()) {
+            runtimeGenerator =
+              CreateInstallTargetGenerator(target, runtimeArgs, false);
+          } else {
             std::ostringstream e;
             e << "TARGETS given no RUNTIME DESTINATION for executable "
-                 "target \"" << target.GetName() << "\".";
+                 "target \""
+              << target.GetName() << "\".";
             this->SetError(e.str());
             return false;
-            }
           }
+        }
 
         // On DLL platforms an executable may also have an import
         // library.  Install it to the archive destination if it
         // exists.
-        if(dll_platform && !archiveArgs.GetDestination().empty() &&
-           target.IsExecutableWithExports())
-          {
+        if (dll_platform && !archiveArgs.GetDestination().empty() &&
+            target.IsExecutableWithExports()) {
           // The import library uses the ARCHIVE properties.
-          archiveGenerator = CreateInstallTargetGenerator(target,
-                                                      archiveArgs, true, true);
-          }
+          archiveGenerator =
+            CreateInstallTargetGenerator(target, archiveArgs, true, true);
         }
-        break;
+      } break;
       case cmState::INTERFACE_LIBRARY:
-          // Nothing to do. An INTERFACE_LIBRARY can be installed, but the
-          // only effect of that is to make it exportable. It installs no
-          // other files itself.
+        // Nothing to do. An INTERFACE_LIBRARY can be installed, but the
+        // only effect of that is to make it exportable. It installs no
+        // other files itself.
         break;
       default:
         // This should never happen due to the above type check.
         // Ignore the case.
         break;
-      }
+    }
 
     // These well-known sets of files are installed *automatically* for
     // FRAMEWORK SHARED library targets on the Mac as part of installing the
@@ -659,94 +550,75 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     // generators for them.
     bool createInstallGeneratorsForTargetFileSets = true;
 
-    if(target.IsFrameworkOnApple()
-        || target.GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (target.IsFrameworkOnApple() ||
+        target.GetType() == cmState::INTERFACE_LIBRARY) {
       createInstallGeneratorsForTargetFileSets = false;
-      }
+    }
 
-    if(createInstallGeneratorsForTargetFileSets && !namelinkOnly)
-      {
+    if (createInstallGeneratorsForTargetFileSets && !namelinkOnly) {
       const char* files = target.GetProperty("PRIVATE_HEADER");
-      if ((files) && (*files))
-        {
+      if ((files) && (*files)) {
         std::vector<std::string> relFiles;
         cmSystemTools::ExpandListArgument(files, relFiles);
         std::vector<std::string> absFiles;
-        if (!this->MakeFilesFullPath("PRIVATE_HEADER", relFiles, absFiles))
-          {
+        if (!this->MakeFilesFullPath("PRIVATE_HEADER", relFiles, absFiles)) {
           return false;
-          }
+        }
 
         // Create the files install generator.
-        if (!privateHeaderArgs.GetDestination().empty())
-          {
-          privateHeaderGenerator =
-            CreateInstallFilesGenerator(this->Makefile, absFiles,
-                                        privateHeaderArgs, false);
-          }
-        else
-          {
+        if (!privateHeaderArgs.GetDestination().empty()) {
+          privateHeaderGenerator = CreateInstallFilesGenerator(
+            this->Makefile, absFiles, privateHeaderArgs, false);
+        } else {
           std::ostringstream e;
           e << "INSTALL TARGETS - target " << target.GetName() << " has "
             << "PRIVATE_HEADER files but no PRIVATE_HEADER DESTINATION.";
           cmSystemTools::Message(e.str().c_str(), "Warning");
-          }
         }
+      }
 
       files = target.GetProperty("PUBLIC_HEADER");
-      if ((files) && (*files))
-        {
+      if ((files) && (*files)) {
         std::vector<std::string> relFiles;
         cmSystemTools::ExpandListArgument(files, relFiles);
         std::vector<std::string> absFiles;
-        if (!this->MakeFilesFullPath("PUBLIC_HEADER", relFiles, absFiles))
-          {
+        if (!this->MakeFilesFullPath("PUBLIC_HEADER", relFiles, absFiles)) {
           return false;
-          }
+        }
 
         // Create the files install generator.
-        if (!publicHeaderArgs.GetDestination().empty())
-          {
-          publicHeaderGenerator =
-            CreateInstallFilesGenerator(this->Makefile, absFiles,
-                                        publicHeaderArgs, false);
-          }
-        else
-          {
+        if (!publicHeaderArgs.GetDestination().empty()) {
+          publicHeaderGenerator = CreateInstallFilesGenerator(
+            this->Makefile, absFiles, publicHeaderArgs, false);
+        } else {
           std::ostringstream e;
           e << "INSTALL TARGETS - target " << target.GetName() << " has "
             << "PUBLIC_HEADER files but no PUBLIC_HEADER DESTINATION.";
           cmSystemTools::Message(e.str().c_str(), "Warning");
-          }
         }
+      }
 
       files = target.GetProperty("RESOURCE");
-      if ((files) && (*files))
-        {
+      if ((files) && (*files)) {
         std::vector<std::string> relFiles;
         cmSystemTools::ExpandListArgument(files, relFiles);
         std::vector<std::string> absFiles;
-        if (!this->MakeFilesFullPath("RESOURCE", relFiles, absFiles))
-          {
+        if (!this->MakeFilesFullPath("RESOURCE", relFiles, absFiles)) {
           return false;
-          }
+        }
 
         // Create the files install generator.
-        if (!resourceArgs.GetDestination().empty())
-          {
+        if (!resourceArgs.GetDestination().empty()) {
           resourceGenerator = CreateInstallFilesGenerator(
             this->Makefile, absFiles, resourceArgs, false);
-          }
-        else
-          {
+        } else {
           std::ostringstream e;
           e << "INSTALL TARGETS - target " << target.GetName() << " has "
             << "RESOURCE files but no RESOURCE DESTINATION.";
           cmSystemTools::Message(e.str().c_str(), "Warning");
-          }
         }
       }
+    }
 
     // Keep track of whether we're installing anything in each category
     installsArchive = installsArchive || archiveGenerator != 0;
@@ -754,8 +626,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     installsRuntime = installsRuntime || runtimeGenerator != 0;
     installsFramework = installsFramework || frameworkGenerator != 0;
     installsBundle = installsBundle || bundleGenerator != 0;
-    installsPrivateHeader = installsPrivateHeader
-      || privateHeaderGenerator != 0;
+    installsPrivateHeader =
+      installsPrivateHeader || privateHeaderGenerator != 0;
     installsPublicHeader = installsPublicHeader || publicHeaderGenerator != 0;
     installsResource = installsResource || resourceGenerator;
 
@@ -770,9 +642,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
 
     // Add this install rule to an export if one was specified and
     // this is not a namelink-only rule.
-    if(!exports.GetString().empty() && !namelinkOnly)
-      {
-      cmTargetExport *te = new cmTargetExport;
+    if (!exports.GetString().empty() && !namelinkOnly) {
+      cmTargetExport* te = new cmTargetExport;
       te->TargetName = target.GetName();
       te->ArchiveGenerator = archiveGenerator;
       te->BundleGenerator = bundleGenerator;
@@ -781,55 +652,48 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
       te->LibraryGenerator = libraryGenerator;
       te->RuntimeGenerator = runtimeGenerator;
       this->Makefile->GetGlobalGenerator()
-        ->GetExportSets()[exports.GetString()]->AddTargetExport(te);
+        ->GetExportSets()[exports.GetString()]
+        ->AddTargetExport(te);
 
       te->InterfaceIncludeDirectories =
-          cmJoin(includesArgs.GetIncludeDirs(), ";");
-      }
+        cmJoin(includesArgs.GetIncludeDirs(), ";");
     }
+  }
 
   // Tell the global generator about any installation component names
   // specified
-  if (installsArchive)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(archiveArgs.GetComponent().c_str());
-    }
-  if (installsLibrary)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(libraryArgs.GetComponent().c_str());
-    }
-  if (installsRuntime)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(runtimeArgs.GetComponent().c_str());
-    }
-  if (installsFramework)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(frameworkArgs.GetComponent().c_str());
-    }
-  if (installsBundle)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(bundleArgs.GetComponent().c_str());
-    }
-  if (installsPrivateHeader)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(privateHeaderArgs.GetComponent().c_str());
-    }
-  if (installsPublicHeader)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(publicHeaderArgs.GetComponent().c_str());
-    }
-  if (installsResource)
-    {
-    this->Makefile->GetGlobalGenerator()
-      ->AddInstallComponent(resourceArgs.GetComponent().c_str());
-    }
+  if (installsArchive) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      archiveArgs.GetComponent().c_str());
+  }
+  if (installsLibrary) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      libraryArgs.GetComponent().c_str());
+  }
+  if (installsRuntime) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      runtimeArgs.GetComponent().c_str());
+  }
+  if (installsFramework) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      frameworkArgs.GetComponent().c_str());
+  }
+  if (installsBundle) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      bundleArgs.GetComponent().c_str());
+  }
+  if (installsPrivateHeader) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      privateHeaderArgs.GetComponent().c_str());
+  }
+  if (installsPublicHeader) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      publicHeaderArgs.GetComponent().c_str());
+  }
+  if (installsResource) {
+    this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+      resourceArgs.GetComponent().c_str());
+  }
 
   return true;
 }
@@ -845,53 +709,46 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
   std::vector<std::string> unknownArgs;
   ica.Parse(&args, &unknownArgs);
 
-  if(!unknownArgs.empty())
-    {
+  if (!unknownArgs.empty()) {
     // Unknown argument.
     std::ostringstream e;
     e << args[0] << " given unknown argument \"" << unknownArgs[0] << "\".";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   const std::vector<std::string>& filesVector = files.GetVector();
 
   // Check if there is something to do.
-  if(filesVector.empty())
-    {
+  if (filesVector.empty()) {
     return true;
-    }
+  }
 
-  if(!ica.GetRename().empty() && filesVector.size() > 1)
-    {
+  if (!ica.GetRename().empty() && filesVector.size() > 1) {
     // The rename option works only with one file.
     std::ostringstream e;
     e << args[0] << " given RENAME option with more than one file.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   std::vector<std::string> absFiles;
-  if (!this->MakeFilesFullPath(args[0].c_str(), filesVector, absFiles))
-    {
+  if (!this->MakeFilesFullPath(args[0].c_str(), filesVector, absFiles)) {
     return false;
-    }
+  }
 
   cmPolicies::PolicyStatus status =
-      this->Makefile->GetPolicyStatus(cmPolicies::CMP0062);
-
-  cmGlobalGenerator *gg = this->Makefile->GetGlobalGenerator();
-  for(std::vector<std::string>::const_iterator fileIt = filesVector.begin();
-      fileIt != filesVector.end(); ++fileIt)
-    {
-    if (gg->IsExportedTargetsFile(*fileIt))
-      {
-      const char *modal = 0;
+    this->Makefile->GetPolicyStatus(cmPolicies::CMP0062);
+
+  cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
+  for (std::vector<std::string>::const_iterator fileIt = filesVector.begin();
+       fileIt != filesVector.end(); ++fileIt) {
+    if (gg->IsExportedTargetsFile(*fileIt)) {
+      const char* modal = 0;
       std::ostringstream e;
       cmake::MessageType messageType = cmake::AUTHOR_WARNING;
 
-      switch(status)
-        {
+      switch (status) {
         case cmPolicies::WARN:
           e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0062) << "\n";
           modal = "should";
@@ -902,53 +759,61 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
         case cmPolicies::NEW:
           modal = "may";
           messageType = cmake::FATAL_ERROR;
-        }
-      if (modal)
-        {
+      }
+      if (modal) {
         e << "The file\n  " << *fileIt << "\nwas generated by the export() "
-          "command.  It " << modal << " not be installed with the "
-          "install() command.  Use the install(EXPORT) mechanism "
-          "instead.  See the cmake-packages(7) manual for more.\n";
+                                          "command.  It "
+          << modal << " not be installed with the "
+                      "install() command.  Use the install(EXPORT) mechanism "
+                      "instead.  See the cmake-packages(7) manual for more.\n";
         this->Makefile->IssueMessage(messageType, e.str());
-        if (messageType == cmake::FATAL_ERROR)
-          {
+        if (messageType == cmake::FATAL_ERROR) {
           return false;
-          }
         }
       }
     }
+  }
 
-  if (!ica.Finalize())
-    {
+  if (!ica.Finalize()) {
     return false;
-    }
+  }
 
-  if(ica.GetDestination().empty())
-    {
+  if (ica.GetDestination().empty()) {
     // A destination is required.
     std::ostringstream e;
     e << args[0] << " given no DESTINATION!";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Create the files install generator.
   this->Makefile->AddInstallGenerator(
     CreateInstallFilesGenerator(this->Makefile, absFiles, ica, programs));
 
-  //Tell the global generator about any installation component names specified.
-  this->Makefile->GetGlobalGenerator()
-                             ->AddInstallComponent(ica.GetComponent().c_str());
+  // Tell the global generator about any installation component names
+  // specified.
+  this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+    ica.GetComponent().c_str());
 
   return true;
 }
 
-bool
-cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
+bool cmInstallCommand::HandleDirectoryMode(
+  std::vector<std::string> const& args)
 {
-  enum Doing { DoingNone, DoingDirs, DoingDestination, DoingPattern,
-               DoingRegex, DoingPermsFile, DoingPermsDir, DoingPermsMatch,
-               DoingConfigurations, DoingComponent };
+  enum Doing
+  {
+    DoingNone,
+    DoingDirs,
+    DoingDestination,
+    DoingPattern,
+    DoingRegex,
+    DoingPermsFile,
+    DoingPermsDir,
+    DoingPermsMatch,
+    DoingConfigurations,
+    DoingComponent
+  };
   Doing doing = DoingDirs;
   bool in_match_mode = false;
   bool optional = false;
@@ -961,228 +826,178 @@ cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
   std::vector<std::string> configurations;
   std::string component = this->DefaultComponentName;
   std::string literal_args;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "DESTINATION")
-      {
-      if(in_match_mode)
-        {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "DESTINATION") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Switch to setting the destination property.
       doing = DoingDestination;
-      }
-    else if(args[i] == "OPTIONAL")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "OPTIONAL") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Mark the rule as optional.
       optional = true;
       doing = DoingNone;
-      }
-    else if(args[i] == "MESSAGE_NEVER")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "MESSAGE_NEVER") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Mark the rule as quiet.
       message_never = true;
       doing = DoingNone;
-      }
-    else if(args[i] == "PATTERN")
-      {
+    } else if (args[i] == "PATTERN") {
       // Switch to a new pattern match rule.
       doing = DoingPattern;
       in_match_mode = true;
-      }
-    else if(args[i] == "REGEX")
-      {
+    } else if (args[i] == "REGEX") {
       // Switch to a new regex match rule.
       doing = DoingRegex;
       in_match_mode = true;
-      }
-    else if(args[i] == "EXCLUDE")
-      {
+    } else if (args[i] == "EXCLUDE") {
       // Add this property to the current match rule.
-      if(!in_match_mode || doing == DoingPattern || doing == DoingRegex)
-        {
+      if (!in_match_mode || doing == DoingPattern || doing == DoingRegex) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" before a PATTERN or REGEX is given.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" before a PATTERN or REGEX is given.";
         this->SetError(e.str());
         return false;
-        }
+      }
       literal_args += " EXCLUDE";
       doing = DoingNone;
-      }
-    else if(args[i] == "PERMISSIONS")
-      {
-      if(!in_match_mode)
-        {
+    } else if (args[i] == "PERMISSIONS") {
+      if (!in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" before a PATTERN or REGEX is given.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" before a PATTERN or REGEX is given.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Switch to setting the current match permissions property.
       literal_args += " PERMISSIONS";
       doing = DoingPermsMatch;
-      }
-    else if(args[i] == "FILE_PERMISSIONS")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "FILE_PERMISSIONS") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Switch to setting the file permissions property.
       doing = DoingPermsFile;
-      }
-    else if(args[i] == "DIRECTORY_PERMISSIONS")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "DIRECTORY_PERMISSIONS") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Switch to setting the directory permissions property.
       doing = DoingPermsDir;
-      }
-    else if(args[i] == "USE_SOURCE_PERMISSIONS")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "USE_SOURCE_PERMISSIONS") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Add this option literally.
       literal_args += " USE_SOURCE_PERMISSIONS";
       doing = DoingNone;
-      }
-    else if(args[i] == "FILES_MATCHING")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "FILES_MATCHING") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Add this option literally.
       literal_args += " FILES_MATCHING";
       doing = DoingNone;
-      }
-    else if(args[i] == "CONFIGURATIONS")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "CONFIGURATIONS") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Switch to setting the configurations property.
       doing = DoingConfigurations;
-      }
-    else if(args[i] == "COMPONENT")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "COMPONENT") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Switch to setting the component property.
       doing = DoingComponent;
-      }
-    else if(args[i] == "EXCLUDE_FROM_ALL")
-      {
-      if(in_match_mode)
-        {
+    } else if (args[i] == "EXCLUDE_FROM_ALL") {
+      if (in_match_mode) {
         std::ostringstream e;
-        e << args[0] << " does not allow \""
-          << args[i] << "\" after PATTERN or REGEX.";
+        e << args[0] << " does not allow \"" << args[i]
+          << "\" after PATTERN or REGEX.";
         this->SetError(e.str().c_str());
         return false;
-        }
+      }
       exclude_from_all = true;
       doing = DoingNone;
-      }
-    else if(doing == DoingDirs)
-      {
+    } else if (doing == DoingDirs) {
       // Convert this directory to a full path.
       std::string dir = args[i];
-      if(!cmSystemTools::FileIsFullPath(dir.c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(dir.c_str())) {
         dir = this->Makefile->GetCurrentSourceDirectory();
         dir += "/";
         dir += args[i];
-        }
+      }
 
       // Make sure the name is a directory.
-      if(cmSystemTools::FileExists(dir.c_str()) &&
-         !cmSystemTools::FileIsDirectory(dir))
-        {
+      if (cmSystemTools::FileExists(dir.c_str()) &&
+          !cmSystemTools::FileIsDirectory(dir)) {
         std::ostringstream e;
-        e << args[0] << " given non-directory \""
-          << args[i] << "\" to install.";
+        e << args[0] << " given non-directory \"" << args[i]
+          << "\" to install.";
         this->SetError(e.str());
         return false;
-        }
+      }
 
       // Store the directory for installation.
       dirs.push_back(dir);
-      }
-    else if(doing == DoingConfigurations)
-      {
+    } else if (doing == DoingConfigurations) {
       configurations.push_back(args[i]);
-      }
-    else if(doing == DoingDestination)
-      {
+    } else if (doing == DoingDestination) {
       destination = args[i].c_str();
       doing = DoingNone;
-      }
-    else if(doing == DoingPattern)
-      {
+    } else if (doing == DoingPattern) {
       // Convert the pattern to a regular expression.  Require a
       // leading slash and trailing end-of-string in the matched
       // string to make sure the pattern matches only whole file
@@ -1193,11 +1008,9 @@ cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
       literal_args += regex;
       literal_args += "$\"";
       doing = DoingNone;
-      }
-    else if(doing == DoingRegex)
-      {
+    } else if (doing == DoingRegex) {
       literal_args += " REGEX \"";
-    // Match rules are case-insensitive on some platforms.
+// Match rules are case-insensitive on some platforms.
 #if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
       std::string regex = cmSystemTools::LowerCase(args[i]);
 #else
@@ -1207,97 +1020,76 @@ cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
       literal_args += regex;
       literal_args += "\"";
       doing = DoingNone;
-      }
-    else if(doing == DoingComponent)
-      {
+    } else if (doing == DoingComponent) {
       component = args[i];
       doing = DoingNone;
-      }
-    else if(doing == DoingPermsFile)
-     {
-     // Check the requested permission.
-     if(!cmInstallCommandArguments::CheckPermissions(args[i],permissions_file))
-        {
+    } else if (doing == DoingPermsFile) {
+      // Check the requested permission.
+      if (!cmInstallCommandArguments::CheckPermissions(args[i],
+                                                       permissions_file)) {
         std::ostringstream e;
-        e << args[0] << " given invalid file permission \""
-          << args[i] << "\".";
+        e << args[0] << " given invalid file permission \"" << args[i]
+          << "\".";
         this->SetError(e.str());
         return false;
-        }
       }
-    else if(doing == DoingPermsDir)
-      {
+    } else if (doing == DoingPermsDir) {
       // Check the requested permission.
-      if(!cmInstallCommandArguments::CheckPermissions(args[i],permissions_dir))
-        {
+      if (!cmInstallCommandArguments::CheckPermissions(args[i],
+                                                       permissions_dir)) {
         std::ostringstream e;
-        e << args[0] << " given invalid directory permission \""
-          << args[i] << "\".";
+        e << args[0] << " given invalid directory permission \"" << args[i]
+          << "\".";
         this->SetError(e.str());
         return false;
-        }
       }
-    else if(doing == DoingPermsMatch)
-      {
+    } else if (doing == DoingPermsMatch) {
       // Check the requested permission.
-      if(!cmInstallCommandArguments::CheckPermissions(args[i], literal_args))
-        {
+      if (!cmInstallCommandArguments::CheckPermissions(args[i],
+                                                       literal_args)) {
         std::ostringstream e;
-        e << args[0] << " given invalid permission \""
-          << args[i] << "\".";
+        e << args[0] << " given invalid permission \"" << args[i] << "\".";
         this->SetError(e.str());
         return false;
-        }
       }
-    else
-      {
+    } else {
       // Unknown argument.
       std::ostringstream e;
       e << args[0] << " given unknown argument \"" << args[i] << "\".";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Support installing an empty directory.
-  if(dirs.empty() && destination)
-    {
+  if (dirs.empty() && destination) {
     dirs.push_back("");
-    }
+  }
 
   // Check if there is something to do.
-  if(dirs.empty())
-    {
+  if (dirs.empty()) {
     return true;
-    }
-  if(!destination)
-    {
+  }
+  if (!destination) {
     // A destination is required.
     std::ostringstream e;
     e << args[0] << " given no DESTINATION!";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(this->Makefile, message_never);
 
   // Create the directory install generator.
-  this->Makefile->AddInstallGenerator(
-    new cmInstallDirectoryGenerator(dirs, destination,
-                                    permissions_file.c_str(),
-                                    permissions_dir.c_str(),
-                                    configurations,
-                                    component.c_str(),
-                                    message,
-                                    exclude_from_all,
-                                    literal_args.c_str(),
-                                    optional));
+  this->Makefile->AddInstallGenerator(new cmInstallDirectoryGenerator(
+    dirs, destination, permissions_file.c_str(), permissions_dir.c_str(),
+    configurations, component.c_str(), message, exclude_from_all,
+    literal_args.c_str(), optional));
 
   // Tell the global generator about any installation component names
   // specified.
-  this->Makefile->GetGlobalGenerator()
-    ->AddInstallComponent(component.c_str());
+  this->Makefile->GetGlobalGenerator()->AddInstallComponent(component.c_str());
 
   return true;
 }
@@ -1317,61 +1109,54 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
   std::vector<std::string> unknownArgs;
   ica.Parse(&args, &unknownArgs);
 
-  if (!unknownArgs.empty())
-    {
+  if (!unknownArgs.empty()) {
     // Unknown argument.
     std::ostringstream e;
     e << args[0] << " given unknown argument \"" << unknownArgs[0] << "\".";
     this->SetError(e.str());
     return false;
-    }
+  }
 
-  if (!ica.Finalize())
-    {
+  if (!ica.Finalize()) {
     return false;
-    }
+  }
 
   // Make sure there is a destination.
-  if(ica.GetDestination().empty())
-    {
+  if (ica.GetDestination().empty()) {
     // A destination is required.
     std::ostringstream e;
     e << args[0] << " given no DESTINATION!";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Check the file name.
   std::string fname = filename.GetString();
-  if(fname.find_first_of(":/\\") != fname.npos)
-    {
+  if (fname.find_first_of(":/\\") != fname.npos) {
     std::ostringstream e;
     e << args[0] << " given invalid export file name \"" << fname << "\".  "
       << "The FILE argument may not contain a path.  "
       << "Specify the path in the DESTINATION argument.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Check the file extension.
-  if(!fname.empty() &&
-     cmSystemTools::GetFilenameLastExtension(fname) != ".cmake")
-    {
+  if (!fname.empty() &&
+      cmSystemTools::GetFilenameLastExtension(fname) != ".cmake") {
     std::ostringstream e;
     e << args[0] << " given invalid export file name \"" << fname << "\".  "
       << "The FILE argument must specify a name ending in \".cmake\".";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Construct the file name.
-  if(fname.empty())
-    {
+  if (fname.empty()) {
     fname = exp.GetString();
     fname += ".cmake";
 
-    if(fname.find_first_of(":/\\") != fname.npos)
-      {
+    if (fname.find_first_of(":/\\") != fname.npos) {
       std::ostringstream e;
       e << args[0] << " given export name \"" << exp.GetString() << "\".  "
         << "This name cannot be safely converted to a file name.  "
@@ -1379,97 +1164,83 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
         << "a file name explicitly.";
       this->SetError(e.str());
       return false;
-      }
     }
-
-  cmExportSet *exportSet = this->Makefile->GetGlobalGenerator()
-                                         ->GetExportSets()[exp.GetString()];
-  if (exportOld.IsEnabled())
-    {
-    for(std::vector<cmTargetExport*>::const_iterator
-          tei = exportSet->GetTargetExports()->begin();
-        tei != exportSet->GetTargetExports()->end(); ++tei)
-      {
+  }
+
+  cmExportSet* exportSet =
+    this->Makefile->GetGlobalGenerator()->GetExportSets()[exp.GetString()];
+  if (exportOld.IsEnabled()) {
+    for (std::vector<cmTargetExport*>::const_iterator tei =
+           exportSet->GetTargetExports()->begin();
+         tei != exportSet->GetTargetExports()->end(); ++tei) {
       cmTargetExport const* te = *tei;
       cmTarget* tgt =
         this->Makefile->GetGlobalGenerator()->FindTarget(te->TargetName);
       const bool newCMP0022Behavior =
-        (tgt &&
-         tgt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
+        (tgt && tgt->GetPolicyStatusCMP0022() != cmPolicies::WARN &&
          tgt->GetPolicyStatusCMP0022() != cmPolicies::OLD);
 
-      if(!newCMP0022Behavior)
-        {
+      if (!newCMP0022Behavior) {
         std::ostringstream e;
         e << "INSTALL(EXPORT) given keyword \""
-          << "EXPORT_LINK_INTERFACE_LIBRARIES" << "\", but target \""
-          << te->TargetName
+          << "EXPORT_LINK_INTERFACE_LIBRARIES"
+          << "\", but target \"" << te->TargetName
           << "\" does not have policy CMP0022 set to NEW.";
         this->SetError(e.str());
         return false;
-        }
       }
     }
+  }
 
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(this->Makefile);
 
   // Create the export install generator.
-  cmInstallExportGenerator* exportGenerator =
-    new cmInstallExportGenerator(
-      exportSet,
-      ica.GetDestination().c_str(),
-      ica.GetPermissions().c_str(), ica.GetConfigurations(),
-      ica.GetComponent().c_str(), message,
-      ica.GetExcludeFromAll(), fname.c_str(),
-      name_space.GetCString(), exportOld.IsEnabled());
+  cmInstallExportGenerator* exportGenerator = new cmInstallExportGenerator(
+    exportSet, ica.GetDestination().c_str(), ica.GetPermissions().c_str(),
+    ica.GetConfigurations(), ica.GetComponent().c_str(), message,
+    ica.GetExcludeFromAll(), fname.c_str(), name_space.GetCString(),
+    exportOld.IsEnabled());
   this->Makefile->AddInstallGenerator(exportGenerator);
 
   return true;
 }
 
-bool cmInstallCommand::MakeFilesFullPath(const char* modeName,
-                                      const std::vector<std::string>& relFiles,
-                                      std::vector<std::string>& absFiles)
+bool cmInstallCommand::MakeFilesFullPath(
+  const char* modeName, const std::vector<std::string>& relFiles,
+  std::vector<std::string>& absFiles)
 {
-  for(std::vector<std::string>::const_iterator fileIt = relFiles.begin();
-      fileIt != relFiles.end();
-      ++fileIt)
-    {
+  for (std::vector<std::string>::const_iterator fileIt = relFiles.begin();
+       fileIt != relFiles.end(); ++fileIt) {
     std::string file = (*fileIt);
     std::string::size_type gpos = cmGeneratorExpression::Find(file);
-    if(gpos != 0 && !cmSystemTools::FileIsFullPath(file.c_str()))
-      {
+    if (gpos != 0 && !cmSystemTools::FileIsFullPath(file.c_str())) {
       file = this->Makefile->GetCurrentSourceDirectory();
       file += "/";
       file += *fileIt;
-      }
+    }
 
     // Make sure the file is not a directory.
-    if(gpos == file.npos && cmSystemTools::FileIsDirectory(file))
-      {
+    if (gpos == file.npos && cmSystemTools::FileIsDirectory(file)) {
       std::ostringstream e;
       e << modeName << " given directory \"" << (*fileIt) << "\" to install.";
       this->SetError(e.str());
       return false;
-      }
+    }
     // Store the file for installation.
     absFiles.push_back(file);
-    }
+  }
   return true;
 }
 
 bool cmInstallCommand::CheckCMP0006(bool& failure)
 {
-  switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0006))
-    {
-    case cmPolicies::WARN:
-      {
+  switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0006)) {
+    case cmPolicies::WARN: {
       this->Makefile->IssueMessage(
         cmake::AUTHOR_WARNING,
-        cmPolicies::GetPolicyWarning(cmPolicies::CMP0006)
-        );
-      }
+        cmPolicies::GetPolicyWarning(cmPolicies::CMP0006));
+    }
     case cmPolicies::OLD:
       // OLD behavior is to allow compatibility
       return true;
@@ -1481,9 +1252,8 @@ bool cmInstallCommand::CheckCMP0006(bool& failure)
       failure = true;
       this->Makefile->IssueMessage(
         cmake::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0006)
-        );
+        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0006));
       break;
-    }
+  }
   return false;
 }
diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h
index 8e14a08..93aca45 100644
--- a/Source/cmInstallCommand.h
+++ b/Source/cmInstallCommand.h
@@ -26,22 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmInstallCommand;
-    }
+  virtual cmCommand* Clone() { return new cmInstallCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install";}
+  virtual std::string GetName() const { return "install"; }
 
   cmTypeMacro(cmInstallCommand, cmCommand);
 
@@ -59,5 +56,4 @@ private:
   std::string DefaultComponentName;
 };
 
-
 #endif
diff --git a/Source/cmInstallCommandArguments.cxx b/Source/cmInstallCommandArguments.cxx
index 57f5f31..57e37a3 100644
--- a/Source/cmInstallCommandArguments.cxx
+++ b/Source/cmInstallCommandArguments.cxx
@@ -14,164 +14,141 @@
 #include "cmSystemTools.h"
 
 // Table of valid permissions.
-const char* cmInstallCommandArguments::PermissionsTable[] =
-{
-  "OWNER_READ", "OWNER_WRITE", "OWNER_EXECUTE",
-  "GROUP_READ", "GROUP_WRITE", "GROUP_EXECUTE",
-  "WORLD_READ", "WORLD_WRITE", "WORLD_EXECUTE",
-  "SETUID", "SETGID", 0
+const char* cmInstallCommandArguments::PermissionsTable[] = {
+  "OWNER_READ",    "OWNER_WRITE",   "OWNER_EXECUTE", "GROUP_READ",
+  "GROUP_WRITE",   "GROUP_EXECUTE", "WORLD_READ",    "WORLD_WRITE",
+  "WORLD_EXECUTE", "SETUID",        "SETGID",        0
 };
 
 const std::string cmInstallCommandArguments::EmptyString;
 
 cmInstallCommandArguments::cmInstallCommandArguments(
-                                           const std::string& defaultComponent)
-:Parser()
-,ArgumentGroup()
-,Destination   (&Parser, "DESTINATION"     , &ArgumentGroup)
-,Component     (&Parser, "COMPONENT"       , &ArgumentGroup)
-,ExcludeFromAll(&Parser, "EXCLUDE_FROM_ALL", &ArgumentGroup)
-,Rename        (&Parser, "RENAME"          , &ArgumentGroup)
-,Permissions   (&Parser, "PERMISSIONS"     , &ArgumentGroup)
-,Configurations(&Parser, "CONFIGURATIONS"  , &ArgumentGroup)
-,Optional      (&Parser, "OPTIONAL"        , &ArgumentGroup)
-,NamelinkOnly  (&Parser, "NAMELINK_ONLY"   , &ArgumentGroup)
-,NamelinkSkip  (&Parser, "NAMELINK_SKIP"   , &ArgumentGroup)
-,GenericArguments(0)
-,DefaultComponentName(defaultComponent)
+  const std::string& defaultComponent)
+  : Parser()
+  , ArgumentGroup()
+  , Destination(&Parser, "DESTINATION", &ArgumentGroup)
+  , Component(&Parser, "COMPONENT", &ArgumentGroup)
+  , ExcludeFromAll(&Parser, "EXCLUDE_FROM_ALL", &ArgumentGroup)
+  , Rename(&Parser, "RENAME", &ArgumentGroup)
+  , Permissions(&Parser, "PERMISSIONS", &ArgumentGroup)
+  , Configurations(&Parser, "CONFIGURATIONS", &ArgumentGroup)
+  , Optional(&Parser, "OPTIONAL", &ArgumentGroup)
+  , NamelinkOnly(&Parser, "NAMELINK_ONLY", &ArgumentGroup)
+  , NamelinkSkip(&Parser, "NAMELINK_SKIP", &ArgumentGroup)
+  , GenericArguments(0)
+  , DefaultComponentName(defaultComponent)
 {
 }
 
 const std::string& cmInstallCommandArguments::GetDestination() const
 {
-  if (!this->DestinationString.empty())
-    {
+  if (!this->DestinationString.empty()) {
     return this->DestinationString;
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetDestination();
-    }
+  }
   return this->EmptyString;
 }
 
 const std::string& cmInstallCommandArguments::GetComponent() const
 {
-  if (!this->Component.GetString().empty())
-    {
+  if (!this->Component.GetString().empty()) {
     return this->Component.GetString();
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetComponent();
-    }
-  if (!this->DefaultComponentName.empty())
-    {
+  }
+  if (!this->DefaultComponentName.empty()) {
     return this->DefaultComponentName;
-    }
+  }
   static std::string unspecifiedComponent = "Unspecified";
   return unspecifiedComponent;
 }
 
 const std::string& cmInstallCommandArguments::GetRename() const
 {
-  if (!this->Rename.GetString().empty())
-    {
+  if (!this->Rename.GetString().empty()) {
     return this->Rename.GetString();
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetRename();
-    }
+  }
   return this->EmptyString;
 }
 
 const std::string& cmInstallCommandArguments::GetPermissions() const
 {
-  if (!this->PermissionsString.empty())
-    {
+  if (!this->PermissionsString.empty()) {
     return this->PermissionsString;
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetPermissions();
-    }
+  }
   return this->EmptyString;
 }
 
 bool cmInstallCommandArguments::GetOptional() const
 {
-  if (this->Optional.IsEnabled())
-    {
+  if (this->Optional.IsEnabled()) {
     return true;
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetOptional();
-    }
+  }
   return false;
 }
 
 bool cmInstallCommandArguments::GetExcludeFromAll() const
 {
-  if (this->ExcludeFromAll.IsEnabled())
-    {
+  if (this->ExcludeFromAll.IsEnabled()) {
     return true;
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetExcludeFromAll();
-    }
+  }
   return false;
 }
 
 bool cmInstallCommandArguments::GetNamelinkOnly() const
 {
-  if (this->NamelinkOnly.IsEnabled())
-    {
+  if (this->NamelinkOnly.IsEnabled()) {
     return true;
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetNamelinkOnly();
-    }
+  }
   return false;
 }
 
 bool cmInstallCommandArguments::GetNamelinkSkip() const
 {
-  if (this->NamelinkSkip.IsEnabled())
-    {
+  if (this->NamelinkSkip.IsEnabled()) {
     return true;
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetNamelinkSkip();
-    }
+  }
   return false;
 }
 
-const std::vector<std::string>&
-    cmInstallCommandArguments::GetConfigurations() const
+const std::vector<std::string>& cmInstallCommandArguments::GetConfigurations()
+  const
 {
-  if (!this->Configurations.GetVector().empty())
-    {
+  if (!this->Configurations.GetVector().empty()) {
     return this->Configurations.GetVector();
-    }
-  if (this->GenericArguments!=0)
-    {
+  }
+  if (this->GenericArguments != 0) {
     return this->GenericArguments->GetConfigurations();
-    }
+  }
   return this->Configurations.GetVector();
 }
 
-
 bool cmInstallCommandArguments::Finalize()
 {
-  if (!this->CheckPermissions())
-    {
+  if (!this->CheckPermissions()) {
     return false;
-    }
+  }
   this->DestinationString = this->Destination.GetString();
   cmSystemTools::ConvertToUnixSlashes(this->DestinationString);
   return true;
@@ -183,45 +160,38 @@ void cmInstallCommandArguments::Parse(const std::vector<std::string>* args,
   this->Parser.Parse(args, unconsumedArgs);
 }
 
-
 bool cmInstallCommandArguments::CheckPermissions()
 {
   this->PermissionsString = "";
-  for(std::vector<std::string>::const_iterator
-      permIt = this->Permissions.GetVector().begin();
-      permIt != this->Permissions.GetVector().end();
-      ++permIt)
-    {
-    if (!this->CheckPermissions(*permIt, this->PermissionsString))
-      {
+  for (std::vector<std::string>::const_iterator permIt =
+         this->Permissions.GetVector().begin();
+       permIt != this->Permissions.GetVector().end(); ++permIt) {
+    if (!this->CheckPermissions(*permIt, this->PermissionsString)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmInstallCommandArguments::CheckPermissions(
-                    const std::string& onePermission, std::string& permissions)
+  const std::string& onePermission, std::string& permissions)
 {
   // Check the permission against the table.
-  for(const char** valid = cmInstallCommandArguments::PermissionsTable;
-      *valid; ++valid)
-    {
-    if(onePermission == *valid)
-      {
+  for (const char** valid = cmInstallCommandArguments::PermissionsTable;
+       *valid; ++valid) {
+    if (onePermission == *valid) {
       // This is a valid permission.
       permissions += " ";
       permissions += onePermission;
       return true;
-      }
     }
+  }
   // This is not a valid permission.
   return false;
 }
 
 cmInstallCommandIncludesArgument::cmInstallCommandIncludesArgument()
 {
-
 }
 
 const std::vector<std::string>&
@@ -231,19 +201,16 @@ cmInstallCommandIncludesArgument::GetIncludeDirs() const
 }
 
 void cmInstallCommandIncludesArgument::Parse(
-                                        const std::vector<std::string>* args,
-                                        std::vector<std::string>*)
+  const std::vector<std::string>* args, std::vector<std::string>*)
 {
-  if(args->empty())
-    {
+  if (args->empty()) {
     return;
-    }
+  }
   std::vector<std::string>::const_iterator it = args->begin();
   ++it;
-  for ( ; it != args->end(); ++it)
-    {
+  for (; it != args->end(); ++it) {
     std::string dir = *it;
     cmSystemTools::ConvertToUnixSlashes(dir);
     this->IncludeDirs.push_back(dir);
-    }
+  }
 }
diff --git a/Source/cmInstallCommandArguments.h b/Source/cmInstallCommandArguments.h
index e83a397..6ccb3e8 100644
--- a/Source/cmInstallCommandArguments.h
+++ b/Source/cmInstallCommandArguments.h
@@ -19,66 +19,68 @@
 
 class cmInstallCommandArguments
 {
-  public:
-    cmInstallCommandArguments(const std::string& defaultComponent);
-    void SetGenericArguments(cmInstallCommandArguments* args)
-                                               {this->GenericArguments = args;}
-    void Parse(const std::vector<std::string>* args,
-               std::vector<std::string>* unconsumedArgs);
-
-    // Compute destination path.and check permissions
-    bool Finalize();
-
-    const std::string& GetDestination() const;
-    const std::string& GetComponent() const;
-    bool GetExcludeFromAll() const;
-    const std::string& GetRename() const;
-    const std::string& GetPermissions() const;
-    const std::vector<std::string>& GetConfigurations() const;
-    bool GetOptional() const;
-    bool GetNamelinkOnly() const;
-    bool GetNamelinkSkip() const;
-
-    // once HandleDirectoryMode() is also switched to using
-    // cmInstallCommandArguments then these two functions can become non-static
-    // private member functions without arguments
-    static bool CheckPermissions(const std::string& onePerm,
-                                 std::string& perm);
-    cmCommandArgumentsHelper Parser;
-    cmCommandArgumentGroup ArgumentGroup;
-  private:
-    cmInstallCommandArguments(); // disabled
-    cmCAString Destination;
-    cmCAString Component;
-    cmCAEnabler ExcludeFromAll;
-    cmCAString Rename;
-    cmCAStringVector Permissions;
-    cmCAStringVector Configurations;
-    cmCAEnabler Optional;
-    cmCAEnabler NamelinkOnly;
-    cmCAEnabler NamelinkSkip;
-
-    std::string DestinationString;
-    std::string PermissionsString;
-
-    cmInstallCommandArguments* GenericArguments;
-    static const char* PermissionsTable[];
-    static const std::string EmptyString;
-    std::string DefaultComponentName;
-    bool CheckPermissions();
+public:
+  cmInstallCommandArguments(const std::string& defaultComponent);
+  void SetGenericArguments(cmInstallCommandArguments* args)
+  {
+    this->GenericArguments = args;
+  }
+  void Parse(const std::vector<std::string>* args,
+             std::vector<std::string>* unconsumedArgs);
+
+  // Compute destination path.and check permissions
+  bool Finalize();
+
+  const std::string& GetDestination() const;
+  const std::string& GetComponent() const;
+  bool GetExcludeFromAll() const;
+  const std::string& GetRename() const;
+  const std::string& GetPermissions() const;
+  const std::vector<std::string>& GetConfigurations() const;
+  bool GetOptional() const;
+  bool GetNamelinkOnly() const;
+  bool GetNamelinkSkip() const;
+
+  // once HandleDirectoryMode() is also switched to using
+  // cmInstallCommandArguments then these two functions can become non-static
+  // private member functions without arguments
+  static bool CheckPermissions(const std::string& onePerm, std::string& perm);
+  cmCommandArgumentsHelper Parser;
+  cmCommandArgumentGroup ArgumentGroup;
+
+private:
+  cmInstallCommandArguments(); // disabled
+  cmCAString Destination;
+  cmCAString Component;
+  cmCAEnabler ExcludeFromAll;
+  cmCAString Rename;
+  cmCAStringVector Permissions;
+  cmCAStringVector Configurations;
+  cmCAEnabler Optional;
+  cmCAEnabler NamelinkOnly;
+  cmCAEnabler NamelinkSkip;
+
+  std::string DestinationString;
+  std::string PermissionsString;
+
+  cmInstallCommandArguments* GenericArguments;
+  static const char* PermissionsTable[];
+  static const std::string EmptyString;
+  std::string DefaultComponentName;
+  bool CheckPermissions();
 };
 
 class cmInstallCommandIncludesArgument
 {
-  public:
-    cmInstallCommandIncludesArgument();
-    void Parse(const std::vector<std::string>* args,
-               std::vector<std::string>* unconsumedArgs);
+public:
+  cmInstallCommandIncludesArgument();
+  void Parse(const std::vector<std::string>* args,
+             std::vector<std::string>* unconsumedArgs);
 
-    const std::vector<std::string>& GetIncludeDirs() const;
+  const std::vector<std::string>& GetIncludeDirs() const;
 
-  private:
-    std::vector<std::string> IncludeDirs;
+private:
+  std::vector<std::string> IncludeDirs;
 };
 
 #endif
diff --git a/Source/cmInstallDirectoryGenerator.cxx b/Source/cmInstallDirectoryGenerator.cxx
index 99141df..671ab4c 100644
--- a/Source/cmInstallDirectoryGenerator.cxx
+++ b/Source/cmInstallDirectoryGenerator.cxx
@@ -14,43 +14,36 @@
 #include "cmGeneratorExpression.h"
 #include "cmLocalGenerator.h"
 
-cmInstallDirectoryGenerator
-::cmInstallDirectoryGenerator(std::vector<std::string> const& dirs,
-                              const char* dest,
-                              const char* file_permissions,
-                              const char* dir_permissions,
-                              std::vector<std::string> const& configurations,
-                              const char* component,
-                              MessageLevel message,
-                              bool exclude_from_all,
-                              const char* literal_args,
-                              bool optional):
-  cmInstallGenerator(dest, configurations, component, message,
-                     exclude_from_all),
-  LocalGenerator(0),
-  Directories(dirs),
-  FilePermissions(file_permissions), DirPermissions(dir_permissions),
-  LiteralArguments(literal_args), Optional(optional)
+cmInstallDirectoryGenerator::cmInstallDirectoryGenerator(
+  std::vector<std::string> const& dirs, const char* dest,
+  const char* file_permissions, const char* dir_permissions,
+  std::vector<std::string> const& configurations, const char* component,
+  MessageLevel message, bool exclude_from_all, const char* literal_args,
+  bool optional)
+  : cmInstallGenerator(dest, configurations, component, message,
+                       exclude_from_all)
+  , LocalGenerator(0)
+  , Directories(dirs)
+  , FilePermissions(file_permissions)
+  , DirPermissions(dir_permissions)
+  , LiteralArguments(literal_args)
+  , Optional(optional)
 {
   // We need per-config actions if destination have generator expressions.
-  if(cmGeneratorExpression::Find(Destination) != std::string::npos)
-    {
+  if (cmGeneratorExpression::Find(Destination) != std::string::npos) {
     this->ActionsPerConfig = true;
-    }
+  }
 
   // We need per-config actions if any directories have generator expressions.
-  for(std::vector<std::string>::const_iterator i = dirs.begin();
-      !this->ActionsPerConfig && i != dirs.end(); ++i)
-    {
-    if(cmGeneratorExpression::Find(*i) != std::string::npos)
-      {
+  for (std::vector<std::string>::const_iterator i = dirs.begin();
+       !this->ActionsPerConfig && i != dirs.end(); ++i) {
+    if (cmGeneratorExpression::Find(*i) != std::string::npos) {
       this->ActionsPerConfig = true;
-      }
     }
+  }
 }
 
-cmInstallDirectoryGenerator
-::~cmInstallDirectoryGenerator()
+cmInstallDirectoryGenerator::~cmInstallDirectoryGenerator()
 {
 }
 
@@ -59,60 +52,46 @@ void cmInstallDirectoryGenerator::Compute(cmLocalGenerator* lg)
   LocalGenerator = lg;
 }
 
-void
-cmInstallDirectoryGenerator::GenerateScriptActions(std::ostream& os,
-                                                   Indent const& indent)
+void cmInstallDirectoryGenerator::GenerateScriptActions(std::ostream& os,
+                                                        Indent const& indent)
 {
-  if(this->ActionsPerConfig)
-    {
+  if (this->ActionsPerConfig) {
     this->cmInstallGenerator::GenerateScriptActions(os, indent);
-    }
-  else
-    {
+  } else {
     this->AddDirectoryInstallRule(os, "", indent, this->Directories);
-    }
+  }
 }
 
 void cmInstallDirectoryGenerator::GenerateScriptForConfig(
-  std::ostream& os,
-  const std::string& config,
-  Indent const& indent)
+  std::ostream& os, const std::string& config, Indent const& indent)
 {
   std::vector<std::string> dirs;
   cmGeneratorExpression ge;
-  for(std::vector<std::string>::const_iterator i = this->Directories.begin();
-      i != this->Directories.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = this->Directories.begin();
+       i != this->Directories.end(); ++i) {
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
-    cmSystemTools::ExpandListArgument(cge->Evaluate(
-        this->LocalGenerator, config), dirs);
-    }
+    cmSystemTools::ExpandListArgument(
+      cge->Evaluate(this->LocalGenerator, config), dirs);
+  }
   this->AddDirectoryInstallRule(os, config, indent, dirs);
 }
 
 void cmInstallDirectoryGenerator::AddDirectoryInstallRule(
-  std::ostream& os,
-  const std::string& config,
-  Indent const& indent,
+  std::ostream& os, const std::string& config, Indent const& indent,
   std::vector<std::string> const& dirs)
 {
   // Write code to install the directories.
   const char* no_rename = 0;
-  this->AddInstallRule(os,
-                       this->GetDestination(config),
-                       cmInstallType_DIRECTORY,
-                       dirs,
-                       this->Optional,
+  this->AddInstallRule(os, this->GetDestination(config),
+                       cmInstallType_DIRECTORY, dirs, this->Optional,
                        this->FilePermissions.c_str(),
-                       this->DirPermissions.c_str(),
-                       no_rename, this->LiteralArguments.c_str(),
-                       indent);
+                       this->DirPermissions.c_str(), no_rename,
+                       this->LiteralArguments.c_str(), indent);
 }
 
-std::string
-cmInstallDirectoryGenerator::GetDestination(std::string const& config) const
+std::string cmInstallDirectoryGenerator::GetDestination(
+  std::string const& config) const
 {
   cmGeneratorExpression ge;
-  return ge.Parse(this->Destination)
-    ->Evaluate(this->LocalGenerator, config);
+  return ge.Parse(this->Destination)->Evaluate(this->LocalGenerator, config);
 }
diff --git a/Source/cmInstallDirectoryGenerator.h b/Source/cmInstallDirectoryGenerator.h
index b137f44..10d7c95 100644
--- a/Source/cmInstallDirectoryGenerator.h
+++ b/Source/cmInstallDirectoryGenerator.h
@@ -17,18 +17,15 @@
 /** \class cmInstallDirectoryGenerator
  * \brief Generate directory installation rules.
  */
-class cmInstallDirectoryGenerator: public cmInstallGenerator
+class cmInstallDirectoryGenerator : public cmInstallGenerator
 {
 public:
   cmInstallDirectoryGenerator(std::vector<std::string> const& dirs,
-                              const char* dest,
-                              const char* file_permissions,
+                              const char* dest, const char* file_permissions,
                               const char* dir_permissions,
                               std::vector<std::string> const& configurations,
-                              const char* component,
-                              MessageLevel message,
-                              bool exclude_from_all,
-                              const char* literal_args,
+                              const char* component, MessageLevel message,
+                              bool exclude_from_all, const char* literal_args,
                               bool optional = false);
   virtual ~cmInstallDirectoryGenerator();
 
@@ -41,8 +38,7 @@ protected:
   virtual void GenerateScriptForConfig(std::ostream& os,
                                        const std::string& config,
                                        Indent const& indent);
-  void AddDirectoryInstallRule(std::ostream& os,
-                               const std::string& config,
+  void AddDirectoryInstallRule(std::ostream& os, const std::string& config,
                                Indent const& indent,
                                std::vector<std::string> const& dirs);
   cmLocalGenerator* LocalGenerator;
diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx
index d77e14f..31fd91a 100644
--- a/Source/cmInstallExportGenerator.cxx
+++ b/Source/cmInstallExportGenerator.cxx
@@ -26,23 +26,18 @@
 #include "cmExportSet.h"
 
 cmInstallExportGenerator::cmInstallExportGenerator(
-  cmExportSet* exportSet,
-  const char* destination,
-  const char* file_permissions,
-  std::vector<std::string> const& configurations,
-  const char* component,
-  MessageLevel message,
-  bool exclude_from_all,
-  const char* filename, const char* name_space,
-  bool exportOld)
-  :cmInstallGenerator(destination, configurations, component, message,
-                      exclude_from_all)
-  ,ExportSet(exportSet)
-  ,FilePermissions(file_permissions)
-  ,FileName(filename)
-  ,Namespace(name_space)
-  ,ExportOld(exportOld)
-  ,LocalGenerator(0)
+  cmExportSet* exportSet, const char* destination,
+  const char* file_permissions, std::vector<std::string> const& configurations,
+  const char* component, MessageLevel message, bool exclude_from_all,
+  const char* filename, const char* name_space, bool exportOld)
+  : cmInstallGenerator(destination, configurations, component, message,
+                       exclude_from_all)
+  , ExportSet(exportSet)
+  , FilePermissions(file_permissions)
+  , FileName(filename)
+  , Namespace(name_space)
+  , ExportOld(exportOld)
+  , LocalGenerator(0)
 {
   this->EFGen = new cmExportInstallFileGenerator(this);
   exportSet->AddInstallation(this);
@@ -63,18 +58,14 @@ void cmInstallExportGenerator::ComputeTempDir()
 {
   // Choose a temporary directory in which to generate the import
   // files to be installed.
-  this->TempDir =
-      this->LocalGenerator->GetCurrentBinaryDirectory();
+  this->TempDir = this->LocalGenerator->GetCurrentBinaryDirectory();
   this->TempDir += cmake::GetCMakeFilesDirectory();
   this->TempDir += "/Export";
-  if(this->Destination.empty())
-    {
+  if (this->Destination.empty()) {
     return;
-    }
-  else
-    {
+  } else {
     this->TempDir += "/";
-    }
+  }
 
   // Enforce a maximum length.
   bool useMD5 = false;
@@ -83,33 +74,24 @@ void cmInstallExportGenerator::ComputeTempDir()
 #else
   std::string::size_type const max_total_len = 1000;
 #endif
-  if(this->TempDir.size() < max_total_len)
-    {
+  if (this->TempDir.size() < max_total_len) {
     // Keep the total path length below the limit.
     std::string::size_type max_len = max_total_len - this->TempDir.size();
-    if(this->Destination.size() > max_len)
-      {
+    if (this->Destination.size() > max_len) {
       useMD5 = true;
-      }
     }
-  else
-    {
+  } else {
     useMD5 = true;
-    }
-  if(useMD5)
-    {
+  }
+  if (useMD5) {
     // Replace the destination path with a hash to keep it short.
-    this->TempDir +=
-      cmSystemTools::ComputeStringMD5(this->Destination);
-    }
-  else
-    {
+    this->TempDir += cmSystemTools::ComputeStringMD5(this->Destination);
+  } else {
     std::string dest = this->Destination;
     // Avoid unix full paths.
-    if(dest[0] == '/')
-      {
+    if (dest[0] == '/') {
       dest[0] = '_';
-      }
+    }
     // Avoid windows full paths by removing colons.
     cmSystemTools::ReplaceString(dest, ":", "_");
     // Avoid relative paths that go up the tree.
@@ -117,20 +99,19 @@ void cmInstallExportGenerator::ComputeTempDir()
     // Avoid spaces.
     cmSystemTools::ReplaceString(dest, " ", "_");
     this->TempDir += dest;
-    }
+  }
 }
 
 void cmInstallExportGenerator::GenerateScript(std::ostream& os)
 {
   // Skip empty sets.
-  if(ExportSet->GetTargetExports()->empty())
-    {
+  if (ExportSet->GetTargetExports()->empty()) {
     std::ostringstream e;
-    e << "INSTALL(EXPORT) given unknown export \""
-      << ExportSet->GetName() << "\"";
+    e << "INSTALL(EXPORT) given unknown export \"" << ExportSet->GetName()
+      << "\"";
     cmSystemTools::Error(e.str().c_str());
     return;
-    }
+  }
 
   // Create the temporary directory in which to store the files.
   this->ComputeTempDir();
@@ -145,35 +126,27 @@ void cmInstallExportGenerator::GenerateScript(std::ostream& os)
   this->EFGen->SetExportFile(this->MainImportFile.c_str());
   this->EFGen->SetNamespace(this->Namespace);
   this->EFGen->SetExportOld(this->ExportOld);
-  if(this->ConfigurationTypes->empty())
-    {
-    if(!this->ConfigurationName.empty())
-      {
+  if (this->ConfigurationTypes->empty()) {
+    if (!this->ConfigurationName.empty()) {
       this->EFGen->AddConfiguration(this->ConfigurationName);
-      }
-    else
-      {
+    } else {
       this->EFGen->AddConfiguration("");
-      }
     }
-  else
-    {
-    for(std::vector<std::string>::const_iterator
-          ci = this->ConfigurationTypes->begin();
-        ci != this->ConfigurationTypes->end(); ++ci)
-      {
+  } else {
+    for (std::vector<std::string>::const_iterator ci =
+           this->ConfigurationTypes->begin();
+         ci != this->ConfigurationTypes->end(); ++ci) {
       this->EFGen->AddConfiguration(*ci);
-      }
     }
+  }
   this->EFGen->GenerateImportFile();
 
   // Perform the main install script generation.
   this->cmInstallGenerator::GenerateScript(os);
 }
 
-void
-cmInstallExportGenerator::GenerateScriptConfigs(std::ostream& os,
-                                                Indent const& indent)
+void cmInstallExportGenerator::GenerateScriptConfigs(std::ostream& os,
+                                                     Indent const& indent)
 {
   // Create the main install rules first.
   this->cmInstallGenerator::GenerateScriptConfigs(os, indent);
@@ -181,20 +154,18 @@ cmInstallExportGenerator::GenerateScriptConfigs(std::ostream& os,
   // Now create a configuration-specific install rule for the import
   // file of each configuration.
   std::vector<std::string> files;
-  for(std::map<std::string, std::string>::const_iterator
-        i = this->EFGen->GetConfigImportFiles().begin();
-      i != this->EFGen->GetConfigImportFiles().end(); ++i)
-    {
+  for (std::map<std::string, std::string>::const_iterator i =
+         this->EFGen->GetConfigImportFiles().begin();
+       i != this->EFGen->GetConfigImportFiles().end(); ++i) {
     files.push_back(i->second);
     std::string config_test = this->CreateConfigTest(i->first);
     os << indent << "if(" << config_test << ")\n";
-    this->AddInstallRule(os, this->Destination,
-                         cmInstallType_FILES, files, false,
-                         this->FilePermissions.c_str(), 0, 0, 0,
+    this->AddInstallRule(os, this->Destination, cmInstallType_FILES, files,
+                         false, this->FilePermissions.c_str(), 0, 0, 0,
                          indent.Next());
     os << indent << "endif()\n";
     files.clear();
-    }
+  }
 }
 
 void cmInstallExportGenerator::GenerateScriptActions(std::ostream& os,
@@ -229,7 +200,6 @@ void cmInstallExportGenerator::GenerateScriptActions(std::ostream& os,
   // Install the main export file.
   std::vector<std::string> files;
   files.push_back(this->MainImportFile);
-  this->AddInstallRule(os, this->Destination,
-                       cmInstallType_FILES, files, false,
-                       this->FilePermissions.c_str(), 0, 0, 0, indent);
+  this->AddInstallRule(os, this->Destination, cmInstallType_FILES, files,
+                       false, this->FilePermissions.c_str(), 0, 0, 0, indent);
 }
diff --git a/Source/cmInstallExportGenerator.h b/Source/cmInstallExportGenerator.h
index 1b1c046..256c0c9 100644
--- a/Source/cmInstallExportGenerator.h
+++ b/Source/cmInstallExportGenerator.h
@@ -23,20 +23,18 @@ class cmMakefile;
 /** \class cmInstallExportGenerator
  * \brief Generate rules for creating an export files.
  */
-class cmInstallExportGenerator: public cmInstallGenerator
+class cmInstallExportGenerator : public cmInstallGenerator
 {
 public:
-  cmInstallExportGenerator(cmExportSet* exportSet,
-                           const char* dest, const char* file_permissions,
+  cmInstallExportGenerator(cmExportSet* exportSet, const char* dest,
+                           const char* file_permissions,
                            const std::vector<std::string>& configurations,
-                           const char* component,
-                           MessageLevel message,
-                           bool exclude_from_all,
-                           const char* filename, const char* name_space,
-                           bool exportOld);
+                           const char* component, MessageLevel message,
+                           bool exclude_from_all, const char* filename,
+                           const char* name_space, bool exportOld);
   ~cmInstallExportGenerator();
 
-  cmExportSet* GetExportSet() {return this->ExportSet;}
+  cmExportSet* GetExportSet() { return this->ExportSet; }
 
   void Compute(cmLocalGenerator* lg);
 
@@ -44,8 +42,7 @@ public:
 
   const std::string& GetNamespace() const { return this->Namespace; }
 
-  std::string const& GetDestination() const
-    { return this->Destination; }
+  std::string const& GetDestination() const { return this->Destination; }
 
 protected:
   virtual void GenerateScript(std::ostream& os);
diff --git a/Source/cmInstallFilesCommand.cxx b/Source/cmInstallFilesCommand.cxx
index d3d258e..64efe61 100644
--- a/Source/cmInstallFilesCommand.cxx
+++ b/Source/cmInstallFilesCommand.cxx
@@ -14,42 +14,36 @@
 #include "cmInstallFilesGenerator.h"
 
 // cmExecutableCommand
-bool cmInstallFilesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmInstallFilesCommand::InitialPass(std::vector<std::string> const& args,
+                                        cmExecutionStatus&)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Enable the install target.
   this->Makefile->GetGlobalGenerator()->EnableInstallTarget();
 
   this->Destination = args[0];
 
-  if((args.size() > 1) && (args[1] == "FILES"))
-    {
+  if ((args.size() > 1) && (args[1] == "FILES")) {
     this->IsFilesForm = true;
-    for(std::vector<std::string>::const_iterator s = args.begin()+2;
-        s != args.end(); ++s)
-      {
+    for (std::vector<std::string>::const_iterator s = args.begin() + 2;
+         s != args.end(); ++s) {
       // Find the source location for each file listed.
       std::string f = this->FindInstallSource(s->c_str());
       this->Files.push_back(f);
-      }
-    this->CreateInstallGenerator();
     }
-  else
-    {
+    this->CreateInstallGenerator();
+  } else {
     this->IsFilesForm = false;
-    this->FinalArgs.insert(this->FinalArgs.end(),
-                           args.begin() + 1, args.end());
-    }
+    this->FinalArgs.insert(this->FinalArgs.end(), args.begin() + 1,
+                           args.end());
+  }
 
-  this->Makefile->GetGlobalGenerator()
-                      ->AddInstallComponent(this->Makefile->GetSafeDefinition(
-                                      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
+  this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+    this->Makefile->GetSafeDefinition("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
 
   return true;
 }
@@ -57,53 +51,45 @@ bool cmInstallFilesCommand
 void cmInstallFilesCommand::FinalPass()
 {
   // No final pass for "FILES" form of arguments.
-  if(this->IsFilesForm)
-    {
+  if (this->IsFilesForm) {
     return;
-    }
+  }
 
   std::string testf;
   std::string ext = this->FinalArgs[0];
 
   // two different options
-  if (this->FinalArgs.size() > 1)
-    {
+  if (this->FinalArgs.size() > 1) {
     // now put the files into the list
     std::vector<std::string>::iterator s = this->FinalArgs.begin();
     ++s;
     // for each argument, get the files
-    for (;s != this->FinalArgs.end(); ++s)
-      {
+    for (; s != this->FinalArgs.end(); ++s) {
       // replace any variables
       std::string temps = *s;
-      if (!cmSystemTools::GetFilenamePath(temps).empty())
-        {
-          testf = cmSystemTools::GetFilenamePath(temps) + "/" +
-            cmSystemTools::GetFilenameWithoutLastExtension(temps) + ext;
-        }
-      else
-        {
-          testf = cmSystemTools::GetFilenameWithoutLastExtension(temps) + ext;
-        }
+      if (!cmSystemTools::GetFilenamePath(temps).empty()) {
+        testf = cmSystemTools::GetFilenamePath(temps) + "/" +
+          cmSystemTools::GetFilenameWithoutLastExtension(temps) + ext;
+      } else {
+        testf = cmSystemTools::GetFilenameWithoutLastExtension(temps) + ext;
+      }
 
       // add to the result
       this->Files.push_back(this->FindInstallSource(testf.c_str()));
-      }
     }
-  else     // reg exp list
-    {
+  } else // reg exp list
+  {
     std::vector<std::string> files;
     std::string regex = this->FinalArgs[0];
-    cmSystemTools::Glob(this->Makefile->GetCurrentSourceDirectory(),
-                        regex, files);
+    cmSystemTools::Glob(this->Makefile->GetCurrentSourceDirectory(), regex,
+                        files);
 
     std::vector<std::string>::iterator s = files.begin();
     // for each argument, get the files
-    for (;s != files.end(); ++s)
-      {
+    for (; s != files.end(); ++s) {
       this->Files.push_back(this->FindInstallSource(s->c_str()));
-      }
     }
+  }
 
   this->CreateInstallGenerator();
 }
@@ -114,29 +100,24 @@ void cmInstallFilesCommand::CreateInstallGenerator() const
   // the prefix.  We skip the leading slash given by the user.
   std::string destination = this->Destination.substr(1);
   cmSystemTools::ConvertToUnixSlashes(destination);
-  if(destination.empty())
-    {
+  if (destination.empty()) {
     destination = ".";
-    }
+  }
 
   // Use a file install generator.
   const char* no_permissions = "";
   const char* no_rename = "";
   bool no_exclude_from_all = false;
-  std::string no_component = this->Makefile->GetSafeDefinition(
-                                       "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
+  std::string no_component =
+    this->Makefile->GetSafeDefinition("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
   std::vector<std::string> no_configurations;
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(this->Makefile);
-  this->Makefile->AddInstallGenerator(
-    new cmInstallFilesGenerator(this->Files,
-                                destination.c_str(), false,
-                                no_permissions, no_configurations,
-                                no_component.c_str(), message,
-                                no_exclude_from_all, no_rename));
+  this->Makefile->AddInstallGenerator(new cmInstallFilesGenerator(
+    this->Files, destination.c_str(), false, no_permissions, no_configurations,
+    no_component.c_str(), message, no_exclude_from_all, no_rename));
 }
 
-
 /**
  * Find a file in the build or source tree for installation given a
  * relative path from the CMakeLists.txt file.  This will favor files
@@ -145,12 +126,11 @@ void cmInstallFilesCommand::CreateInstallGenerator() const
  */
 std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
 {
-  if(cmSystemTools::FileIsFullPath(name) ||
-     cmGeneratorExpression::Find(name) == 0)
-    {
+  if (cmSystemTools::FileIsFullPath(name) ||
+      cmGeneratorExpression::Find(name) == 0) {
     // This is a full path.
     return name;
-    }
+  }
 
   // This is a relative path.
   std::string tb = this->Makefile->GetCurrentBinaryDirectory();
@@ -160,20 +140,15 @@ std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
   ts += "/";
   ts += name;
 
-  if(cmSystemTools::FileExists(tb.c_str()))
-    {
+  if (cmSystemTools::FileExists(tb.c_str())) {
     // The file exists in the binary tree.  Use it.
     return tb;
-    }
-  else if(cmSystemTools::FileExists(ts.c_str()))
-    {
+  } else if (cmSystemTools::FileExists(ts.c_str())) {
     // The file exists in the source tree.  Use it.
     return ts;
-    }
-  else
-    {
+  } else {
     // The file doesn't exist.  Assume it will be present in the
     // binary tree when the install occurs.
     return tb;
-    }
+  }
 }
diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h
index 8062d11..0d0388a 100644
--- a/Source/cmInstallFilesCommand.h
+++ b/Source/cmInstallFilesCommand.h
@@ -26,22 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmInstallFilesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmInstallFilesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install_files";}
+  virtual std::string GetName() const { return "install_files"; }
 
   /**
    * This is called at the end after all the information
@@ -58,12 +55,11 @@ protected:
   void CreateInstallGenerator() const;
   std::string FindInstallSource(const char* name) const;
 
- private:
+private:
   std::vector<std::string> FinalArgs;
   bool IsFilesForm;
   std::string Destination;
   std::vector<std::string> Files;
 };
 
-
 #endif
diff --git a/Source/cmInstallFilesGenerator.cxx b/Source/cmInstallFilesGenerator.cxx
index a61c38e..a2cfc5a 100644
--- a/Source/cmInstallFilesGenerator.cxx
+++ b/Source/cmInstallFilesGenerator.cxx
@@ -16,44 +16,35 @@
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 
-cmInstallFilesGenerator
-::cmInstallFilesGenerator(std::vector<std::string> const& files,
-                          const char* dest, bool programs,
-                          const char* file_permissions,
-                          std::vector<std::string> const& configurations,
-                          const char* component,
-                          MessageLevel message,
-                          bool exclude_from_all,
-                          const char* rename,
-                          bool optional):
-  cmInstallGenerator(dest, configurations, component, message,
-                     exclude_from_all),
-  LocalGenerator(0),
-  Files(files),
-  FilePermissions(file_permissions),
-  Rename(rename),
-  Programs(programs),
-  Optional(optional)
+cmInstallFilesGenerator::cmInstallFilesGenerator(
+  std::vector<std::string> const& files, const char* dest, bool programs,
+  const char* file_permissions, std::vector<std::string> const& configurations,
+  const char* component, MessageLevel message, bool exclude_from_all,
+  const char* rename, bool optional)
+  : cmInstallGenerator(dest, configurations, component, message,
+                       exclude_from_all)
+  , LocalGenerator(0)
+  , Files(files)
+  , FilePermissions(file_permissions)
+  , Rename(rename)
+  , Programs(programs)
+  , Optional(optional)
 {
   // We need per-config actions if the destination has generator expressions.
-  if(cmGeneratorExpression::Find(Destination) != std::string::npos)
-    {
+  if (cmGeneratorExpression::Find(Destination) != std::string::npos) {
     this->ActionsPerConfig = true;
-    }
+  }
 
   // We need per-config actions if any files have generator expressions.
-  for(std::vector<std::string>::const_iterator i = files.begin();
-      !this->ActionsPerConfig && i != files.end(); ++i)
-    {
-    if(cmGeneratorExpression::Find(*i) != std::string::npos)
-      {
+  for (std::vector<std::string>::const_iterator i = files.begin();
+       !this->ActionsPerConfig && i != files.end(); ++i) {
+    if (cmGeneratorExpression::Find(*i) != std::string::npos) {
       this->ActionsPerConfig = true;
-      }
     }
+  }
 }
 
-cmInstallFilesGenerator
-::~cmInstallFilesGenerator()
+cmInstallFilesGenerator::~cmInstallFilesGenerator()
 {
 }
 
@@ -62,58 +53,46 @@ void cmInstallFilesGenerator::Compute(cmLocalGenerator* lg)
   this->LocalGenerator = lg;
 }
 
-std::string
-cmInstallFilesGenerator::GetDestination(std::string const& config) const
+std::string cmInstallFilesGenerator::GetDestination(
+  std::string const& config) const
 {
   cmGeneratorExpression ge;
-  return ge.Parse(this->Destination)
-    ->Evaluate(this->LocalGenerator, config);
+  return ge.Parse(this->Destination)->Evaluate(this->LocalGenerator, config);
 }
 
 void cmInstallFilesGenerator::AddFilesInstallRule(
-  std::ostream& os,
-  const std::string config,
-  Indent const& indent,
+  std::ostream& os, const std::string config, Indent const& indent,
   std::vector<std::string> const& files)
 {
   // Write code to install the files.
   const char* no_dir_permissions = 0;
-  this->AddInstallRule(os,
-                       this->GetDestination(config),
-                       (this->Programs
-                        ? cmInstallType_PROGRAMS
-                        : cmInstallType_FILES),
-                       files,
-                       this->Optional,
-                       this->FilePermissions.c_str(), no_dir_permissions,
-                       this->Rename.c_str(), 0, indent);
+  this->AddInstallRule(
+    os, this->GetDestination(config),
+    (this->Programs ? cmInstallType_PROGRAMS : cmInstallType_FILES), files,
+    this->Optional, this->FilePermissions.c_str(), no_dir_permissions,
+    this->Rename.c_str(), 0, indent);
 }
 
 void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
                                                     Indent const& indent)
 {
-  if(this->ActionsPerConfig)
-    {
+  if (this->ActionsPerConfig) {
     this->cmInstallGenerator::GenerateScriptActions(os, indent);
-    }
-  else
-    {
+  } else {
     this->AddFilesInstallRule(os, "", indent, this->Files);
-    }
+  }
 }
 
-void cmInstallFilesGenerator::GenerateScriptForConfig(std::ostream& os,
-                                                    const std::string& config,
-                                                    Indent const& indent)
+void cmInstallFilesGenerator::GenerateScriptForConfig(
+  std::ostream& os, const std::string& config, Indent const& indent)
 {
   std::vector<std::string> files;
   cmGeneratorExpression ge;
-  for(std::vector<std::string>::const_iterator i = this->Files.begin();
-      i != this->Files.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = this->Files.begin();
+       i != this->Files.end(); ++i) {
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
-    cmSystemTools::ExpandListArgument(cge->Evaluate(
-        this->LocalGenerator, config), files);
-    }
+    cmSystemTools::ExpandListArgument(
+      cge->Evaluate(this->LocalGenerator, config), files);
+  }
   this->AddFilesInstallRule(os, config, indent, files);
 }
diff --git a/Source/cmInstallFilesGenerator.h b/Source/cmInstallFilesGenerator.h
index efaf62b..86b5899 100644
--- a/Source/cmInstallFilesGenerator.h
+++ b/Source/cmInstallFilesGenerator.h
@@ -17,17 +17,15 @@
 /** \class cmInstallFilesGenerator
  * \brief Generate file installation rules.
  */
-class cmInstallFilesGenerator: public cmInstallGenerator
+class cmInstallFilesGenerator : public cmInstallGenerator
 {
 public:
   cmInstallFilesGenerator(std::vector<std::string> const& files,
                           const char* dest, bool programs,
                           const char* file_permissions,
                           std::vector<std::string> const& configurations,
-                          const char* component,
-                          MessageLevel message,
-                          bool exclude_from_all,
-                          const char* rename,
+                          const char* component, MessageLevel message,
+                          bool exclude_from_all, const char* rename,
                           bool optional = false);
   virtual ~cmInstallFilesGenerator();
 
@@ -40,8 +38,7 @@ protected:
   virtual void GenerateScriptForConfig(std::ostream& os,
                                        const std::string& config,
                                        Indent const& indent);
-  void AddFilesInstallRule(std::ostream& os,
-                           const std::string config,
+  void AddFilesInstallRule(std::ostream& os, const std::string config,
                            Indent const& indent,
                            std::vector<std::string> const& files);
 
diff --git a/Source/cmInstallGenerator.cxx b/Source/cmInstallGenerator.cxx
index 4218011..e3d5bad 100644
--- a/Source/cmInstallGenerator.cxx
+++ b/Source/cmInstallGenerator.cxx
@@ -14,146 +14,136 @@
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 
-cmInstallGenerator
-::cmInstallGenerator(const char* destination,
-                     std::vector<std::string> const& configurations,
-                     const char* component,
-                     MessageLevel message,
-                     bool exclude_from_all):
-  cmScriptGenerator("CMAKE_INSTALL_CONFIG_NAME", configurations),
-  Destination(destination? destination:""),
-  Component(component? component:""),
-  Message(message),
-  ExcludeFromAll(exclude_from_all)
+cmInstallGenerator::cmInstallGenerator(
+  const char* destination, std::vector<std::string> const& configurations,
+  const char* component, MessageLevel message, bool exclude_from_all)
+  : cmScriptGenerator("CMAKE_INSTALL_CONFIG_NAME", configurations)
+  , Destination(destination ? destination : "")
+  , Component(component ? component : "")
+  , Message(message)
+  , ExcludeFromAll(exclude_from_all)
 {
 }
 
-cmInstallGenerator
-::~cmInstallGenerator()
+cmInstallGenerator::~cmInstallGenerator()
 {
 }
 
-void cmInstallGenerator
-::AddInstallRule(
-                 std::ostream& os,
-                 std::string const& dest,
-                 cmInstallType type,
-                 std::vector<std::string> const& files,
-                 bool optional /* = false */,
-                 const char* permissions_file /* = 0 */,
-                 const char* permissions_dir /* = 0 */,
-                 const char* rename /* = 0 */,
-                 const char* literal_args /* = 0 */,
-                 Indent const& indent
-                 )
+void cmInstallGenerator::AddInstallRule(
+  std::ostream& os, std::string const& dest, cmInstallType type,
+  std::vector<std::string> const& files, bool optional /* = false */,
+  const char* permissions_file /* = 0 */,
+  const char* permissions_dir /* = 0 */, const char* rename /* = 0 */,
+  const char* literal_args /* = 0 */, Indent const& indent)
 {
   // Use the FILE command to install the file.
   std::string stype;
-  switch(type)
-    {
-    case cmInstallType_DIRECTORY:      stype = "DIRECTORY"; break;
-    case cmInstallType_PROGRAMS:       stype = "PROGRAM"; break;
-    case cmInstallType_EXECUTABLE:     stype = "EXECUTABLE"; break;
-    case cmInstallType_STATIC_LIBRARY: stype = "STATIC_LIBRARY"; break;
-    case cmInstallType_SHARED_LIBRARY: stype = "SHARED_LIBRARY"; break;
-    case cmInstallType_MODULE_LIBRARY: stype = "MODULE"; break;
-    case cmInstallType_FILES:          stype = "FILE"; break;
-    }
+  switch (type) {
+    case cmInstallType_DIRECTORY:
+      stype = "DIRECTORY";
+      break;
+    case cmInstallType_PROGRAMS:
+      stype = "PROGRAM";
+      break;
+    case cmInstallType_EXECUTABLE:
+      stype = "EXECUTABLE";
+      break;
+    case cmInstallType_STATIC_LIBRARY:
+      stype = "STATIC_LIBRARY";
+      break;
+    case cmInstallType_SHARED_LIBRARY:
+      stype = "SHARED_LIBRARY";
+      break;
+    case cmInstallType_MODULE_LIBRARY:
+      stype = "MODULE";
+      break;
+    case cmInstallType_FILES:
+      stype = "FILE";
+      break;
+  }
   os << indent;
-  if (cmSystemTools::FileIsFullPath(dest.c_str()))
-     {
-     os << "list(APPEND CMAKE_ABSOLUTE_DESTINATION_FILES\n";
-     os << indent << " \"";
-     for(std::vector<std::string>::const_iterator fi = files.begin();
-               fi != files.end(); ++fi)
-             {
-               if (fi!=files.begin())
-                 {
-                 os << ";";
-                 }
-               os << dest << "/";
-               if (rename && *rename)
-                 {
-                 os << rename;
-                 }
-               else
-                 {
-                 os << cmSystemTools::GetFilenameName(*fi);
-                 }
-             }
-     os << "\")\n";
-     os << indent << "if(CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
-     os << indent << indent << "message(WARNING \"ABSOLUTE path INSTALL "
-        << "DESTINATION : ${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";
-     os << indent << "endif()\n";
+  if (cmSystemTools::FileIsFullPath(dest.c_str())) {
+    os << "list(APPEND CMAKE_ABSOLUTE_DESTINATION_FILES\n";
+    os << indent << " \"";
+    for (std::vector<std::string>::const_iterator fi = files.begin();
+         fi != files.end(); ++fi) {
+      if (fi != files.begin()) {
+        os << ";";
+      }
+      os << dest << "/";
+      if (rename && *rename) {
+        os << rename;
+      } else {
+        os << cmSystemTools::GetFilenameName(*fi);
+      }
+    }
+    os << "\")\n";
+    os << indent << "if(CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
+    os << indent << indent << "message(WARNING \"ABSOLUTE path INSTALL "
+       << "DESTINATION : ${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";
+    os << indent << "endif()\n";
 
-     os << indent << "if(CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
-     os << indent << indent << "message(FATAL_ERROR \"ABSOLUTE path INSTALL "
-        << "DESTINATION forbidden (by caller): "
-        << "${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";
-     os << indent << "endif()\n";
-     }
+    os << indent << "if(CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
+    os << indent << indent << "message(FATAL_ERROR \"ABSOLUTE path INSTALL "
+       << "DESTINATION forbidden (by caller): "
+       << "${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";
+    os << indent << "endif()\n";
+  }
   std::string absDest = this->ConvertToAbsoluteDestination(dest);
   os << "file(INSTALL DESTINATION \"" << absDest << "\" TYPE " << stype;
-  if(optional)
-    {
+  if (optional) {
     os << " OPTIONAL";
-    }
-  switch(this->Message)
-    {
-    case MessageDefault: break;
-    case MessageAlways: os << " MESSAGE_ALWAYS"; break;
-    case MessageLazy:   os << " MESSAGE_LAZY"; break;
-    case MessageNever:  os << " MESSAGE_NEVER"; break;
-    }
-  if(permissions_file && *permissions_file)
-    {
+  }
+  switch (this->Message) {
+    case MessageDefault:
+      break;
+    case MessageAlways:
+      os << " MESSAGE_ALWAYS";
+      break;
+    case MessageLazy:
+      os << " MESSAGE_LAZY";
+      break;
+    case MessageNever:
+      os << " MESSAGE_NEVER";
+      break;
+  }
+  if (permissions_file && *permissions_file) {
     os << " PERMISSIONS" << permissions_file;
-    }
-  if(permissions_dir && *permissions_dir)
-    {
+  }
+  if (permissions_dir && *permissions_dir) {
     os << " DIR_PERMISSIONS" << permissions_dir;
-    }
-  if(rename && *rename)
-    {
+  }
+  if (rename && *rename) {
     os << " RENAME \"" << rename << "\"";
-    }
+  }
   os << " FILES";
-  if(files.size() == 1)
-    {
+  if (files.size() == 1) {
     os << " \"" << files[0] << "\"";
-    }
-  else
-    {
-    for(std::vector<std::string>::const_iterator fi = files.begin();
-        fi != files.end(); ++fi)
-      {
+  } else {
+    for (std::vector<std::string>::const_iterator fi = files.begin();
+         fi != files.end(); ++fi) {
       os << "\n" << indent << "  \"" << *fi << "\"";
-      }
+    }
     os << "\n" << indent << " ";
-    if(!(literal_args && *literal_args))
-      {
+    if (!(literal_args && *literal_args)) {
       os << " ";
-      }
     }
-  if(literal_args && *literal_args)
-    {
+  }
+  if (literal_args && *literal_args) {
     os << literal_args;
-    }
+  }
   os << ")\n";
 }
 
-std::string
-cmInstallGenerator::CreateComponentTest(const char* component,
-                                        bool exclude_from_all)
+std::string cmInstallGenerator::CreateComponentTest(const char* component,
+                                                    bool exclude_from_all)
 {
   std::string result = "\"${CMAKE_INSTALL_COMPONENT}\" STREQUAL \"";
   result += component;
   result += "\"";
-  if(!exclude_from_all)
-    {
+  if (!exclude_from_all) {
     result += " OR NOT CMAKE_INSTALL_COMPONENT";
-    }
+  }
   return result;
 }
 
@@ -164,7 +154,7 @@ void cmInstallGenerator::GenerateScript(std::ostream& os)
 
   // Begin this block of installation.
   std::string component_test =
-    this->CreateComponentTest(this->Component.c_str(),this->ExcludeFromAll);
+    this->CreateComponentTest(this->Component.c_str(), this->ExcludeFromAll);
   os << indent << "if(" << component_test << ")\n";
 
   // Generate the script possibly with per-configuration code.
@@ -179,38 +169,32 @@ bool cmInstallGenerator::InstallsForConfig(const std::string& config)
   return this->GeneratesForConfig(config);
 }
 
-std::string
-cmInstallGenerator::ConvertToAbsoluteDestination(std::string const& dest) const
+std::string cmInstallGenerator::ConvertToAbsoluteDestination(
+  std::string const& dest) const
 {
   std::string result;
-  if(!dest.empty() &&
-     !cmSystemTools::FileIsFullPath(dest.c_str()))
-    {
+  if (!dest.empty() && !cmSystemTools::FileIsFullPath(dest.c_str())) {
     result = "${CMAKE_INSTALL_PREFIX}/";
-    }
+  }
   result += dest;
   return result;
 }
 
-cmInstallGenerator::MessageLevel
-cmInstallGenerator::SelectMessageLevel(cmMakefile* mf, bool never)
+cmInstallGenerator::MessageLevel cmInstallGenerator::SelectMessageLevel(
+  cmMakefile* mf, bool never)
 {
-  if(never)
-    {
+  if (never) {
     return MessageNever;
-    }
+  }
   std::string m = mf->GetSafeDefinition("CMAKE_INSTALL_MESSAGE");
-  if(m == "ALWAYS")
-    {
+  if (m == "ALWAYS") {
     return MessageAlways;
-    }
-  if(m == "LAZY")
-    {
+  }
+  if (m == "LAZY") {
     return MessageLazy;
-    }
-  if(m == "NEVER")
-    {
+  }
+  if (m == "NEVER") {
     return MessageNever;
-    }
+  }
   return MessageDefault;
 }
diff --git a/Source/cmInstallGenerator.h b/Source/cmInstallGenerator.h
index db895908..e271d53 100644
--- a/Source/cmInstallGenerator.h
+++ b/Source/cmInstallGenerator.h
@@ -22,7 +22,7 @@ class cmMakefile;
  * \brief Support class for generating install scripts.
  *
  */
-class cmInstallGenerator: public cmScriptGenerator
+class cmInstallGenerator : public cmScriptGenerator
 {
 public:
   enum MessageLevel
@@ -35,23 +35,17 @@ public:
 
   cmInstallGenerator(const char* destination,
                      std::vector<std::string> const& configurations,
-                     const char* component,
-                     MessageLevel message,
+                     const char* component, MessageLevel message,
                      bool exclude_from_all);
   virtual ~cmInstallGenerator();
 
-  void AddInstallRule(
-    std::ostream& os,
-    std::string const& dest,
-    cmInstallType type,
-    std::vector<std::string> const& files,
-    bool optional = false,
-    const char* permissions_file = 0,
-    const char* permissions_dir = 0,
-    const char* rename = 0,
-    const char* literal_args = 0,
-    Indent const& indent = Indent()
-    );
+  void AddInstallRule(std::ostream& os, std::string const& dest,
+                      cmInstallType type,
+                      std::vector<std::string> const& files,
+                      bool optional = false, const char* permissions_file = 0,
+                      const char* permissions_dir = 0, const char* rename = 0,
+                      const char* literal_args = 0,
+                      Indent const& indent = Indent());
 
   /** Get the install destination as it should appear in the
       installation script.  */
diff --git a/Source/cmInstallProgramsCommand.cxx b/Source/cmInstallProgramsCommand.cxx
index 790215d..2e5fc1f 100644
--- a/Source/cmInstallProgramsCommand.cxx
+++ b/Source/cmInstallProgramsCommand.cxx
@@ -13,14 +13,13 @@
 
 #include "cmInstallFilesGenerator.h"
 // cmExecutableCommand
-bool cmInstallProgramsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmInstallProgramsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Enable the install target.
   this->Makefile->GetGlobalGenerator()->EnableInstallTarget();
@@ -29,9 +28,8 @@ bool cmInstallProgramsCommand
 
   this->FinalArgs.insert(this->FinalArgs.end(), args.begin() + 1, args.end());
 
-  this->Makefile->GetGlobalGenerator()
-                       ->AddInstallComponent(this->Makefile->GetSafeDefinition(
-                                      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
+  this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+    this->Makefile->GetSafeDefinition("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
 
   return true;
 }
@@ -39,65 +37,55 @@ bool cmInstallProgramsCommand
 void cmInstallProgramsCommand::FinalPass()
 {
   bool files_mode = false;
-  if(!this->FinalArgs.empty() && this->FinalArgs[0] == "FILES")
-    {
+  if (!this->FinalArgs.empty() && this->FinalArgs[0] == "FILES") {
     files_mode = true;
-    }
+  }
 
   // two different options
-  if (this->FinalArgs.size() > 1 || files_mode)
-    {
+  if (this->FinalArgs.size() > 1 || files_mode) {
     // for each argument, get the programs
     std::vector<std::string>::iterator s = this->FinalArgs.begin();
-    if(files_mode)
-      {
+    if (files_mode) {
       // Skip the FILES argument in files mode.
       ++s;
-      }
-    for(;s != this->FinalArgs.end(); ++s)
-      {
+    }
+    for (; s != this->FinalArgs.end(); ++s) {
       // add to the result
       this->Files.push_back(this->FindInstallSource(s->c_str()));
-      }
     }
-  else     // reg exp list
-    {
+  } else // reg exp list
+  {
     std::vector<std::string> programs;
     cmSystemTools::Glob(this->Makefile->GetCurrentSourceDirectory(),
                         this->FinalArgs[0], programs);
 
     std::vector<std::string>::iterator s = programs.begin();
     // for each argument, get the programs
-    for (;s != programs.end(); ++s)
-      {
+    for (; s != programs.end(); ++s) {
       this->Files.push_back(this->FindInstallSource(s->c_str()));
-      }
     }
+  }
 
   // Construct the destination.  This command always installs under
   // the prefix.  We skip the leading slash given by the user.
   std::string destination = this->Destination.substr(1);
   cmSystemTools::ConvertToUnixSlashes(destination);
-  if(destination.empty())
-    {
+  if (destination.empty()) {
     destination = ".";
-    }
+  }
 
   // Use a file install generator.
   const char* no_permissions = "";
   const char* no_rename = "";
   bool no_exclude_from_all = false;
-  std::string no_component = this->Makefile->GetSafeDefinition(
-                                       "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
+  std::string no_component =
+    this->Makefile->GetSafeDefinition("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
   std::vector<std::string> no_configurations;
   cmInstallGenerator::MessageLevel message =
     cmInstallGenerator::SelectMessageLevel(this->Makefile);
-  this->Makefile->AddInstallGenerator(
-    new cmInstallFilesGenerator(this->Files,
-                                destination.c_str(), true,
-                                no_permissions, no_configurations,
-                                no_component.c_str(), message,
-                                no_exclude_from_all, no_rename));
+  this->Makefile->AddInstallGenerator(new cmInstallFilesGenerator(
+    this->Files, destination.c_str(), true, no_permissions, no_configurations,
+    no_component.c_str(), message, no_exclude_from_all, no_rename));
 }
 
 /**
@@ -106,15 +94,13 @@ void cmInstallProgramsCommand::FinalPass()
  * present in the build tree.  If a full path is given, it is just
  * returned.
  */
-std::string cmInstallProgramsCommand
-::FindInstallSource(const char* name) const
+std::string cmInstallProgramsCommand::FindInstallSource(const char* name) const
 {
-  if(cmSystemTools::FileIsFullPath(name) ||
-     cmGeneratorExpression::Find(name) == 0)
-    {
+  if (cmSystemTools::FileIsFullPath(name) ||
+      cmGeneratorExpression::Find(name) == 0) {
     // This is a full path.
     return name;
-    }
+  }
 
   // This is a relative path.
   std::string tb = this->Makefile->GetCurrentBinaryDirectory();
@@ -124,20 +110,15 @@ std::string cmInstallProgramsCommand
   ts += "/";
   ts += name;
 
-  if(cmSystemTools::FileExists(tb.c_str()))
-    {
+  if (cmSystemTools::FileExists(tb.c_str())) {
     // The file exists in the binary tree.  Use it.
     return tb;
-    }
-  else if(cmSystemTools::FileExists(ts.c_str()))
-    {
+  } else if (cmSystemTools::FileExists(ts.c_str())) {
     // The file exists in the source tree.  Use it.
     return ts;
-    }
-  else
-    {
+  } else {
     // The file doesn't exist.  Assume it will be present in the
     // binary tree when the install occurs.
     return tb;
-    }
+  }
 }
diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h
index 524debf..b104c69 100644
--- a/Source/cmInstallProgramsCommand.h
+++ b/Source/cmInstallProgramsCommand.h
@@ -26,22 +26,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmInstallProgramsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmInstallProgramsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install_programs";}
+  virtual std::string GetName() const { return "install_programs"; }
 
   /**
    * This is called at the end after all the information
@@ -57,11 +54,11 @@ public:
 
 protected:
   std::string FindInstallSource(const char* name) const;
+
 private:
   std::vector<std::string> FinalArgs;
   std::string Destination;
   std::vector<std::string> Files;
 };
 
-
 #endif
diff --git a/Source/cmInstallScriptGenerator.cxx b/Source/cmInstallScriptGenerator.cxx
index c676569..1b0f1d1 100644
--- a/Source/cmInstallScriptGenerator.cxx
+++ b/Source/cmInstallScriptGenerator.cxx
@@ -11,17 +11,18 @@
 ============================================================================*/
 #include "cmInstallScriptGenerator.h"
 
-cmInstallScriptGenerator
-::cmInstallScriptGenerator(const char* script, bool code,
-                           const char* component, bool exclude_from_all) :
-  cmInstallGenerator(0, std::vector<std::string>(), component, MessageDefault,
-                     exclude_from_all),
-  Script(script), Code(code)
+cmInstallScriptGenerator::cmInstallScriptGenerator(const char* script,
+                                                   bool code,
+                                                   const char* component,
+                                                   bool exclude_from_all)
+  : cmInstallGenerator(0, std::vector<std::string>(), component,
+                       MessageDefault, exclude_from_all)
+  , Script(script)
+  , Code(code)
 {
 }
 
-cmInstallScriptGenerator
-::~cmInstallScriptGenerator()
+cmInstallScriptGenerator::~cmInstallScriptGenerator()
 {
 }
 
@@ -32,14 +33,11 @@ void cmInstallScriptGenerator::GenerateScript(std::ostream& os)
     this->CreateComponentTest(this->Component.c_str(), this->ExcludeFromAll);
   os << indent << "if(" << component_test << ")\n";
 
-  if(this->Code)
-    {
+  if (this->Code) {
     os << indent.Next() << this->Script << "\n";
-    }
-  else
-    {
+  } else {
     os << indent.Next() << "include(\"" << this->Script << "\")\n";
-    }
+  }
 
   os << indent << "endif()\n\n";
 }
diff --git a/Source/cmInstallScriptGenerator.h b/Source/cmInstallScriptGenerator.h
index 7e7c0c8..ff2f2fa 100644
--- a/Source/cmInstallScriptGenerator.h
+++ b/Source/cmInstallScriptGenerator.h
@@ -17,11 +17,11 @@
 /** \class cmInstallScriptGenerator
  * \brief Generate target installation rules.
  */
-class cmInstallScriptGenerator: public cmInstallGenerator
+class cmInstallScriptGenerator : public cmInstallGenerator
 {
 public:
   cmInstallScriptGenerator(const char* script, bool code,
-    const char* component, bool exclude_from_all);
+                           const char* component, bool exclude_from_all);
   virtual ~cmInstallScriptGenerator();
 
 protected:
diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx
index 7e5817e..e68bac2 100644
--- a/Source/cmInstallTargetGenerator.cxx
+++ b/Source/cmInstallTargetGenerator.cxx
@@ -22,68 +22,57 @@
 
 #include <assert.h>
 
-cmInstallTargetGenerator
-::cmInstallTargetGenerator(const std::string& targetName,
-                           const char* dest, bool implib,
-                           const char* file_permissions,
-                           std::vector<std::string> const& configurations,
-                           const char* component,
-                           MessageLevel message,
-                           bool exclude_from_all,
-                           bool optional):
-  cmInstallGenerator(dest, configurations, component, message,
-                     exclude_from_all),
-  TargetName(targetName),
-  Target(0),
-  FilePermissions(file_permissions),
-  ImportLibrary(implib),
-  Optional(optional)
+cmInstallTargetGenerator::cmInstallTargetGenerator(
+  const std::string& targetName, const char* dest, bool implib,
+  const char* file_permissions, std::vector<std::string> const& configurations,
+  const char* component, MessageLevel message, bool exclude_from_all,
+  bool optional)
+  : cmInstallGenerator(dest, configurations, component, message,
+                       exclude_from_all)
+  , TargetName(targetName)
+  , Target(0)
+  , FilePermissions(file_permissions)
+  , ImportLibrary(implib)
+  , Optional(optional)
 {
   this->ActionsPerConfig = true;
   this->NamelinkMode = NamelinkModeNone;
 }
 
-cmInstallTargetGenerator
-::~cmInstallTargetGenerator()
+cmInstallTargetGenerator::~cmInstallTargetGenerator()
 {
 }
 
 void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
 {
   // Warn if installing an exclude-from-all target.
-  if(this->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-    {
+  if (this->Target->GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
     std::ostringstream msg;
     msg << "WARNING: Target \"" << this->Target->GetName()
         << "\" has EXCLUDE_FROM_ALL set and will not be built by default "
         << "but an install rule has been provided for it.  CMake does "
         << "not define behavior for this case.";
     cmSystemTools::Message(msg.str().c_str(), "Warning");
-    }
+  }
 
   // Perform the main install script generation.
   this->cmInstallGenerator::GenerateScript(os);
 }
 
-void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
-                                                    const std::string& config,
-                                                    Indent const& indent)
+void cmInstallTargetGenerator::GenerateScriptForConfig(
+  std::ostream& os, const std::string& config, Indent const& indent)
 {
   // Compute the build tree directory from which to copy the target.
   std::string fromDirConfig;
-  if(this->Target->NeedRelinkBeforeInstall(config))
-    {
+  if (this->Target->NeedRelinkBeforeInstall(config)) {
     fromDirConfig =
-        this->Target->GetLocalGenerator()->GetCurrentBinaryDirectory();
+      this->Target->GetLocalGenerator()->GetCurrentBinaryDirectory();
     fromDirConfig += cmake::GetCMakeFilesDirectory();
     fromDirConfig += "/CMakeRelink.dir/";
-    }
-  else
-    {
-    fromDirConfig =
-        this->Target->GetDirectory(config, this->ImportLibrary);
+  } else {
+    fromDirConfig = this->Target->GetDirectory(config, this->ImportLibrary);
     fromDirConfig += "/";
-    }
+  }
   std::string toDir =
     this->ConvertToAbsoluteDestination(this->GetDestination(config));
   toDir += "/";
@@ -94,12 +83,19 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
   std::string literal_args;
   cmState::TargetType targetType = this->Target->GetType();
   cmInstallType type = cmInstallType();
-  switch(targetType)
-    {
-    case cmState::EXECUTABLE: type = cmInstallType_EXECUTABLE; break;
-    case cmState::STATIC_LIBRARY: type = cmInstallType_STATIC_LIBRARY; break;
-    case cmState::SHARED_LIBRARY: type = cmInstallType_SHARED_LIBRARY; break;
-    case cmState::MODULE_LIBRARY: type = cmInstallType_MODULE_LIBRARY; break;
+  switch (targetType) {
+    case cmState::EXECUTABLE:
+      type = cmInstallType_EXECUTABLE;
+      break;
+    case cmState::STATIC_LIBRARY:
+      type = cmInstallType_STATIC_LIBRARY;
+      break;
+    case cmState::SHARED_LIBRARY:
+      type = cmInstallType_SHARED_LIBRARY;
+      break;
+    case cmState::MODULE_LIBRARY:
+      type = cmInstallType_MODULE_LIBRARY;
+      break;
     case cmState::INTERFACE_LIBRARY:
       // Not reachable. We never create a cmInstallTargetGenerator for
       // an INTERFACE_LIBRARY.
@@ -109,12 +105,12 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
     case cmState::UTILITY:
     case cmState::GLOBAL_TARGET:
     case cmState::UNKNOWN_LIBRARY:
-      this->Target->GetLocalGenerator()->IssueMessage(cmake::INTERNAL_ERROR,
+      this->Target->GetLocalGenerator()->IssueMessage(
+        cmake::INTERNAL_ERROR,
         "cmInstallTargetGenerator created with non-installable target.");
       return;
-    }
-  if(targetType == cmState::EXECUTABLE)
-    {
+  }
+  if (targetType == cmState::EXECUTABLE) {
     // There is a bug in cmInstallCommand if this fails.
     assert(this->NamelinkMode == NamelinkModeNone);
 
@@ -123,33 +119,27 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
     std::string targetNameImport;
     std::string targetNamePDB;
     this->Target->GetExecutableNames(targetName, targetNameReal,
-                                     targetNameImport, targetNamePDB,
-                                     config);
-    if(this->ImportLibrary)
-      {
+                                     targetNameImport, targetNamePDB, config);
+    if (this->ImportLibrary) {
       std::string from1 = fromDirConfig + targetNameImport;
       std::string to1 = toDir + targetNameImport;
       filesFrom.push_back(from1);
       filesTo.push_back(to1);
       std::string targetNameImportLib;
-      if(this->Target->GetImplibGNUtoMS(targetNameImport,
-                                        targetNameImportLib))
-        {
+      if (this->Target->GetImplibGNUtoMS(targetNameImport,
+                                         targetNameImportLib)) {
         filesFrom.push_back(fromDirConfig + targetNameImportLib);
         filesTo.push_back(toDir + targetNameImportLib);
-        }
+      }
 
       // An import library looks like a static library.
       type = cmInstallType_STATIC_LIBRARY;
-      }
-    else
-      {
+    } else {
       std::string from1 = fromDirConfig + targetName;
       std::string to1 = toDir + targetName;
 
       // Handle OSX Bundles.
-      if(this->Target->IsAppBundleOnApple())
-        {
+      if (this->Target->IsAppBundleOnApple()) {
         cmMakefile const* mf = this->Target->Target->GetMakefile();
 
         // Install the whole app bundle directory.
@@ -159,41 +149,32 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
 
         // Tweaks apply to the binary inside the bundle.
         to1 += ".app/";
-        if(!mf->PlatformIsAppleIos())
-          {
+        if (!mf->PlatformIsAppleIos()) {
           to1 += "Contents/MacOS/";
-          }
-        to1 += targetName;
         }
-      else
-        {
+        to1 += targetName;
+      } else {
         // Tweaks apply to the real file, so list it first.
-        if(targetNameReal != targetName)
-          {
+        if (targetNameReal != targetName) {
           std::string from2 = fromDirConfig + targetNameReal;
           std::string to2 = toDir += targetNameReal;
           filesFrom.push_back(from2);
           filesTo.push_back(to2);
-          }
         }
+      }
 
       filesFrom.push_back(from1);
       filesTo.push_back(to1);
-      }
     }
-  else
-    {
+  } else {
     std::string targetName;
     std::string targetNameSO;
     std::string targetNameReal;
     std::string targetNameImport;
     std::string targetNamePDB;
-    this->Target->GetLibraryNames(targetName, targetNameSO,
-                                          targetNameReal,
-                                  targetNameImport, targetNamePDB,
-                                  config);
-    if(this->ImportLibrary)
-      {
+    this->Target->GetLibraryNames(targetName, targetNameSO, targetNameReal,
+                                  targetNameImport, targetNamePDB, config);
+    if (this->ImportLibrary) {
       // There is a bug in cmInstallCommand if this fails.
       assert(this->NamelinkMode == NamelinkModeNone);
 
@@ -202,18 +183,15 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
       filesFrom.push_back(from1);
       filesTo.push_back(to1);
       std::string targetNameImportLib;
-      if(this->Target->GetImplibGNUtoMS(targetNameImport,
-                                        targetNameImportLib))
-        {
+      if (this->Target->GetImplibGNUtoMS(targetNameImport,
+                                         targetNameImportLib)) {
         filesFrom.push_back(fromDirConfig + targetNameImportLib);
         filesTo.push_back(toDir + targetNameImportLib);
-        }
+      }
 
       // An import library looks like a static library.
       type = cmInstallType_STATIC_LIBRARY;
-      }
-    else if(this->Target->IsFrameworkOnApple())
-      {
+    } else if (this->Target->IsFrameworkOnApple()) {
       // There is a bug in cmInstallCommand if this fails.
       assert(this->NamelinkMode == NamelinkModeNone);
 
@@ -229,9 +207,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
 
       filesFrom.push_back(from1);
       filesTo.push_back(to1);
-      }
-    else if(this->Target->IsCFBundleOnApple())
-      {
+    } else if (this->Target->IsCFBundleOnApple()) {
       // Install the whole app bundle directory.
       type = cmInstallType_DIRECTORY;
       literal_args += " USE_SOURCE_PERMISSIONS";
@@ -243,9 +219,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
 
       filesFrom.push_back(from1);
       filesTo.push_back(to1);
-      }
-    else
-      {
+    } else {
       bool haveNamelink = false;
 
       // Library link name.
@@ -255,79 +229,65 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
       // Library interface name.
       std::string fromSOName;
       std::string toSOName;
-      if(targetNameSO != targetName)
-        {
+      if (targetNameSO != targetName) {
         haveNamelink = true;
         fromSOName = fromDirConfig + targetNameSO;
         toSOName = toDir + targetNameSO;
-        }
+      }
 
       // Library implementation name.
       std::string fromRealName;
       std::string toRealName;
-      if(targetNameReal != targetName &&
-         targetNameReal != targetNameSO)
-        {
+      if (targetNameReal != targetName && targetNameReal != targetNameSO) {
         haveNamelink = true;
         fromRealName = fromDirConfig + targetNameReal;
         toRealName = toDir + targetNameReal;
-        }
+      }
 
       // Add the names based on the current namelink mode.
-      if(haveNamelink)
-        {
+      if (haveNamelink) {
         // With a namelink we need to check the mode.
-        if(this->NamelinkMode == NamelinkModeOnly)
-          {
+        if (this->NamelinkMode == NamelinkModeOnly) {
           // Install the namelink only.
           filesFrom.push_back(fromName);
           filesTo.push_back(toName);
-          }
-        else
-          {
+        } else {
           // Install the real file if it has its own name.
-          if(!fromRealName.empty())
-            {
+          if (!fromRealName.empty()) {
             filesFrom.push_back(fromRealName);
             filesTo.push_back(toRealName);
-            }
+          }
 
           // Install the soname link if it has its own name.
-          if(!fromSOName.empty())
-            {
+          if (!fromSOName.empty()) {
             filesFrom.push_back(fromSOName);
             filesTo.push_back(toSOName);
-            }
+          }
 
           // Install the namelink if it is not to be skipped.
-          if(this->NamelinkMode != NamelinkModeSkip)
-            {
+          if (this->NamelinkMode != NamelinkModeSkip) {
             filesFrom.push_back(fromName);
             filesTo.push_back(toName);
-            }
           }
         }
-      else
-        {
+      } else {
         // Without a namelink there will be only one file.  Install it
         // if this is not a namelink-only rule.
-        if(this->NamelinkMode != NamelinkModeOnly)
-          {
+        if (this->NamelinkMode != NamelinkModeOnly) {
           filesFrom.push_back(fromName);
           filesTo.push_back(toName);
-          }
         }
       }
     }
+  }
 
   // If this fails the above code is buggy.
   assert(filesFrom.size() == filesTo.size());
 
   // Skip this rule if no files are to be installed for the target.
-  if(filesFrom.empty())
-    {
+  if (filesFrom.empty()) {
     return;
-    }
+  }
 
   // Add pre-installation tweaks.
   this->AddTweak(os, indent, config, filesTo,
@@ -337,10 +297,9 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
   const char* no_dir_permissions = 0;
   const char* no_rename = 0;
   bool optional = this->Optional || this->ImportLibrary;
-  this->AddInstallRule(os, this->GetDestination(config),
-                       type, filesFrom, optional,
-                       this->FilePermissions.c_str(), no_dir_permissions,
-                       no_rename, literal_args.c_str(),
+  this->AddInstallRule(os, this->GetDestination(config), type, filesFrom,
+                       optional, this->FilePermissions.c_str(),
+                       no_dir_permissions, no_rename, literal_args.c_str(),
                        indent);
 
   // Add post-installation tweaks.
@@ -348,61 +307,49 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
                  &cmInstallTargetGenerator::PostReplacementTweaks);
 }
 
-std::string
-cmInstallTargetGenerator::GetDestination(std::string const& config) const
+std::string cmInstallTargetGenerator::GetDestination(
+  std::string const& config) const
 {
   cmGeneratorExpression ge;
   return ge.Parse(this->Destination)
     ->Evaluate(this->Target->GetLocalGenerator(), config);
 }
 
-std::string
-cmInstallTargetGenerator::GetInstallFilename(const std::string& config) const
+std::string cmInstallTargetGenerator::GetInstallFilename(
+  const std::string& config) const
 {
-  NameType nameType = this->ImportLibrary? NameImplib : NameNormal;
-  return
-    cmInstallTargetGenerator::GetInstallFilename(this->Target, config,
-                                                 nameType);
+  NameType nameType = this->ImportLibrary ? NameImplib : NameNormal;
+  return cmInstallTargetGenerator::GetInstallFilename(this->Target, config,
+                                                      nameType);
 }
 
-std::string
-cmInstallTargetGenerator::GetInstallFilename(cmGeneratorTarget const* target,
-                                             const std::string& config,
-                                             NameType nameType)
+std::string cmInstallTargetGenerator::GetInstallFilename(
+  cmGeneratorTarget const* target, const std::string& config,
+  NameType nameType)
 {
   std::string fname;
   // Compute the name of the library.
-  if(target->GetType() == cmState::EXECUTABLE)
-    {
+  if (target->GetType() == cmState::EXECUTABLE) {
     std::string targetName;
     std::string targetNameReal;
     std::string targetNameImport;
     std::string targetNamePDB;
-    target->GetExecutableNames(targetName, targetNameReal,
-                               targetNameImport, targetNamePDB,
-                               config);
-    if(nameType == NameImplib)
-      {
+    target->GetExecutableNames(targetName, targetNameReal, targetNameImport,
+                               targetNamePDB, config);
+    if (nameType == NameImplib) {
       // Use the import library name.
-      if(!target->GetImplibGNUtoMS(targetNameImport, fname,
-                                   "${CMAKE_IMPORT_LIBRARY_SUFFIX}"))
-        {
+      if (!target->GetImplibGNUtoMS(targetNameImport, fname,
+                                    "${CMAKE_IMPORT_LIBRARY_SUFFIX}")) {
         fname = targetNameImport;
-        }
       }
-    else if(nameType == NameReal)
-      {
+    } else if (nameType == NameReal) {
       // Use the canonical name.
       fname = targetNameReal;
-      }
-    else
-      {
+    } else {
       // Use the canonical name.
       fname = targetName;
-      }
     }
-  else
-    {
+  } else {
     std::string targetName;
     std::string targetNameSO;
     std::string targetNameReal;
@@ -410,31 +357,23 @@ cmInstallTargetGenerator::GetInstallFilename(cmGeneratorTarget const* target,
     std::string targetNamePDB;
     target->GetLibraryNames(targetName, targetNameSO, targetNameReal,
                             targetNameImport, targetNamePDB, config);
-    if(nameType == NameImplib)
-      {
+    if (nameType == NameImplib) {
       // Use the import library name.
-      if(!target->GetImplibGNUtoMS(targetNameImport, fname,
-                                   "${CMAKE_IMPORT_LIBRARY_SUFFIX}"))
-        {
+      if (!target->GetImplibGNUtoMS(targetNameImport, fname,
+                                    "${CMAKE_IMPORT_LIBRARY_SUFFIX}")) {
         fname = targetNameImport;
-        }
       }
-    else if(nameType == NameSO)
-      {
+    } else if (nameType == NameSO) {
       // Use the soname.
       fname = targetNameSO;
-      }
-    else if(nameType == NameReal)
-      {
+    } else if (nameType == NameReal) {
       // Use the real name.
       fname = targetNameReal;
-      }
-    else
-      {
+    } else {
       // Use the canonical name.
       fname = targetName;
-      }
     }
+  }
 
   return fname;
 }
@@ -444,53 +383,47 @@ void cmInstallTargetGenerator::Compute(cmLocalGenerator* lg)
   this->Target = lg->FindLocalNonAliasGeneratorTarget(this->TargetName);
 }
 
-void
-cmInstallTargetGenerator
-::AddTweak(std::ostream& os, Indent const& indent, const std::string& config,
-           std::string const& file, TweakMethod tweak)
+void cmInstallTargetGenerator::AddTweak(std::ostream& os, Indent const& indent,
+                                        const std::string& config,
+                                        std::string const& file,
+                                        TweakMethod tweak)
 {
   std::ostringstream tw;
   (this->*tweak)(tw, indent.Next(), config, file);
   std::string tws = tw.str();
-  if(!tws.empty())
-    {
+  if (!tws.empty()) {
     os << indent << "if(EXISTS \"" << file << "\" AND\n"
        << indent << "   NOT IS_SYMLINK \"" << file << "\")\n";
     os << tws;
     os << indent << "endif()\n";
-    }
+  }
 }
 
-void
-cmInstallTargetGenerator
-::AddTweak(std::ostream& os, Indent const& indent, const std::string& config,
-           std::vector<std::string> const& files, TweakMethod tweak)
+void cmInstallTargetGenerator::AddTweak(std::ostream& os, Indent const& indent,
+                                        const std::string& config,
+                                        std::vector<std::string> const& files,
+                                        TweakMethod tweak)
 {
-  if(files.size() == 1)
-    {
+  if (files.size() == 1) {
     // Tweak a single file.
     this->AddTweak(os, indent, config, this->GetDestDirPath(files[0]), tweak);
-    }
-  else
-    {
+  } else {
     // Generate a foreach loop to tweak multiple files.
     std::ostringstream tw;
     this->AddTweak(tw, indent.Next(), config, "${file}", tweak);
     std::string tws = tw.str();
-    if(!tws.empty())
-      {
+    if (!tws.empty()) {
       Indent indent2 = indent.Next().Next();
       os << indent << "foreach(file\n";
-      for(std::vector<std::string>::const_iterator i = files.begin();
-          i != files.end(); ++i)
-        {
+      for (std::vector<std::string>::const_iterator i = files.begin();
+           i != files.end(); ++i) {
         os << indent2 << "\"" << this->GetDestDirPath(*i) << "\"\n";
-        }
+      }
       os << indent2 << ")\n";
       os << tws;
       os << indent << "endforeach()\n";
-      }
     }
+  }
 }
 
 std::string cmInstallTargetGenerator::GetDestDirPath(std::string const& file)
@@ -498,10 +431,9 @@ std::string cmInstallTargetGenerator::GetDestDirPath(std::string const& file)
   // Construct the path of the file on disk after installation on
   // which tweaks may be performed.
   std::string toDestDirPath = "$ENV{DESTDIR}";
-  if(file[0] != '/' && file[0] != '$')
-    {
+  if (file[0] != '/' && file[0] != '$') {
     toDestDirPath += "/";
-    }
+  }
   toDestDirPath += file;
   return toDestDirPath;
 }
@@ -515,9 +447,9 @@ void cmInstallTargetGenerator::PreReplacementTweaks(std::ostream& os,
 }
 
 void cmInstallTargetGenerator::PostReplacementTweaks(std::ostream& os,
-                                                    Indent const& indent,
-                                                    const std::string& config,
-                                                    std::string const& file)
+                                                     Indent const& indent,
+                                                     const std::string& config,
+                                                     std::string const& file)
 {
   this->AddInstallNamePatchRule(os, indent, config, file);
   this->AddChrpathPatchRule(os, indent, config, file);
@@ -526,58 +458,52 @@ void cmInstallTargetGenerator::PostReplacementTweaks(std::ostream& os,
   this->AddStripRule(os, indent, file);
 }
 
-void
-cmInstallTargetGenerator
-::AddInstallNamePatchRule(std::ostream& os, Indent const& indent,
-                          const std::string& config,
-                          std::string const& toDestDirPath)
+void cmInstallTargetGenerator::AddInstallNamePatchRule(
+  std::ostream& os, Indent const& indent, const std::string& config,
+  std::string const& toDestDirPath)
 {
-  if(this->ImportLibrary ||
-     !(this->Target->GetType() == cmState::SHARED_LIBRARY ||
-       this->Target->GetType() == cmState::MODULE_LIBRARY ||
-       this->Target->GetType() == cmState::EXECUTABLE))
-    {
+  if (this->ImportLibrary ||
+      !(this->Target->GetType() == cmState::SHARED_LIBRARY ||
+        this->Target->GetType() == cmState::MODULE_LIBRARY ||
+        this->Target->GetType() == cmState::EXECUTABLE)) {
     return;
-    }
+  }
 
   // Fix the install_name settings in installed binaries.
-  std::string installNameTool = this->Target->Target->GetMakefile()
-      ->GetSafeDefinition("CMAKE_INSTALL_NAME_TOOL");
+  std::string installNameTool =
+    this->Target->Target->GetMakefile()->GetSafeDefinition(
+      "CMAKE_INSTALL_NAME_TOOL");
 
-  if(installNameTool.empty())
-    {
+  if (installNameTool.empty()) {
     return;
-    }
+  }
 
   // Build a map of build-tree install_name to install-tree install_name for
   // shared libraries linked to this target.
   std::map<std::string, std::string> install_name_remap;
-  if(cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config))
-    {
-    std::set<cmGeneratorTarget const*> const& sharedLibs
-                                            = cli->GetSharedLibrariesLinked();
-    for(std::set<cmGeneratorTarget const*>::const_iterator j
-        = sharedLibs.begin(); j != sharedLibs.end(); ++j)
-      {
+  if (cmComputeLinkInformation* cli =
+        this->Target->GetLinkInformation(config)) {
+    std::set<cmGeneratorTarget const*> const& sharedLibs =
+      cli->GetSharedLibrariesLinked();
+    for (std::set<cmGeneratorTarget const*>::const_iterator j =
+           sharedLibs.begin();
+         j != sharedLibs.end(); ++j) {
       cmGeneratorTarget const* tgt = *j;
 
       // The install_name of an imported target does not change.
-      if(tgt->IsImported())
-        {
+      if (tgt->IsImported()) {
         continue;
-        }
+      }
 
       // If the build tree and install tree use different path
       // components of the install_name field then we need to create a
       // mapping to be applied after installation.
       std::string for_build = tgt->GetInstallNameDirForBuildTree(config);
       std::string for_install = tgt->GetInstallNameDirForInstallTree();
-      if(for_build != for_install)
-        {
+      if (for_build != for_install) {
         // The directory portions differ.  Append the filename to
         // create the mapping.
-        std::string fname =
-          this->GetInstallFilename(tgt, config, NameSO);
+        std::string fname = this->GetInstallFilename(tgt, config, NameSO);
 
         // Map from the build-tree install_name.
         for_build += fname;
@@ -587,83 +513,72 @@ cmInstallTargetGenerator
 
         // Store the mapping entry.
         install_name_remap[for_build] = for_install;
-        }
       }
     }
+  }
 
   // Edit the install_name of the target itself if necessary.
   std::string new_id;
-  if(this->Target->GetType() == cmState::SHARED_LIBRARY)
-    {
+  if (this->Target->GetType() == cmState::SHARED_LIBRARY) {
     std::string for_build =
       this->Target->GetInstallNameDirForBuildTree(config);
-    std::string for_install =
-      this->Target->GetInstallNameDirForInstallTree();
+    std::string for_install = this->Target->GetInstallNameDirForInstallTree();
 
-    if(this->Target->IsFrameworkOnApple() && for_install.empty())
-      {
+    if (this->Target->IsFrameworkOnApple() && for_install.empty()) {
       // Frameworks seem to have an id corresponding to their own full
       // path.
       // ...
       // for_install = fullDestPath_without_DESTDIR_or_name;
-      }
+    }
 
     // If the install name will change on installation set the new id
     // on the installed file.
-    if(for_build != for_install)
-      {
+    if (for_build != for_install) {
       // Prepare to refer to the install-tree install_name.
       new_id = for_install;
       new_id += this->GetInstallFilename(this->Target, config, NameSO);
-      }
     }
+  }
 
   // Write a rule to run install_name_tool to set the install-tree
   // install_name value and references.
-  if(!new_id.empty() || !install_name_remap.empty())
-    {
+  if (!new_id.empty() || !install_name_remap.empty()) {
     os << indent << "execute_process(COMMAND \"" << installNameTool;
     os << "\"";
-    if(!new_id.empty())
-      {
+    if (!new_id.empty()) {
       os << "\n" << indent << "  -id \"" << new_id << "\"";
-      }
-    for(std::map<std::string, std::string>::const_iterator
-          i = install_name_remap.begin();
-        i != install_name_remap.end(); ++i)
-      {
-      os << "\n" << indent << "  -change \""
-         << i->first << "\" \"" << i->second << "\"";
-      }
-    os << "\n" << indent << "  \"" << toDestDirPath << "\")\n";
     }
+    for (std::map<std::string, std::string>::const_iterator i =
+           install_name_remap.begin();
+         i != install_name_remap.end(); ++i) {
+      os << "\n"
+         << indent << "  -change \"" << i->first << "\" \"" << i->second
+         << "\"";
+    }
+    os << "\n" << indent << "  \"" << toDestDirPath << "\")\n";
+  }
 }
 
-void
-cmInstallTargetGenerator
-::AddRPathCheckRule(std::ostream& os, Indent const& indent,
-                    const std::string& config,
-                    std::string const& toDestDirPath)
+void cmInstallTargetGenerator::AddRPathCheckRule(
+  std::ostream& os, Indent const& indent, const std::string& config,
+  std::string const& toDestDirPath)
 {
   // Skip the chrpath if the target does not need it.
-  if(this->ImportLibrary || !this->Target->IsChrpathUsed(config))
-    {
+  if (this->ImportLibrary || !this->Target->IsChrpathUsed(config)) {
     return;
-    }
+  }
   // Skip if on Apple
-  if(this->Target->Target->GetMakefile()
-     ->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
+  if (this->Target->Target->GetMakefile()->IsOn(
+        "CMAKE_PLATFORM_HAS_INSTALLNAME")) {
     return;
-    }
+  }
 
   // Get the link information for this target.
   // It can provide the RPATH.
   cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
-  if(!cli)
-    {
+  if (!cli) {
     return;
-    }
+  }
 
   // Get the install RPATH from the link information.
   std::string newRpath = cli->GetChrpathString();
@@ -678,30 +593,25 @@ cmInstallTargetGenerator
   /* clang-format on */
 }
 
-void
-cmInstallTargetGenerator
-::AddChrpathPatchRule(std::ostream& os, Indent const& indent,
-                      const std::string& config,
-                      std::string const& toDestDirPath)
+void cmInstallTargetGenerator::AddChrpathPatchRule(
+  std::ostream& os, Indent const& indent, const std::string& config,
+  std::string const& toDestDirPath)
 {
   // Skip the chrpath if the target does not need it.
-  if(this->ImportLibrary || !this->Target->IsChrpathUsed(config))
-    {
+  if (this->ImportLibrary || !this->Target->IsChrpathUsed(config)) {
     return;
-    }
+  }
 
   // Get the link information for this target.
   // It can provide the RPATH.
   cmComputeLinkInformation* cli = this->Target->GetLinkInformation(config);
-  if(!cli)
-    {
+  if (!cli) {
     return;
-    }
+  }
 
   cmMakefile* mf = this->Target->Target->GetMakefile();
 
-  if(mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME"))
-    {
+  if (mf->IsOn("CMAKE_PLATFORM_HAS_INSTALLNAME")) {
     // If using install_name_tool, set up the rules to modify the rpaths.
     std::string installNameTool =
       mf->GetSafeDefinition("CMAKE_INSTALL_NAME_TOOL");
@@ -716,57 +626,50 @@ cmInstallTargetGenerator
     std::stringstream ss(darwin_major_version_s);
     int darwin_major_version;
     ss >> darwin_major_version;
-    if(!ss.fail() && darwin_major_version <= 9 &&
-       (!oldRuntimeDirs.empty() || !newRuntimeDirs.empty())
-      )
-      {
+    if (!ss.fail() && darwin_major_version <= 9 &&
+        (!oldRuntimeDirs.empty() || !newRuntimeDirs.empty())) {
       std::ostringstream msg;
-      msg << "WARNING: Target \"" << this->Target->GetName()
+      msg
+        << "WARNING: Target \"" << this->Target->GetName()
         << "\" has runtime paths which cannot be changed during install.  "
         << "To change runtime paths, OS X version 10.6 or newer is required.  "
         << "Therefore, runtime paths will not be changed when installing.  "
         << "CMAKE_BUILD_WITH_INSTALL_RPATH may be used to work around"
            " this limitation.";
       mf->IssueMessage(cmake::WARNING, msg.str());
-      }
-    else
-      {
+    } else {
       // Note: These paths are kept unique to avoid
       // install_name_tool corruption.
       std::set<std::string> runpaths;
-      for(std::vector<std::string>::const_iterator i = oldRuntimeDirs.begin();
-          i != oldRuntimeDirs.end(); ++i)
-        {
+      for (std::vector<std::string>::const_iterator i = oldRuntimeDirs.begin();
+           i != oldRuntimeDirs.end(); ++i) {
         std::string runpath =
           mf->GetGlobalGenerator()->ExpandCFGIntDir(*i, config);
 
-        if(runpaths.find(runpath) == runpaths.end())
-          {
+        if (runpaths.find(runpath) == runpaths.end()) {
           runpaths.insert(runpath);
-          os << indent << "execute_process(COMMAND " << installNameTool <<"\n";
+          os << indent << "execute_process(COMMAND " << installNameTool
+             << "\n";
           os << indent << "  -delete_rpath \"" << runpath << "\"\n";
           os << indent << "  \"" << toDestDirPath << "\")\n";
-          }
         }
+      }
 
       runpaths.clear();
-      for(std::vector<std::string>::const_iterator i = newRuntimeDirs.begin();
-          i != newRuntimeDirs.end(); ++i)
-        {
+      for (std::vector<std::string>::const_iterator i = newRuntimeDirs.begin();
+           i != newRuntimeDirs.end(); ++i) {
         std::string runpath =
           mf->GetGlobalGenerator()->ExpandCFGIntDir(*i, config);
 
-        if(runpaths.find(runpath) == runpaths.end())
-          {
-          os << indent << "execute_process(COMMAND " << installNameTool <<"\n";
+        if (runpaths.find(runpath) == runpaths.end()) {
+          os << indent << "execute_process(COMMAND " << installNameTool
+             << "\n";
           os << indent << "  -add_rpath \"" << runpath << "\"\n";
           os << indent << "  \"" << toDestDirPath << "\")\n";
-          }
         }
       }
     }
-  else
-    {
+  } else {
     // Construct the original rpath string to be replaced.
     std::string oldRpath = cli->GetRPathString(false);
 
@@ -774,43 +677,39 @@ cmInstallTargetGenerator
     std::string newRpath = cli->GetChrpathString();
 
     // Skip the rule if the paths are identical
-    if(oldRpath == newRpath)
-      {
+    if (oldRpath == newRpath) {
       return;
-      }
+    }
 
     // Write a rule to run chrpath to set the install-tree RPATH
     os << indent << "file(RPATH_CHANGE\n"
        << indent << "     FILE \"" << toDestDirPath << "\"\n"
        << indent << "     OLD_RPATH \"" << oldRpath << "\"\n"
        << indent << "     NEW_RPATH \"" << newRpath << "\")\n";
-    }
+  }
 }
 
-void
-cmInstallTargetGenerator::AddStripRule(std::ostream& os,
-                                       Indent const& indent,
-                                       const std::string& toDestDirPath)
+void cmInstallTargetGenerator::AddStripRule(std::ostream& os,
+                                            Indent const& indent,
+                                            const std::string& toDestDirPath)
 {
 
   // don't strip static and import libraries, because it removes the only
   // symbol table they have so you can't link to them anymore
-  if(this->Target->GetType()==cmState::STATIC_LIBRARY || this->ImportLibrary)
-    {
+  if (this->Target->GetType() == cmState::STATIC_LIBRARY ||
+      this->ImportLibrary) {
     return;
-    }
+  }
 
   // Don't handle OSX Bundles.
-  if(this->Target->Target->GetMakefile()->IsOn("APPLE") &&
-     this->Target->GetPropertyAsBool("MACOSX_BUNDLE"))
-    {
+  if (this->Target->Target->GetMakefile()->IsOn("APPLE") &&
+      this->Target->GetPropertyAsBool("MACOSX_BUNDLE")) {
     return;
-    }
+  }
 
-  if(! this->Target->Target->GetMakefile()->IsSet("CMAKE_STRIP"))
-    {
+  if (!this->Target->Target->GetMakefile()->IsSet("CMAKE_STRIP")) {
     return;
-    }
+  }
 
   os << indent << "if(CMAKE_INSTALL_DO_STRIP)\n";
   os << indent << "  execute_process(COMMAND \""
@@ -819,56 +718,47 @@ cmInstallTargetGenerator::AddStripRule(std::ostream& os,
   os << indent << "endif()\n";
 }
 
-void
-cmInstallTargetGenerator::AddRanlibRule(std::ostream& os,
-                                        Indent const& indent,
-                                        const std::string& toDestDirPath)
+void cmInstallTargetGenerator::AddRanlibRule(std::ostream& os,
+                                             Indent const& indent,
+                                             const std::string& toDestDirPath)
 {
   // Static libraries need ranlib on this platform.
-  if(this->Target->GetType() != cmState::STATIC_LIBRARY)
-    {
+  if (this->Target->GetType() != cmState::STATIC_LIBRARY) {
     return;
-    }
+  }
 
   // Perform post-installation processing on the file depending
   // on its type.
-  if(!this->Target->Target->GetMakefile()->IsOn("APPLE"))
-    {
+  if (!this->Target->Target->GetMakefile()->IsOn("APPLE")) {
     return;
-    }
+  }
 
   std::string ranlib =
     this->Target->Target->GetMakefile()->GetRequiredDefinition("CMAKE_RANLIB");
-  if(ranlib.empty())
-    {
+  if (ranlib.empty()) {
     return;
-    }
+  }
 
-  os << indent << "execute_process(COMMAND \""
-     << ranlib << "\" \"" << toDestDirPath << "\")\n";
+  os << indent << "execute_process(COMMAND \"" << ranlib << "\" \""
+     << toDestDirPath << "\")\n";
 }
 
-void
-cmInstallTargetGenerator
-::AddUniversalInstallRule(std::ostream& os,
-                          Indent const& indent,
-                          const std::string& toDestDirPath)
+void cmInstallTargetGenerator::AddUniversalInstallRule(
+  std::ostream& os, Indent const& indent, const std::string& toDestDirPath)
 {
   cmMakefile const* mf = this->Target->Target->GetMakefile();
 
-  if(!mf->PlatformIsAppleIos() || !mf->IsOn("XCODE"))
-    {
+  if (!mf->PlatformIsAppleIos() || !mf->IsOn("XCODE")) {
     return;
-    }
+  }
 
   const char* xcodeVersion = mf->GetDefinition("XCODE_VERSION");
-  if(!xcodeVersion || cmSystemTools::VersionCompareGreater("6", xcodeVersion))
-    {
+  if (!xcodeVersion ||
+      cmSystemTools::VersionCompareGreater("6", xcodeVersion)) {
     return;
-    }
+  }
 
-  switch(this->Target->GetType())
-    {
+  switch (this->Target->GetType()) {
     case cmState::EXECUTABLE:
     case cmState::STATIC_LIBRARY:
     case cmState::SHARED_LIBRARY:
@@ -877,15 +767,14 @@ cmInstallTargetGenerator
 
     default:
       return;
-    }
+  }
 
-  if(!this->Target->Target->GetPropertyAsBool("IOS_INSTALL_COMBINED"))
-   {
-   return;
-   }
+  if (!this->Target->Target->GetPropertyAsBool("IOS_INSTALL_COMBINED")) {
+    return;
+  }
 
   os << indent << "include(CMakeIOSInstallCombined)\n";
   os << indent << "ios_install_combined("
-               << "\"" << this->Target->Target->GetName() << "\" "
-               << "\"" << toDestDirPath << "\")\n";
+     << "\"" << this->Target->Target->GetName() << "\" "
+     << "\"" << toDestDirPath << "\")\n";
 }
diff --git a/Source/cmInstallTargetGenerator.h b/Source/cmInstallTargetGenerator.h
index 46b4532..2fd85b5 100644
--- a/Source/cmInstallTargetGenerator.h
+++ b/Source/cmInstallTargetGenerator.h
@@ -19,18 +19,14 @@ class cmGeneratorTarget;
 /** \class cmInstallTargetGenerator
  * \brief Generate target installation rules.
  */
-class cmInstallTargetGenerator: public cmInstallGenerator
+class cmInstallTargetGenerator : public cmInstallGenerator
 {
 public:
-  cmInstallTargetGenerator(
-    std::string const& targetName, const char* dest, bool implib,
-    const char* file_permissions,
-    std::vector<std::string> const& configurations,
-    const char* component,
-    MessageLevel message,
-    bool exclude_from_all,
-    bool optional
-    );
+  cmInstallTargetGenerator(std::string const& targetName, const char* dest,
+                           bool implib, const char* file_permissions,
+                           std::vector<std::string> const& configurations,
+                           const char* component, MessageLevel message,
+                           bool exclude_from_all, bool optional);
   virtual ~cmInstallTargetGenerator();
 
   /** Select the policy for installing shared library linkable name
@@ -71,16 +67,16 @@ protected:
   virtual void GenerateScriptForConfig(std::ostream& os,
                                        const std::string& config,
                                        Indent const& indent);
-  typedef void (cmInstallTargetGenerator::*TweakMethod)(
-    std::ostream&, Indent const&, const std::string&, std::string const&
-    );
+  typedef void (cmInstallTargetGenerator::*TweakMethod)(std::ostream&,
+                                                        Indent const&,
+                                                        const std::string&,
+                                                        std::string const&);
   void AddTweak(std::ostream& os, Indent const& indent,
                 const std::string& config, std::string const& file,
                 TweakMethod tweak);
   void AddTweak(std::ostream& os, Indent const& indent,
                 const std::string& config,
-                std::vector<std::string> const& files,
-                TweakMethod tweak);
+                std::vector<std::string> const& files, TweakMethod tweak);
   std::string GetDestDirPath(std::string const& file);
   void PreReplacementTweaks(std::ostream& os, Indent const& indent,
                             const std::string& config,
diff --git a/Source/cmInstallTargetsCommand.cxx b/Source/cmInstallTargetsCommand.cxx
index 7e7b848..056ea24 100644
--- a/Source/cmInstallTargetsCommand.cxx
+++ b/Source/cmInstallTargetsCommand.cxx
@@ -12,54 +12,44 @@
 #include "cmInstallTargetsCommand.h"
 
 // cmExecutableCommand
-bool cmInstallTargetsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmInstallTargetsCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Enable the install target.
   this->Makefile->GetGlobalGenerator()->EnableInstallTarget();
 
-  cmTargets &tgts = this->Makefile->GetTargets();
+  cmTargets& tgts = this->Makefile->GetTargets();
   std::vector<std::string>::const_iterator s = args.begin();
   ++s;
   std::string runtime_dir = "/bin";
-  for (;s != args.end(); ++s)
-    {
-    if (*s == "RUNTIME_DIRECTORY")
-      {
+  for (; s != args.end(); ++s) {
+    if (*s == "RUNTIME_DIRECTORY") {
       ++s;
-      if ( s == args.end() )
-        {
+      if (s == args.end()) {
         this->SetError("called with RUNTIME_DIRECTORY but no actual "
                        "directory");
         return false;
-        }
+      }
 
       runtime_dir = *s;
-      }
-    else if (tgts.find(*s) != tgts.end())
-      {
+    } else if (tgts.find(*s) != tgts.end()) {
       tgts[*s].SetInstallPath(args[0].c_str());
       tgts[*s].SetRuntimeInstallPath(runtime_dir.c_str());
       tgts[*s].SetHaveInstallRule(true);
-      }
-    else
-      {
+    } else {
       std::string str = "Cannot find target: \"" + *s + "\" to install.";
       this->SetError(str);
       return false;
-      }
     }
+  }
 
-  this->Makefile->GetGlobalGenerator()
-                       ->AddInstallComponent(this->Makefile->GetSafeDefinition(
-                                      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
+  this->Makefile->GetGlobalGenerator()->AddInstallComponent(
+    this->Makefile->GetSafeDefinition("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
 
   return true;
 }
-
diff --git a/Source/cmInstallTargetsCommand.h b/Source/cmInstallTargetsCommand.h
index 05160eb..b0d04b0 100644
--- a/Source/cmInstallTargetsCommand.h
+++ b/Source/cmInstallTargetsCommand.h
@@ -27,25 +27,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmInstallTargetsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmInstallTargetsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "install_targets";}
+  virtual std::string GetName() const { return "install_targets"; }
 
   cmTypeMacro(cmInstallTargetsCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmInstalledFile.cxx b/Source/cmInstalledFile.cxx
index 3dac750..ed0f74b 100644
--- a/Source/cmInstalledFile.cxx
+++ b/Source/cmInstalledFile.cxx
@@ -15,23 +15,20 @@
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 
-cmInstalledFile::cmInstalledFile():
-  NameExpression(0)
+cmInstalledFile::cmInstalledFile()
+  : NameExpression(0)
 {
-
 }
 
 cmInstalledFile::~cmInstalledFile()
 {
-  if(NameExpression)
-    {
+  if (NameExpression) {
     delete NameExpression;
-    }
+  }
 }
 
 cmInstalledFile::Property::Property()
 {
-
 }
 
 cmInstalledFile::Property::~Property()
@@ -64,14 +61,15 @@ void cmInstalledFile::RemoveProperty(const std::string& prop)
 }
 
 void cmInstalledFile::SetProperty(cmMakefile const* mf,
-  const std::string& prop, const char* value)
+                                  const std::string& prop, const char* value)
 {
   this->RemoveProperty(prop);
   this->AppendProperty(mf, prop, value);
 }
 
 void cmInstalledFile::AppendProperty(cmMakefile const* mf,
-  const std::string& prop, const char* value, bool /*asString*/)
+                                     const std::string& prop,
+                                     const char* value, bool /*asString*/)
 {
   cmListFileBacktrace backtrace = mf->GetBacktrace();
   cmGeneratorExpression ge(backtrace);
@@ -80,34 +78,31 @@ void cmInstalledFile::AppendProperty(cmMakefile const* mf,
   property.ValueExpressions.push_back(ge.Parse(value).release());
 }
 
-bool cmInstalledFile::HasProperty(
-  const std::string& prop) const
+bool cmInstalledFile::HasProperty(const std::string& prop) const
 {
   return this->Properties.find(prop) != this->Properties.end();
 }
 
-bool cmInstalledFile::GetProperty(
-  const std::string& prop, std::string& value) const
+bool cmInstalledFile::GetProperty(const std::string& prop,
+                                  std::string& value) const
 {
   PropertyMapType::const_iterator i = this->Properties.find(prop);
-  if(i == this->Properties.end())
-    {
+  if (i == this->Properties.end()) {
     return false;
-    }
+  }
 
   Property const& property = i->second;
 
   std::string output;
   std::string separator;
 
-  for(ExpressionVectorType::const_iterator
-    j = property.ValueExpressions.begin();
-    j != property.ValueExpressions.end(); ++j)
-    {
+  for (ExpressionVectorType::const_iterator j =
+         property.ValueExpressions.begin();
+       j != property.ValueExpressions.end(); ++j) {
     output += separator;
     output += (*j)->GetInput();
     separator = ";";
-    }
+  }
 
   value = output;
   return true;
@@ -121,7 +116,7 @@ bool cmInstalledFile::GetPropertyAsBool(const std::string& prop) const
 }
 
 void cmInstalledFile::GetPropertyAsList(const std::string& prop,
-  std::vector<std::string>& list) const
+                                        std::vector<std::string>& list) const
 {
   std::string value;
   this->GetProperty(prop, value);
diff --git a/Source/cmInstalledFile.h b/Source/cmInstalledFile.h
index 3af90a7..d000891 100644
--- a/Source/cmInstalledFile.h
+++ b/Source/cmInstalledFile.h
@@ -22,12 +22,10 @@
 class cmInstalledFile
 {
 public:
-
   typedef cmsys::auto_ptr<cmCompiledGeneratorExpression>
     CompiledGeneratorExpressionPtrType;
 
-  typedef std::vector<cmCompiledGeneratorExpression*>
-    ExpressionVectorType;
+  typedef std::vector<cmCompiledGeneratorExpression*> ExpressionVectorType;
 
   struct Property
   {
@@ -45,11 +43,11 @@ public:
 
   void RemoveProperty(const std::string& prop);
 
-  void SetProperty(cmMakefile const* mf,
-    const std::string& prop, const char *value);
+  void SetProperty(cmMakefile const* mf, const std::string& prop,
+                   const char* value);
 
-  void AppendProperty(cmMakefile const* mf,
-    const std::string& prop, const char* value,bool asString=false);
+  void AppendProperty(cmMakefile const* mf, const std::string& prop,
+                      const char* value, bool asString = false);
 
   bool HasProperty(const std::string& prop) const;
 
@@ -58,7 +56,7 @@ public:
   bool GetPropertyAsBool(const std::string& prop) const;
 
   void GetPropertyAsList(const std::string& prop,
-    std::vector<std::string>& list) const;
+                         std::vector<std::string>& list) const;
 
   void SetName(cmMakefile* mf, const std::string& name);
 
diff --git a/Source/cmLinkDirectoriesCommand.cxx b/Source/cmLinkDirectoriesCommand.cxx
index b77c3be..a33b429 100644
--- a/Source/cmLinkDirectoriesCommand.cxx
+++ b/Source/cmLinkDirectoriesCommand.cxx
@@ -12,19 +12,17 @@
 #include "cmLinkDirectoriesCommand.h"
 
 // cmLinkDirectoriesCommand
-bool cmLinkDirectoriesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmLinkDirectoriesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
- if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
 
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
     this->AddLinkDir(*i);
-    }
+  }
   return true;
 }
 
@@ -32,8 +30,7 @@ void cmLinkDirectoriesCommand::AddLinkDir(std::string const& dir)
 {
   std::string unixPath = dir;
   cmSystemTools::ConvertToUnixSlashes(unixPath);
-  if(!cmSystemTools::FileIsFullPath(unixPath.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(unixPath.c_str())) {
     bool convertToAbsolute = false;
     std::ostringstream e;
     /* clang-format off */
@@ -41,8 +38,7 @@ void cmLinkDirectoriesCommand::AddLinkDir(std::string const& dir)
       << "  " << unixPath << "\n"
       << "as a link directory.\n";
     /* clang-format on */
-    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0015))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0015)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0015);
         this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str());
@@ -57,14 +53,13 @@ void cmLinkDirectoriesCommand::AddLinkDir(std::string const& dir)
         // NEW behavior converts
         convertToAbsolute = true;
         break;
-      }
-    if (convertToAbsolute)
-      {
+    }
+    if (convertToAbsolute) {
       std::string tmp = this->Makefile->GetCurrentSourceDirectory();
       tmp += "/";
       tmp += unixPath;
       unixPath = tmp;
-      }
     }
+  }
   this->Makefile->AppendProperty("LINK_DIRECTORIES", unixPath.c_str());
 }
diff --git a/Source/cmLinkDirectoriesCommand.h b/Source/cmLinkDirectoriesCommand.h
index 8e04baf..7014a69 100644
--- a/Source/cmLinkDirectoriesCommand.h
+++ b/Source/cmLinkDirectoriesCommand.h
@@ -28,28 +28,24 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmLinkDirectoriesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmLinkDirectoriesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "link_directories";}
+  virtual std::string GetName() const { return "link_directories"; }
 
   cmTypeMacro(cmLinkDirectoriesCommand, cmCommand);
+
 private:
   void AddLinkDir(std::string const& dir);
 };
 
-
-
 #endif
diff --git a/Source/cmLinkItem.h b/Source/cmLinkItem.h
index 561293e..0fbe093 100644
--- a/Source/cmLinkItem.h
+++ b/Source/cmLinkItem.h
@@ -19,28 +19,51 @@
 class cmGeneratorTarget;
 
 // Basic information about each link item.
-class cmLinkItem: public std::string
+class cmLinkItem : public std::string
 {
   typedef std::string std_string;
+
 public:
-  cmLinkItem(): std_string(), Target(0) {}
-  cmLinkItem(const std_string& n,
-             cmGeneratorTarget const* t): std_string(n), Target(t) {}
-  cmLinkItem(cmLinkItem const& r): std_string(r), Target(r.Target) {}
+  cmLinkItem()
+    : std_string()
+    , Target(0)
+  {
+  }
+  cmLinkItem(const std_string& n, cmGeneratorTarget const* t)
+    : std_string(n)
+    , Target(t)
+  {
+  }
+  cmLinkItem(cmLinkItem const& r)
+    : std_string(r)
+    , Target(r.Target)
+  {
+  }
   cmGeneratorTarget const* Target;
 };
 
-class cmLinkImplItem: public cmLinkItem
+class cmLinkImplItem : public cmLinkItem
 {
 public:
-  cmLinkImplItem(): cmLinkItem(), Backtrace(), FromGenex(false) {}
-  cmLinkImplItem(std::string const& n,
-                 cmGeneratorTarget const* t,
-                 cmListFileBacktrace const& bt,
-                 bool fromGenex):
-    cmLinkItem(n, t), Backtrace(bt), FromGenex(fromGenex) {}
-  cmLinkImplItem(cmLinkImplItem const& r):
-    cmLinkItem(r), Backtrace(r.Backtrace), FromGenex(r.FromGenex) {}
+  cmLinkImplItem()
+    : cmLinkItem()
+    , Backtrace()
+    , FromGenex(false)
+  {
+  }
+  cmLinkImplItem(std::string const& n, cmGeneratorTarget const* t,
+                 cmListFileBacktrace const& bt, bool fromGenex)
+    : cmLinkItem(n, t)
+    , Backtrace(bt)
+    , FromGenex(fromGenex)
+  {
+  }
+  cmLinkImplItem(cmLinkImplItem const& r)
+    : cmLinkItem(r)
+    , Backtrace(r.Backtrace)
+    , FromGenex(r.FromGenex)
+  {
+  }
   cmListFileBacktrace Backtrace;
   bool FromGenex;
 };
@@ -63,7 +86,7 @@ struct cmLinkInterfaceLibraries
   std::vector<cmLinkItem> Libraries;
 };
 
-struct cmLinkInterface: public cmLinkInterfaceLibraries
+struct cmLinkInterface : public cmLinkInterfaceLibraries
 {
   // Languages whose runtime libraries must be linked.
   std::vector<std::string> Languages;
@@ -81,15 +104,23 @@ struct cmLinkInterface: public cmLinkInterfaceLibraries
 
   bool ImplementationIsInterface;
 
-  cmLinkInterface(): Multiplicity(0), ImplementationIsInterface(false) {}
+  cmLinkInterface()
+    : Multiplicity(0)
+    , ImplementationIsInterface(false)
+  {
+  }
 };
 
-struct cmOptionalLinkInterface: public cmLinkInterface
+struct cmOptionalLinkInterface : public cmLinkInterface
 {
-  cmOptionalLinkInterface():
-    LibrariesDone(false), AllDone(false),
-    Exists(false), HadHeadSensitiveCondition(false),
-    ExplicitLibraries(0) {}
+  cmOptionalLinkInterface()
+    : LibrariesDone(false)
+    , AllDone(false)
+    , Exists(false)
+    , HadHeadSensitiveCondition(false)
+    , ExplicitLibraries(0)
+  {
+  }
   bool LibrariesDone;
   bool AllDone;
   bool Exists;
@@ -97,49 +128,48 @@ struct cmOptionalLinkInterface: public cmLinkInterface
   const char* ExplicitLibraries;
 };
 
-struct cmHeadToLinkInterfaceMap:
-    public std::map<cmGeneratorTarget const*, cmOptionalLinkInterface>
+struct cmHeadToLinkInterfaceMap
+  : public std::map<cmGeneratorTarget const*, cmOptionalLinkInterface>
 {
 };
 
-struct cmLinkImplementation: public cmLinkImplementationLibraries
+struct cmLinkImplementation : public cmLinkImplementationLibraries
 {
   // Languages whose runtime libraries must be linked.
   std::vector<std::string> Languages;
 };
 
 // Cache link implementation computation from each configuration.
-struct cmOptionalLinkImplementation: public cmLinkImplementation
+struct cmOptionalLinkImplementation : public cmLinkImplementation
 {
-  cmOptionalLinkImplementation():
-    LibrariesDone(false), LanguagesDone(false),
-    HadHeadSensitiveCondition(false) {}
+  cmOptionalLinkImplementation()
+    : LibrariesDone(false)
+    , LanguagesDone(false)
+    , HadHeadSensitiveCondition(false)
+  {
+  }
   bool LibrariesDone;
   bool LanguagesDone;
   bool HadHeadSensitiveCondition;
 };
 
 /** Compute the link type to use for the given configuration.  */
-inline cmTargetLinkLibraryType
-CMP0003_ComputeLinkType(const std::string& config,
-                        std::vector<std::string> const& debugConfigs)
+inline cmTargetLinkLibraryType CMP0003_ComputeLinkType(
+  const std::string& config, std::vector<std::string> const& debugConfigs)
 {
   // No configuration is always optimized.
-  if(config.empty())
-    {
+  if (config.empty()) {
     return OPTIMIZED_LibraryType;
-    }
+  }
 
   // Check if any entry in the list matches this configuration.
   std::string configUpper = cmSystemTools::UpperCase(config);
   if (std::find(debugConfigs.begin(), debugConfigs.end(), configUpper) !=
-      debugConfigs.end())
-    {
+      debugConfigs.end()) {
     return DEBUG_LibraryType;
-    }
+  }
   // The current configuration is not a debug configuration.
   return OPTIMIZED_LibraryType;
 }
 
-
 #endif
diff --git a/Source/cmLinkLibrariesCommand.cxx b/Source/cmLinkLibrariesCommand.cxx
index eb3bfce..5d23d6a 100644
--- a/Source/cmLinkLibrariesCommand.cxx
+++ b/Source/cmLinkLibrariesCommand.cxx
@@ -12,48 +12,36 @@
 #include "cmLinkLibrariesCommand.h"
 
 // cmLinkLibrariesCommand
-bool cmLinkLibrariesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmLinkLibrariesCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
   // add libraries, nothe that there is an optional prefix
   // of debug and optimized than can be used
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
-    if (*i == "debug")
-      {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
+    if (*i == "debug") {
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("The \"debug\" argument must be followed by "
                        "a library");
         return false;
-        }
-      this->Makefile->AddLinkLibrary(*i,
-                                 DEBUG_LibraryType);
       }
-    else if (*i == "optimized")
-      {
+      this->Makefile->AddLinkLibrary(*i, DEBUG_LibraryType);
+    } else if (*i == "optimized") {
       ++i;
-      if(i == args.end())
-        {
+      if (i == args.end()) {
         this->SetError("The \"optimized\" argument must be followed by "
                        "a library");
         return false;
-        }
-      this->Makefile->AddLinkLibrary(*i,
-                                 OPTIMIZED_LibraryType);
       }
-    else
-      {
+      this->Makefile->AddLinkLibrary(*i, OPTIMIZED_LibraryType);
+    } else {
       this->Makefile->AddLinkLibrary(*i);
-      }
     }
+  }
 
   return true;
 }
-
diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h
index 1ddefc4..6ab50ce 100644
--- a/Source/cmLinkLibrariesCommand.h
+++ b/Source/cmLinkLibrariesCommand.h
@@ -27,26 +27,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmLinkLibrariesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmLinkLibrariesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "link_libraries";}
+  virtual std::string GetName() const { return "link_libraries"; }
 
   cmTypeMacro(cmLinkLibrariesCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmLinkedTree.h b/Source/cmLinkedTree.h
index 3b41459..1a85396 100644
--- a/Source/cmLinkedTree.h
+++ b/Source/cmLinkedTree.h
@@ -32,12 +32,13 @@
   forward-only-iterated toward the root.  Extending the tree never
   invalidates existing iterators.
  */
-template<typename T>
+template <typename T>
 class cmLinkedTree
 {
   typedef typename std::vector<T>::size_type PositionType;
   typedef T* PointerType;
   typedef T& ReferenceType;
+
 public:
   class iterator : public std::iterator<std::forward_iterator_tag, T>
   {
@@ -48,16 +49,16 @@ public:
     PositionType Position;
 
     iterator(cmLinkedTree* tree, PositionType pos)
-      : Tree(tree), Position(pos)
+      : Tree(tree)
+      , Position(pos)
     {
-
     }
 
   public:
     iterator()
-      : Tree(0), Position(0)
+      : Tree(0)
+      , Position(0)
     {
-
     }
 
     void operator++()
@@ -122,10 +123,9 @@ public:
 
     bool IsValid() const
     {
-      if (!this->Tree)
-        {
+      if (!this->Tree) {
         return false;
-        }
+      }
       return this->Position <= this->Tree->Data.size();
     }
 
@@ -142,36 +142,26 @@ public:
     return iterator(const_cast<cmLinkedTree*>(this), 0);
   }
 
-  iterator Push(iterator it)
-  {
-    return Push_impl(it, T());
-  }
+  iterator Push(iterator it) { return Push_impl(it, T()); }
 
-  iterator Push(iterator it, T t)
-  {
-    return Push_impl(it, t);
-  }
+  iterator Push(iterator it, T t) { return Push_impl(it, t); }
 
-  bool IsLast(iterator it)
-    {
-    return it.Position == this->Data.size();
-    }
+  bool IsLast(iterator it) { return it.Position == this->Data.size(); }
 
   iterator Pop(iterator it)
-    {
+  {
     assert(!this->Data.empty());
     assert(this->UpPositions.size() == this->Data.size());
     bool const isLast = this->IsLast(it);
     ++it;
     // If this is the last entry then no other entry can refer
     // to it so we can drop its storage.
-    if (isLast)
-      {
+    if (isLast) {
       this->Data.pop_back();
       this->UpPositions.pop_back();
-      }
-    return it;
     }
+    return it;
+  }
 
   iterator Truncate()
   {
@@ -190,15 +180,9 @@ public:
   }
 
 private:
-  T& GetReference(PositionType pos)
-  {
-    return this->Data[pos];
-  }
+  T& GetReference(PositionType pos) { return this->Data[pos]; }
 
-  T* GetPointer(PositionType pos)
-  {
-    return &this->Data[pos];
-  }
+  T* GetPointer(PositionType pos) { return &this->Data[pos]; }
 
   iterator Push_impl(iterator it, T t)
   {
diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx
index feecb1e..32e965d 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -19,62 +19,50 @@
 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h> // required for atoi
-bool cmListCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmListCommand::InitialPass(std::vector<std::string> const& args,
+                                cmExecutionStatus&)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("must be called with at least two arguments.");
     return false;
-    }
+  }
 
-  const std::string &subCommand = args[0];
-  if(subCommand == "LENGTH")
-    {
+  const std::string& subCommand = args[0];
+  if (subCommand == "LENGTH") {
     return this->HandleLengthCommand(args);
-    }
-  if(subCommand == "GET")
-    {
+  }
+  if (subCommand == "GET") {
     return this->HandleGetCommand(args);
-    }
-  if(subCommand == "APPEND")
-    {
+  }
+  if (subCommand == "APPEND") {
     return this->HandleAppendCommand(args);
-    }
-  if(subCommand == "FIND")
-    {
+  }
+  if (subCommand == "FIND") {
     return this->HandleFindCommand(args);
-    }
-  if(subCommand == "INSERT")
-    {
+  }
+  if (subCommand == "INSERT") {
     return this->HandleInsertCommand(args);
-    }
-  if(subCommand == "REMOVE_AT")
-    {
+  }
+  if (subCommand == "REMOVE_AT") {
     return this->HandleRemoveAtCommand(args);
-    }
-  if(subCommand == "REMOVE_ITEM")
-    {
+  }
+  if (subCommand == "REMOVE_ITEM") {
     return this->HandleRemoveItemCommand(args);
-    }
-  if(subCommand == "REMOVE_DUPLICATES")
-    {
+  }
+  if (subCommand == "REMOVE_DUPLICATES") {
     return this->HandleRemoveDuplicatesCommand(args);
-    }
-  if(subCommand == "SORT")
-    {
+  }
+  if (subCommand == "SORT") {
     return this->HandleSortCommand(args);
-    }
-  if(subCommand == "REVERSE")
-    {
+  }
+  if (subCommand == "REVERSE") {
     return this->HandleReverseCommand(args);
-    }
-  if(subCommand == "FILTER")
-    {
+  }
+  if (subCommand == "FILTER") {
     return this->HandleFilterCommand(args);
-    }
+  }
 
-  std::string e = "does not recognize sub-command "+subCommand;
+  std::string e = "does not recognize sub-command " + subCommand;
   this->SetError(e);
   return false;
 }
@@ -83,12 +71,10 @@ bool cmListCommand::GetListString(std::string& listString,
                                   const std::string& var)
 {
   // get the old value
-  const char* cacheValue
-    = this->Makefile->GetDefinition(var);
-  if(!cacheValue)
-    {
+  const char* cacheValue = this->Makefile->GetDefinition(var);
+  if (!cacheValue) {
     return false;
-    }
+  }
   listString = cacheValue;
   return true;
 }
@@ -97,27 +83,22 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
                             const std::string& var)
 {
   std::string listString;
-  if ( !this->GetListString(listString, var) )
-    {
+  if (!this->GetListString(listString, var)) {
     return false;
-    }
+  }
   // if the size of the list
-  if(listString.empty())
-    {
+  if (listString.empty()) {
     return true;
-    }
+  }
   // expand the variable into a list
   cmSystemTools::ExpandListArgument(listString, list, true);
   // if no empty elements then just return
-  if (std::find(list.begin(), list.end(), std::string()) == list.end())
-    {
+  if (std::find(list.begin(), list.end(), std::string()) == list.end()) {
     return true;
-    }
+  }
   // if we have empty elements we need to check policy CMP0007
-  switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0007))
-    {
-    case cmPolicies::WARN:
-      {
+  switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0007)) {
+    case cmPolicies::WARN: {
       // Default is to warn and use old behavior
       // OLD behavior is to allow compatibility, so recall
       // ExpandListArgument without the true which will remove
@@ -128,10 +109,9 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
       warn += " List has value = [";
       warn += listString;
       warn += "].";
-      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
-                                   warn);
+      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, warn);
       return true;
-      }
+    }
     case cmPolicies::OLD:
       // OLD behavior is to allow compatibility, so recall
       // ExpandListArgument without the true which will remove
@@ -145,20 +125,18 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
     case cmPolicies::REQUIRED_ALWAYS:
       this->Makefile->IssueMessage(
         cmake::FATAL_ERROR,
-        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007)
-        );
+        cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007));
       return false;
-    }
+  }
   return true;
 }
 
 bool cmListCommand::HandleLengthCommand(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("sub-command LENGTH requires two arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   const std::string& variableName = args[args.size() - 1];
@@ -177,52 +155,45 @@ bool cmListCommand::HandleLengthCommand(std::vector<std::string> const& args)
 
 bool cmListCommand::HandleGetCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("sub-command GET requires at least three arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   const std::string& variableName = args[args.size() - 1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->Makefile->AddDefinition(variableName, "NOTFOUND");
     return true;
-    }
+  }
   // FIXME: Add policy to make non-existing lists an error like empty lists.
-  if(varArgsExpanded.empty())
-    {
+  if (varArgsExpanded.empty()) {
     this->SetError("GET given empty list");
     return false;
-    }
+  }
 
   std::string value;
   size_t cc;
   const char* sep = "";
   size_t nitem = varArgsExpanded.size();
-  for ( cc = 2; cc < args.size()-1; cc ++ )
-    {
+  for (cc = 2; cc < args.size() - 1; cc++) {
     int item = atoi(args[cc].c_str());
     value += sep;
     sep = ";";
-    if ( item < 0 )
-      {
+    if (item < 0) {
       item = (int)nitem + item;
-      }
-    if ( item < 0 || nitem <= (size_t)item )
-      {
+    }
+    if (item < 0 || nitem <= (size_t)item) {
       std::ostringstream str;
-      str << "index: " << item << " out of range (-"
-          << nitem << ", "
+      str << "index: " << item << " out of range (-" << nitem << ", "
           << nitem - 1 << ")";
       this->SetError(str.str());
       return false;
-      }
-    value += varArgsExpanded[item];
     }
+    value += varArgsExpanded[item];
+  }
 
   this->Makefile->AddDefinition(variableName, value.c_str());
   return true;
@@ -233,20 +204,18 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
   assert(args.size() >= 2);
 
   // Skip if nothing to append.
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     return true;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::string listString;
   this->GetListString(listString, listName);
 
-  if(!listString.empty() && !args.empty())
-    {
+  if (!listString.empty() && !args.empty()) {
     listString += ";";
-    }
+  }
   listString += cmJoin(cmMakeRange(args).advance(2), ";");
 
   this->Makefile->AddDefinition(listName, listString.c_str());
@@ -255,31 +224,28 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
 
 bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args)
 {
-  if(args.size() != 4)
-    {
+  if (args.size() != 4) {
     this->SetError("sub-command FIND requires three arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   const std::string& variableName = args[args.size() - 1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->Makefile->AddDefinition(variableName, "-1");
     return true;
-    }
+  }
 
   std::vector<std::string>::iterator it =
-      std::find(varArgsExpanded.begin(), varArgsExpanded.end(), args[2]);
-  if (it != varArgsExpanded.end())
-    {
+    std::find(varArgsExpanded.begin(), varArgsExpanded.end(), args[2]);
+  if (it != varArgsExpanded.end()) {
     std::ostringstream indexStream;
     indexStream << std::distance(varArgsExpanded.begin(), it);
     this->Makefile->AddDefinition(variableName, indexStream.str().c_str());
     return true;
-    }
+  }
 
   this->Makefile->AddDefinition(variableName, "-1");
   return true;
@@ -287,103 +253,93 @@ bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args)
 
 bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("sub-command INSERT requires at least three arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
 
   // expand the variable
   int item = atoi(args[2].c_str());
   std::vector<std::string> varArgsExpanded;
-  if((!this->GetList(varArgsExpanded, listName)
-      || varArgsExpanded.empty()) && item != 0)
-    {
+  if ((!this->GetList(varArgsExpanded, listName) || varArgsExpanded.empty()) &&
+      item != 0) {
     std::ostringstream str;
     str << "index: " << item << " out of range (0, 0)";
     this->SetError(str.str());
     return false;
-    }
+  }
 
-  if (!varArgsExpanded.empty())
-    {
+  if (!varArgsExpanded.empty()) {
     size_t nitem = varArgsExpanded.size();
-    if ( item < 0 )
-      {
+    if (item < 0) {
       item = (int)nitem + item;
-      }
-    if ( item < 0 || nitem <= (size_t)item )
-      {
+    }
+    if (item < 0 || nitem <= (size_t)item) {
       std::ostringstream str;
-      str << "index: " << item << " out of range (-"
-        << varArgsExpanded.size() << ", "
-        << (varArgsExpanded.empty() ? 0 : (varArgsExpanded.size() - 1)) << ")";
+      str << "index: " << item << " out of range (-" << varArgsExpanded.size()
+          << ", "
+          << (varArgsExpanded.empty() ? 0 : (varArgsExpanded.size() - 1))
+          << ")";
       this->SetError(str.str());
       return false;
-      }
     }
+  }
 
-  varArgsExpanded.insert(varArgsExpanded.begin()+item,
-                         args.begin() + 3, args.end());
+  varArgsExpanded.insert(varArgsExpanded.begin() + item, args.begin() + 3,
+                         args.end());
 
   std::string value = cmJoin(varArgsExpanded, ";");
   this->Makefile->AddDefinition(listName, value.c_str());
   return true;
 }
 
-bool cmListCommand
-::HandleRemoveItemCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleRemoveItemCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command REMOVE_ITEM requires two or more arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command REMOVE_ITEM requires list to be present.");
     return false;
-    }
+  }
 
   std::vector<std::string> remove(args.begin() + 2, args.end());
   std::sort(remove.begin(), remove.end());
   std::vector<std::string>::const_iterator remEnd =
-      std::unique(remove.begin(), remove.end());
+    std::unique(remove.begin(), remove.end());
   std::vector<std::string>::const_iterator remBegin = remove.begin();
 
   std::vector<std::string>::const_iterator argsEnd =
-      cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd));
+    cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd));
   std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
   std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
   this->Makefile->AddDefinition(listName, value.c_str());
   return true;
 }
 
-bool cmListCommand
-::HandleReverseCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleReverseCommand(std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
-  if(args.size() > 2)
-    {
-    this->SetError(
-      "sub-command REVERSE only takes one argument.");
+  if (args.size() > 2) {
+    this->SetError("sub-command REVERSE only takes one argument.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command REVERSE requires list to be present.");
     return false;
-    }
+  }
 
   std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";");
 
@@ -391,56 +347,48 @@ bool cmListCommand
   return true;
 }
 
-bool cmListCommand
-::HandleRemoveDuplicatesCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleRemoveDuplicatesCommand(
+  std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
-  if(args.size() > 2)
-    {
-    this->SetError(
-      "sub-command REMOVE_DUPLICATES only takes one argument.");
+  if (args.size() > 2) {
+    this->SetError("sub-command REMOVE_DUPLICATES only takes one argument.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError(
       "sub-command REMOVE_DUPLICATES requires list to be present.");
     return false;
-    }
+  }
 
   std::vector<std::string>::const_iterator argsEnd =
-      cmRemoveDuplicates(varArgsExpanded);
-  std::vector<std::string>::const_iterator argsBegin =
-      varArgsExpanded.begin();
+    cmRemoveDuplicates(varArgsExpanded);
+  std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
   std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
 
   this->Makefile->AddDefinition(listName, value.c_str());
   return true;
 }
 
-bool cmListCommand
-::HandleSortCommand(std::vector<std::string> const& args)
+bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args)
 {
   assert(args.size() >= 2);
-  if(args.size() > 2)
-    {
-    this->SetError(
-      "sub-command SORT only takes one argument.");
+  if (args.size() > 2) {
+    this->SetError("sub-command SORT only takes one argument.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command SORT requires list to be present.");
     return false;
-    }
+  }
 
   std::sort(varArgsExpanded.begin(), varArgsExpanded.end());
 
@@ -449,60 +397,52 @@ bool cmListCommand
   return true;
 }
 
-bool cmListCommand::HandleRemoveAtCommand(
-  std::vector<std::string> const& args)
+bool cmListCommand::HandleRemoveAtCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command REMOVE_AT requires at least "
                    "two arguments.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command REMOVE_AT requires list to be present.");
     return false;
-    }
+  }
   // FIXME: Add policy to make non-existing lists an error like empty lists.
-  if(varArgsExpanded.empty())
-    {
+  if (varArgsExpanded.empty()) {
     this->SetError("REMOVE_AT given empty list");
     return false;
-    }
+  }
 
   size_t cc;
   std::vector<size_t> removed;
   size_t nitem = varArgsExpanded.size();
-  for ( cc = 2; cc < args.size(); ++ cc )
-    {
+  for (cc = 2; cc < args.size(); ++cc) {
     int item = atoi(args[cc].c_str());
-    if ( item < 0 )
-      {
+    if (item < 0) {
       item = (int)nitem + item;
-      }
-    if ( item < 0 || nitem <= (size_t)item )
-      {
+    }
+    if (item < 0 || nitem <= (size_t)item) {
       std::ostringstream str;
-      str << "index: " << item << " out of range (-"
-          << nitem << ", "
+      str << "index: " << item << " out of range (-" << nitem << ", "
           << nitem - 1 << ")";
       this->SetError(str.str());
       return false;
-      }
-    removed.push_back(static_cast<size_t>(item));
     }
+    removed.push_back(static_cast<size_t>(item));
+  }
 
   std::sort(removed.begin(), removed.end());
   std::vector<size_t>::const_iterator remEnd =
-      std::unique(removed.begin(), removed.end());
+    std::unique(removed.begin(), removed.end());
   std::vector<size_t>::const_iterator remBegin = removed.begin();
 
   std::vector<std::string>::const_iterator argsEnd =
-      cmRemoveIndices(varArgsExpanded, cmMakeRange(remBegin, remEnd));
+    cmRemoveIndices(varArgsExpanded, cmMakeRange(remBegin, remEnd));
   std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
   std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
 
@@ -510,74 +450,67 @@ bool cmListCommand::HandleRemoveAtCommand(
   return true;
 }
 
-bool cmListCommand::HandleFilterCommand(
-  std::vector<std::string> const& args)
+bool cmListCommand::HandleFilterCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command FILTER requires a list to be specified.");
     return false;
-    }
+  }
 
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("sub-command FILTER requires an operator to be specified.");
     return false;
-    }
+  }
 
-  if(args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("sub-command FILTER requires a mode to be specified.");
     return false;
-    }
+  }
 
   const std::string& listName = args[1];
   // expand the variable
   std::vector<std::string> varArgsExpanded;
-  if ( !this->GetList(varArgsExpanded, listName) )
-    {
+  if (!this->GetList(varArgsExpanded, listName)) {
     this->SetError("sub-command FILTER requires list to be present.");
     return false;
-    }
+  }
 
   const std::string& op = args[2];
   bool includeMatches;
-  if(op == "INCLUDE")
-    {
+  if (op == "INCLUDE") {
     includeMatches = true;
-    }
-  else if(op == "EXCLUDE")
-    {
+  } else if (op == "EXCLUDE") {
     includeMatches = false;
-    }
-  else
-    {
+  } else {
     this->SetError("sub-command FILTER does not recognize operator " + op);
     return false;
-    }
+  }
 
   const std::string& mode = args[3];
-  if(mode == "REGEX")
-    {
-    if(args.size() != 5)
-      {
+  if (mode == "REGEX") {
+    if (args.size() != 5) {
       this->SetError("sub-command FILTER, mode REGEX "
-          "requires five arguments.");
+                     "requires five arguments.");
       return false;
-      }
-    return this->FilterRegex(args, includeMatches, listName, varArgsExpanded);
     }
+    return this->FilterRegex(args, includeMatches, listName, varArgsExpanded);
+  }
 
   this->SetError("sub-command FILTER does not recognize mode " + mode);
   return false;
 }
 
-class MatchesRegex {
+class MatchesRegex
+{
 public:
   MatchesRegex(cmsys::RegularExpression& in_regex, bool in_includeMatches)
-    : regex(in_regex), includeMatches(in_includeMatches) {}
+    : regex(in_regex)
+    , includeMatches(in_includeMatches)
+  {
+  }
 
-  bool operator()(const std::string& target) {
+  bool operator()(const std::string& target)
+  {
     return regex.find(target) ^ includeMatches;
   }
 
@@ -587,26 +520,25 @@ private:
 };
 
 bool cmListCommand::FilterRegex(std::vector<std::string> const& args,
-    bool includeMatches,
-    std::string const& listName,
-    std::vector<std::string>& varArgsExpanded)
+                                bool includeMatches,
+                                std::string const& listName,
+                                std::vector<std::string>& varArgsExpanded)
 {
   const std::string& pattern = args[4];
   cmsys::RegularExpression regex(pattern);
-  if(!regex.is_valid())
-    {
+  if (!regex.is_valid()) {
     std::string error = "sub-command FILTER, mode REGEX ";
     error += "failed to compile regex \"";
     error += pattern;
     error += "\".";
     this->SetError(error);
     return false;
-    }
+  }
 
   std::vector<std::string>::iterator argsBegin = varArgsExpanded.begin();
   std::vector<std::string>::iterator argsEnd = varArgsExpanded.end();
   std::vector<std::string>::iterator newArgsEnd =
-      std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches));
+    std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches));
 
   std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";");
   this->Makefile->AddDefinition(listName, value.c_str());
diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h
index 25edee8..56d9694 100644
--- a/Source/cmListCommand.h
+++ b/Source/cmListCommand.h
@@ -24,17 +24,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmListCommand;
-    }
+  virtual cmCommand* Clone() { return new cmListCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -44,9 +41,10 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "list";}
+  virtual std::string GetName() const { return "list"; }
 
   cmTypeMacro(cmListCommand, cmCommand);
+
 protected:
   bool HandleLengthCommand(std::vector<std::string> const& args);
   bool HandleGetCommand(std::vector<std::string> const& args);
@@ -59,16 +57,12 @@ protected:
   bool HandleSortCommand(std::vector<std::string> const& args);
   bool HandleReverseCommand(std::vector<std::string> const& args);
   bool HandleFilterCommand(std::vector<std::string> const& args);
-  bool FilterRegex(std::vector<std::string> const& args,
-      bool includeMatches,
-      std::string const& listName,
-      std::vector<std::string>& varArgsExpanded
-      );
-
+  bool FilterRegex(std::vector<std::string> const& args, bool includeMatches,
+                   std::string const& listName,
+                   std::vector<std::string>& varArgsExpanded);
 
   bool GetList(std::vector<std::string>& list, const std::string& var);
   bool GetListString(std::string& listString, const std::string& var);
 };
 
-
 #endif
diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx
index 8788e41..f47e9b6 100644
--- a/Source/cmListFileCache.cxx
+++ b/Source/cmListFileCache.cxx
@@ -19,7 +19,6 @@
 
 #include <cmsys/RegularExpression.hxx>
 
-
 struct cmListFileParser
 {
   cmListFileParser(cmListFile* lf, cmMakefile* mf, const char* filename);
@@ -33,13 +32,20 @@ struct cmListFileParser
   const char* FileName;
   cmListFileLexer* Lexer;
   cmListFileFunction Function;
-  enum { SeparationOkay, SeparationWarning, SeparationError} Separation;
+  enum
+  {
+    SeparationOkay,
+    SeparationWarning,
+    SeparationError
+  } Separation;
 };
 
 cmListFileParser::cmListFileParser(cmListFile* lf, cmMakefile* mf,
-                                   const char* filename):
-  ListFile(lf), Makefile(mf), FileName(filename),
-  Lexer(cmListFileLexer_New())
+                                   const char* filename)
+  : ListFile(lf)
+  , Makefile(mf)
+  , FileName(filename)
+  , Lexer(cmListFileLexer_New())
 {
 }
 
@@ -52,58 +58,40 @@ bool cmListFileParser::ParseFile()
 {
   // Open the file.
   cmListFileLexer_BOM bom;
-  if(!cmListFileLexer_SetFileName(this->Lexer, this->FileName, &bom))
-    {
+  if (!cmListFileLexer_SetFileName(this->Lexer, this->FileName, &bom)) {
     cmSystemTools::Error("cmListFileCache: error can not open file ",
                          this->FileName);
     return false;
-    }
+  }
 
   // Verify the Byte-Order-Mark, if any.
-  if(bom != cmListFileLexer_BOM_None &&
-     bom != cmListFileLexer_BOM_UTF8)
-    {
+  if (bom != cmListFileLexer_BOM_None && bom != cmListFileLexer_BOM_UTF8) {
     cmListFileLexer_SetFileName(this->Lexer, 0, 0);
     std::ostringstream m;
     m << "File\n  " << this->FileName << "\n"
       << "starts with a Byte-Order-Mark that is not UTF-8.";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, m.str());
     return false;
-    }
+  }
 
   // Use a simple recursive-descent parser to process the token
   // stream.
   bool haveNewline = true;
-  while(cmListFileLexer_Token* token =
-        cmListFileLexer_Scan(this->Lexer))
-    {
-    if(token->type == cmListFileLexer_Token_Space)
-      {
-      }
-    else if(token->type == cmListFileLexer_Token_Newline)
-      {
+  while (cmListFileLexer_Token* token = cmListFileLexer_Scan(this->Lexer)) {
+    if (token->type == cmListFileLexer_Token_Space) {
+    } else if (token->type == cmListFileLexer_Token_Newline) {
       haveNewline = true;
-      }
-    else if(token->type == cmListFileLexer_Token_CommentBracket)
-      {
+    } else if (token->type == cmListFileLexer_Token_CommentBracket) {
       haveNewline = false;
-      }
-    else if(token->type == cmListFileLexer_Token_Identifier)
-      {
-      if(haveNewline)
-        {
+    } else if (token->type == cmListFileLexer_Token_Identifier) {
+      if (haveNewline) {
         haveNewline = false;
-        if(this->ParseFunction(token->text, token->line))
-          {
+        if (this->ParseFunction(token->text, token->line)) {
           this->ListFile->Functions.push_back(this->Function);
-          }
-        else
-          {
+        } else {
           return false;
-          }
         }
-      else
-        {
+      } else {
         std::ostringstream error;
         error << "Error in cmake code at\n"
               << this->FileName << ":" << token->line << ":\n"
@@ -112,63 +100,51 @@ bool cmListFileParser::ParseFile()
               << " with text \"" << token->text << "\".";
         cmSystemTools::Error(error.str().c_str());
         return false;
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream error;
       error << "Error in cmake code at\n"
             << this->FileName << ":" << token->line << ":\n"
             << "Parse error.  Expected a command name, got "
             << cmListFileLexer_GetTypeAsString(this->Lexer, token->type)
-            << " with text \""
-            << token->text << "\".";
+            << " with text \"" << token->text << "\".";
       cmSystemTools::Error(error.str().c_str());
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool cmListFile::ParseFile(const char* filename,
-                           bool topLevel,
-                           cmMakefile *mf)
+bool cmListFile::ParseFile(const char* filename, bool topLevel, cmMakefile* mf)
 {
-  if(!cmSystemTools::FileExists(filename) ||
-     cmSystemTools::FileIsDirectory(filename))
-    {
+  if (!cmSystemTools::FileExists(filename) ||
+      cmSystemTools::FileIsDirectory(filename)) {
     return false;
-    }
+  }
 
   bool parseError = false;
 
   {
-  cmListFileParser parser(this, mf, filename);
-  parseError = !parser.ParseFile();
+    cmListFileParser parser(this, mf, filename);
+    parseError = !parser.ParseFile();
   }
 
   // do we need a cmake_policy(VERSION call?
-  if(topLevel)
-  {
+  if (topLevel) {
     bool hasVersion = false;
     // search for the right policy command
-    for(std::vector<cmListFileFunction>::iterator i
-          = this->Functions.begin();
-        i != this->Functions.end(); ++i)
-    {
-      if (cmSystemTools::LowerCase(i->Name) == "cmake_minimum_required")
-      {
+    for (std::vector<cmListFileFunction>::iterator i = this->Functions.begin();
+         i != this->Functions.end(); ++i) {
+      if (cmSystemTools::LowerCase(i->Name) == "cmake_minimum_required") {
         hasVersion = true;
         break;
       }
     }
     // if no policy command is found this is an error if they use any
     // non advanced functions or a lot of functions
-    if(!hasVersion)
-    {
+    if (!hasVersion) {
       bool isProblem = true;
-      if (this->Functions.size() < 30)
-      {
+      if (this->Functions.size() < 30) {
         // the list of simple commands DO NOT ADD TO THIS LIST!!!!!
         // these commands must have backwards compatibility forever and
         // and that is a lot longer than your tiny mind can comprehend mortal
@@ -185,59 +161,50 @@ bool cmListFile::ParseFile(const char* filename,
         allowedCommands.insert("option");
         allowedCommands.insert("message");
         isProblem = false;
-        for(std::vector<cmListFileFunction>::iterator i
-              = this->Functions.begin();
-            i != this->Functions.end(); ++i)
-        {
+        for (std::vector<cmListFileFunction>::iterator i =
+               this->Functions.begin();
+             i != this->Functions.end(); ++i) {
           std::string name = cmSystemTools::LowerCase(i->Name);
-          if (allowedCommands.find(name) == allowedCommands.end())
-          {
+          if (allowedCommands.find(name) == allowedCommands.end()) {
             isProblem = true;
             break;
           }
         }
       }
 
-      if (isProblem)
-      {
-      // Tell the top level cmMakefile to diagnose
-      // this violation of CMP0000.
-      mf->SetCheckCMP0000(true);
+      if (isProblem) {
+        // Tell the top level cmMakefile to diagnose
+        // this violation of CMP0000.
+        mf->SetCheckCMP0000(true);
 
-      // Implicitly set the version for the user.
-      mf->SetPolicyVersion("2.4");
+        // Implicitly set the version for the user.
+        mf->SetPolicyVersion("2.4");
       }
     }
   }
 
-  if(topLevel)
-    {
+  if (topLevel) {
     bool hasProject = false;
     // search for a project command
-    for(std::vector<cmListFileFunction>::iterator i
-          = this->Functions.begin();
-        i != this->Functions.end(); ++i)
-      {
-      if(cmSystemTools::LowerCase(i->Name) == "project")
-        {
+    for (std::vector<cmListFileFunction>::iterator i = this->Functions.begin();
+         i != this->Functions.end(); ++i) {
+      if (cmSystemTools::LowerCase(i->Name) == "project") {
         hasProject = true;
         break;
-        }
       }
+    }
     // if no project command is found, add one
-    if(!hasProject)
-      {
+    if (!hasProject) {
       cmListFileFunction project;
       project.Name = "PROJECT";
       cmListFileArgument prj("Project", cmListFileArgument::Unquoted, 0);
       project.Arguments.push_back(prj);
-      this->Functions.insert(this->Functions.begin(),project);
-      }
+      this->Functions.insert(this->Functions.begin(), project);
     }
-  if(parseError)
-    {
+  }
+  if (parseError) {
     return false;
-    }
+  }
   return true;
 }
 
@@ -250,10 +217,10 @@ bool cmListFileParser::ParseFunction(const char* name, long line)
 
   // Command name has already been parsed.  Read the left paren.
   cmListFileLexer_Token* token;
-  while((token = cmListFileLexer_Scan(this->Lexer)) &&
-        token->type == cmListFileLexer_Token_Space) {}
-  if(!token)
-    {
+  while ((token = cmListFileLexer_Scan(this->Lexer)) &&
+         token->type == cmListFileLexer_Token_Space) {
+  }
+  if (!token) {
     std::ostringstream error;
     /* clang-format off */
     error << "Error in cmake code at\n" << this->FileName << ":"
@@ -262,89 +229,69 @@ bool cmListFileParser::ParseFunction(const char* name, long line)
     /* clang-format on */
     cmSystemTools::Error(error.str().c_str());
     return false;
-    }
-  if(token->type != cmListFileLexer_Token_ParenLeft)
-    {
+  }
+  if (token->type != cmListFileLexer_Token_ParenLeft) {
     std::ostringstream error;
-    error << "Error in cmake code at\n" << this->FileName << ":"
+    error << "Error in cmake code at\n"
+          << this->FileName << ":"
           << cmListFileLexer_GetCurrentLine(this->Lexer) << ":\n"
           << "Parse error.  Expected \"(\", got "
           << cmListFileLexer_GetTypeAsString(this->Lexer, token->type)
           << " with text \"" << token->text << "\".";
     cmSystemTools::Error(error.str().c_str());
     return false;
-    }
+  }
 
   // Arguments.
   unsigned long lastLine;
   unsigned long parenDepth = 0;
   this->Separation = SeparationOkay;
-  while((lastLine = cmListFileLexer_GetCurrentLine(this->Lexer),
-         token = cmListFileLexer_Scan(this->Lexer)))
-    {
-    if(token->type == cmListFileLexer_Token_Space ||
-       token->type == cmListFileLexer_Token_Newline)
-      {
+  while ((lastLine = cmListFileLexer_GetCurrentLine(this->Lexer),
+          token = cmListFileLexer_Scan(this->Lexer))) {
+    if (token->type == cmListFileLexer_Token_Space ||
+        token->type == cmListFileLexer_Token_Newline) {
       this->Separation = SeparationOkay;
       continue;
-      }
-    if(token->type == cmListFileLexer_Token_ParenLeft)
-      {
+    }
+    if (token->type == cmListFileLexer_Token_ParenLeft) {
       parenDepth++;
       this->Separation = SeparationOkay;
-      if(!this->AddArgument(token, cmListFileArgument::Unquoted))
-        {
+      if (!this->AddArgument(token, cmListFileArgument::Unquoted)) {
         return false;
-        }
       }
-    else if(token->type == cmListFileLexer_Token_ParenRight)
-      {
-      if (parenDepth == 0)
-        {
+    } else if (token->type == cmListFileLexer_Token_ParenRight) {
+      if (parenDepth == 0) {
         return true;
-        }
+      }
       parenDepth--;
       this->Separation = SeparationOkay;
-      if(!this->AddArgument(token, cmListFileArgument::Unquoted))
-        {
+      if (!this->AddArgument(token, cmListFileArgument::Unquoted)) {
         return false;
-        }
-      this->Separation = SeparationWarning;
       }
-    else if(token->type == cmListFileLexer_Token_Identifier ||
-            token->type == cmListFileLexer_Token_ArgumentUnquoted)
-      {
-      if(!this->AddArgument(token, cmListFileArgument::Unquoted))
-        {
-        return false;
-        }
       this->Separation = SeparationWarning;
-      }
-    else if(token->type == cmListFileLexer_Token_ArgumentQuoted)
-      {
-      if(!this->AddArgument(token, cmListFileArgument::Quoted))
-        {
+    } else if (token->type == cmListFileLexer_Token_Identifier ||
+               token->type == cmListFileLexer_Token_ArgumentUnquoted) {
+      if (!this->AddArgument(token, cmListFileArgument::Unquoted)) {
         return false;
-        }
+      }
       this->Separation = SeparationWarning;
+    } else if (token->type == cmListFileLexer_Token_ArgumentQuoted) {
+      if (!this->AddArgument(token, cmListFileArgument::Quoted)) {
+        return false;
       }
-    else if(token->type == cmListFileLexer_Token_ArgumentBracket)
-      {
-      if(!this->AddArgument(token, cmListFileArgument::Bracket))
-        {
+      this->Separation = SeparationWarning;
+    } else if (token->type == cmListFileLexer_Token_ArgumentBracket) {
+      if (!this->AddArgument(token, cmListFileArgument::Bracket)) {
         return false;
-        }
-      this->Separation = SeparationError;
       }
-    else if(token->type == cmListFileLexer_Token_CommentBracket)
-      {
       this->Separation = SeparationError;
-      }
-    else
-      {
+    } else if (token->type == cmListFileLexer_Token_CommentBracket) {
+      this->Separation = SeparationError;
+    } else {
       // Error.
       std::ostringstream error;
-      error << "Error in cmake code at\n" << this->FileName << ":"
+      error << "Error in cmake code at\n"
+            << this->FileName << ":"
             << cmListFileLexer_GetCurrentLine(this->Lexer) << ":\n"
             << "Parse error.  Function missing ending \")\".  "
             << "Instead found "
@@ -352,8 +299,8 @@ bool cmListFileParser::ParseFunction(const char* name, long line)
             << " with text \"" << token->text << "\".";
       cmSystemTools::Error(error.str().c_str());
       return false;
-      }
     }
+  }
 
   std::ostringstream error;
   error << "Error in cmake code at\n"
@@ -370,10 +317,9 @@ bool cmListFileParser::AddArgument(cmListFileLexer_Token* token,
 {
   cmListFileArgument a(token->text, delim, token->line);
   this->Function.Arguments.push_back(a);
-  if(this->Separation == SeparationOkay)
-    {
+  if (this->Separation == SeparationOkay) {
     return true;
-    }
+  }
   bool isError = (this->Separation == SeparationError ||
                   delim == cmListFileArgument::Bracket);
   std::ostringstream m;
@@ -383,90 +329,86 @@ bool cmListFileParser::AddArgument(cmListFileLexer_Token* token,
     << token->column << "\n"
     << "Argument not separated from preceding token by whitespace.";
   /* clang-format on */
-  if(isError)
-    {
+  if (isError) {
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, m.str());
     return false;
-    }
-  else
-    {
+  } else {
     this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, m.str());
     return true;
-    }
+  }
 }
 
-struct cmListFileBacktrace::Entry: public cmListFileContext
+struct cmListFileBacktrace::Entry : public cmListFileContext
 {
-  Entry(cmListFileContext const& lfc, Entry* up):
-    cmListFileContext(lfc), Up(up), RefCount(0)
-    {
-    if (this->Up)
-      {
+  Entry(cmListFileContext const& lfc, Entry* up)
+    : cmListFileContext(lfc)
+    , Up(up)
+    , RefCount(0)
+  {
+    if (this->Up) {
       this->Up->Ref();
-      }
     }
+  }
   ~Entry()
-    {
-    if (this->Up)
-      {
+  {
+    if (this->Up) {
       this->Up->Unref();
-      }
-    }
-  void Ref()
-    {
-    ++this->RefCount;
     }
+  }
+  void Ref() { ++this->RefCount; }
   void Unref()
-    {
-    if (--this->RefCount == 0)
-      {
+  {
+    if (--this->RefCount == 0) {
       delete this;
-      }
     }
+  }
   Entry* Up;
   unsigned int RefCount;
 };
 
-cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom,
-                                         Entry* up,
-                                         cmListFileContext const& lfc):
-  Bottom(bottom), Cur(new Entry(lfc, up))
+cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom, Entry* up,
+                                         cmListFileContext const& lfc)
+  : Bottom(bottom)
+  , Cur(new Entry(lfc, up))
 {
   assert(this->Bottom.IsValid());
   this->Cur->Ref();
 }
 
-cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom, Entry* cur):
-  Bottom(bottom), Cur(cur)
+cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom, Entry* cur)
+  : Bottom(bottom)
+  , Cur(cur)
 {
-  if (this->Cur)
-    {
+  if (this->Cur) {
     assert(this->Bottom.IsValid());
     this->Cur->Ref();
-    }
+  }
 }
 
-cmListFileBacktrace::cmListFileBacktrace(): Bottom(), Cur(0)
+cmListFileBacktrace::cmListFileBacktrace()
+  : Bottom()
+  , Cur(0)
 {
 }
 
-cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot snapshot):
-  Bottom(snapshot.GetCallStackBottom()), Cur(0)
+cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot snapshot)
+  : Bottom(snapshot.GetCallStackBottom())
+  , Cur(0)
 {
 }
 
-cmListFileBacktrace::cmListFileBacktrace(cmListFileBacktrace const& r):
-  Bottom(r.Bottom), Cur(r.Cur)
+cmListFileBacktrace::cmListFileBacktrace(cmListFileBacktrace const& r)
+  : Bottom(r.Bottom)
+  , Cur(r.Cur)
 {
-  if (this->Cur)
-    {
+  if (this->Cur) {
     assert(this->Bottom.IsValid());
     this->Cur->Ref();
-    }
+  }
 }
 
-cmListFileBacktrace&
-cmListFileBacktrace::operator=(cmListFileBacktrace const& r)
+cmListFileBacktrace& cmListFileBacktrace::operator=(
+  cmListFileBacktrace const& r)
 {
   cmListFileBacktrace tmp(r);
   std::swap(this->Cur, tmp.Cur);
@@ -476,14 +418,12 @@ cmListFileBacktrace::operator=(cmListFileBacktrace const& r)
 
 cmListFileBacktrace::~cmListFileBacktrace()
 {
-  if (this->Cur)
-    {
+  if (this->Cur) {
     this->Cur->Unref();
-    }
+  }
 }
 
-cmListFileBacktrace
-cmListFileBacktrace::Push(std::string const& file) const
+cmListFileBacktrace cmListFileBacktrace::Push(std::string const& file) const
 {
   // We are entering a file-level scope but have not yet reached
   // any specific line or command invocation within it.  This context
@@ -494,8 +434,8 @@ cmListFileBacktrace::Push(std::string const& file) const
   return cmListFileBacktrace(this->Bottom, this->Cur, lfc);
 }
 
-cmListFileBacktrace
-cmListFileBacktrace::Push(cmListFileContext const& lfc) const
+cmListFileBacktrace cmListFileBacktrace::Push(
+  cmListFileContext const& lfc) const
 {
   return cmListFileBacktrace(this->Bottom, this->Cur, lfc);
 }
@@ -508,83 +448,70 @@ cmListFileBacktrace cmListFileBacktrace::Pop() const
 
 cmListFileContext const& cmListFileBacktrace::Top() const
 {
-  if (this->Cur)
-    {
+  if (this->Cur) {
     return *this->Cur;
-    }
-  else
-    {
+  } else {
     static cmListFileContext const empty;
     return empty;
-    }
+  }
 }
 
 void cmListFileBacktrace::PrintTitle(std::ostream& out) const
 {
-  if (!this->Cur)
-    {
+  if (!this->Cur) {
     return;
-    }
+  }
   cmOutputConverter converter(this->Bottom);
   cmListFileContext lfc = *this->Cur;
-  if (!this->Bottom.GetState()->GetIsInTryCompile())
-    {
+  if (!this->Bottom.GetState()->GetIsInTryCompile()) {
     lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
-    }
+  }
   out << (lfc.Line ? " at " : " in ") << lfc;
 }
 
 void cmListFileBacktrace::PrintCallStack(std::ostream& out) const
 {
-  if (!this->Cur || !this->Cur->Up)
-    {
+  if (!this->Cur || !this->Cur->Up) {
     return;
-    }
+  }
 
   bool first = true;
   cmOutputConverter converter(this->Bottom);
-  for (Entry* i = this->Cur->Up; i; i = i->Up)
-    {
-    if (i->Name.empty())
-      {
+  for (Entry* i = this->Cur->Up; i; i = i->Up) {
+    if (i->Name.empty()) {
       // Skip this whole-file scope.  When we get here we already will
       // have printed a more-specific context within the file.
       continue;
-      }
-    if (first)
-      {
+    }
+    if (first) {
       first = false;
       out << "Call Stack (most recent call first):\n";
-      }
+    }
     cmListFileContext lfc = *i;
-    if (!this->Bottom.GetState()->GetIsInTryCompile())
-      {
+    if (!this->Bottom.GetState()->GetIsInTryCompile()) {
       lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
-      }
-    out << "  " << lfc << "\n";
     }
+    out << "  " << lfc << "\n";
+  }
 }
 
 std::ostream& operator<<(std::ostream& os, cmListFileContext const& lfc)
 {
   os << lfc.FilePath;
-  if(lfc.Line)
-    {
+  if (lfc.Line) {
     os << ":" << lfc.Line;
-    if(!lfc.Name.empty())
-      {
+    if (!lfc.Name.empty()) {
       os << " (" << lfc.Name << ")";
-      }
     }
+  }
   return os;
 }
 
 bool operator<(const cmListFileContext& lhs, const cmListFileContext& rhs)
 {
-  if(lhs.Line != rhs.Line)
-    {
+  if (lhs.Line != rhs.Line) {
     return lhs.Line < rhs.Line;
-    }
+  }
   return lhs.FilePath < rhs.FilePath;
 }
 
diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h
index 9fa8585..d72c360 100644
--- a/Source/cmListFileCache.h
+++ b/Source/cmListFileCache.h
@@ -29,30 +29,44 @@ struct cmCommandContext
 {
   std::string Name;
   long Line;
-  cmCommandContext(): Name(), Line(0) {}
+  cmCommandContext()
+    : Name()
+    , Line(0)
+  {
+  }
 };
 
 struct cmListFileArgument
 {
   enum Delimiter
-    {
+  {
     Unquoted,
     Quoted,
     Bracket
-    };
-  cmListFileArgument(): Value(), Delim(Unquoted), Line(0) {}
+  };
+  cmListFileArgument()
+    : Value()
+    , Delim(Unquoted)
+    , Line(0)
+  {
+  }
   cmListFileArgument(const cmListFileArgument& r)
-    : Value(r.Value), Delim(r.Delim), Line(r.Line) {}
+    : Value(r.Value)
+    , Delim(r.Delim)
+    , Line(r.Line)
+  {
+  }
   cmListFileArgument(const std::string& v, Delimiter d, long line)
-    : Value(v), Delim(d), Line(line) {}
-  bool operator == (const cmListFileArgument& r) const
-    {
+    : Value(v)
+    , Delim(d)
+    , Line(line)
+  {
+  }
+  bool operator==(const cmListFileArgument& r) const
+  {
     return (this->Value == r.Value) && (this->Delim == r.Delim);
-    }
-  bool operator != (const cmListFileArgument& r) const
-    {
-    return !(*this == r);
-    }
+  }
+  bool operator!=(const cmListFileArgument& r) const { return !(*this == r); }
   std::string Value;
   Delimiter Delim;
   long Line;
@@ -64,7 +78,12 @@ public:
   std::string Name;
   std::string FilePath;
   long Line;
-  cmListFileContext(): Name(), FilePath(), Line(0) {}
+  cmListFileContext()
+    : Name()
+    , FilePath()
+    , Line(0)
+  {
+  }
 
   static cmListFileContext FromCommandContext(cmCommandContext const& lfcc,
                                               std::string const& fileName)
@@ -82,7 +101,7 @@ bool operator<(const cmListFileContext& lhs, const cmListFileContext& rhs);
 bool operator==(cmListFileContext const& lhs, cmListFileContext const& rhs);
 bool operator!=(cmListFileContext const& lhs, cmListFileContext const& rhs);
 
-struct cmListFileFunction: public cmCommandContext
+struct cmListFileFunction : public cmCommandContext
 {
   std::vector<cmListFileArgument> Arguments;
 };
@@ -127,6 +146,7 @@ public:
 
   // Print the call stack below the top of the backtrace.
   void PrintCallStack(std::ostream& out) const;
+
 private:
   struct Entry;
   cmState::Snapshot Bottom;
@@ -138,9 +158,7 @@ private:
 
 struct cmListFile
 {
-  bool ParseFile(const char* path,
-                 bool topLevel,
-                 cmMakefile *mf);
+  bool ParseFile(const char* path, bool topLevel, cmMakefile* mf);
 
   std::vector<cmListFileFunction> Functions;
 };
diff --git a/Source/cmListFileLexer.h b/Source/cmListFileLexer.h
index bd2868a..88300e1 100644
--- a/Source/cmListFileLexer.h
+++ b/Source/cmListFileLexer.h
@@ -12,8 +12,7 @@
 #ifndef cmListFileLexer_h
 #define cmListFileLexer_h
 
-typedef enum cmListFileLexer_Type_e
-{
+typedef enum cmListFileLexer_Type_e {
   cmListFileLexer_Token_None,
   cmListFileLexer_Token_Space,
   cmListFileLexer_Token_Newline,
@@ -53,8 +52,7 @@ typedef enum cmListFileLexer_BOM_e cmListFileLexer_BOM;
 typedef struct cmListFileLexer_s cmListFileLexer;
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
 cmListFileLexer* cmListFileLexer_New();
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index 4865e56..85188d1 100644
--- a/Source/cmLoadCacheCommand.cxx
+++ b/Source/cmLoadCacheCommand.cxx
@@ -15,76 +15,63 @@
 #include <cmsys/RegularExpression.hxx>
 
 // cmLoadCacheCommand
-bool cmLoadCacheCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmLoadCacheCommand::InitialPass(std::vector<std::string> const& args,
+                                     cmExecutionStatus&)
 {
-  if (args.size()< 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with wrong number of arguments.");
-    }
+  }
 
-  if(args.size() >= 2 && args[1] == "READ_WITH_PREFIX")
-    {
+  if (args.size() >= 2 && args[1] == "READ_WITH_PREFIX") {
     return this->ReadWithPrefix(args);
-    }
+  }
 
   // Cache entries to be excluded from the import list.
   // If this set is empty, all cache entries are brought in
   // and they can not be overridden.
-  bool excludeFiles=false;
+  bool excludeFiles = false;
   unsigned int i;
   std::set<std::string> excludes;
 
-  for(i=0; i<args.size(); i++)
-    {
-    if (excludeFiles)
-      {
+  for (i = 0; i < args.size(); i++) {
+    if (excludeFiles) {
       excludes.insert(args[i]);
-      }
-    if (args[i] == "EXCLUDE")
-      {
-      excludeFiles=true;
-      }
-    if (excludeFiles && (args[i] == "INCLUDE_INTERNALS"))
-      {
+    }
+    if (args[i] == "EXCLUDE") {
+      excludeFiles = true;
+    }
+    if (excludeFiles && (args[i] == "INCLUDE_INTERNALS")) {
       break;
-      }
     }
+  }
 
   // Internal cache entries to be imported.
   // If this set is empty, no internal cache entries are
   // brought in.
-  bool includeFiles=false;
+  bool includeFiles = false;
   std::set<std::string> includes;
 
-  for(i=0; i<args.size(); i++)
-    {
-    if (includeFiles)
-      {
+  for (i = 0; i < args.size(); i++) {
+    if (includeFiles) {
       includes.insert(args[i]);
-      }
-    if (args[i] == "INCLUDE_INTERNALS")
-      {
-      includeFiles=true;
-      }
-    if (includeFiles && (args[i] == "EXCLUDE"))
-      {
+    }
+    if (args[i] == "INCLUDE_INTERNALS") {
+      includeFiles = true;
+    }
+    if (includeFiles && (args[i] == "EXCLUDE")) {
       break;
-      }
     }
+  }
 
   // Loop over each build directory listed in the arguments.  Each
   // directory has a cache file.
-  for(i=0; i<args.size(); i++)
-    {
-    if ((args[i] == "EXCLUDE") || (args[i] == "INCLUDE_INTERNALS"))
-      {
+  for (i = 0; i < args.size(); i++) {
+    if ((args[i] == "EXCLUDE") || (args[i] == "INCLUDE_INTERNALS")) {
       break;
-      }
-    this->Makefile->GetCMakeInstance()->LoadCache(args[i], false,
-                                                  excludes, includes);
     }
-
+    this->Makefile->GetCMakeInstance()->LoadCache(args[i], false, excludes,
+                                                  includes);
+  }
 
   return true;
 }
@@ -92,20 +79,18 @@ bool cmLoadCacheCommand
 bool cmLoadCacheCommand::ReadWithPrefix(std::vector<std::string> const& args)
 {
   // Make sure we have a prefix.
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     this->SetError("READ_WITH_PREFIX form must specify a prefix.");
     return false;
-    }
+  }
 
   // Make sure the cache file exists.
-  std::string cacheFile = args[0]+"/CMakeCache.txt";
-  if(!cmSystemTools::FileExists(cacheFile.c_str()))
-    {
+  std::string cacheFile = args[0] + "/CMakeCache.txt";
+  if (!cmSystemTools::FileExists(cacheFile.c_str())) {
     std::string e = "Cannot load cache file from " + cacheFile;
     this->SetError(e);
     return false;
-    }
+  }
 
   // Prepare the table of variables to read.
   this->Prefix = args[2];
@@ -120,47 +105,41 @@ bool cmLoadCacheCommand::ReadWithPrefix(std::vector<std::string> const& args)
   const int bufferSize = 4096;
   char buffer[bufferSize];
   std::string line;
-  while(fin)
-    {
+  while (fin) {
     // Read a block of the file.
     fin.read(buffer, bufferSize);
-    if(fin.gcount())
-      {
+    if (fin.gcount()) {
       // Parse for newlines directly.
       const char* i = buffer;
-      const char* end = buffer+fin.gcount();
-      while(i != end)
-        {
+      const char* end = buffer + fin.gcount();
+      while (i != end) {
         const char* begin = i;
-        while(i != end && *i != '\n') { ++i; }
-        if(i == begin || *(i-1) != '\r')
-          {
+        while (i != end && *i != '\n') {
+          ++i;
+        }
+        if (i == begin || *(i - 1) != '\r') {
           // Include this portion of the line.
-          line += std::string(begin, i-begin);
-          }
-        else
-          {
+          line += std::string(begin, i - begin);
+        } else {
           // Include this portion of the line.
           // Don't include the \r in a \r\n pair.
-          line += std::string(begin, i-1-begin);
-          }
-        if(i != end)
-          {
+          line += std::string(begin, i - 1 - begin);
+        }
+        if (i != end) {
           // Completed a line.
           this->CheckLine(line.c_str());
           line = "";
 
           // Skip the newline character.
           ++i;
-          }
         }
       }
     }
-  if(!line.empty())
-    {
+  }
+  if (!line.empty()) {
     // Partial last line.
     this->CheckLine(line.c_str());
-    }
+  }
 
   return true;
 }
@@ -171,22 +150,17 @@ void cmLoadCacheCommand::CheckLine(const char* line)
   std::string var;
   std::string value;
   cmState::CacheEntryType type = cmState::UNINITIALIZED;
-  if(cmake::ParseCacheEntry(line, var, value, type))
-    {
+  if (cmake::ParseCacheEntry(line, var, value, type)) {
     // Found a real entry.  See if this one was requested.
-    if(this->VariablesToRead.find(var) != this->VariablesToRead.end())
-      {
+    if (this->VariablesToRead.find(var) != this->VariablesToRead.end()) {
       // This was requested.  Set this variable locally with the given
       // prefix.
       var = this->Prefix + var;
-      if(!value.empty())
-        {
+      if (!value.empty()) {
         this->Makefile->AddDefinition(var, value.c_str());
-        }
-      else
-        {
+      } else {
         this->Makefile->RemoveDefinition(var);
-        }
       }
     }
+  }
 }
diff --git a/Source/cmLoadCacheCommand.h b/Source/cmLoadCacheCommand.h
index 04207d0..67d93ac 100644
--- a/Source/cmLoadCacheCommand.h
+++ b/Source/cmLoadCacheCommand.h
@@ -25,26 +25,23 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmLoadCacheCommand;
-    }
+  virtual cmCommand* Clone() { return new cmLoadCacheCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "load_cache";}
+  virtual std::string GetName() const { return "load_cache"; }
 
   cmTypeMacro(cmLoadCacheCommand, cmCommand);
-protected:
 
+protected:
   std::set<std::string> VariablesToRead;
   std::string Prefix;
 
@@ -52,5 +49,4 @@ protected:
   void CheckLine(const char* line);
 };
 
-
 #endif
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index 14b70e4..081c22e 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -20,19 +20,19 @@
 #include <stdlib.h>
 
 #ifdef __QNX__
-# include <malloc.h> /* for malloc/free on QNX */
+#include <malloc.h> /* for malloc/free on QNX */
 #endif
 
 #include <signal.h>
 extern "C" void TrapsForSignalsCFunction(int sig);
 
-
 // a class for loadabple commands
 class cmLoadedCommand : public cmCommand
 {
 public:
-  cmLoadedCommand() {
-    memset(&this->info,0,sizeof(this->info));
+  cmLoadedCommand()
+  {
+    memset(&this->info, 0, sizeof(this->info));
     this->info.CAPI = &cmStaticCAPI;
   }
 
@@ -43,19 +43,19 @@ public:
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
-    {
-      cmLoadedCommand *newC = new cmLoadedCommand;
-      // we must copy when we clone
-      memcpy(&newC->info,&this->info,sizeof(info));
-      return newC;
-    }
+  {
+    cmLoadedCommand* newC = new cmLoadedCommand;
+    // we must copy when we clone
+    memcpy(&newC->info, &this->info, sizeof(info));
+    return newC;
+  }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &);
+                           cmExecutionStatus&);
 
   /**
    * This is called at the end after all the information
@@ -65,7 +65,9 @@ public:
    */
   virtual void FinalPass();
   virtual bool HasFinalPass() const
-    { return this->info.FinalPass? true:false; }
+  {
+    return this->info.FinalPass ? true : false;
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
@@ -74,35 +76,31 @@ public:
 
   static const char* LastName;
   static void TrapsForSignals(int sig)
-    {
-      fprintf(stderr, "CMake loaded command %s crashed with signal: %d.\n",
-              cmLoadedCommand::LastName, sig);
-    }
+  {
+    fprintf(stderr, "CMake loaded command %s crashed with signal: %d.\n",
+            cmLoadedCommand::LastName, sig);
+  }
   static void InstallSignalHandlers(const char* name, int remove = 0)
-    {
-      cmLoadedCommand::LastName = name;
-      if(!name)
-        {
-        cmLoadedCommand::LastName = "????";
-        }
-
-      if(!remove)
-        {
-        signal(SIGSEGV, TrapsForSignalsCFunction);
+  {
+    cmLoadedCommand::LastName = name;
+    if (!name) {
+      cmLoadedCommand::LastName = "????";
+    }
+
+    if (!remove) {
+      signal(SIGSEGV, TrapsForSignalsCFunction);
 #ifdef SIGBUS
-        signal(SIGBUS,  TrapsForSignalsCFunction);
+      signal(SIGBUS, TrapsForSignalsCFunction);
 #endif
-        signal(SIGILL,  TrapsForSignalsCFunction);
-        }
-      else
-        {
-        signal(SIGSEGV, 0);
+      signal(SIGILL, TrapsForSignalsCFunction);
+    } else {
+      signal(SIGSEGV, 0);
 #ifdef SIGBUS
-        signal(SIGBUS,  0);
+      signal(SIGBUS, 0);
 #endif
-        signal(SIGILL,  0);
-        }
+      signal(SIGILL, 0);
     }
+  }
 
   cmTypeMacro(cmLoadedCommand, cmCommand);
 
@@ -114,89 +112,80 @@ extern "C" void TrapsForSignalsCFunction(int sig)
   cmLoadedCommand::TrapsForSignals(sig);
 }
 
-
 const char* cmLoadedCommand::LastName = 0;
 
 bool cmLoadedCommand::InitialPass(std::vector<std::string> const& args,
-                                  cmExecutionStatus &)
+                                  cmExecutionStatus&)
 {
-  if (!info.InitialPass)
-    {
+  if (!info.InitialPass) {
     return true;
-    }
+  }
 
   // clear the error string
-  if (this->info.Error)
-    {
+  if (this->info.Error) {
     free(this->info.Error);
-    }
+  }
 
   // create argc and argv and then invoke the command
-  int argc = static_cast<int> (args.size());
-  char **argv = 0;
-  if (argc)
-    {
-    argv = (char **)malloc(argc*sizeof(char *));
-    }
+  int argc = static_cast<int>(args.size());
+  char** argv = 0;
+  if (argc) {
+    argv = (char**)malloc(argc * sizeof(char*));
+  }
   int i;
-  for (i = 0; i < argc; ++i)
-    {
+  for (i = 0; i < argc; ++i) {
     argv[i] = strdup(args[i].c_str());
-    }
+  }
   cmLoadedCommand::InstallSignalHandlers(info.Name);
-  int result = info.InitialPass((void *)&info,
-                                (void *)this->Makefile,argc,argv);
+  int result =
+    info.InitialPass((void*)&info, (void*)this->Makefile, argc, argv);
   cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
-  cmFreeArguments(argc,argv);
+  cmFreeArguments(argc, argv);
 
-  if (result)
-    {
+  if (result) {
     return true;
-    }
+  }
 
   /* Initial Pass must have failed so set the error string */
-  if (this->info.Error)
-    {
+  if (this->info.Error) {
     this->SetError(this->info.Error);
-    }
+  }
   return false;
 }
 
 void cmLoadedCommand::FinalPass()
 {
-  if (this->info.FinalPass)
-    {
+  if (this->info.FinalPass) {
     cmLoadedCommand::InstallSignalHandlers(info.Name);
-    this->info.FinalPass((void *)&this->info,(void *)this->Makefile);
+    this->info.FinalPass((void*)&this->info, (void*)this->Makefile);
     cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
-    }
+  }
 }
 
 cmLoadedCommand::~cmLoadedCommand()
 {
-  if (this->info.Destructor)
-    {
+  if (this->info.Destructor) {
     cmLoadedCommand::InstallSignalHandlers(info.Name);
-    this->info.Destructor((void *)&this->info);
+    this->info.Destructor((void*)&this->info);
     cmLoadedCommand::InstallSignalHandlers(info.Name, 1);
-    }
-  if (this->info.Error)
-    {
+  }
+  if (this->info.Error) {
     free(this->info.Error);
-    }
+  }
 }
 
 // cmLoadCommandCommand
-bool cmLoadCommandCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0031,
-      "The load_command command should not be called; see CMP0031."))
-    { return true; }
-  if(args.size() < 1 )
-    {
+  if (this->Disallowed(
+        cmPolicies::CMP0031,
+        "The load_command command should not be called; see CMP0031.")) {
     return true;
-    }
+  }
+  if (args.size() < 1) {
+    return true;
+  }
 
   // Construct a variable to report what file was loaded, if any.
   // Start by removing the definition in case of failure.
@@ -213,72 +202,64 @@ bool cmLoadCommandCommand
 
   // search for the file
   std::vector<std::string> path;
-  for (unsigned int j = 1; j < args.size(); j++)
-    {
+  for (unsigned int j = 1; j < args.size(); j++) {
     // expand variables
     std::string exp = args[j];
     cmSystemTools::ExpandRegistryValues(exp);
 
     // Glob the entry in case of wildcards.
     cmSystemTools::GlobDirs(exp, path);
-    }
+  }
 
   // Try to find the program.
   std::string fullPath = cmSystemTools::FindFile(moduleName.c_str(), path);
-  if (fullPath == "")
-    {
+  if (fullPath == "") {
     std::ostringstream e;
-    e << "Attempt to load command failed from file \""
-      << moduleName << "\"";
+    e << "Attempt to load command failed from file \"" << moduleName << "\"";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // try loading the shared library / dll
-  cmsys::DynamicLoader::LibraryHandle lib
-    = cmDynamicLoader::OpenLibrary(fullPath.c_str());
-  if(!lib)
-    {
+  cmsys::DynamicLoader::LibraryHandle lib =
+    cmDynamicLoader::OpenLibrary(fullPath.c_str());
+  if (!lib) {
     std::string err = "Attempt to load the library ";
     err += fullPath + " failed.";
     const char* error = cmsys::DynamicLoader::LastError();
-    if ( error )
-      {
+    if (error) {
       err += " Additional error info is:\n";
       err += error;
-      }
+    }
     this->SetError(err);
     return false;
-    }
+  }
 
   // Report what file was loaded for this command.
   this->Makefile->AddDefinition(reportVar, fullPath.c_str());
 
   // find the init function
   std::string initFuncName = args[0] + "Init";
-  CM_INIT_FUNCTION initFunction
-    = (CM_INIT_FUNCTION)
-    cmsys::DynamicLoader::GetSymbolAddress(lib, initFuncName.c_str());
-  if ( !initFunction )
-    {
+  CM_INIT_FUNCTION initFunction =
+    (CM_INIT_FUNCTION)cmsys::DynamicLoader::GetSymbolAddress(
+      lib, initFuncName.c_str());
+  if (!initFunction) {
     initFuncName = "_";
     initFuncName += args[0];
     initFuncName += "Init";
     initFunction = (CM_INIT_FUNCTION)(
       cmsys::DynamicLoader::GetSymbolAddress(lib, initFuncName.c_str()));
-    }
+  }
   // if the symbol is found call it to set the name on the
   // function blocker
-  if(initFunction)
-    {
+  if (initFunction) {
     // create a function blocker and set it up
-    cmLoadedCommand *f = new cmLoadedCommand();
+    cmLoadedCommand* f = new cmLoadedCommand();
     (*initFunction)(&f->info);
     this->Makefile->GetState()->AddCommand(f);
     return true;
-    }
+  }
   this->SetError("Attempt to load command failed. "
                  "No init function found.");
   return false;
 }
-
diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h
index 445e167..e00a01e 100644
--- a/Source/cmLoadCommandCommand.h
+++ b/Source/cmLoadCommandCommand.h
@@ -19,11 +19,9 @@ class cmLoadCommandCommand : public cmCommand
 public:
   virtual cmCommand* Clone() { return new cmLoadCommandCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const {return "load_command";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "load_command"; }
   cmTypeMacro(cmLoadCommandCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmLocalCommonGenerator.cxx b/Source/cmLocalCommonGenerator.cxx
index 5a18e2f..3ebd128 100644
--- a/Source/cmLocalCommonGenerator.cxx
+++ b/Source/cmLocalCommonGenerator.cxx
@@ -14,8 +14,8 @@
 #include "cmMakefile.h"
 
 cmLocalCommonGenerator::cmLocalCommonGenerator(cmGlobalGenerator* gg,
-                                               cmMakefile* mf):
-  cmLocalGenerator(gg, mf)
+                                               cmMakefile* mf)
+  : cmLocalGenerator(gg, mf)
 {
 }
 
@@ -26,14 +26,11 @@ cmLocalCommonGenerator::~cmLocalCommonGenerator()
 void cmLocalCommonGenerator::SetConfigName()
 {
   // Store the configuration name that will be generated.
-  if(const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE"))
-    {
+  if (const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE")) {
     // Use the build type given by the user.
     this->ConfigName = config;
-    }
-  else
-    {
+  } else {
     // No configuration type given.
     this->ConfigName = "";
-    }
+  }
 }
diff --git a/Source/cmLocalCommonGenerator.h b/Source/cmLocalCommonGenerator.h
index 6b4b1cd..d282054 100644
--- a/Source/cmLocalCommonGenerator.h
+++ b/Source/cmLocalCommonGenerator.h
@@ -19,7 +19,7 @@ class cmCommonTargetGenerator;
 /** \class cmLocalCommonGenerator
  * \brief Common infrastructure for Makefile and Ninja local generators.
  */
-class cmLocalCommonGenerator: public cmLocalGenerator
+class cmLocalCommonGenerator : public cmLocalGenerator
 {
 public:
   cmLocalCommonGenerator(cmGlobalGenerator* gg, cmMakefile* mf);
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 8d985b1..0ff13d9 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -29,8 +29,8 @@
 #include "cmake.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# define CM_LG_ENCODE_OBJECT_NAMES
-# include <cmsys/MD5.h>
+#define CM_LG_ENCODE_OBJECT_NAMES
+#include <cmsys/MD5.h>
 #endif
 
 #include <ctype.h> // for isalpha
@@ -42,10 +42,9 @@
 #include <StorageDefs.h>
 #endif
 
-cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg,
-                                   cmMakefile* makefile)
-  : cmOutputConverter(makefile->GetStateSnapshot()),
-    StateSnapshot(makefile->GetStateSnapshot())
+cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, cmMakefile* makefile)
+  : cmOutputConverter(makefile->GetStateSnapshot())
+  , StateSnapshot(makefile->GetStateSnapshot())
 {
   this->GlobalGenerator = gg;
 
@@ -74,40 +73,33 @@ void cmLocalGenerator::IssueMessage(cmake::MessageType t,
 
 void cmLocalGenerator::ComputeObjectMaxPath()
 {
-  // Choose a maximum object file name length.
+// Choose a maximum object file name length.
 #if defined(_WIN32) || defined(__CYGWIN__)
   this->ObjectPathMax = 250;
 #else
   this->ObjectPathMax = 1000;
 #endif
   const char* plen = this->Makefile->GetDefinition("CMAKE_OBJECT_PATH_MAX");
-  if(plen && *plen)
-    {
+  if (plen && *plen) {
     unsigned int pmax;
-    if(sscanf(plen, "%u", &pmax) == 1)
-      {
-      if(pmax >= 128)
-        {
+    if (sscanf(plen, "%u", &pmax) == 1) {
+      if (pmax >= 128) {
         this->ObjectPathMax = pmax;
-        }
-      else
-        {
+      } else {
         std::ostringstream w;
         w << "CMAKE_OBJECT_PATH_MAX is set to " << pmax
           << ", which is less than the minimum of 128.  "
           << "The value will be ignored.";
         this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream w;
       w << "CMAKE_OBJECT_PATH_MAX is set to \"" << plen
         << "\", which fails to parse as a positive integer.  "
         << "The value will be ignored.";
       this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-      }
     }
+  }
   this->ObjectMaxPathViolations.clear();
 }
 
@@ -115,42 +107,36 @@ void cmLocalGenerator::TraceDependencies()
 {
   std::vector<std::string> configs;
   this->Makefile->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) {
     this->GlobalGenerator->CreateEvaluationSourceFiles(*ci);
-    }
+  }
   // Generate the rule files for each target.
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
-    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
+    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
-    (*t)->TraceDependencies();
     }
+    (*t)->TraceDependencies();
+  }
 }
 
 void cmLocalGenerator::GenerateTestFiles()
 {
-  if ( !this->Makefile->IsOn("CMAKE_TESTING_ENABLED") )
-    {
+  if (!this->Makefile->IsOn("CMAKE_TESTING_ENABLED")) {
     return;
-    }
+  }
 
   // Compute the set of configurations.
   std::vector<std::string> configurationTypes;
   const std::string& config =
     this->Makefile->GetConfigurations(configurationTypes, false);
 
-  std::string file =
-      this->StateSnapshot.GetDirectory().GetCurrentBinary();
+  std::string file = this->StateSnapshot.GetDirectory().GetCurrentBinary();
   file += "/";
   file += "CTestTestfile.cmake";
 
@@ -159,11 +145,9 @@ void cmLocalGenerator::GenerateTestFiles()
 
   fout << "# CMake generated Testfile for " << std::endl
        << "# Source directory: "
-       << this->StateSnapshot.GetDirectory().GetCurrentSource()
-       << std::endl
+       << this->StateSnapshot.GetDirectory().GetCurrentSource() << std::endl
        << "# Build directory: "
-       << this->StateSnapshot.GetDirectory().GetCurrentBinary()
-       << std::endl
+       << this->StateSnapshot.GetDirectory().GetCurrentBinary() << std::endl
        << "# " << std::endl
        << "# This file includes the relevant testing commands "
        << "required for " << std::endl
@@ -172,78 +156,72 @@ void cmLocalGenerator::GenerateTestFiles()
 
   const char* testIncludeFile =
     this->Makefile->GetProperty("TEST_INCLUDE_FILE");
-  if ( testIncludeFile )
-    {
+  if (testIncludeFile) {
     fout << "include(\"" << testIncludeFile << "\")" << std::endl;
-    }
+  }
 
   // Ask each test generator to write its code.
-  std::vector<cmTestGenerator*> const&
-    testers = this->Makefile->GetTestGenerators();
-  for(std::vector<cmTestGenerator*>::const_iterator gi = testers.begin();
-      gi != testers.end(); ++gi)
-    {
+  std::vector<cmTestGenerator*> const& testers =
+    this->Makefile->GetTestGenerators();
+  for (std::vector<cmTestGenerator*>::const_iterator gi = testers.begin();
+       gi != testers.end(); ++gi) {
     (*gi)->Compute(this);
     (*gi)->Generate(fout, config, configurationTypes);
-    }
+  }
   size_t i;
-  std::vector<cmState::Snapshot> children
-      = this->Makefile->GetStateSnapshot().GetChildren();
-  for(i = 0; i < children.size(); ++i)
-    {
+  std::vector<cmState::Snapshot> children =
+    this->Makefile->GetStateSnapshot().GetChildren();
+  for (i = 0; i < children.size(); ++i) {
     // TODO: Use add_subdirectory instead?
     fout << "subdirs(";
     std::string outP = children[i].GetDirectory().GetCurrentBinary();
-    fout << this->Convert(outP,START_OUTPUT);
+    fout << this->Convert(outP, START_OUTPUT);
     fout << ")" << std::endl;
-    }
+  }
 }
 
 void cmLocalGenerator::CreateEvaluationFileOutputs(std::string const& config)
 {
   std::vector<cmGeneratorExpressionEvaluationFile*> ef =
-      this->Makefile->GetEvaluationFiles();
-  for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
-      li = ef.begin(); li != ef.end(); ++li)
-    {
+    this->Makefile->GetEvaluationFiles();
+  for (std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator li =
+         ef.begin();
+       li != ef.end(); ++li) {
     (*li)->CreateOutputFile(this, config);
-    }
+  }
 }
 
 void cmLocalGenerator::ProcessEvaluationFiles(
-    std::vector<std::string>& generatedFiles)
+  std::vector<std::string>& generatedFiles)
 {
   std::vector<cmGeneratorExpressionEvaluationFile*> ef =
-      this->Makefile->GetEvaluationFiles();
-  for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
-      li = ef.begin();
-      li != ef.end();
-      ++li)
-    {
+    this->Makefile->GetEvaluationFiles();
+  for (std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator li =
+         ef.begin();
+       li != ef.end(); ++li) {
     (*li)->Generate(this);
-    if (cmSystemTools::GetFatalErrorOccured())
-      {
+    if (cmSystemTools::GetFatalErrorOccured()) {
       return;
-      }
+    }
     std::vector<std::string> files = (*li)->GetFiles();
     std::sort(files.begin(), files.end());
 
     std::vector<std::string> intersection;
-    std::set_intersection(files.begin(), files.end(),
-                          generatedFiles.begin(), generatedFiles.end(),
+    std::set_intersection(files.begin(), files.end(), generatedFiles.begin(),
+                          generatedFiles.end(),
                           std::back_inserter(intersection));
-    if (!intersection.empty())
-      {
+    if (!intersection.empty()) {
       cmSystemTools::Error("Files to be generated by multiple different "
-        "commands: ", cmWrap('"', intersection, '"', " ").c_str());
+                           "commands: ",
+                           cmWrap('"', intersection, '"', " ").c_str());
       return;
-      }
+    }
 
     generatedFiles.insert(generatedFiles.end(), files.begin(), files.end());
     std::vector<std::string>::iterator newIt =
-        generatedFiles.end() - files.size();
+      generatedFiles.end() - files.size();
     std::inplace_merge(generatedFiles.begin(), newIt, generatedFiles.end());
-    }
+  }
 }
 
 void cmLocalGenerator::GenerateInstallRules()
@@ -252,49 +230,38 @@ void cmLocalGenerator::GenerateInstallRules()
   const char* prefix = this->Makefile->GetDefinition("CMAKE_INSTALL_PREFIX");
 #if defined(_WIN32) && !defined(__CYGWIN__)
   std::string prefix_win32;
-  if(!prefix)
-    {
-    if(!cmSystemTools::GetEnv("SystemDrive", prefix_win32))
-      {
+  if (!prefix) {
+    if (!cmSystemTools::GetEnv("SystemDrive", prefix_win32)) {
       prefix_win32 = "C:";
-      }
+    }
     const char* project_name = this->Makefile->GetDefinition("PROJECT_NAME");
-    if(project_name && project_name[0])
-      {
+    if (project_name && project_name[0]) {
       prefix_win32 += "/Program Files/";
       prefix_win32 += project_name;
-      }
-    else
-      {
+    } else {
       prefix_win32 += "/InstalledCMakeProject";
-      }
-    prefix = prefix_win32.c_str();
     }
+    prefix = prefix_win32.c_str();
+  }
 #elif defined(__HAIKU__)
   char dir[B_PATH_NAME_LENGTH];
-  if (!prefix)
-    {
-    if (find_directory(B_SYSTEM_DIRECTORY, -1, false, dir, sizeof(dir))
-        == B_OK)
-      {
+  if (!prefix) {
+    if (find_directory(B_SYSTEM_DIRECTORY, -1, false, dir, sizeof(dir)) ==
+        B_OK) {
       prefix = dir;
-      }
-    else
-      {
+    } else {
       prefix = "/boot/system";
-      }
     }
+  }
 #else
-  if (!prefix)
-    {
+  if (!prefix) {
     prefix = "/usr/local";
-    }
+  }
 #endif
-  if (const char *stagingPrefix
-                  = this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX"))
-    {
+  if (const char* stagingPrefix =
+        this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX")) {
     prefix = stagingPrefix;
-    }
+  }
 
   // Compute the set of configurations.
   std::vector<std::string> configurationTypes;
@@ -303,41 +270,35 @@ void cmLocalGenerator::GenerateInstallRules()
 
   // Choose a default install configuration.
   std::string default_config = config;
-  const char* default_order[] = {"RELEASE", "MINSIZEREL",
-                                 "RELWITHDEBINFO", "DEBUG", 0};
-  for(const char** c = default_order; *c && default_config.empty(); ++c)
-    {
-    for(std::vector<std::string>::iterator i = configurationTypes.begin();
-        i != configurationTypes.end(); ++i)
-      {
-      if(cmSystemTools::UpperCase(*i) == *c)
-        {
+  const char* default_order[] = { "RELEASE", "MINSIZEREL", "RELWITHDEBINFO",
+                                  "DEBUG", 0 };
+  for (const char** c = default_order; *c && default_config.empty(); ++c) {
+    for (std::vector<std::string>::iterator i = configurationTypes.begin();
+         i != configurationTypes.end(); ++i) {
+      if (cmSystemTools::UpperCase(*i) == *c) {
         default_config = *i;
-        }
       }
     }
-  if(default_config.empty() && !configurationTypes.empty())
-    {
+  }
+  if (default_config.empty() && !configurationTypes.empty()) {
     default_config = configurationTypes[0];
-    }
+  }
 
   // Create the install script file.
-  std::string file =
-      this->StateSnapshot.GetDirectory().GetCurrentBinary();
+  std::string file = this->StateSnapshot.GetDirectory().GetCurrentBinary();
   std::string homedir = this->GetState()->GetBinaryDirectory();
   int toplevel_install = 0;
-  if (file == homedir)
-    {
+  if (file == homedir) {
     toplevel_install = 1;
-    }
+  }
   file += "/cmake_install.cmake";
   cmGeneratedFileStream fout(file.c_str());
   fout.SetCopyIfDifferent(true);
 
   // Write the header.
   fout << "# Install script for directory: "
-       << this->StateSnapshot.GetDirectory().GetCurrentSource()
-       << std::endl << std::endl;
+       << this->StateSnapshot.GetDirectory().GetCurrentSource() << std::endl
+       << std::endl;
   fout << "# Set the install prefix" << std::endl
        << "if(NOT DEFINED CMAKE_INSTALL_PREFIX)" << std::endl
        << "  set(CMAKE_INSTALL_PREFIX \"" << prefix << "\")" << std::endl
@@ -379,9 +340,8 @@ void cmLocalGenerator::GenerateInstallRules()
   /* clang-format on */
 
   // Copy user-specified install options to the install code.
-  if(const char* so_no_exe =
-     this->Makefile->GetDefinition("CMAKE_INSTALL_SO_NO_EXE"))
-    {
+  if (const char* so_no_exe =
+        this->Makefile->GetDefinition("CMAKE_INSTALL_SO_NO_EXE")) {
     /* clang-format off */
     fout <<
       "# Install shared libraries without execute permission?\n"
@@ -390,46 +350,41 @@ void cmLocalGenerator::GenerateInstallRules()
       "endif()\n"
       "\n";
     /* clang-format on */
-    }
+  }
 
   // Ask each install generator to write its code.
   std::vector<cmInstallGenerator*> const& installers =
     this->Makefile->GetInstallGenerators();
-  for(std::vector<cmInstallGenerator*>::const_iterator
-        gi = installers.begin();
-      gi != installers.end(); ++gi)
-    {
+  for (std::vector<cmInstallGenerator*>::const_iterator gi =
+         installers.begin();
+       gi != installers.end(); ++gi) {
     (*gi)->Generate(fout, config, configurationTypes);
-    }
+  }
 
   // Write rules from old-style specification stored in targets.
   this->GenerateTargetInstallRules(fout, config, configurationTypes);
 
   // Include install scripts from subdirectories.
-  std::vector<cmState::Snapshot> children
-      = this->Makefile->GetStateSnapshot().GetChildren();
-  if(!children.empty())
-    {
+  std::vector<cmState::Snapshot> children =
+    this->Makefile->GetStateSnapshot().GetChildren();
+  if (!children.empty()) {
     fout << "if(NOT CMAKE_INSTALL_LOCAL_ONLY)\n";
     fout << "  # Include the install script for each subdirectory.\n";
-    for(std::vector<cmState::Snapshot>::const_iterator
-          ci = children.begin(); ci != children.end(); ++ci)
-      {
-      if(!ci->GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL"))
-        {
+    for (std::vector<cmState::Snapshot>::const_iterator ci = children.begin();
+         ci != children.end(); ++ci) {
+      if (!ci->GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
         std::string odir = ci->GetDirectory().GetCurrentBinary();
         cmSystemTools::ConvertToUnixSlashes(odir);
-        fout << "  include(\"" <<  odir
-             << "/cmake_install.cmake\")" << std::endl;
-        }
+        fout << "  include(\"" << odir << "/cmake_install.cmake\")"
+             << std::endl;
       }
+    }
     fout << "\n";
     fout << "endif()\n\n";
-    }
+  }
 
   // Record the install manifest.
-  if ( toplevel_install )
-    {
+  if (toplevel_install) {
     /* clang-format off */
     fout <<
       "if(CMAKE_INSTALL_COMPONENT)\n"
@@ -444,10 +399,9 @@ void cmLocalGenerator::GenerateInstallRules()
       "file(WRITE \"" << homedir << "/${CMAKE_INSTALL_MANIFEST}\"\n"
       "     \"${CMAKE_INSTALL_MANIFEST_CONTENT}\")\n";
     /* clang-format on */
-    }
+  }
 }
 
-
 void cmLocalGenerator::AddGeneratorTarget(cmGeneratorTarget* gt)
 {
   this->GeneratorTargets.push_back(gt);
@@ -470,28 +424,26 @@ struct NamedGeneratorTargetFinder
   NamedGeneratorTargetFinder(std::string const& name)
     : Name(name)
   {
-
   }
 
   bool operator()(cmGeneratorTarget* tgt)
   {
     return tgt->GetName() == this->Name;
   }
+
 private:
   std::string Name;
 };
 
 cmGeneratorTarget* cmLocalGenerator::FindLocalNonAliasGeneratorTarget(
-    const std::string& name) const
+  const std::string& name) const
 {
   std::vector<cmGeneratorTarget*>::const_iterator ti =
-      std::find_if(this->GeneratorTargets.begin(),
-                   this->GeneratorTargets.end(),
-                   NamedGeneratorTargetFinder(name));
-  if ( ti != this->GeneratorTargets.end() )
-    {
+    std::find_if(this->GeneratorTargets.begin(), this->GeneratorTargets.end(),
+                 NamedGeneratorTargetFinder(name));
+  if (ti != this->GeneratorTargets.end()) {
     return *ti;
-    }
+  }
   return 0;
 }
 
@@ -500,28 +452,24 @@ void cmLocalGenerator::ComputeTargetManifest()
   // Collect the set of configuration types.
   std::vector<std::string> configNames;
   this->Makefile->GetConfigurations(configNames);
-  if(configNames.empty())
-    {
+  if (configNames.empty()) {
     configNames.push_back("");
-    }
+  }
 
   // Add our targets to the manifest for each configuration.
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
     cmGeneratorTarget* target = *t;
-    if (target->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (target->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
-    for(std::vector<std::string>::iterator ci = configNames.begin();
-        ci != configNames.end(); ++ci)
-      {
+    }
+    for (std::vector<std::string>::iterator ci = configNames.begin();
+         ci != configNames.end(); ++ci) {
       const char* config = ci->c_str();
       target->ComputeTargetManifest(config);
-      }
     }
+  }
 }
 
 bool cmLocalGenerator::IsRootMakefile() const
@@ -544,8 +492,7 @@ cmState::Snapshot cmLocalGenerator::GetStateSnapshot() const
 // replaced in the form <var> with GetSafeDefinition(var).
 // ${LANG} is replaced in the variable first with all enabled
 // languages.
-static const char* ruleReplaceVars[] =
-{
+static const char* ruleReplaceVars[] = {
   "CMAKE_${LANG}_COMPILER",
   "CMAKE_SHARED_LIBRARY_CREATE_${LANG}_FLAGS",
   "CMAKE_SHARED_MODULE_CREATE_${LANG}_FLAGS",
@@ -563,266 +510,195 @@ static const char* ruleReplaceVars[] =
   0
 };
 
-std::string
-cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
-                                     const RuleVariables& replaceValues)
+std::string cmLocalGenerator::ExpandRuleVariable(
+  std::string const& variable, const RuleVariables& replaceValues)
 {
-  if(replaceValues.LinkFlags)
-    {
-    if(variable == "LINK_FLAGS")
-      {
+  if (replaceValues.LinkFlags) {
+    if (variable == "LINK_FLAGS") {
       return replaceValues.LinkFlags;
-      }
     }
-  if(replaceValues.Manifests)
-    {
-    if(variable == "MANIFESTS")
-      {
+  }
+  if (replaceValues.Manifests) {
+    if (variable == "MANIFESTS") {
       return replaceValues.Manifests;
-      }
     }
-  if(replaceValues.Flags)
-    {
-    if(variable == "FLAGS")
-      {
+  }
+  if (replaceValues.Flags) {
+    if (variable == "FLAGS") {
       return replaceValues.Flags;
-      }
     }
+  }
 
-  if(replaceValues.Source)
-    {
-    if(variable == "SOURCE")
-      {
+  if (replaceValues.Source) {
+    if (variable == "SOURCE") {
       return replaceValues.Source;
-      }
     }
-  if(replaceValues.PreprocessedSource)
-    {
-    if(variable == "PREPROCESSED_SOURCE")
-      {
+  }
+  if (replaceValues.PreprocessedSource) {
+    if (variable == "PREPROCESSED_SOURCE") {
       return replaceValues.PreprocessedSource;
-      }
     }
-  if(replaceValues.AssemblySource)
-    {
-    if(variable == "ASSEMBLY_SOURCE")
-      {
+  }
+  if (replaceValues.AssemblySource) {
+    if (variable == "ASSEMBLY_SOURCE") {
       return replaceValues.AssemblySource;
-      }
     }
-  if(replaceValues.Object)
-    {
-    if(variable == "OBJECT")
-      {
+  }
+  if (replaceValues.Object) {
+    if (variable == "OBJECT") {
       return replaceValues.Object;
-      }
     }
-  if(replaceValues.ObjectDir)
-    {
-    if(variable == "OBJECT_DIR")
-      {
+  }
+  if (replaceValues.ObjectDir) {
+    if (variable == "OBJECT_DIR") {
       return replaceValues.ObjectDir;
-      }
     }
-  if(replaceValues.ObjectFileDir)
-    {
-    if(variable == "OBJECT_FILE_DIR")
-      {
+  }
+  if (replaceValues.ObjectFileDir) {
+    if (variable == "OBJECT_FILE_DIR") {
       return replaceValues.ObjectFileDir;
-      }
     }
-  if(replaceValues.Objects)
-    {
-    if(variable == "OBJECTS")
-      {
+  }
+  if (replaceValues.Objects) {
+    if (variable == "OBJECTS") {
       return replaceValues.Objects;
-      }
     }
-  if(replaceValues.ObjectsQuoted)
-    {
-    if(variable == "OBJECTS_QUOTED")
-      {
+  }
+  if (replaceValues.ObjectsQuoted) {
+    if (variable == "OBJECTS_QUOTED") {
       return replaceValues.ObjectsQuoted;
-      }
     }
-  if(replaceValues.Defines && variable == "DEFINES")
-    {
+  }
+  if (replaceValues.Defines && variable == "DEFINES") {
     return replaceValues.Defines;
-    }
-  if(replaceValues.Includes && variable == "INCLUDES")
-    {
+  }
+  if (replaceValues.Includes && variable == "INCLUDES") {
     return replaceValues.Includes;
-    }
-  if(replaceValues.TargetPDB )
-    {
-    if(variable == "TARGET_PDB")
-      {
+  }
+  if (replaceValues.TargetPDB) {
+    if (variable == "TARGET_PDB") {
       return replaceValues.TargetPDB;
-      }
     }
-  if(replaceValues.TargetCompilePDB)
-    {
-    if(variable == "TARGET_COMPILE_PDB")
-      {
+  }
+  if (replaceValues.TargetCompilePDB) {
+    if (variable == "TARGET_COMPILE_PDB") {
       return replaceValues.TargetCompilePDB;
-      }
     }
-  if(replaceValues.DependencyFile )
-    {
-    if(variable == "DEP_FILE")
-      {
+  }
+  if (replaceValues.DependencyFile) {
+    if (variable == "DEP_FILE") {
       return replaceValues.DependencyFile;
-      }
     }
+  }
 
-  if(replaceValues.Target)
-    {
-    if(variable == "TARGET_QUOTED")
-      {
+  if (replaceValues.Target) {
+    if (variable == "TARGET_QUOTED") {
       std::string targetQuoted = replaceValues.Target;
-      if(!targetQuoted.empty() && targetQuoted[0] != '\"')
-        {
+      if (!targetQuoted.empty() && targetQuoted[0] != '\"') {
         targetQuoted = '\"';
         targetQuoted += replaceValues.Target;
         targetQuoted += '\"';
-        }
-      return targetQuoted;
       }
-    if(variable == "TARGET_UNQUOTED")
-      {
+      return targetQuoted;
+    }
+    if (variable == "TARGET_UNQUOTED") {
       std::string unquoted = replaceValues.Target;
       std::string::size_type sz = unquoted.size();
-      if(sz > 2 && unquoted[0] == '\"' && unquoted[sz-1] == '\"')
-        {
-        unquoted = unquoted.substr(1, sz-2);
-        }
-      return unquoted;
+      if (sz > 2 && unquoted[0] == '\"' && unquoted[sz - 1] == '\"') {
+        unquoted = unquoted.substr(1, sz - 2);
       }
-    if(replaceValues.LanguageCompileFlags)
-      {
-      if(variable == "LANGUAGE_COMPILE_FLAGS")
-        {
+      return unquoted;
+    }
+    if (replaceValues.LanguageCompileFlags) {
+      if (variable == "LANGUAGE_COMPILE_FLAGS") {
         return replaceValues.LanguageCompileFlags;
-        }
       }
-    if(replaceValues.Target)
-      {
-      if(variable == "TARGET")
-        {
+    }
+    if (replaceValues.Target) {
+      if (variable == "TARGET") {
         return replaceValues.Target;
-        }
       }
-    if(variable == "TARGET_IMPLIB")
-      {
+    }
+    if (variable == "TARGET_IMPLIB") {
       return this->TargetImplib;
-      }
-    if(variable == "TARGET_VERSION_MAJOR")
-      {
-      if(replaceValues.TargetVersionMajor)
-        {
+    }
+    if (variable == "TARGET_VERSION_MAJOR") {
+      if (replaceValues.TargetVersionMajor) {
         return replaceValues.TargetVersionMajor;
-        }
-      else
-        {
+      } else {
         return "0";
-        }
       }
-    if(variable == "TARGET_VERSION_MINOR")
-      {
-      if(replaceValues.TargetVersionMinor)
-        {
+    }
+    if (variable == "TARGET_VERSION_MINOR") {
+      if (replaceValues.TargetVersionMinor) {
         return replaceValues.TargetVersionMinor;
-        }
-      else
-        {
+      } else {
         return "0";
-        }
       }
-    if(replaceValues.Target)
-      {
-      if(variable == "TARGET_BASE")
-        {
+    }
+    if (replaceValues.Target) {
+      if (variable == "TARGET_BASE") {
         // Strip the last extension off the target name.
         std::string targetBase = replaceValues.Target;
         std::string::size_type pos = targetBase.rfind(".");
-        if(pos != targetBase.npos)
-          {
-        return targetBase.substr(0, pos);
-          }
-        else
-          {
+        if (pos != targetBase.npos) {
+          return targetBase.substr(0, pos);
+        } else {
           return targetBase;
-          }
         }
       }
     }
-  if(variable == "TARGET_SONAME" || variable == "SONAME_FLAG" ||
-     variable == "TARGET_INSTALLNAME_DIR")
-    {
+  }
+  if (variable == "TARGET_SONAME" || variable == "SONAME_FLAG" ||
+      variable == "TARGET_INSTALLNAME_DIR") {
     // All these variables depend on TargetSOName
-    if(replaceValues.TargetSOName)
-      {
-      if(variable == "TARGET_SONAME")
-        {
+    if (replaceValues.TargetSOName) {
+      if (variable == "TARGET_SONAME") {
         return replaceValues.TargetSOName;
-        }
-      if(variable == "SONAME_FLAG" && replaceValues.SONameFlag)
-        {
+      }
+      if (variable == "SONAME_FLAG" && replaceValues.SONameFlag) {
         return replaceValues.SONameFlag;
-        }
-      if(replaceValues.TargetInstallNameDir &&
-         variable == "TARGET_INSTALLNAME_DIR")
-        {
+      }
+      if (replaceValues.TargetInstallNameDir &&
+          variable == "TARGET_INSTALLNAME_DIR") {
         return replaceValues.TargetInstallNameDir;
-        }
       }
-    return "";
     }
-  if(replaceValues.LinkLibraries)
-    {
-    if(variable == "LINK_LIBRARIES")
-      {
+    return "";
+  }
+  if (replaceValues.LinkLibraries) {
+    if (variable == "LINK_LIBRARIES") {
       return replaceValues.LinkLibraries;
-      }
     }
-  if(replaceValues.Language)
-    {
-    if(variable == "LANGUAGE")
-      {
+  }
+  if (replaceValues.Language) {
+    if (variable == "LANGUAGE") {
       return replaceValues.Language;
-      }
     }
-  if(replaceValues.CMTarget)
-    {
-    if(variable == "TARGET_NAME")
-      {
+  }
+  if (replaceValues.CMTarget) {
+    if (variable == "TARGET_NAME") {
       return replaceValues.CMTarget->GetName();
-      }
-    if(variable == "TARGET_TYPE")
-      {
+    }
+    if (variable == "TARGET_TYPE") {
       return cmState::GetTargetTypeName(replaceValues.CMTarget->GetType());
-      }
     }
-  if(replaceValues.Output)
-    {
-    if(variable == "OUTPUT")
-      {
+  }
+  if (replaceValues.Output) {
+    if (variable == "OUTPUT") {
       return replaceValues.Output;
-      }
     }
-  if(variable == "CMAKE_COMMAND")
-    {
+  }
+  if (variable == "CMAKE_COMMAND") {
     return this->Convert(cmSystemTools::GetCMakeCommand(), FULL, SHELL);
-    }
+  }
   std::vector<std::string> enabledLanguages =
-      this->GetState()->GetEnabledLanguages();
+    this->GetState()->GetEnabledLanguages();
   // loop over language specific replace variables
   int pos = 0;
-  while(ruleReplaceVars[pos])
-    {
-    for(std::vector<std::string>::iterator i = enabledLanguages.begin();
-        i != enabledLanguages.end(); ++i)
-      {
+  while (ruleReplaceVars[pos]) {
+    for (std::vector<std::string>::iterator i = enabledLanguages.begin();
+         i != enabledLanguages.end(); ++i) {
       const char* lang = i->c_str();
       std::string actualReplace = ruleReplaceVars[pos];
       // If this is the compiler then look for the extra variable
@@ -834,221 +710,176 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
       const char* compilerOptionExternalToolchain = 0;
       const char* compilerSysroot = 0;
       const char* compilerOptionSysroot = 0;
-      if(actualReplace == "CMAKE_${LANG}_COMPILER")
-        {
+      if (actualReplace == "CMAKE_${LANG}_COMPILER") {
         std::string arg1 = actualReplace + "_ARG1";
         cmSystemTools::ReplaceString(arg1, "${LANG}", lang);
         compilerArg1 = this->Makefile->GetDefinition(arg1);
-        compilerTarget
-              = this->Makefile->GetDefinition(
-                std::string("CMAKE_") + lang + "_COMPILER_TARGET");
-        compilerOptionTarget
-              = this->Makefile->GetDefinition(
-                std::string("CMAKE_") + lang +
-                                          "_COMPILE_OPTIONS_TARGET");
-        compilerExternalToolchain
-              = this->Makefile->GetDefinition(
-                std::string("CMAKE_") + lang +
-                                    "_COMPILER_EXTERNAL_TOOLCHAIN");
-        compilerOptionExternalToolchain
-              = this->Makefile->GetDefinition(
-                std::string("CMAKE_") + lang +
-                              "_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN");
-        compilerSysroot
-              = this->Makefile->GetDefinition("CMAKE_SYSROOT");
-        compilerOptionSysroot
-              = this->Makefile->GetDefinition(
-                std::string("CMAKE_") + lang +
-                              "_COMPILE_OPTIONS_SYSROOT");
-        }
-      if(actualReplace.find("${LANG}") != actualReplace.npos)
-        {
+        compilerTarget = this->Makefile->GetDefinition(
+          std::string("CMAKE_") + lang + "_COMPILER_TARGET");
+        compilerOptionTarget = this->Makefile->GetDefinition(
+          std::string("CMAKE_") + lang + "_COMPILE_OPTIONS_TARGET");
+        compilerExternalToolchain = this->Makefile->GetDefinition(
+          std::string("CMAKE_") + lang + "_COMPILER_EXTERNAL_TOOLCHAIN");
+        compilerOptionExternalToolchain =
+          this->Makefile->GetDefinition(std::string("CMAKE_") + lang +
+                                        "_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN");
+        compilerSysroot = this->Makefile->GetDefinition("CMAKE_SYSROOT");
+        compilerOptionSysroot = this->Makefile->GetDefinition(
+          std::string("CMAKE_") + lang + "_COMPILE_OPTIONS_SYSROOT");
+      }
+      if (actualReplace.find("${LANG}") != actualReplace.npos) {
         cmSystemTools::ReplaceString(actualReplace, "${LANG}", lang);
-        }
-      if(actualReplace == variable)
-        {
-        std::string replace =
-          this->Makefile->GetSafeDefinition(variable);
+      }
+      if (actualReplace == variable) {
+        std::string replace = this->Makefile->GetSafeDefinition(variable);
         // if the variable is not a FLAG then treat it like a path
-        if(variable.find("_FLAG") == variable.npos)
-          {
+        if (variable.find("_FLAG") == variable.npos) {
           std::string ret = this->ConvertToOutputForExisting(replace);
           // if there is a required first argument to the compiler add it
           // to the compiler string
-          if(compilerArg1)
-            {
+          if (compilerArg1) {
             ret += " ";
             ret += compilerArg1;
-            }
-          if (compilerTarget && compilerOptionTarget)
-            {
+          }
+          if (compilerTarget && compilerOptionTarget) {
             ret += " ";
             ret += compilerOptionTarget;
             ret += compilerTarget;
-            }
-          if (compilerExternalToolchain && compilerOptionExternalToolchain)
-            {
+          }
+          if (compilerExternalToolchain && compilerOptionExternalToolchain) {
             ret += " ";
             ret += compilerOptionExternalToolchain;
             ret += this->EscapeForShell(compilerExternalToolchain, true);
-            }
-          if (compilerSysroot && compilerOptionSysroot)
-            {
+          }
+          if (compilerSysroot && compilerOptionSysroot) {
             ret += " ";
             ret += compilerOptionSysroot;
             ret += this->EscapeForShell(compilerSysroot, true);
-            }
-          return ret;
           }
-        return replace;
+          return ret;
         }
+        return replace;
       }
-    pos++;
     }
+    pos++;
+  }
   return variable;
 }
 
-
-void
-cmLocalGenerator::ExpandRuleVariables(std::string& s,
-                                      const RuleVariables& replaceValues)
+void cmLocalGenerator::ExpandRuleVariables(std::string& s,
+                                           const RuleVariables& replaceValues)
 {
-  if(replaceValues.RuleLauncher)
-    {
+  if (replaceValues.RuleLauncher) {
     this->InsertRuleLauncher(s, replaceValues.CMTarget,
                              replaceValues.RuleLauncher);
-    }
+  }
   std::string::size_type start = s.find('<');
   // no variables to expand
-  if(start == s.npos)
-    {
+  if (start == s.npos) {
     return;
-    }
+  }
   std::string::size_type pos = 0;
   std::string expandedInput;
-  while(start != s.npos && start < s.size()-2)
-    {
+  while (start != s.npos && start < s.size() - 2) {
     std::string::size_type end = s.find('>', start);
     // if we find a < with no > we are done
-    if(end == s.npos)
-      {
+    if (end == s.npos) {
       return;
-      }
-    char c = s[start+1];
+    }
+    char c = s[start + 1];
     // if the next char after the < is not A-Za-z then
     // skip it and try to find the next < in the string
-    if(!isalpha(c))
-      {
-      start = s.find('<', start+1);
-      }
-    else
-      {
+    if (!isalpha(c)) {
+      start = s.find('<', start + 1);
+    } else {
       // extract the var
-      std::string var = s.substr(start+1,  end - start-1);
-      std::string replace = this->ExpandRuleVariable(var,
-                                                     replaceValues);
-      expandedInput += s.substr(pos, start-pos);
+      std::string var = s.substr(start + 1, end - start - 1);
+      std::string replace = this->ExpandRuleVariable(var, replaceValues);
+      expandedInput += s.substr(pos, start - pos);
       expandedInput += replace;
       // move to next one
-      start = s.find('<', start+var.size()+2);
-      pos = end+1;
-      }
+      start = s.find('<', start + var.size() + 2);
+      pos = end + 1;
     }
+  }
   // add the rest of the input
-  expandedInput += s.substr(pos, s.size()-pos);
+  expandedInput += s.substr(pos, s.size() - pos);
   s = expandedInput;
 }
 
 const char* cmLocalGenerator::GetRuleLauncher(cmGeneratorTarget* target,
                                               const std::string& prop)
 {
-  if(target)
-    {
+  if (target) {
     return target->GetProperty(prop);
-    }
-  else
-    {
+  } else {
     return this->Makefile->GetProperty(prop);
-    }
+  }
 }
 
 void cmLocalGenerator::InsertRuleLauncher(std::string& s,
                                           cmGeneratorTarget* target,
                                           const std::string& prop)
 {
-  if(const char* val = this->GetRuleLauncher(target, prop))
-    {
+  if (const char* val = this->GetRuleLauncher(target, prop)) {
     std::ostringstream wrapped;
     wrapped << val << " " << s;
     s = wrapped.str();
-    }
+  }
 }
 
-std::string
-cmLocalGenerator::ConvertToIncludeReference(std::string const& path,
-                                            OutputFormat format,
-                                            bool forceFullPaths)
+std::string cmLocalGenerator::ConvertToIncludeReference(
+  std::string const& path, OutputFormat format, bool forceFullPaths)
 {
   return this->ConvertToOutputForExisting(
-    path, forceFullPaths? FULL : START_OUTPUT, format);
+    path, forceFullPaths ? FULL : START_OUTPUT, format);
 }
 
 std::string cmLocalGenerator::GetIncludeFlags(
-                                     const std::vector<std::string> &includes,
-                                     cmGeneratorTarget* target,
-                                     const std::string& lang,
-                                     bool forceFullPaths,
-                                     bool forResponseFile,
-                                     const std::string& config)
-{
-  if(lang.empty())
-    {
+  const std::vector<std::string>& includes, cmGeneratorTarget* target,
+  const std::string& lang, bool forceFullPaths, bool forResponseFile,
+  const std::string& config)
+{
+  if (lang.empty()) {
     return "";
-    }
+  }
 
-  OutputFormat shellFormat = forResponseFile? RESPONSE : SHELL;
+  OutputFormat shellFormat = forResponseFile ? RESPONSE : SHELL;
   std::ostringstream includeFlags;
 
   std::string flagVar = "CMAKE_INCLUDE_FLAG_";
   flagVar += lang;
-  const char* includeFlag =
-    this->Makefile->GetSafeDefinition(flagVar);
+  const char* includeFlag = this->Makefile->GetSafeDefinition(flagVar);
   flagVar = "CMAKE_INCLUDE_FLAG_SEP_";
   flagVar += lang;
   const char* sep = this->Makefile->GetDefinition(flagVar);
   bool quotePaths = false;
-  if(this->Makefile->GetDefinition("CMAKE_QUOTE_INCLUDE_PATHS"))
-    {
+  if (this->Makefile->GetDefinition("CMAKE_QUOTE_INCLUDE_PATHS")) {
     quotePaths = true;
-    }
+  }
   bool repeatFlag = true;
   // should the include flag be repeated like ie. -IA -IB
-  if(!sep)
-    {
+  if (!sep) {
     sep = " ";
-    }
-  else
-    {
+  } else {
     // if there is a separator then the flag is not repeated but is only
     // given once i.e.  -classpath a:b:c
     repeatFlag = false;
-    }
+  }
 
   // Support special system include flag if it is available and the
   // normal flag is repeated for each directory.
   std::string sysFlagVar = "CMAKE_INCLUDE_SYSTEM_FLAG_";
   sysFlagVar += lang;
   const char* sysIncludeFlag = 0;
-  if(repeatFlag)
-    {
+  if (repeatFlag) {
     sysIncludeFlag = this->Makefile->GetDefinition(sysFlagVar);
-    }
+  }
 
   std::string fwSearchFlagVar = "CMAKE_";
   fwSearchFlagVar += lang;
   fwSearchFlagVar += "_FRAMEWORK_SEARCH_FLAG";
-  const char* fwSearchFlag =
-    this->Makefile->GetDefinition(fwSearchFlagVar);
+  const char* fwSearchFlag = this->Makefile->GetDefinition(fwSearchFlagVar);
 
   std::string sysFwSearchFlagVar = "CMAKE_";
   sysFwSearchFlagVar += lang;
@@ -1062,63 +893,50 @@ std::string cmLocalGenerator::GetIncludeFlags(
   emitted.insert("/System/Library/Frameworks");
 #endif
   std::vector<std::string>::const_iterator i;
-  for(i = includes.begin(); i != includes.end(); ++i)
-    {
-    if(fwSearchFlag && *fwSearchFlag && this->Makefile->IsOn("APPLE")
-       && cmSystemTools::IsPathToFramework(i->c_str()))
-      {
+  for (i = includes.begin(); i != includes.end(); ++i) {
+    if (fwSearchFlag && *fwSearchFlag && this->Makefile->IsOn("APPLE") &&
+        cmSystemTools::IsPathToFramework(i->c_str())) {
       std::string frameworkDir = *i;
       frameworkDir += "/../";
       frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
-      if(emitted.insert(frameworkDir).second)
-        {
+      if (emitted.insert(frameworkDir).second) {
         if (sysFwSearchFlag && target &&
-            target->IsSystemIncludeDirectory(*i, config))
-          {
+            target->IsSystemIncludeDirectory(*i, config)) {
           includeFlags << sysFwSearchFlag;
-          }
-        else
-          {
+        } else {
           includeFlags << fwSearchFlag;
-          }
-        includeFlags << this->ConvertToOutputFormat(frameworkDir, shellFormat)
-          << " ";
         }
-      continue;
+        includeFlags << this->ConvertToOutputFormat(frameworkDir, shellFormat)
+                     << " ";
       }
+      continue;
+    }
 
-    if(!flagUsed || repeatFlag)
-      {
-      if(sysIncludeFlag && target &&
-         target->IsSystemIncludeDirectory(*i, config))
-        {
+    if (!flagUsed || repeatFlag) {
+      if (sysIncludeFlag && target &&
+          target->IsSystemIncludeDirectory(*i, config)) {
         includeFlags << sysIncludeFlag;
-        }
-      else
-        {
+      } else {
         includeFlags << includeFlag;
-        }
-      flagUsed = true;
       }
+      flagUsed = true;
+    }
     std::string includePath =
       this->ConvertToIncludeReference(*i, shellFormat, forceFullPaths);
-    if(quotePaths && !includePath.empty() && includePath[0] != '\"')
-      {
+    if (quotePaths && !includePath.empty() && includePath[0] != '\"') {
       includeFlags << "\"";
-      }
+    }
     includeFlags << includePath;
-    if(quotePaths && !includePath.empty() && includePath[0] != '\"')
-      {
+    if (quotePaths && !includePath.empty() && includePath[0] != '\"') {
       includeFlags << "\"";
-      }
-    includeFlags << sep;
     }
+    includeFlags << sep;
+  }
   std::string flags = includeFlags.str();
   // remove trailing separators
-  if((sep[0] != ' ') && !flags.empty() && flags[flags.size()-1] == sep[0])
-    {
-    flags[flags.size()-1] = ' ';
-    }
+  if ((sep[0] != ' ') && !flags.empty() && flags[flags.size() - 1] == sep[0]) {
+    flags[flags.size() - 1] = ' ';
+  }
   return flags;
 }
 
@@ -1132,87 +950,79 @@ void cmLocalGenerator::AddCompileDefinitions(std::set<std::string>& defines,
   this->AppendDefines(defines, targetDefines);
 }
 
-void cmLocalGenerator::AddCompileOptions(
-  std::string& flags, cmGeneratorTarget* target,
-  const std::string& lang, const std::string& config
-  )
+void cmLocalGenerator::AddCompileOptions(std::string& flags,
+                                         cmGeneratorTarget* target,
+                                         const std::string& lang,
+                                         const std::string& config)
 {
-  std::string langFlagRegexVar = std::string("CMAKE_")+lang+"_FLAG_REGEX";
+  std::string langFlagRegexVar = std::string("CMAKE_") + lang + "_FLAG_REGEX";
 
-  if(const char* langFlagRegexStr =
-     this->Makefile->GetDefinition(langFlagRegexVar))
-    {
+  if (const char* langFlagRegexStr =
+        this->Makefile->GetDefinition(langFlagRegexVar)) {
     // Filter flags acceptable to this language.
     cmsys::RegularExpression r(langFlagRegexStr);
     std::vector<std::string> opts;
-    if(const char* targetFlags = target->GetProperty("COMPILE_FLAGS"))
-      {
+    if (const char* targetFlags = target->GetProperty("COMPILE_FLAGS")) {
       cmSystemTools::ParseWindowsCommandLine(targetFlags, opts);
-      }
+    }
     target->GetCompileOptions(opts, config, lang);
-    for(std::vector<std::string>::const_iterator i = opts.begin();
-        i != opts.end(); ++i)
-      {
-      if(r.find(i->c_str()))
-        {
+    for (std::vector<std::string>::const_iterator i = opts.begin();
+         i != opts.end(); ++i) {
+      if (r.find(i->c_str())) {
         // (Re-)Escape this flag.  COMPILE_FLAGS were already parsed
         // as a command line above, and COMPILE_OPTIONS are escaped.
         this->AppendFlagEscape(flags, *i);
-        }
       }
     }
-  else
-    {
+  } else {
     // Use all flags.
-    if(const char* targetFlags = target->GetProperty("COMPILE_FLAGS"))
-      {
+    if (const char* targetFlags = target->GetProperty("COMPILE_FLAGS")) {
       // COMPILE_FLAGS are not escaped for historical reasons.
       this->AppendFlags(flags, targetFlags);
-      }
+    }
     std::vector<std::string> opts;
     target->GetCompileOptions(opts, config, lang);
-    for(std::vector<std::string>::const_iterator i = opts.begin();
-        i != opts.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = opts.begin();
+         i != opts.end(); ++i) {
       // COMPILE_OPTIONS are escaped.
       this->AppendFlagEscape(flags, *i);
-      }
     }
+  }
   std::vector<std::string> features;
   target->GetCompileFeatures(features, config);
-  for(std::vector<std::string>::const_iterator it = features.begin();
-      it != features.end(); ++it)
-    {
-     if (!this->Makefile->AddRequiredTargetFeature(target->Target, *it))
-      {
+  for (std::vector<std::string>::const_iterator it = features.begin();
+       it != features.end(); ++it) {
+    if (!this->Makefile->AddRequiredTargetFeature(target->Target, *it)) {
       return;
-      }
     }
+  }
 
-  for(std::map<std::string, std::string>::const_iterator it
-      = target->GetMaxLanguageStandards().begin();
-      it != target->GetMaxLanguageStandards().end(); ++it)
-    {
+  for (std::map<std::string, std::string>::const_iterator it =
+         target->GetMaxLanguageStandards().begin();
+       it != target->GetMaxLanguageStandards().end(); ++it) {
     const char* standard = target->GetProperty(it->first + "_STANDARD");
-    if(!standard)
-      {
+    if (!standard) {
       continue;
-      }
-    if (this->Makefile->IsLaterStandard(it->first, standard, it->second))
-      {
+    }
+    if (this->Makefile->IsLaterStandard(it->first, standard, it->second)) {
       std::ostringstream e;
-      e << "The COMPILE_FEATURES property of target \""
-        << target->GetName() << "\" was evaluated when computing the link "
-        "implementation, and the \"" << it->first << "_STANDARD\" was \""
-        << it->second << "\" for that computation.  Computing the "
-        "COMPILE_FEATURES based on the link implementation resulted in a "
-        "higher \"" << it->first << "_STANDARD\" \"" << standard << "\".  "
-        "This is not permitted. The COMPILE_FEATURES may not both depend on "
-        "and be depended on by the link implementation." << std::endl;
+      e << "The COMPILE_FEATURES property of target \"" << target->GetName()
+        << "\" was evaluated when computing the link "
+           "implementation, and the \""
+        << it->first << "_STANDARD\" was \"" << it->second
+        << "\" for that computation.  Computing the "
+           "COMPILE_FEATURES based on the link implementation resulted in a "
+           "higher \""
+        << it->first << "_STANDARD\" \"" << standard
+        << "\".  "
+           "This is not permitted. The COMPILE_FEATURES may not both depend "
+           "on "
+           "and be depended on by the link implementation."
+        << std::endl;
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
     }
+  }
   this->AddCompilerRequirementFlag(flags, target, lang);
 }
 
@@ -1220,8 +1030,7 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
                                              cmGeneratorTarget const* target,
                                              const std::string& lang,
                                              const std::string& config,
-                                             bool stripImplicitInclDirs
-                                            ) const
+                                             bool stripImplicitInclDirs) const
 {
   // Need to decide whether to automatically include the source and
   // binary directories at the beginning of the include path.
@@ -1235,39 +1044,33 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
   // file in a subdirectory of the current source directory but we
   // cannot fix this because not all native build tools support
   // per-source-file include paths.
-  if(this->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR"))
-    {
+  if (this->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR")) {
     includeSourceDir = true;
     includeBinaryDir = true;
-    }
+  }
 
   // Do not repeat an include path.
   std::set<std::string> emitted;
 
   // Store the automatic include paths.
-  if(includeBinaryDir)
-    {
+  if (includeBinaryDir) {
     std::string binDir = this->StateSnapshot.GetDirectory().GetCurrentBinary();
-    if(emitted.find(binDir) == emitted.end())
-      {
+    if (emitted.find(binDir) == emitted.end()) {
       dirs.push_back(binDir);
       emitted.insert(binDir);
-      }
     }
-  if(includeSourceDir)
-    {
+  }
+  if (includeSourceDir) {
     std::string srcDir = this->StateSnapshot.GetDirectory().GetCurrentSource();
-    if(emitted.find(srcDir) == emitted.end())
-      {
+    if (emitted.find(srcDir) == emitted.end()) {
       dirs.push_back(srcDir);
       emitted.insert(srcDir);
-      }
     }
+  }
 
-  if(!target)
-    {
+  if (!target) {
     return;
-    }
+  }
 
   std::string rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
 
@@ -1276,22 +1079,19 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
   std::string impDirVar = "CMAKE_";
   impDirVar += lang;
   impDirVar += "_IMPLICIT_INCLUDE_DIRECTORIES";
-  if(const char* value = this->Makefile->GetDefinition(impDirVar))
-    {
+  if (const char* value = this->Makefile->GetDefinition(impDirVar)) {
     std::vector<std::string> impDirVec;
     cmSystemTools::ExpandListArgument(value, impDirVec);
-    for(std::vector<std::string>::const_iterator i = impDirVec.begin();
-        i != impDirVec.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = impDirVec.begin();
+         i != impDirVec.end(); ++i) {
       std::string d = rootPath + *i;
       cmSystemTools::ConvertToUnixSlashes(d);
       emitted.insert(d);
-      if (!stripImplicitInclDirs)
-        {
+      if (!stripImplicitInclDirs) {
         implicitDirs.push_back(*i);
-        }
       }
     }
+  }
 
   // Get the target-specific include directories.
   std::vector<std::string> includes;
@@ -1300,74 +1100,61 @@ void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
 
   // Support putting all the in-project include directories first if
   // it is requested by the project.
-  if(this->Makefile->IsOn("CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE"))
-    {
+  if (this->Makefile->IsOn("CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE")) {
     const char* topSourceDir = this->GetState()->GetSourceDirectory();
     const char* topBinaryDir = this->GetState()->GetBinaryDirectory();
-    for(std::vector<std::string>::const_iterator i = includes.begin();
-        i != includes.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = includes.begin();
+         i != includes.end(); ++i) {
       // Emit this directory only if it is a subdirectory of the
       // top-level source or binary tree.
-      if(cmSystemTools::ComparePath(*i, topSourceDir) ||
-         cmSystemTools::ComparePath(*i, topBinaryDir) ||
-         cmSystemTools::IsSubDirectory(*i, topSourceDir) ||
-         cmSystemTools::IsSubDirectory(*i, topBinaryDir))
-        {
-        if(emitted.insert(*i).second)
-          {
+      if (cmSystemTools::ComparePath(*i, topSourceDir) ||
+          cmSystemTools::ComparePath(*i, topBinaryDir) ||
+          cmSystemTools::IsSubDirectory(*i, topSourceDir) ||
+          cmSystemTools::IsSubDirectory(*i, topBinaryDir)) {
+        if (emitted.insert(*i).second) {
           dirs.push_back(*i);
-          }
         }
       }
     }
+  }
 
   // Construct the final ordered include directory list.
-  for(std::vector<std::string>::const_iterator i = includes.begin();
-      i != includes.end(); ++i)
-    {
-    if(emitted.insert(*i).second)
-      {
+  for (std::vector<std::string>::const_iterator i = includes.begin();
+       i != includes.end(); ++i) {
+    if (emitted.insert(*i).second) {
       dirs.push_back(*i);
-      }
     }
+  }
 
-  for(std::vector<std::string>::const_iterator i = implicitDirs.begin();
-      i != implicitDirs.end(); ++i)
-    {
-    if(std::find(includes.begin(), includes.end(), *i) != includes.end())
-      {
+  for (std::vector<std::string>::const_iterator i = implicitDirs.begin();
+       i != implicitDirs.end(); ++i) {
+    if (std::find(includes.begin(), includes.end(), *i) != includes.end()) {
       dirs.push_back(*i);
-      }
     }
+  }
 }
 
 void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags,
                                              std::string const& config,
                                              cmGeneratorTarget* target)
 {
-  this->AppendFlags(flags,
-    this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"));
-  if(!config.empty())
-    {
+  this->AppendFlags(
+    flags, this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"));
+  if (!config.empty()) {
     std::string name = "CMAKE_STATIC_LINKER_FLAGS_" + config;
     this->AppendFlags(flags, this->Makefile->GetSafeDefinition(name));
-    }
+  }
   this->AppendFlags(flags, target->GetProperty("STATIC_LIBRARY_FLAGS"));
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     std::string name = "STATIC_LIBRARY_FLAGS_" + config;
     this->AppendFlags(flags, target->GetProperty(name));
-    }
+  }
 }
 
-void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
-                                 std::string& flags,
-                                 std::string& linkFlags,
-                                 std::string& frameworkPath,
-                                 std::string& linkPath,
-                                 cmGeneratorTarget* target,
-                                 bool useWatcomQuote)
+void cmLocalGenerator::GetTargetFlags(
+  std::string& linkLibs, std::string& flags, std::string& linkFlags,
+  std::string& frameworkPath, std::string& linkPath, cmGeneratorTarget* target,
+  bool useWatcomQuote)
 {
   std::string buildType =
     this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
@@ -1375,140 +1162,115 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
   const char* libraryLinkVariable =
     "CMAKE_SHARED_LINKER_FLAGS"; // default to shared library
 
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::STATIC_LIBRARY:
       this->GetStaticLibraryFlags(linkFlags, buildType, target);
       break;
     case cmState::MODULE_LIBRARY:
       libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS";
-    case cmState::SHARED_LIBRARY:
-      {
+    case cmState::SHARED_LIBRARY: {
       linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable);
       linkFlags += " ";
-      if(!buildType.empty())
-        {
+      if (!buildType.empty()) {
         std::string build = libraryLinkVariable;
         build += "_";
         build += buildType;
         linkFlags += this->Makefile->GetSafeDefinition(build);
         linkFlags += " ";
-        }
-      if(this->Makefile->IsOn("WIN32") &&
-         !(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW")))
-        {
+      }
+      if (this->Makefile->IsOn("WIN32") &&
+          !(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW"))) {
         std::vector<cmSourceFile*> sources;
         target->GetSourceFiles(sources, buildType);
-        for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
-            i != sources.end(); ++i)
-          {
+        for (std::vector<cmSourceFile*>::const_iterator i = sources.begin();
+             i != sources.end(); ++i) {
           cmSourceFile* sf = *i;
-          if(sf->GetExtension() == "def")
-            {
+          if (sf->GetExtension() == "def") {
             linkFlags +=
               this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
-            linkFlags += this->Convert(sf->GetFullPath(),
-                                       FULL, SHELL);
+            linkFlags += this->Convert(sf->GetFullPath(), FULL, SHELL);
             linkFlags += " ";
-            }
           }
         }
+      }
       const char* targetLinkFlags = target->GetProperty("LINK_FLAGS");
-      if(targetLinkFlags)
-        {
+      if (targetLinkFlags) {
         linkFlags += targetLinkFlags;
         linkFlags += " ";
-        }
-      if(!buildType.empty())
-        {
+      }
+      if (!buildType.empty()) {
         std::string configLinkFlags = "LINK_FLAGS_";
         configLinkFlags += buildType;
         targetLinkFlags = target->GetProperty(configLinkFlags);
-        if(targetLinkFlags)
-          {
+        if (targetLinkFlags) {
           linkFlags += targetLinkFlags;
           linkFlags += " ";
-          }
         }
-      this->OutputLinkLibraries(linkLibs, frameworkPath, linkPath,
-                                *target, false, false, useWatcomQuote);
       }
-      break;
-    case cmState::EXECUTABLE:
-      {
-      linkFlags +=
-        this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
+      this->OutputLinkLibraries(linkLibs, frameworkPath, linkPath, *target,
+                                false, false, useWatcomQuote);
+    } break;
+    case cmState::EXECUTABLE: {
+      linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
       linkFlags += " ";
-      if(!buildType.empty())
-        {
+      if (!buildType.empty()) {
         std::string build = "CMAKE_EXE_LINKER_FLAGS_";
         build += buildType;
         linkFlags += this->Makefile->GetSafeDefinition(build);
         linkFlags += " ";
-        }
+      }
       std::string linkLanguage = target->GetLinkerLanguage(buildType);
-      if(linkLanguage.empty())
-        {
-        cmSystemTools::Error
-          ("CMake can not determine linker language for target: ",
-           target->GetName().c_str());
+      if (linkLanguage.empty()) {
+        cmSystemTools::Error(
+          "CMake can not determine linker language for target: ",
+          target->GetName().c_str());
         return;
-        }
+      }
       this->AddLanguageFlags(flags, linkLanguage, buildType);
-      this->OutputLinkLibraries(linkLibs, frameworkPath, linkPath,
-                                *target, false, false, useWatcomQuote);
-      if(cmSystemTools::IsOn
-         (this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
-        {
-        std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_")
-          + linkLanguage + std::string("_FLAGS");
+      this->OutputLinkLibraries(linkLibs, frameworkPath, linkPath, *target,
+                                false, false, useWatcomQuote);
+      if (cmSystemTools::IsOn(
+            this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
+        std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_") +
+          linkLanguage + std::string("_FLAGS");
         linkFlags += this->Makefile->GetSafeDefinition(sFlagVar);
         linkFlags += " ";
-        }
-      if ( target->GetPropertyAsBool("WIN32_EXECUTABLE") )
-        {
+      }
+      if (target->GetPropertyAsBool("WIN32_EXECUTABLE")) {
         linkFlags +=
           this->Makefile->GetSafeDefinition("CMAKE_CREATE_WIN32_EXE");
         linkFlags += " ";
-        }
-      else
-        {
+      } else {
         linkFlags +=
           this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE");
         linkFlags += " ";
-        }
-      if (target->IsExecutableWithExports())
-        {
+      }
+      if (target->IsExecutableWithExports()) {
         std::string exportFlagVar = "CMAKE_EXE_EXPORTS_";
         exportFlagVar += linkLanguage;
         exportFlagVar += "_FLAG";
 
-        linkFlags +=
-          this->Makefile->GetSafeDefinition(exportFlagVar);
+        linkFlags += this->Makefile->GetSafeDefinition(exportFlagVar);
         linkFlags += " ";
-        }
+      }
       const char* targetLinkFlags = target->GetProperty("LINK_FLAGS");
-      if(targetLinkFlags)
-        {
+      if (targetLinkFlags) {
         linkFlags += targetLinkFlags;
         linkFlags += " ";
-        }
-      if(!buildType.empty())
-        {
+      }
+      if (!buildType.empty()) {
         std::string configLinkFlags = "LINK_FLAGS_";
         configLinkFlags += buildType;
         targetLinkFlags = target->GetProperty(configLinkFlags);
-        if(targetLinkFlags)
-          {
+        if (targetLinkFlags) {
           linkFlags += targetLinkFlags;
           linkFlags += " ";
-          }
         }
       }
-      break;
+    } break;
     default:
       break;
-    }
+  }
 }
 
 std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
@@ -1516,27 +1278,24 @@ std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
   // Work-ardound command line parsing limitations in MSVC 6.0
-  if(this->Makefile->IsOn("MSVC60"))
-    {
+  if (this->Makefile->IsOn("MSVC60")) {
     // Search for the last space.
     std::string::size_type pos = lib.rfind(' ');
-    if(pos != lib.npos)
-      {
+    if (pos != lib.npos) {
       // Find the slash after the last space, if any.
       pos = lib.find('/', pos);
 
       // Convert the portion of the path with a space to a short path.
       std::string sp;
-      if(cmSystemTools::GetShortPath(lib.substr(0, pos).c_str(), sp))
-        {
+      if (cmSystemTools::GetShortPath(lib.substr(0, pos).c_str(), sp)) {
         // Append the rest of the path with no space.
         sp += lib.substr(pos);
 
         // Convert to an output path.
         return this->Convert(sp.c_str(), NONE, format);
-        }
       }
     }
+  }
 #endif
 
   // Normal behavior.
@@ -1551,21 +1310,19 @@ std::string cmLocalGenerator::ConvertToLinkReference(std::string const& lib,
 void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
                                            std::string& frameworkPath,
                                            std::string& linkPath,
-                                           cmGeneratorTarget &tgt,
-                                           bool relink,
+                                           cmGeneratorTarget& tgt, bool relink,
                                            bool forResponseFile,
                                            bool useWatcomQuote)
 {
-  OutputFormat shellFormat = (forResponseFile) ? RESPONSE :
-                             ((useWatcomQuote) ? WATCOMQUOTE : SHELL);
+  OutputFormat shellFormat =
+    (forResponseFile) ? RESPONSE : ((useWatcomQuote) ? WATCOMQUOTE : SHELL);
   bool escapeAllowMakeVars = !forResponseFile;
   std::ostringstream fout;
   std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
   cmComputeLinkInformation* pcli = tgt.GetLinkInformation(config);
-  if(!pcli)
-    {
+  if (!pcli) {
     return;
-    }
+  }
   cmComputeLinkInformation& cli = *pcli;
 
   // Collect library linking flags command line options.
@@ -1580,17 +1337,14 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
 
   // Flags to link an executable to shared libraries.
   if (tgt.GetType() == cmState::EXECUTABLE &&
-      this->StateSnapshot.GetState()->
-        GetGlobalPropertyAsBool("TARGET_SUPPORTS_SHARED_LIBS"))
-    {
+      this->StateSnapshot.GetState()->GetGlobalPropertyAsBool(
+        "TARGET_SUPPORTS_SHARED_LIBS")) {
     bool add_shlib_flags = false;
-    switch(tgt.GetPolicyStatusCMP0065())
-      {
+    switch (tgt.GetPolicyStatusCMP0065()) {
       case cmPolicies::WARN:
-        if(!tgt.GetPropertyAsBool("ENABLE_EXPORTS") &&
-           this->Makefile->PolicyOptionalWarningEnabled(
-             "CMAKE_POLICY_WARNING_CMP0065"))
-          {
+        if (!tgt.GetPropertyAsBool("ENABLE_EXPORTS") &&
+            this->Makefile->PolicyOptionalWarningEnabled(
+              "CMAKE_POLICY_WARNING_CMP0065")) {
           std::ostringstream w;
           /* clang-format off */
           w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0065) << "\n"
@@ -1599,7 +1353,7 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
             "executables regardless of thier ENABLE_EXPORTS property.";
           /* clang-format on */
           this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-          }
+        }
       case cmPolicies::OLD:
         // OLD behavior is to always add the flags
         add_shlib_flags = true;
@@ -1608,190 +1362,164 @@ void cmLocalGenerator::OutputLinkLibraries(std::string& linkLibraries,
       case cmPolicies::REQUIRED_ALWAYS:
         this->IssueMessage(
           cmake::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0065)
-          );
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0065));
       case cmPolicies::NEW:
         // NEW behavior is to only add the flags if ENABLE_EXPORTS is on
         add_shlib_flags = tgt.GetPropertyAsBool("ENABLE_EXPORTS");
         break;
-      }
+    }
 
-    if(add_shlib_flags)
-      {
+    if (add_shlib_flags) {
       std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_";
       linkFlagsVar += linkLanguage;
       linkFlagsVar += "_FLAGS";
       linkLibs = this->Makefile->GetSafeDefinition(linkFlagsVar);
       linkLibs += " ";
-      }
     }
+  }
 
   // Append the framework search path flags.
   std::string fwSearchFlagVar = "CMAKE_";
   fwSearchFlagVar += linkLanguage;
   fwSearchFlagVar += "_FRAMEWORK_SEARCH_FLAG";
-  const char* fwSearchFlag =
-    this->Makefile->GetDefinition(fwSearchFlagVar);
-  if(fwSearchFlag && *fwSearchFlag)
-    {
+  const char* fwSearchFlag = this->Makefile->GetDefinition(fwSearchFlagVar);
+  if (fwSearchFlag && *fwSearchFlag) {
     std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths();
-    for(std::vector<std::string>::const_iterator fdi = fwDirs.begin();
-        fdi != fwDirs.end(); ++fdi)
-      {
+    for (std::vector<std::string>::const_iterator fdi = fwDirs.begin();
+         fdi != fwDirs.end(); ++fdi) {
       frameworkPath += fwSearchFlag;
       frameworkPath += this->Convert(*fdi, NONE, shellFormat);
       frameworkPath += " ";
-      }
     }
+  }
 
   // Append the library search path flags.
   std::vector<std::string> const& libDirs = cli.GetDirectories();
-  for(std::vector<std::string>::const_iterator libDir = libDirs.begin();
-      libDir != libDirs.end(); ++libDir)
-    {
-    std::string libpath = this->ConvertToOutputForExisting(*libDir,
-                                                           START_OUTPUT,
-                                                           shellFormat);
+  for (std::vector<std::string>::const_iterator libDir = libDirs.begin();
+       libDir != libDirs.end(); ++libDir) {
+    std::string libpath =
+      this->ConvertToOutputForExisting(*libDir, START_OUTPUT, shellFormat);
     linkPath += " " + libPathFlag;
     linkPath += libpath;
     linkPath += libPathTerminator;
     linkPath += " ";
-    }
+  }
 
   // Append the link items.
   typedef cmComputeLinkInformation::ItemVector ItemVector;
   ItemVector const& items = cli.GetItems();
-  for(ItemVector::const_iterator li = items.begin(); li != items.end(); ++li)
-    {
-    if(li->Target && li->Target->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (ItemVector::const_iterator li = items.begin(); li != items.end();
+       ++li) {
+    if (li->Target && li->Target->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
-    if(li->IsPath)
-      {
+    }
+    if (li->IsPath) {
       linkLibs += this->ConvertToLinkReference(li->Value, shellFormat);
-      }
-    else
-      {
+    } else {
       linkLibs += li->Value;
-      }
-    linkLibs += " ";
     }
+    linkLibs += " ";
+  }
 
   // Write the library flags to the build rule.
   fout << linkLibs;
 
   // Check what kind of rpath flags to use.
-  if(cli.GetRuntimeSep().empty())
-    {
+  if (cli.GetRuntimeSep().empty()) {
     // Each rpath entry gets its own option ("-R a -R b -R c")
     std::vector<std::string> runtimeDirs;
     cli.GetRPath(runtimeDirs, relink);
 
     std::string rpath;
-    for(std::vector<std::string>::iterator ri = runtimeDirs.begin();
-        ri != runtimeDirs.end(); ++ri)
-      {
+    for (std::vector<std::string>::iterator ri = runtimeDirs.begin();
+         ri != runtimeDirs.end(); ++ri) {
       rpath += cli.GetRuntimeFlag();
       rpath += this->Convert(*ri, NONE, shellFormat);
       rpath += " ";
-      }
-    fout << rpath;
     }
-  else
-    {
+    fout << rpath;
+  } else {
     // All rpath entries are combined ("-Wl,-rpath,a:b:c").
     std::string rpath = cli.GetRPathString(relink);
 
     // Store the rpath option in the stream.
-    if(!rpath.empty())
-      {
+    if (!rpath.empty()) {
       fout << cli.GetRuntimeFlag();
       fout << this->EscapeForShell(rpath, escapeAllowMakeVars);
       fout << " ";
-      }
     }
+  }
 
   // Add the linker runtime search path if any.
   std::string rpath_link = cli.GetRPathLinkString();
-  if(!cli.GetRPathLinkFlag().empty() && !rpath_link.empty())
-    {
+  if (!cli.GetRPathLinkFlag().empty() && !rpath_link.empty()) {
     fout << cli.GetRPathLinkFlag();
     fout << this->EscapeForShell(rpath_link, escapeAllowMakeVars);
     fout << " ";
-    }
+  }
 
   // Add standard libraries for this language.
   std::string standardLibsVar = "CMAKE_";
   standardLibsVar += cli.GetLinkLanguage();
   standardLibsVar += "_STANDARD_LIBRARIES";
-  if(const char* stdLibs =
-     this->Makefile->GetDefinition(standardLibsVar))
-    {
+  if (const char* stdLibs = this->Makefile->GetDefinition(standardLibsVar)) {
     fout << stdLibs << " ";
-    }
+  }
 
   linkLibraries = fout.str();
 }
 
-
 void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
                                             cmGeneratorTarget const* target,
                                             const std::string& lang,
                                             const std::string& config)
 {
   // Only add Mac OS X specific flags on Darwin platforms (OSX and iphone):
-  if(!this->Makefile->IsOn("APPLE"))
-    {
+  if (!this->Makefile->IsOn("APPLE")) {
     return;
-    }
+  }
 
-  if(this->EmitUniversalBinaryFlags)
-    {
+  if (this->EmitUniversalBinaryFlags) {
     std::vector<std::string> archs;
     target->GetAppleArchs(config, archs);
     const char* sysroot = this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT");
-    if(sysroot && sysroot[0] == '/' && !sysroot[1])
-      { sysroot = 0; }
+    if (sysroot && sysroot[0] == '/' && !sysroot[1]) {
+      sysroot = 0;
+    }
     std::string sysrootFlagVar =
       std::string("CMAKE_") + lang + "_SYSROOT_FLAG";
-    const char* sysrootFlag =
-      this->Makefile->GetDefinition(sysrootFlagVar);
+    const char* sysrootFlag = this->Makefile->GetDefinition(sysrootFlagVar);
     const char* deploymentTarget =
       this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
     std::string deploymentTargetFlagVar =
       std::string("CMAKE_") + lang + "_OSX_DEPLOYMENT_TARGET_FLAG";
     const char* deploymentTargetFlag =
       this->Makefile->GetDefinition(deploymentTargetFlagVar);
-    if(!archs.empty() && !lang.empty() && (lang[0] =='C' || lang[0] == 'F'))
-      {
-      for(std::vector<std::string>::iterator i = archs.begin();
-          i != archs.end(); ++i)
-        {
+    if (!archs.empty() && !lang.empty() &&
+        (lang[0] == 'C' || lang[0] == 'F')) {
+      for (std::vector<std::string>::iterator i = archs.begin();
+           i != archs.end(); ++i) {
         flags += " -arch ";
         flags += *i;
-        }
       }
+    }
 
-    if(sysrootFlag && *sysrootFlag && sysroot && *sysroot)
-      {
+    if (sysrootFlag && *sysrootFlag && sysroot && *sysroot) {
       flags += " ";
       flags += sysrootFlag;
       flags += " ";
       flags += this->Convert(sysroot, NONE, SHELL);
-      }
+    }
 
-    if (deploymentTargetFlag && *deploymentTargetFlag &&
-        deploymentTarget && *deploymentTarget)
-      {
+    if (deploymentTargetFlag && *deploymentTargetFlag && deploymentTarget &&
+        *deploymentTarget) {
       flags += " ";
       flags += deploymentTargetFlag;
       flags += deploymentTarget;
-      }
     }
+  }
 }
 
-
 void cmLocalGenerator::AddLanguageFlags(std::string& flags,
                                         const std::string& lang,
                                         const std::string& config)
@@ -1803,22 +1531,19 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
   this->AddConfigVariableFlags(flags, flagsVar, config);
 }
 
-cmGeneratorTarget*
-cmLocalGenerator::FindGeneratorTargetToUse(const std::string& name) const
+cmGeneratorTarget* cmLocalGenerator::FindGeneratorTargetToUse(
+  const std::string& name) const
 {
-  std::vector<cmGeneratorTarget*>::const_iterator
-    imported = std::find_if(this->ImportedGeneratorTargets.begin(),
-                            this->ImportedGeneratorTargets.end(),
-                            NamedGeneratorTargetFinder(name));
-  if(imported != this->ImportedGeneratorTargets.end())
-    {
+  std::vector<cmGeneratorTarget*>::const_iterator imported = std::find_if(
+    this->ImportedGeneratorTargets.begin(),
+    this->ImportedGeneratorTargets.end(), NamedGeneratorTargetFinder(name));
+  if (imported != this->ImportedGeneratorTargets.end()) {
     return *imported;
-    }
+  }
 
-  if(cmGeneratorTarget* t = this->FindLocalNonAliasGeneratorTarget(name))
-    {
+  if (cmGeneratorTarget* t = this->FindLocalNonAliasGeneratorTarget(name)) {
     return t;
-    }
+  }
 
   return this->GetGlobalGenerator()->FindGeneratorTarget(name);
 }
@@ -1836,46 +1561,38 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName,
 
   // If the input name is the empty string, there is no real
   // dependency. Short-circuit the other checks:
-  if(name == "")
-    {
+  if (name == "") {
     return false;
-    }
+  }
 
-  if(cmSystemTools::GetFilenameLastExtension(name) == ".exe")
-    {
+  if (cmSystemTools::GetFilenameLastExtension(name) == ".exe") {
     name = cmSystemTools::GetFilenameWithoutLastExtension(name);
-    }
+  }
 
   // Look for a CMake target with the given name.
-  if(cmGeneratorTarget* target =
-     this->FindGeneratorTargetToUse(name))
-    {
+  if (cmGeneratorTarget* target = this->FindGeneratorTargetToUse(name)) {
     // make sure it is not just a coincidence that the target name
     // found is part of the inName
-    if(cmSystemTools::FileIsFullPath(inName.c_str()))
-      {
+    if (cmSystemTools::FileIsFullPath(inName.c_str())) {
       std::string tLocation;
-      if(target->GetType() >= cmState::EXECUTABLE &&
-         target->GetType() <= cmState::MODULE_LIBRARY)
-        {
+      if (target->GetType() >= cmState::EXECUTABLE &&
+          target->GetType() <= cmState::MODULE_LIBRARY) {
         tLocation = target->GetLocation(config);
         tLocation = cmSystemTools::GetFilenamePath(tLocation);
         tLocation = cmSystemTools::CollapseFullPath(tLocation);
-        }
-      std::string depLocation = cmSystemTools::GetFilenamePath(
-        std::string(inName));
+      }
+      std::string depLocation =
+        cmSystemTools::GetFilenamePath(std::string(inName));
       depLocation = cmSystemTools::CollapseFullPath(depLocation);
-      if(depLocation != tLocation)
-        {
+      if (depLocation != tLocation) {
         // it is a full path to a depend that has the same name
         // as a target but is in a different location so do not use
         // the target as the depend
         dep = inName;
         return true;
-        }
       }
-    switch (target->GetType())
-      {
+    }
+    switch (target->GetType()) {
       case cmState::EXECUTABLE:
       case cmState::STATIC_LIBRARY:
       case cmState::SHARED_LIBRARY:
@@ -1896,24 +1613,22 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName,
         // A utility target has no file on which to depend.  This was listed
         // only to get the target-level dependency.
         return false;
-      }
     }
+  }
 
   // The name was not that of a CMake target.  It must name a file.
-  if(cmSystemTools::FileIsFullPath(inName.c_str()))
-    {
+  if (cmSystemTools::FileIsFullPath(inName.c_str())) {
     // This is a full path.  Return it as given.
     dep = inName;
     return true;
-    }
+  }
 
   // Check for a source file in this directory that matches the
   // dependency.
-  if(cmSourceFile* sf = this->Makefile->GetSource(inName))
-    {
+  if (cmSourceFile* sf = this->Makefile->GetSource(inName)) {
     dep = sf->GetFullPath();
     return true;
-    }
+  }
 
   // Treat the name as relative to the source directory in which it
   // was given.
@@ -1924,82 +1639,69 @@ bool cmLocalGenerator::GetRealDependency(const std::string& inName,
 }
 
 void cmLocalGenerator::AddSharedFlags(std::string& flags,
-                                      const std::string& lang,
-                                      bool shared)
+                                      const std::string& lang, bool shared)
 {
   std::string flagsVar;
 
   // Add flags for dealing with shared libraries for this language.
-  if(shared)
-    {
+  if (shared) {
     flagsVar = "CMAKE_SHARED_LIBRARY_";
     flagsVar += lang;
     flagsVar += "_FLAGS";
     this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar));
-    }
+  }
 }
 
-void cmLocalGenerator::
-AddCompilerRequirementFlag(std::string &flags,
-                           cmGeneratorTarget const* target,
-                           const std::string& lang)
+void cmLocalGenerator::AddCompilerRequirementFlag(
+  std::string& flags, cmGeneratorTarget const* target, const std::string& lang)
 {
-  if (lang.empty())
-    {
+  if (lang.empty()) {
     return;
-    }
-  const char* defaultStd
-      = this->Makefile->GetDefinition("CMAKE_" + lang + "_STANDARD_DEFAULT");
-  if (!defaultStd || !*defaultStd)
-    {
+  }
+  const char* defaultStd =
+    this->Makefile->GetDefinition("CMAKE_" + lang + "_STANDARD_DEFAULT");
+  if (!defaultStd || !*defaultStd) {
     // This compiler has no notion of language standard levels.
     return;
-    }
+  }
   std::string stdProp = lang + "_STANDARD";
-  const char *standardProp = target->GetProperty(stdProp);
-  if (!standardProp)
-    {
+  const char* standardProp = target->GetProperty(stdProp);
+  if (!standardProp) {
     return;
-    }
+  }
   std::string extProp = lang + "_EXTENSIONS";
   std::string type = "EXTENSION";
   bool ext = true;
-  if (const char* extPropValue = target->GetProperty(extProp))
-    {
-    if (cmSystemTools::IsOff(extPropValue))
-      {
+  if (const char* extPropValue = target->GetProperty(extProp)) {
+    if (cmSystemTools::IsOff(extPropValue)) {
       ext = false;
       type = "STANDARD";
-      }
     }
+  }
 
-  if (target->GetPropertyAsBool(lang + "_STANDARD_REQUIRED"))
-    {
+  if (target->GetPropertyAsBool(lang + "_STANDARD_REQUIRED")) {
     std::string option_flag =
-              "CMAKE_" + lang + standardProp
-                      + "_" + type + "_COMPILE_OPTION";
+      "CMAKE_" + lang + standardProp + "_" + type + "_COMPILE_OPTION";
 
-    const char *opt = target->Target->GetMakefile()
-        ->GetDefinition(option_flag);
-    if (!opt)
-      {
+    const char* opt =
+      target->Target->GetMakefile()->GetDefinition(option_flag);
+    if (!opt) {
       std::ostringstream e;
       e << "Target \"" << target->GetName() << "\" requires the language "
-           "dialect \"" << lang << standardProp << "\" "
-        << (ext ? "(with compiler extensions)" : "") << ", but CMake "
+                                               "dialect \""
+        << lang << standardProp << "\" "
+        << (ext ? "(with compiler extensions)" : "")
+        << ", but CMake "
            "does not know the compile flags to use to enable it.";
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
-      }
-    else
-      {
+    } else {
       this->AppendFlagEscape(flags, opt);
-      }
-    return;
     }
+    return;
+  }
 
   static std::map<std::string, std::vector<std::string> > langStdMap;
-  if (langStdMap.empty())
-    {
+  if (langStdMap.empty()) {
     // Maintain sorted order, most recent first.
     langStdMap["CXX"].push_back("14");
     langStdMap["CXX"].push_back("11");
@@ -2008,146 +1710,126 @@ AddCompilerRequirementFlag(std::string &flags,
     langStdMap["C"].push_back("11");
     langStdMap["C"].push_back("99");
     langStdMap["C"].push_back("90");
-    }
+  }
 
   std::string standard(standardProp);
 
   std::vector<std::string>& stds = langStdMap[lang];
 
   std::vector<std::string>::const_iterator stdIt =
-                                std::find(stds.begin(), stds.end(), standard);
-  if (stdIt == stds.end())
-    {
+    std::find(stds.begin(), stds.end(), standard);
+  if (stdIt == stds.end()) {
     std::string e =
       lang + "_STANDARD is set to invalid value '" + standard + "'";
-    this->GetGlobalGenerator()->GetCMakeInstance()
-      ->IssueMessage(cmake::FATAL_ERROR, e, target->GetBacktrace());
+    this->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
+      cmake::FATAL_ERROR, e, target->GetBacktrace());
     return;
-    }
+  }
 
   std::vector<std::string>::const_iterator defaultStdIt =
     std::find(stds.begin(), stds.end(), defaultStd);
-  if (defaultStdIt == stds.end())
-    {
-    std::string e =
-      "CMAKE_" + lang + "_STANDARD_DEFAULT is set to invalid value '" +
-      std::string(defaultStd) + "'";
+  if (defaultStdIt == stds.end()) {
+    std::string e = "CMAKE_" + lang +
+      "_STANDARD_DEFAULT is set to invalid value '" + std::string(defaultStd) +
+      "'";
     this->IssueMessage(cmake::INTERNAL_ERROR, e);
     return;
-    }
+  }
 
   // Greater or equal because the standards are stored in
   // backward chronological order.
-  if (stdIt >= defaultStdIt)
-    {
+  if (stdIt >= defaultStdIt) {
     std::string option_flag =
-              "CMAKE_" + lang + *stdIt
-                      + "_" + type + "_COMPILE_OPTION";
+      "CMAKE_" + lang + *stdIt + "_" + type + "_COMPILE_OPTION";
 
-    const char *opt =
-        target->Target->GetMakefile()->GetRequiredDefinition(option_flag);
+    const char* opt =
+      target->Target->GetMakefile()->GetRequiredDefinition(option_flag);
     this->AppendFlagEscape(flags, opt);
     return;
-    }
+  }
 
-  for ( ; stdIt < defaultStdIt; ++stdIt)
-    {
+  for (; stdIt < defaultStdIt; ++stdIt) {
     std::string option_flag =
-              "CMAKE_" + lang + *stdIt
-                      + "_" + type + "_COMPILE_OPTION";
+      "CMAKE_" + lang + *stdIt + "_" + type + "_COMPILE_OPTION";
 
-    if (const char *opt = target->Target
-        ->GetMakefile()->GetDefinition(option_flag))
-      {
+    if (const char* opt =
+          target->Target->GetMakefile()->GetDefinition(option_flag)) {
       this->AppendFlagEscape(flags, opt);
       return;
-      }
     }
+  }
 }
 
-static void AddVisibilityCompileOption(std::string &flags,
+static void AddVisibilityCompileOption(std::string& flags,
                                        cmGeneratorTarget const* target,
-                                       cmLocalGenerator *lg,
+                                       cmLocalGenerator* lg,
                                        const std::string& lang,
                                        std::string* warnCMP0063)
 {
   std::string l(lang);
   std::string compileOption = "CMAKE_" + l + "_COMPILE_OPTIONS_VISIBILITY";
-  const char *opt = lg->GetMakefile()->GetDefinition(compileOption);
-  if (!opt)
-    {
+  const char* opt = lg->GetMakefile()->GetDefinition(compileOption);
+  if (!opt) {
     return;
-    }
+  }
   std::string flagDefine = l + "_VISIBILITY_PRESET";
 
-  const char *prop = target->GetProperty(flagDefine);
-  if (!prop)
-    {
+  const char* prop = target->GetProperty(flagDefine);
+  if (!prop) {
     return;
-    }
-  if (warnCMP0063)
-    {
+  }
+  if (warnCMP0063) {
     *warnCMP0063 += "  " + flagDefine + "\n";
     return;
-    }
-  if (strcmp(prop, "hidden") != 0
-      && strcmp(prop, "default") != 0
-      && strcmp(prop, "protected") != 0
-      && strcmp(prop, "internal") != 0 )
-    {
+  }
+  if (strcmp(prop, "hidden") != 0 && strcmp(prop, "default") != 0 &&
+      strcmp(prop, "protected") != 0 && strcmp(prop, "internal") != 0) {
     std::ostringstream e;
-    e << "Target " << target->GetName() << " uses unsupported value \""
-      << prop << "\" for " << flagDefine << ".";
+    e << "Target " << target->GetName() << " uses unsupported value \"" << prop
+      << "\" for " << flagDefine << ".";
     cmSystemTools::Error(e.str().c_str());
     return;
-    }
+  }
   std::string option = std::string(opt) + prop;
   lg->AppendFlags(flags, option);
 }
 
-static void AddInlineVisibilityCompileOption(std::string &flags,
-                                       cmGeneratorTarget const* target,
-                                       cmLocalGenerator *lg,
-                                       std::string* warnCMP0063)
+static void AddInlineVisibilityCompileOption(std::string& flags,
+                                             cmGeneratorTarget const* target,
+                                             cmLocalGenerator* lg,
+                                             std::string* warnCMP0063)
 {
-  std::string compileOption
-                = "CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN";
-  const char *opt = lg->GetMakefile()->GetDefinition(compileOption);
-  if (!opt)
-    {
+  std::string compileOption =
+    "CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN";
+  const char* opt = lg->GetMakefile()->GetDefinition(compileOption);
+  if (!opt) {
     return;
-    }
+  }
 
   bool prop = target->GetPropertyAsBool("VISIBILITY_INLINES_HIDDEN");
-  if (!prop)
-    {
+  if (!prop) {
     return;
-    }
-  if (warnCMP0063)
-    {
+  }
+  if (warnCMP0063) {
     *warnCMP0063 += "  VISIBILITY_INLINES_HIDDEN\n";
     return;
-    }
+  }
   lg->AppendFlags(flags, opt);
 }
 
-void cmLocalGenerator
-::AddVisibilityPresetFlags(std::string &flags, cmGeneratorTarget const* target,
-                            const std::string& lang)
+void cmLocalGenerator::AddVisibilityPresetFlags(
+  std::string& flags, cmGeneratorTarget const* target, const std::string& lang)
 {
-  if (lang.empty())
-    {
+  if (lang.empty()) {
     return;
-    }
+  }
 
   std::string warnCMP0063;
-  std::string *pWarnCMP0063 = 0;
+  std::string* pWarnCMP0063 = 0;
   if (target->GetType() != cmState::SHARED_LIBRARY &&
       target->GetType() != cmState::MODULE_LIBRARY &&
-      !target->IsExecutableWithExports())
-    {
-    switch (target->GetPolicyStatusCMP0063())
-      {
+      !target->IsExecutableWithExports()) {
+    switch (target->GetPolicyStatusCMP0063()) {
       case cmPolicies::OLD:
         return;
       case cmPolicies::WARN:
@@ -2155,19 +1837,16 @@ void cmLocalGenerator
         break;
       default:
         break;
-      }
     }
+  }
 
   AddVisibilityCompileOption(flags, target, this, lang, pWarnCMP0063);
 
-  if(lang == "CXX")
-    {
+  if (lang == "CXX") {
     AddInlineVisibilityCompileOption(flags, target, this, pWarnCMP0063);
-    }
+  }
 
-  if (!warnCMP0063.empty() &&
-      this->WarnCMP0063.insert(target).second)
-    {
+  if (!warnCMP0063.empty() && this->WarnCMP0063.insert(target).second) {
     std::ostringstream w;
     /* clang-format off */
     w <<
@@ -2178,13 +1857,12 @@ void cmLocalGenerator
       warnCMP0063 <<
       "For compatibility CMake is not honoring them for this target.";
     /* clang-format on */
-    target->GetLocalGenerator()->GetCMakeInstance()
-      ->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
-                     target->GetBacktrace());
-    }
+    target->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
+      cmake::AUTHOR_WARNING, w.str(), target->GetBacktrace());
+  }
 }
 
-void cmLocalGenerator::AddCMP0018Flags(std::string &flags,
+void cmLocalGenerator::AddCMP0018Flags(std::string& flags,
                                        cmGeneratorTarget const* target,
                                        std::string const& lang,
                                        const std::string& config)
@@ -2192,60 +1870,50 @@ void cmLocalGenerator::AddCMP0018Flags(std::string &flags,
   int targetType = target->GetType();
 
   bool shared = ((targetType == cmState::SHARED_LIBRARY) ||
-                  (targetType == cmState::MODULE_LIBRARY));
+                 (targetType == cmState::MODULE_LIBRARY));
 
-  if (this->GetShouldUseOldFlags(shared, lang))
-    {
+  if (this->GetShouldUseOldFlags(shared, lang)) {
     this->AddSharedFlags(flags, lang, shared);
-    }
-  else
-    {
-    if (target->GetType() == cmState::OBJECT_LIBRARY)
-      {
-      if (target->GetPropertyAsBool("POSITION_INDEPENDENT_CODE"))
-        {
+  } else {
+    if (target->GetType() == cmState::OBJECT_LIBRARY) {
+      if (target->GetPropertyAsBool("POSITION_INDEPENDENT_CODE")) {
         this->AddPositionIndependentFlags(flags, lang, targetType);
-        }
-      return;
       }
+      return;
+    }
 
     if (target->GetLinkInterfaceDependentBoolProperty(
-                                                "POSITION_INDEPENDENT_CODE",
-                                                config))
-      {
+          "POSITION_INDEPENDENT_CODE", config)) {
       this->AddPositionIndependentFlags(flags, lang, targetType);
-      }
-    if (shared)
-      {
+    }
+    if (shared) {
       this->AppendFeatureOptions(flags, lang, "DLL");
-      }
     }
+  }
 }
 
 bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
-                                            const std::string &lang) const
+                                            const std::string& lang) const
 {
   std::string originalFlags =
     this->GlobalGenerator->GetSharedLibFlagsForLanguage(lang);
-  if (shared)
-    {
+  if (shared) {
     std::string flagsVar = "CMAKE_SHARED_LIBRARY_";
     flagsVar += lang;
     flagsVar += "_FLAGS";
-    const char* flags =
-        this->Makefile->GetSafeDefinition(flagsVar);
-
-    if (flags && flags != originalFlags)
-      {
-      switch (this->GetPolicyStatus(cmPolicies::CMP0018))
-        {
-        case cmPolicies::WARN:
-        {
+    const char* flags = this->Makefile->GetSafeDefinition(flagsVar);
+
+    if (flags && flags != originalFlags) {
+      switch (this->GetPolicyStatus(cmPolicies::CMP0018)) {
+        case cmPolicies::WARN: {
           std::ostringstream e;
-          e << "Variable " << flagsVar << " has been modified. CMake "
-            "will ignore the POSITION_INDEPENDENT_CODE target property for "
-            "shared libraries and will use the " << flagsVar << " variable "
-            "instead.  This may cause errors if the original content of "
+          e << "Variable " << flagsVar
+            << " has been modified. CMake "
+               "will ignore the POSITION_INDEPENDENT_CODE target property for "
+               "shared libraries and will use the "
+            << flagsVar
+            << " variable "
+               "instead.  This may cause errors if the original content of "
             << flagsVar << " was removed.\n"
             << cmPolicies::GetPolicyWarning(cmPolicies::CMP0018);
 
@@ -2258,9 +1926,9 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
         case cmPolicies::REQUIRED_ALWAYS:
         case cmPolicies::NEW:
           return false;
-        }
       }
     }
+  }
   return false;
 }
 
@@ -2270,30 +1938,26 @@ void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags,
 {
   const char* picFlags = 0;
 
-  if(targetType == cmState::EXECUTABLE)
-    {
+  if (targetType == cmState::EXECUTABLE) {
     std::string flagsVar = "CMAKE_";
     flagsVar += lang;
     flagsVar += "_COMPILE_OPTIONS_PIE";
     picFlags = this->Makefile->GetSafeDefinition(flagsVar);
-    }
-  if (!picFlags)
-    {
+  }
+  if (!picFlags) {
     std::string flagsVar = "CMAKE_";
     flagsVar += lang;
     flagsVar += "_COMPILE_OPTIONS_PIC";
     picFlags = this->Makefile->GetSafeDefinition(flagsVar);
-    }
-  if (picFlags)
-    {
+  }
+  if (picFlags) {
     std::vector<std::string> options;
     cmSystemTools::ExpandListArgument(picFlags, options);
-    for(std::vector<std::string>::const_iterator oi = options.begin();
-        oi != options.end(); ++oi)
-      {
+    for (std::vector<std::string>::const_iterator oi = options.begin();
+         oi != options.end(); ++oi) {
       this->AppendFlagEscape(flags, *oi);
-      }
     }
+  }
 }
 
 void cmLocalGenerator::AddConfigVariableFlags(std::string& flags,
@@ -2304,34 +1968,29 @@ void cmLocalGenerator::AddConfigVariableFlags(std::string& flags,
   std::string flagsVar = var;
   this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar));
   // Add the flags from the build-type specific variable.
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     flagsVar += "_";
     flagsVar += cmSystemTools::UpperCase(config);
     this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar));
-    }
+  }
 }
 
 void cmLocalGenerator::AppendFlags(std::string& flags,
                                    const std::string& newFlags)
 {
-  if(!newFlags.empty())
-    {
-    if(!flags.empty())
-      {
+  if (!newFlags.empty()) {
+    if (!flags.empty()) {
       flags += " ";
-      }
-    flags += newFlags;
     }
+    flags += newFlags;
+  }
 }
 
-void cmLocalGenerator::AppendFlags(std::string& flags,
-                                   const char* newFlags)
+void cmLocalGenerator::AppendFlags(std::string& flags, const char* newFlags)
 {
-  if(newFlags && *newFlags)
-    {
+  if (newFlags && *newFlags) {
     this->AppendFlags(flags, std::string(newFlags));
-    }
+  }
 }
 
 void cmLocalGenerator::AppendFlagEscape(std::string& flags,
@@ -2344,10 +2003,9 @@ void cmLocalGenerator::AppendDefines(std::set<std::string>& defines,
                                      const char* defines_list)
 {
   // Short-circuit if there are no definitions.
-  if(!defines_list)
-    {
+  if (!defines_list) {
     return;
-    }
+  }
 
   // Expand the list of definitions.
   std::vector<std::string> defines_vec;
@@ -2355,48 +2013,42 @@ void cmLocalGenerator::AppendDefines(std::set<std::string>& defines,
   this->AppendDefines(defines, defines_vec);
 }
 
-void cmLocalGenerator::AppendDefines(std::set<std::string>& defines,
-                                  const std::vector<std::string> &defines_vec)
+void cmLocalGenerator::AppendDefines(
+  std::set<std::string>& defines, const std::vector<std::string>& defines_vec)
 {
-  for(std::vector<std::string>::const_iterator di = defines_vec.begin();
-      di != defines_vec.end(); ++di)
-    {
+  for (std::vector<std::string>::const_iterator di = defines_vec.begin();
+       di != defines_vec.end(); ++di) {
     // Skip unsupported definitions.
-    if(!this->CheckDefinition(*di))
-      {
+    if (!this->CheckDefinition(*di)) {
       continue;
-      }
-    defines.insert(*di);
     }
+    defines.insert(*di);
+  }
 }
 
 void cmLocalGenerator::JoinDefines(const std::set<std::string>& defines,
-                                   std::string &definesString,
+                                   std::string& definesString,
                                    const std::string& lang)
 {
   // Lookup the define flag for the current language.
   std::string dflag = "-D";
-  if(!lang.empty())
-    {
+  if (!lang.empty()) {
     std::string defineFlagVar = "CMAKE_";
     defineFlagVar += lang;
     defineFlagVar += "_DEFINE_FLAG";
     const char* df = this->Makefile->GetDefinition(defineFlagVar);
-    if(df && *df)
-      {
+    if (df && *df) {
       dflag = df;
-      }
     }
+  }
 
   std::set<std::string>::const_iterator defineIt = defines.begin();
   const std::set<std::string>::const_iterator defineEnd = defines.end();
   const char* itemSeparator = definesString.empty() ? "" : " ";
-  for( ; defineIt != defineEnd; ++defineIt)
-    {
+  for (; defineIt != defineEnd; ++defineIt) {
     // Append the definition with proper escaping.
     std::string def = dflag;
-    if(this->GetState()->UseWatcomWMake())
-      {
+    if (this->GetState()->UseWatcomWMake()) {
       // The Watcom compiler does its own command line parsing instead
       // of using the windows shell rules.  Definitions are one of
       //   -DNAME
@@ -2407,50 +2059,44 @@ void cmLocalGenerator::JoinDefines(const std::set<std::string>& defines,
       // command line without any escapes.  However we still have to
       // get the '$' and '#' characters through WMake as '$$' and
       // '$#'.
-      for(const char* c = defineIt->c_str(); *c; ++c)
-        {
-        if(*c == '$' || *c == '#')
-          {
+      for (const char* c = defineIt->c_str(); *c; ++c) {
+        if (*c == '$' || *c == '#') {
           def += '$';
-          }
-        def += *c;
         }
+        def += *c;
       }
-    else
-      {
+    } else {
       // Make the definition appear properly on the command line.  Use
       // -DNAME="value" instead of -D"NAME=value" for historical reasons.
       std::string::size_type eq = defineIt->find("=");
       def += defineIt->substr(0, eq);
-      if(eq != defineIt->npos)
-        {
+      if (eq != defineIt->npos) {
         def += "=";
         def += this->EscapeForShell(defineIt->c_str() + eq + 1, true);
-        }
       }
+    }
     definesString += itemSeparator;
     itemSeparator = " ";
     definesString += def;
-    }
+  }
 }
 
-void cmLocalGenerator::AppendFeatureOptions(
-  std::string& flags, const std::string& lang, const char* feature)
+void cmLocalGenerator::AppendFeatureOptions(std::string& flags,
+                                            const std::string& lang,
+                                            const char* feature)
 {
   std::string optVar = "CMAKE_";
   optVar += lang;
   optVar += "_COMPILE_OPTIONS_";
   optVar += feature;
-  if(const char* optionList = this->Makefile->GetDefinition(optVar))
-    {
+  if (const char* optionList = this->Makefile->GetDefinition(optVar)) {
     std::vector<std::string> options;
     cmSystemTools::ExpandListArgument(optionList, options);
-    for(std::vector<std::string>::const_iterator oi = options.begin();
-        oi != options.end(); ++oi)
-      {
+    for (std::vector<std::string>::const_iterator oi = options.begin();
+         oi != options.end(); ++oi) {
       this->AppendFlagEscape(flags, *oi);
-      }
     }
+  }
 }
 
 const char* cmLocalGenerator::GetFeature(const std::string& feature,
@@ -2459,20 +2105,17 @@ const char* cmLocalGenerator::GetFeature(const std::string& feature,
   std::string featureName = feature;
   // TODO: Define accumulation policy for features (prepend, append, replace).
   // Currently we always replace.
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     featureName += "_";
     featureName += cmSystemTools::UpperCase(config);
-    }
+  }
   cmState::Snapshot snp = this->StateSnapshot;
-  while(snp.IsValid())
-    {
-    if(const char* value = snp.GetDirectory().GetProperty(featureName))
-      {
+  while (snp.IsValid()) {
+    if (const char* value = snp.GetDirectory().GetProperty(featureName)) {
       return value;
-      }
-    snp = snp.GetBuildsystemDirectoryParent();
     }
+    snp = snp.GetBuildsystemDirectoryParent();
+  }
   return 0;
 }
 
@@ -2481,135 +2124,118 @@ std::string cmLocalGenerator::GetProjectName() const
   return this->StateSnapshot.GetProjectName();
 }
 
-std::string
-cmLocalGenerator::ConstructComment(cmCustomCommandGenerator const& ccg,
-                                   const char* default_comment)
+std::string cmLocalGenerator::ConstructComment(
+  cmCustomCommandGenerator const& ccg, const char* default_comment)
 {
   // Check for a comment provided with the command.
-  if(ccg.GetComment())
-    {
+  if (ccg.GetComment()) {
     return ccg.GetComment();
-    }
+  }
 
   // Construct a reasonable default comment if possible.
-  if(!ccg.GetOutputs().empty())
-    {
+  if (!ccg.GetOutputs().empty()) {
     std::string comment;
     comment = "Generating ";
     const char* sep = "";
-    for(std::vector<std::string>::const_iterator o = ccg.GetOutputs().begin();
-        o != ccg.GetOutputs().end(); ++o)
-      {
+    for (std::vector<std::string>::const_iterator o = ccg.GetOutputs().begin();
+         o != ccg.GetOutputs().end(); ++o) {
       comment += sep;
       comment += this->Convert(*o, cmLocalGenerator::START_OUTPUT);
       sep = ", ";
-      }
-    return comment;
     }
+    return comment;
+  }
 
   // Otherwise use the provided default.
   return default_comment;
 }
 
-class cmInstallTargetGeneratorLocal: public cmInstallTargetGenerator
+class cmInstallTargetGeneratorLocal : public cmInstallTargetGenerator
 {
 public:
   cmInstallTargetGeneratorLocal(cmLocalGenerator* lg, std::string const& t,
-                                const char* dest, bool implib):
-    cmInstallTargetGenerator(
-      t, dest, implib, "", std::vector<std::string>(), "Unspecified",
-      cmInstallGenerator::SelectMessageLevel(lg->GetMakefile()),
-      false, false)
+                                const char* dest, bool implib)
+    : cmInstallTargetGenerator(
+        t, dest, implib, "", std::vector<std::string>(), "Unspecified",
+        cmInstallGenerator::SelectMessageLevel(lg->GetMakefile()), false,
+        false)
   {
     this->Compute(lg);
   }
 };
 
-void
-cmLocalGenerator
-::GenerateTargetInstallRules(
+void cmLocalGenerator::GenerateTargetInstallRules(
   std::ostream& os, const std::string& config,
   std::vector<std::string> const& configurationTypes)
 {
   // Convert the old-style install specification from each target to
   // an install generator and run it.
   std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); ++l)
-    {
-    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); ++l) {
+    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
 
     // Include the user-specified pre-install script for this target.
-    if(const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT"))
-      {
+    if (const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT")) {
       cmInstallScriptGenerator g(preinstall, false, 0, false);
       g.Generate(os, config, configurationTypes);
-      }
+    }
 
     // Install this target if a destination is given.
-    if((*l)->Target->GetInstallPath() != "")
-      {
+    if ((*l)->Target->GetInstallPath() != "") {
       // Compute the full install destination.  Note that converting
       // to unix slashes also removes any trailing slash.
       // We also skip over the leading slash given by the user.
       std::string destination = (*l)->Target->GetInstallPath().substr(1);
       cmSystemTools::ConvertToUnixSlashes(destination);
-      if(destination.empty())
-        {
+      if (destination.empty()) {
         destination = ".";
-        }
+      }
 
       // Generate the proper install generator for this target type.
-      switch((*l)->GetType())
-        {
+      switch ((*l)->GetType()) {
         case cmState::EXECUTABLE:
         case cmState::STATIC_LIBRARY:
-        case cmState::MODULE_LIBRARY:
-          {
+        case cmState::MODULE_LIBRARY: {
           // Use a target install generator.
-          cmInstallTargetGeneratorLocal
-            g(this, (*l)->GetName(), destination.c_str(), false);
+          cmInstallTargetGeneratorLocal g(this, (*l)->GetName(),
+                                          destination.c_str(), false);
           g.Generate(os, config, configurationTypes);
-          }
-          break;
-        case cmState::SHARED_LIBRARY:
-          {
+        } break;
+        case cmState::SHARED_LIBRARY: {
 #if defined(_WIN32) || defined(__CYGWIN__)
           // Special code to handle DLL.  Install the import library
           // to the normal destination and the DLL to the runtime
           // destination.
-          cmInstallTargetGeneratorLocal
-            g1(this, (*l)->GetName(), destination.c_str(), true);
+          cmInstallTargetGeneratorLocal g1(this, (*l)->GetName(),
+                                           destination.c_str(), true);
           g1.Generate(os, config, configurationTypes);
           // We also skip over the leading slash given by the user.
           destination = (*l)->Target->GetRuntimeInstallPath().substr(1);
           cmSystemTools::ConvertToUnixSlashes(destination);
-          cmInstallTargetGeneratorLocal
-            g2(this, (*l)->GetName(), destination.c_str(), false);
+          cmInstallTargetGeneratorLocal g2(this, (*l)->GetName(),
+                                           destination.c_str(), false);
           g2.Generate(os, config, configurationTypes);
 #else
           // Use a target install generator.
-          cmInstallTargetGeneratorLocal
-            g(this, (*l)->GetName(), destination.c_str(), false);
+          cmInstallTargetGeneratorLocal g(this, (*l)->GetName(),
+                                          destination.c_str(), false);
           g.Generate(os, config, configurationTypes);
 #endif
-          }
-          break;
+        } break;
         default:
           break;
-        }
       }
+    }
 
     // Include the user-specified post-install script for this target.
-    if(const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT"))
-      {
+    if (const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT")) {
       cmInstallScriptGenerator g(postinstall, false, 0, false);
       g.Generate(os, config, configurationTypes);
-      }
     }
+  }
 }
 
 #if defined(CM_LG_ENCODE_OBJECT_NAMES)
@@ -2624,27 +2250,24 @@ static std::string cmLocalGeneratorMD5(const char* input)
   return std::string(md5out, 32);
 }
 
-static bool
-cmLocalGeneratorShortenObjectName(std::string& objName,
-                                  std::string::size_type max_len)
+static bool cmLocalGeneratorShortenObjectName(std::string& objName,
+                                              std::string::size_type max_len)
 {
   // Replace the beginning of the path portion of the object name with
   // its own md5 sum.
-  std::string::size_type pos = objName.find('/', objName.size()-max_len+32);
-  if(pos != objName.npos)
-    {
+  std::string::size_type pos =
+    objName.find('/', objName.size() - max_len + 32);
+  if (pos != objName.npos) {
     std::string md5name = cmLocalGeneratorMD5(objName.substr(0, pos).c_str());
     md5name += objName.substr(pos);
     objName = md5name;
 
     // The object name is now short enough.
     return true;
-    }
-  else
-    {
+  } else {
     // The object name could not be shortened enough.
     return false;
-    }
+  }
 }
 
 bool cmLocalGeneratorCheckObjectName(std::string& objName,
@@ -2653,41 +2276,32 @@ bool cmLocalGeneratorCheckObjectName(std::string& objName,
 {
   // Enforce the maximum file name length if possible.
   std::string::size_type max_obj_len = max_total_len;
-  if(dir_len < max_total_len)
-    {
+  if (dir_len < max_total_len) {
     max_obj_len = max_total_len - dir_len;
-    if(objName.size() > max_obj_len)
-      {
+    if (objName.size() > max_obj_len) {
       // The current object file name is too long.  Try to shorten it.
       return cmLocalGeneratorShortenObjectName(objName, max_obj_len);
-      }
-    else
-      {
+    } else {
       // The object file name is short enough.
       return true;
-      }
     }
-  else
-    {
+  } else {
     // The build directory in which the object will be stored is
     // already too deep.
     return false;
-    }
+  }
 }
 #endif
 
-std::string&
-cmLocalGenerator
-::CreateSafeUniqueObjectFileName(const std::string& sin,
-                                 std::string const& dir_max)
+std::string& cmLocalGenerator::CreateSafeUniqueObjectFileName(
+  const std::string& sin, std::string const& dir_max)
 {
   // Look for an existing mapped name for this object file.
-  std::map<std::string,std::string>::iterator it =
+  std::map<std::string, std::string>::iterator it =
     this->UniqueObjectNamesMap.find(sin);
 
   // If no entry exists create one.
-  if(it == this->UniqueObjectNamesMap.end())
-    {
+  if (it == this->UniqueObjectNamesMap.end()) {
     // Start with the original name.
     std::string ssin = sin;
 
@@ -2704,44 +2318,35 @@ cmLocalGenerator
     cmSystemTools::ReplaceString(ssin, " ", "_");
 
     // Mangle the name if necessary.
-    if(this->Makefile->IsOn("CMAKE_MANGLE_OBJECT_FILE_NAMES"))
-      {
+    if (this->Makefile->IsOn("CMAKE_MANGLE_OBJECT_FILE_NAMES")) {
       bool done;
       int cc = 0;
       char rpstr[100];
       sprintf(rpstr, "_p_");
       cmSystemTools::ReplaceString(ssin, "+", rpstr);
       std::string sssin = sin;
-      do
-        {
+      do {
         done = true;
-        for ( it = this->UniqueObjectNamesMap.begin();
-              it != this->UniqueObjectNamesMap.end();
-              ++ it )
-          {
-          if ( it->second == ssin )
-            {
+        for (it = this->UniqueObjectNamesMap.begin();
+             it != this->UniqueObjectNamesMap.end(); ++it) {
+          if (it->second == ssin) {
             done = false;
-            }
           }
-        if ( done )
-          {
+        }
+        if (done) {
           break;
-          }
+        }
         sssin = ssin;
         cmSystemTools::ReplaceString(ssin, "_p_", rpstr);
         sprintf(rpstr, "_p%d_", cc++);
-        }
-      while ( !done );
-      }
+      } while (!done);
+    }
 
 #if defined(CM_LG_ENCODE_OBJECT_NAMES)
-    if(!cmLocalGeneratorCheckObjectName(ssin, dir_max.size(),
-                                        this->ObjectPathMax))
-      {
+    if (!cmLocalGeneratorCheckObjectName(ssin, dir_max.size(),
+                                         this->ObjectPathMax)) {
       // Warn if this is the first time the path has been seen.
-      if(this->ObjectMaxPathViolations.insert(dir_max).second)
-        {
+      if (this->ObjectMaxPathViolations.insert(dir_max).second) {
         std::ostringstream m;
         /* clang-format off */
         m << "The object file directory\n"
@@ -2756,8 +2361,8 @@ cmLocalGenerator
           << "The build may not work correctly.";
         /* clang-format on */
         this->IssueMessage(cmake::WARNING, m.str());
-        }
       }
+    }
 #else
     (void)dir_max;
 #endif
@@ -2765,17 +2370,15 @@ cmLocalGenerator
     // Insert the newly mapped object file name.
     std::map<std::string, std::string>::value_type e(sin, ssin);
     it = this->UniqueObjectNamesMap.insert(e).first;
-    }
+  }
 
   // Return the map entry.
   return it->second;
 }
 
 void cmLocalGenerator::ComputeObjectFilenames(
-                            std::map<cmSourceFile const*, std::string>&,
-                            cmGeneratorTarget const*)
+  std::map<cmSourceFile const*, std::string>&, cmGeneratorTarget const*)
 {
-
 }
 
 bool cmLocalGenerator::IsWindowsShell() const
@@ -2798,11 +2401,9 @@ bool cmLocalGenerator::IsNMake() const
   return this->GetState()->UseNMake();
 }
 
-std::string
-cmLocalGenerator
-::GetObjectFileNameWithoutTarget(const cmSourceFile& source,
-                                 std::string const& dir_max,
-                                 bool* hasSourceExtension)
+std::string cmLocalGenerator::GetObjectFileNameWithoutTarget(
+  const cmSourceFile& source, std::string const& dir_max,
+  bool* hasSourceExtension)
 {
   // Construct the object file name using the full path to the source
   // file which is its only unique identification.
@@ -2823,82 +2424,64 @@ cmLocalGenerator
   // Select a nice-looking reference to the source file to construct
   // the object file name.
   std::string objectName;
-  if((relSource && !relBinary) || (subSource && !subBinary))
-    {
+  if ((relSource && !relBinary) || (subSource && !subBinary)) {
     objectName = relFromSource;
-    }
-  else if((relBinary && !relSource) || (subBinary && !subSource))
-    {
+  } else if ((relBinary && !relSource) || (subBinary && !subSource)) {
     objectName = relFromBinary;
-    }
-  else if(relFromBinary.length() < relFromSource.length())
-    {
+  } else if (relFromBinary.length() < relFromSource.length()) {
     objectName = relFromBinary;
-    }
-  else
-    {
+  } else {
     objectName = relFromSource;
-    }
+  }
 
   // if it is still a full path check for the try compile case
   // try compile never have in source sources, and should not
   // have conflicting source file names in the same target
-  if(cmSystemTools::FileIsFullPath(objectName.c_str()))
-    {
-    if(this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile())
-      {
+  if (cmSystemTools::FileIsFullPath(objectName.c_str())) {
+    if (this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile()) {
       objectName = cmSystemTools::GetFilenameName(source.GetFullPath());
-      }
     }
+  }
 
   // Replace the original source file extension with the object file
   // extension.
   bool keptSourceExtension = true;
-  if(!source.GetPropertyAsBool("KEEP_EXTENSION"))
-    {
+  if (!source.GetPropertyAsBool("KEEP_EXTENSION")) {
     // Decide whether this language wants to replace the source
     // extension with the object extension.  For CMake 2.4
     // compatibility do this by default.
     bool replaceExt = this->NeedBackwardsCompatibility_2_4();
-    if(!replaceExt)
-      {
+    if (!replaceExt) {
       std::string lang = source.GetLanguage();
-      if(!lang.empty())
-        {
+      if (!lang.empty()) {
         std::string repVar = "CMAKE_";
         repVar += lang;
         repVar += "_OUTPUT_EXTENSION_REPLACE";
         replaceExt = this->Makefile->IsOn(repVar);
-        }
       }
+    }
 
     // Remove the source extension if it is to be replaced.
-    if(replaceExt)
-      {
+    if (replaceExt) {
       keptSourceExtension = false;
       std::string::size_type dot_pos = objectName.rfind(".");
-      if(dot_pos != std::string::npos)
-        {
+      if (dot_pos != std::string::npos) {
         objectName = objectName.substr(0, dot_pos);
-        }
       }
+    }
 
     // Store the new extension.
-    objectName +=
-      this->GlobalGenerator->GetLanguageOutputExtension(source);
-    }
-  if(hasSourceExtension)
-    {
+    objectName += this->GlobalGenerator->GetLanguageOutputExtension(source);
+  }
+  if (hasSourceExtension) {
     *hasSourceExtension = keptSourceExtension;
-    }
+  }
 
   // Convert to a safe name.
   return this->CreateSafeUniqueObjectFileName(objectName, dir_max);
 }
 
-std::string
-cmLocalGenerator
-::GetSourceFileLanguage(const cmSourceFile& source)
+std::string cmLocalGenerator::GetSourceFileLanguage(const cmSourceFile& source)
 {
   return source.GetLanguage();
 }
@@ -2928,8 +2511,8 @@ const char* cmLocalGenerator::GetCurrentSourceDirectory() const
   return this->StateSnapshot.GetDirectory().GetCurrentSource();
 }
 
-std::string
-cmLocalGenerator::GetTargetDirectory(const cmGeneratorTarget*) const
+std::string cmLocalGenerator::GetTargetDirectory(
+  const cmGeneratorTarget*) const
 {
   cmSystemTools::Error("GetTargetDirectory"
                        " called on cmLocalGenerator");
@@ -2940,24 +2523,27 @@ KWIML_INT_uint64_t cmLocalGenerator::GetBackwardsCompatibility()
 {
   // The computed version may change until the project is fully
   // configured.
-  if(!this->BackwardsCompatibilityFinal)
-    {
+  if (!this->BackwardsCompatibilityFinal) {
     unsigned int major = 0;
     unsigned int minor = 0;
     unsigned int patch = 0;
-    if(const char* value
-       = this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY"))
-      {
-      switch(sscanf(value, "%u.%u.%u", &major, &minor, &patch))
-        {
-        case 2: patch = 0; break;
-        case 1: minor = 0; patch = 0; break;
-        default: break;
-        }
+    if (const char* value =
+          this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY")) {
+      switch (sscanf(value, "%u.%u.%u", &major, &minor, &patch)) {
+        case 2:
+          patch = 0;
+          break;
+        case 1:
+          minor = 0;
+          patch = 0;
+          break;
+        default:
+          break;
       }
+    }
     this->BackwardsCompatibility = CMake_VERSION_ENCODE(major, minor, patch);
     this->BackwardsCompatibilityFinal = true;
-    }
+  }
 
   return this->BackwardsCompatibility;
 }
@@ -2966,11 +2552,10 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4()
 {
   // Check the policy to decide whether to pay attention to this
   // variable.
-  switch(this->GetPolicyStatus(cmPolicies::CMP0001))
-    {
+  switch (this->GetPolicyStatus(cmPolicies::CMP0001)) {
     case cmPolicies::WARN:
-      // WARN is just OLD without warning because user code does not
-      // always affect whether this check is done.
+    // WARN is just OLD without warning because user code does not
+    // always affect whether this check is done.
     case cmPolicies::OLD:
       // Old behavior is to check the variable.
       break;
@@ -2984,17 +2569,16 @@ bool cmLocalGenerator::NeedBackwardsCompatibility_2_4()
       // 2.6 or higher.  Once we add that requirement then this whole
       // method can be removed anyway.
       return false;
-    }
+  }
 
   // Compatibility is needed if CMAKE_BACKWARDS_COMPATIBILITY is set
   // equal to or lower than the given version.
   KWIML_INT_uint64_t actual_compat = this->GetBackwardsCompatibility();
-  return (actual_compat &&
-          actual_compat <= CMake_VERSION_ENCODE(2, 4, 255));
+  return (actual_compat && actual_compat <= CMake_VERSION_ENCODE(2, 4, 255));
 }
 
-cmPolicies::PolicyStatus
-cmLocalGenerator::GetPolicyStatus(cmPolicies::PolicyID id) const
+cmPolicies::PolicyStatus cmLocalGenerator::GetPolicyStatus(
+  cmPolicies::PolicyID id) const
 {
   return this->Makefile->GetPolicyStatus(id);
 }
@@ -3003,10 +2587,8 @@ bool cmLocalGenerator::CheckDefinition(std::string const& define) const
 {
   // Many compilers do not support -DNAME(arg)=sdf so we disable it.
   std::string::size_type pos = define.find_first_of("(=");
-  if (pos != std::string::npos)
-    {
-    if (define[pos] == '(')
-      {
+  if (pos != std::string::npos) {
+    if (define[pos] == '(') {
       std::ostringstream e;
       /* clang-format off */
       e << "WARNING: Function-style preprocessor definitions may not be "
@@ -3017,12 +2599,11 @@ bool cmLocalGenerator::CheckDefinition(std::string const& define) const
       /* clang-format on */
       cmSystemTools::Message(e.str().c_str());
       return false;
-      }
     }
+  }
 
   // Many compilers do not support # in the value so we disable it.
-  if(define.find_first_of("#") != define.npos)
-    {
+  if (define.find_first_of("#") != define.npos) {
     std::ostringstream e;
     /* clang-format off */
     e << "WARNING: Preprocessor definitions containing '#' may not be "
@@ -3033,19 +2614,18 @@ bool cmLocalGenerator::CheckDefinition(std::string const& define) const
     /* clang-format on */
     cmSystemTools::Message(e.str().c_str());
     return false;
-    }
+  }
 
   // Assume it is supported.
   return true;
 }
 
 static void cmLGInfoProp(cmMakefile* mf, cmGeneratorTarget* target,
-    const std::string& prop)
+                         const std::string& prop)
 {
-  if(const char* val = target->GetProperty(prop))
-    {
+  if (const char* val = target->GetProperty(prop)) {
     mf->AddDefinition(prop, val);
-    }
+  }
 }
 
 void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target,
@@ -3054,23 +2634,20 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target,
 {
   // Find the Info.plist template.
   const char* in = target->GetProperty("MACOSX_BUNDLE_INFO_PLIST");
-  std::string inFile = (in && *in)? in : "MacOSXBundleInfo.plist.in";
-  if(!cmSystemTools::FileIsFullPath(inFile.c_str()))
-    {
+  std::string inFile = (in && *in) ? in : "MacOSXBundleInfo.plist.in";
+  if (!cmSystemTools::FileIsFullPath(inFile.c_str())) {
     std::string inMod = this->Makefile->GetModulesFile(inFile.c_str());
-    if(!inMod.empty())
-      {
+    if (!inMod.empty()) {
       inFile = inMod;
-      }
     }
-  if(!cmSystemTools::FileExists(inFile.c_str(), true))
-    {
+  }
+  if (!cmSystemTools::FileExists(inFile.c_str(), true)) {
     std::ostringstream e;
-    e << "Target " << target->GetName() << " Info.plist template \""
-      << inFile << "\" could not be found.";
+    e << "Target " << target->GetName() << " Info.plist template \"" << inFile
+      << "\" could not be found.";
     cmSystemTools::Error(e.str().c_str());
     return;
-    }
+  }
 
   // Convert target properties to variables in an isolated makefile
   // scope to configure the file.  If properties are set they will
@@ -3090,29 +2667,25 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target,
   mf->ConfigureFile(inFile.c_str(), fname, false, false, false);
 }
 
-void cmLocalGenerator::GenerateFrameworkInfoPList(cmGeneratorTarget* target,
-                                                const std::string& targetName,
-                                                const char* fname)
+void cmLocalGenerator::GenerateFrameworkInfoPList(
+  cmGeneratorTarget* target, const std::string& targetName, const char* fname)
 {
   // Find the Info.plist template.
   const char* in = target->GetProperty("MACOSX_FRAMEWORK_INFO_PLIST");
-  std::string inFile = (in && *in)? in : "MacOSXFrameworkInfo.plist.in";
-  if(!cmSystemTools::FileIsFullPath(inFile.c_str()))
-    {
+  std::string inFile = (in && *in) ? in : "MacOSXFrameworkInfo.plist.in";
+  if (!cmSystemTools::FileIsFullPath(inFile.c_str())) {
     std::string inMod = this->Makefile->GetModulesFile(inFile.c_str());
-    if(!inMod.empty())
-      {
+    if (!inMod.empty()) {
       inFile = inMod;
-      }
     }
-  if(!cmSystemTools::FileExists(inFile.c_str(), true))
-    {
+  }
+  if (!cmSystemTools::FileExists(inFile.c_str(), true)) {
     std::ostringstream e;
-    e << "Target " << target->GetName() << " Info.plist template \""
-      << inFile << "\" could not be found.";
+    e << "Target " << target->GetName() << " Info.plist template \"" << inFile
+      << "\" could not be found.";
     cmSystemTools::Error(e.str().c_str());
     return;
-    }
+  }
 
   // Convert target properties to variables in an isolated makefile
   // scope to configure the file.  If properties are set they will
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 33db68c..892ad4f 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -71,36 +71,36 @@ public:
   bool IsRootMakefile() const;
 
   ///! Get the makefile for this generator
-  cmMakefile *GetMakefile() {
-    return this->Makefile; }
+  cmMakefile* GetMakefile() { return this->Makefile; }
 
   ///! Get the makefile for this generator, const version
-    const cmMakefile *GetMakefile() const {
-      return this->Makefile; }
+  const cmMakefile* GetMakefile() const { return this->Makefile; }
 
   ///! Get the GlobalGenerator this is associated with
-  cmGlobalGenerator *GetGlobalGenerator() {
-    return this->GlobalGenerator; }
-  const cmGlobalGenerator *GetGlobalGenerator() const {
-    return this->GlobalGenerator; }
+  cmGlobalGenerator* GetGlobalGenerator() { return this->GlobalGenerator; }
+  const cmGlobalGenerator* GetGlobalGenerator() const
+  {
+    return this->GlobalGenerator;
+  }
 
   cmState* GetState() const;
   cmState::Snapshot GetStateSnapshot() const;
 
   void AddArchitectureFlags(std::string& flags,
                             cmGeneratorTarget const* target,
-                            const std::string&lang, const std::string& config);
+                            const std::string& lang,
+                            const std::string& config);
 
   void AddLanguageFlags(std::string& flags, const std::string& lang,
                         const std::string& config);
-  void AddCMP0018Flags(std::string &flags, cmGeneratorTarget const* target,
+  void AddCMP0018Flags(std::string& flags, cmGeneratorTarget const* target,
                        std::string const& lang, const std::string& config);
-  void AddVisibilityPresetFlags(std::string &flags,
+  void AddVisibilityPresetFlags(std::string& flags,
                                 cmGeneratorTarget const* target,
                                 const std::string& lang);
   void AddConfigVariableFlags(std::string& flags, const std::string& var,
                               const std::string& config);
-  void AddCompilerRequirementFlag(std::string &flags,
+  void AddCompilerRequirementFlag(std::string& flags,
                                   cmGeneratorTarget const* target,
                                   const std::string& lang);
   ///! Append flags to a string.
@@ -109,51 +109,48 @@ public:
   virtual void AppendFlagEscape(std::string& flags,
                                 const std::string& rawFlag);
   ///! Get the include flags for the current makefile and language
-  std::string GetIncludeFlags(const std::vector<std::string> &includes,
+  std::string GetIncludeFlags(const std::vector<std::string>& includes,
                               cmGeneratorTarget* target,
                               const std::string& lang,
                               bool forceFullPaths = false,
                               bool forResponseFile = false,
                               const std::string& config = "");
 
-  const std::vector<cmGeneratorTarget*> &GetGeneratorTargets() const
-    {
-      return this->GeneratorTargets;
-    }
+  const std::vector<cmGeneratorTarget*>& GetGeneratorTargets() const
+  {
+    return this->GeneratorTargets;
+  }
 
-  const std::vector<cmGeneratorTarget*> &GetImportedGeneratorTargets() const
-    {
-      return this->ImportedGeneratorTargets;
-    }
+  const std::vector<cmGeneratorTarget*>& GetImportedGeneratorTargets() const
+  {
+    return this->ImportedGeneratorTargets;
+  }
 
   void AddGeneratorTarget(cmGeneratorTarget* gt);
   void AddImportedGeneratorTarget(cmGeneratorTarget* gt);
   void AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt);
 
-  cmGeneratorTarget*
-    FindLocalNonAliasGeneratorTarget(const std::string& name) const;
+  cmGeneratorTarget* FindLocalNonAliasGeneratorTarget(
+    const std::string& name) const;
   cmGeneratorTarget* FindGeneratorTargetToUse(const std::string& name) const;
 
   /**
    * Encode a list of preprocessor definitions for the compiler
    * command line.
    */
-  void AppendDefines(std::set<std::string>& defines,
-                     const char* defines_list);
-  void AppendDefines(std::set<std::string>& defines,
-                     std::string defines_list)
+  void AppendDefines(std::set<std::string>& defines, const char* defines_list);
+  void AppendDefines(std::set<std::string>& defines, std::string defines_list)
   {
     this->AppendDefines(defines, defines_list.c_str());
   }
   void AppendDefines(std::set<std::string>& defines,
-                     const std::vector<std::string> &defines_vec);
+                     const std::vector<std::string>& defines_vec);
 
   /**
    * Join a set of defines into a definesString with a space separator.
    */
   void JoinDefines(const std::set<std::string>& defines,
-                   std::string &definesString,
-                   const std::string& lang);
+                   std::string& definesString, const std::string& lang);
 
   /** Lookup and append options associated with a particular feature.  */
   void AppendFeatureOptions(std::string& flags, const std::string& lang,
@@ -182,14 +179,14 @@ public:
                                                 bool forceFullPaths = false);
 
   /** Called from command-line hook to clear dependencies.  */
-  virtual void ClearDependencies(cmMakefile* /* mf */,
-                                 bool /* verbose */) {}
+  virtual void ClearDependencies(cmMakefile* /* mf */, bool /* verbose */) {}
 
   /** Called from command-line hook to update dependencies.  */
-  virtual bool UpdateDependencies(const char* /* tgtInfo */,
-                                  bool /*verbose*/,
+  virtual bool UpdateDependencies(const char* /* tgtInfo */, bool /*verbose*/,
                                   bool /*color*/)
-    { return true; }
+  {
+    return true;
+  }
 
   /** Get the include flags for the current makefile and language.  */
   void GetIncludeDirectories(std::vector<std::string>& dirs,
@@ -217,10 +214,7 @@ public:
   // ExpandRuleVariables
   struct RuleVariables
   {
-    RuleVariables()
-      {
-        memset(this, 0,  sizeof(*this));
-      }
+    RuleVariables() { memset(this, 0, sizeof(*this)); }
     cmGeneratorTarget* CMTarget;
     const char* TargetPDB;
     const char* TargetCompilePDB;
@@ -256,8 +250,8 @@ public:
    * Get the relative path from the generator output directory to a
    * per-target support directory.
    */
-  virtual std::string
-  GetTargetDirectory(cmGeneratorTarget const* target) const;
+  virtual std::string GetTargetDirectory(
+    cmGeneratorTarget const* target) const;
 
   /**
    * Get the level of backwards compatibility requested by the project
@@ -308,23 +302,19 @@ public:
                                              bool* hasSourceExtension = 0);
 
   /** Fill out the static linker flags for the given target.  */
-  void GetStaticLibraryFlags(std::string& flags,
-                             std::string const& config,
+  void GetStaticLibraryFlags(std::string& flags, std::string const& config,
                              cmGeneratorTarget* target);
 
   /** Fill out these strings for the given target.  Libraries to link,
    *  flags, and linkflags. */
-  void GetTargetFlags(std::string& linkLibs,
-                      std::string& flags,
-                      std::string& linkFlags,
-                      std::string& frameworkPath,
-                      std::string& linkPath,
-                      cmGeneratorTarget* target,
+  void GetTargetFlags(std::string& linkLibs, std::string& flags,
+                      std::string& linkFlags, std::string& frameworkPath,
+                      std::string& linkPath, cmGeneratorTarget* target,
                       bool useWatcomQuote);
 
   virtual void ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt = 0);
+    std::map<cmSourceFile const*, std::string>& mapping,
+    cmGeneratorTarget const* gt = 0);
 
   bool IsWindowsShell() const;
   bool IsWatcomWMake() const;
@@ -339,12 +329,9 @@ public:
 protected:
   ///! put all the libraries for a target on into the given stream
   void OutputLinkLibraries(std::string& linkLibraries,
-                                   std::string& frameworkPath,
-                                   std::string& linkPath,
-                                   cmGeneratorTarget &,
-                                   bool relink,
-                                   bool forResponseFile,
-                                   bool useWatcomQuote);
+                           std::string& frameworkPath, std::string& linkPath,
+                           cmGeneratorTarget&, bool relink,
+                           bool forResponseFile, bool useWatcomQuote);
 
   // Expand rule variables in CMake of the type found in language rules
   void ExpandRuleVariables(std::string& string,
@@ -373,9 +360,9 @@ protected:
       definition.  Issues a warning.  */
   virtual bool CheckDefinition(std::string const& define) const;
 
-  cmMakefile *Makefile;
+  cmMakefile* Makefile;
   cmState::Snapshot StateSnapshot;
-  cmGlobalGenerator *GlobalGenerator;
+  cmGlobalGenerator* GlobalGenerator;
   std::map<std::string, std::string> UniqueObjectNamesMap;
   std::string::size_type ObjectPathMax;
   std::set<std::string> ObjectMaxPathViolations;
@@ -394,10 +381,11 @@ protected:
 
   KWIML_INT_uint64_t BackwardsCompatibility;
   bool BackwardsCompatibilityFinal;
+
 private:
   void AddSharedFlags(std::string& flags, const std::string& lang,
                       bool shared);
-  bool GetShouldUseOldFlags(bool shared, const std::string &lang) const;
+  bool GetShouldUseOldFlags(bool shared, const std::string& lang) const;
   void AddPositionIndependentFlags(std::string& flags, std::string const& l,
                                    int targetType);
 
@@ -405,7 +393,7 @@ private:
 };
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-bool cmLocalGeneratorCheckObjectName(std::string &objName,
+bool cmLocalGeneratorCheckObjectName(std::string& objName,
                                      std::string::size_type dir_len,
                                      std::string::size_type max_total_len);
 #endif
diff --git a/Source/cmLocalGhsMultiGenerator.cxx b/Source/cmLocalGhsMultiGenerator.cxx
index f23f27d..01537dd 100644
--- a/Source/cmLocalGhsMultiGenerator.cxx
+++ b/Source/cmLocalGhsMultiGenerator.cxx
@@ -23,20 +23,20 @@ cmLocalGhsMultiGenerator::cmLocalGhsMultiGenerator(cmGlobalGenerator* gg,
 {
 }
 
-cmLocalGhsMultiGenerator::~cmLocalGhsMultiGenerator() {}
+cmLocalGhsMultiGenerator::~cmLocalGhsMultiGenerator()
+{
+}
 
 void cmLocalGhsMultiGenerator::Generate()
 {
   std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
 
   for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-       l != tgts.end(); ++l)
-    {
-    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+       l != tgts.end(); ++l) {
+    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     cmGhsMultiTargetGenerator tg(*l);
     tg.Generate();
-    }
+  }
 }
diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx
index 800c071..671d8a0 100644
--- a/Source/cmLocalNinjaGenerator.cxx
+++ b/Source/cmLocalNinjaGenerator.cxx
@@ -43,10 +43,9 @@ void cmLocalNinjaGenerator::Generate()
   // directory from the top output directory.
   this->HomeRelativeOutputPath =
     this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT);
-  if(this->HomeRelativeOutputPath == ".")
-    {
+  if (this->HomeRelativeOutputPath == ".") {
     this->HomeRelativeOutputPath = "";
-    }
+  }
 
   this->SetConfigName();
 
@@ -56,50 +55,44 @@ void cmLocalNinjaGenerator::Generate()
 #endif
 
   // We do that only once for the top CMakeLists.txt file.
-  if(this->IsRootMakefile())
-    {
+  if (this->IsRootMakefile()) {
     this->WriteBuildFileTop();
 
     this->WritePools(this->GetRulesFileStream());
 
-    const std::string showIncludesPrefix = this->GetMakefile()
-             ->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
-    if (!showIncludesPrefix.empty())
-      {
+    const std::string showIncludesPrefix =
+      this->GetMakefile()->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
+    if (!showIncludesPrefix.empty()) {
       cmGlobalNinjaGenerator::WriteComment(this->GetRulesFileStream(),
                                            "localized /showIncludes string");
-      this->GetRulesFileStream()
-            << "msvc_deps_prefix = " << showIncludesPrefix << "\n\n";
-      }
+      this->GetRulesFileStream() << "msvc_deps_prefix = " << showIncludesPrefix
+                                 << "\n\n";
     }
+  }
 
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
-    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
+    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(*t);
-    if(tg)
-      {
+    if (tg) {
       tg->Generate();
       // Add the target to "all" if required.
       if (!this->GetGlobalNinjaGenerator()->IsExcluded(
-            this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0],
-            *t))
+            this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0], *t))
         this->GetGlobalNinjaGenerator()->AddDependencyToAll(*t);
       delete tg;
-      }
     }
+  }
 
   this->WriteCustomCommandBuildStatements();
 }
 
 // TODO: Picked up from cmLocalUnixMakefileGenerator3.  Refactor it.
-std::string cmLocalNinjaGenerator
-::GetTargetDirectory(cmGeneratorTarget const* target) const
+std::string cmLocalNinjaGenerator::GetTargetDirectory(
+  cmGeneratorTarget const* target) const
 {
   std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
   dir += target->GetName();
@@ -113,11 +106,11 @@ std::string cmLocalNinjaGenerator
 
 // Non-virtual public methods.
 
-const cmGlobalNinjaGenerator*
-cmLocalNinjaGenerator::GetGlobalNinjaGenerator() const
+const cmGlobalNinjaGenerator* cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
+  const
 {
-  return
-    static_cast<const cmGlobalNinjaGenerator*>(this->GetGlobalGenerator());
+  return static_cast<const cmGlobalNinjaGenerator*>(
+    this->GetGlobalGenerator());
 }
 
 cmGlobalNinjaGenerator* cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
@@ -127,19 +120,16 @@ cmGlobalNinjaGenerator* cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
 
 // Virtual protected methods.
 
-std::string
-cmLocalNinjaGenerator::ConvertToLinkReference(std::string const& lib,
-                                              OutputFormat format)
+std::string cmLocalNinjaGenerator::ConvertToLinkReference(
+  std::string const& lib, OutputFormat format)
 {
   return this->Convert(lib, HOME_OUTPUT, format);
 }
 
-std::string
-cmLocalNinjaGenerator::ConvertToIncludeReference(std::string const& path,
-                                                 OutputFormat format,
-                                                 bool forceFullPaths)
+std::string cmLocalNinjaGenerator::ConvertToIncludeReference(
+  std::string const& path, OutputFormat format, bool forceFullPaths)
 {
-  return this->Convert(path, forceFullPaths? FULL : HOME_OUTPUT, format);
+  return this->Convert(path, forceFullPaths ? FULL : HOME_OUTPUT, format);
 }
 
 // Private methods.
@@ -178,10 +168,8 @@ void cmLocalNinjaGenerator::WriteBuildFileTop()
 void cmLocalNinjaGenerator::WriteProjectHeader(std::ostream& os)
 {
   cmGlobalNinjaGenerator::WriteDivider(os);
-  os
-    << "# Project: " << this->GetProjectName() << std::endl
-    << "# Configuration: " << this->ConfigName << std::endl
-    ;
+  os << "# Project: " << this->GetProjectName() << std::endl
+     << "# Configuration: " << this->ConfigName << std::endl;
   cmGlobalNinjaGenerator::WriteDivider(os);
 }
 
@@ -189,115 +177,99 @@ void cmLocalNinjaGenerator::WriteNinjaRequiredVersion(std::ostream& os)
 {
   // Default required version
   std::string requiredVersion =
-      this->GetGlobalNinjaGenerator()->RequiredNinjaVersion();
+    this->GetGlobalNinjaGenerator()->RequiredNinjaVersion();
 
   // Ninja generator uses the 'console' pool if available (>= 1.5)
-  if(this->GetGlobalNinjaGenerator()->SupportsConsolePool())
-    {
+  if (this->GetGlobalNinjaGenerator()->SupportsConsolePool()) {
     requiredVersion =
       this->GetGlobalNinjaGenerator()->RequiredNinjaVersionForConsolePool();
-    }
+  }
 
-  cmGlobalNinjaGenerator::WriteComment(os,
-                          "Minimal version of Ninja required by this file");
-  os
-    << "ninja_required_version = "
-    << requiredVersion
-    << std::endl << std::endl
-    ;
+  cmGlobalNinjaGenerator::WriteComment(
+    os, "Minimal version of Ninja required by this file");
+  os << "ninja_required_version = " << requiredVersion << std::endl
+     << std::endl;
 }
 
 void cmLocalNinjaGenerator::WritePools(std::ostream& os)
 {
   cmGlobalNinjaGenerator::WriteDivider(os);
 
-  const char* jobpools = this->GetCMakeInstance()->GetState()
-                             ->GetGlobalProperty("JOB_POOLS");
-  if (jobpools)
-    {
-    cmGlobalNinjaGenerator::WriteComment(os,
-                            "Pools defined by global property JOB_POOLS");
+  const char* jobpools =
+    this->GetCMakeInstance()->GetState()->GetGlobalProperty("JOB_POOLS");
+  if (jobpools) {
+    cmGlobalNinjaGenerator::WriteComment(
+      os, "Pools defined by global property JOB_POOLS");
     std::vector<std::string> pools;
     cmSystemTools::ExpandListArgument(jobpools, pools);
-    for (size_t i = 0; i < pools.size(); ++i)
-      {
+    for (size_t i = 0; i < pools.size(); ++i) {
       const std::string pool = pools[i];
       const std::string::size_type eq = pool.find("=");
       unsigned int jobs;
       if (eq != std::string::npos &&
-          sscanf(pool.c_str() + eq, "=%u", &jobs) == 1)
-        {
+          sscanf(pool.c_str() + eq, "=%u", &jobs) == 1) {
         os << "pool " << pool.substr(0, eq) << std::endl;
         os << "  depth = " << jobs << std::endl;
         os << std::endl;
-        }
-      else
-        {
+      } else {
         cmSystemTools::Error("Invalid pool defined by property 'JOB_POOLS': ",
                              pool.c_str());
-        }
       }
     }
+  }
 }
 
 void cmLocalNinjaGenerator::WriteNinjaFilesInclusion(std::ostream& os)
 {
   cmGlobalNinjaGenerator::WriteDivider(os);
-  os
-    << "# Include auxiliary files.\n"
-    << "\n"
-    ;
-  cmGlobalNinjaGenerator::WriteInclude(os,
-                                      cmGlobalNinjaGenerator::NINJA_RULES_FILE,
-                                       "Include rules file.");
+  os << "# Include auxiliary files.\n"
+     << "\n";
+  cmGlobalNinjaGenerator::WriteInclude(
+    os, cmGlobalNinjaGenerator::NINJA_RULES_FILE, "Include rules file.");
   os << "\n";
 }
 
 void cmLocalNinjaGenerator::ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt)
+  std::map<cmSourceFile const*, std::string>& mapping,
+  cmGeneratorTarget const* gt)
 {
-  for(std::map<cmSourceFile const*, std::string>::iterator
-      si = mapping.begin(); si != mapping.end(); ++si)
-    {
+  for (std::map<cmSourceFile const*, std::string>::iterator si =
+         mapping.begin();
+       si != mapping.end(); ++si) {
     cmSourceFile const* sf = si->first;
-    si->second = this->GetObjectFileNameWithoutTarget(*sf,
-                                                      gt->ObjectDirectory);
-    }
+    si->second =
+      this->GetObjectFileNameWithoutTarget(*sf, gt->ObjectDirectory);
+  }
 }
 
 void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
 {
   cmGlobalNinjaGenerator::WriteDivider(os);
-  os
-    << "# Write statements declared in CMakeLists.txt:" << std::endl
-    << "# "
-    << this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE") << std::endl;
-  if(this->IsRootMakefile())
+  os << "# Write statements declared in CMakeLists.txt:" << std::endl
+     << "# " << this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE")
+     << std::endl;
+  if (this->IsRootMakefile())
     os << "# Which is the root file." << std::endl;
   cmGlobalNinjaGenerator::WriteDivider(os);
   os << std::endl;
 }
 
-void
-cmLocalNinjaGenerator
-::AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs)
+void cmLocalNinjaGenerator::AppendTargetOutputs(cmGeneratorTarget* target,
+                                                cmNinjaDeps& outputs)
 {
   this->GetGlobalNinjaGenerator()->AppendTargetOutputs(target, outputs);
 }
 
-void
-cmLocalNinjaGenerator
-::AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs)
+void cmLocalNinjaGenerator::AppendTargetDepends(cmGeneratorTarget* target,
+                                                cmNinjaDeps& outputs)
 {
   this->GetGlobalNinjaGenerator()->AppendTargetDepends(target, outputs);
 }
 
 void cmLocalNinjaGenerator::AppendCustomCommandDeps(
-  cmCustomCommandGenerator const& ccg,
-  cmNinjaDeps &ninjaDeps)
+  cmCustomCommandGenerator const& ccg, cmNinjaDeps& ninjaDeps)
 {
-  const std::vector<std::string> &deps = ccg.GetDepends();
+  const std::vector<std::string>& deps = ccg.GetDepends();
   for (std::vector<std::string>::const_iterator i = deps.begin();
        i != deps.end(); ++i) {
     std::string dep;
@@ -308,7 +280,7 @@ void cmLocalNinjaGenerator::AppendCustomCommandDeps(
 }
 
 std::string cmLocalNinjaGenerator::BuildCommandLine(
-                                    const std::vector<std::string> &cmdLines)
+  const std::vector<std::string>& cmdLines)
 {
   // If we have no commands but we need to build a command anyway, use ":".
   // This happens when building a POST_BUILD value for link targets that
@@ -324,36 +296,30 @@ std::string cmLocalNinjaGenerator::BuildCommandLine(
   for (std::vector<std::string>::const_iterator li = cmdLines.begin();
        li != cmdLines.end(); ++li)
 #ifdef _WIN32
-    {
-    if (li != cmdLines.begin())
-      {
+  {
+    if (li != cmdLines.begin()) {
       cmd << " && ";
-      }
-    else if (cmdLines.size() > 1)
-      {
+    } else if (cmdLines.size() > 1) {
       cmd << "cmd.exe /C \"";
-      }
-    cmd << *li;
     }
-  if (cmdLines.size() > 1)
-    {
+    cmd << *li;
+  }
+  if (cmdLines.size() > 1) {
     cmd << "\"";
-    }
+  }
 #else
-    {
-    if (li != cmdLines.begin())
-      {
+  {
+    if (li != cmdLines.begin()) {
       cmd << " && ";
-      }
-    cmd << *li;
     }
+    cmd << *li;
+  }
 #endif
   return cmd.str();
 }
 
 void cmLocalNinjaGenerator::AppendCustomCommandLines(
-  cmCustomCommandGenerator const& ccg,
-  std::vector<std::string> &cmdLines)
+  cmCustomCommandGenerator const& ccg, std::vector<std::string>& cmdLines)
 {
   if (ccg.GetNumberOfCommands() > 0) {
     std::string wd = ccg.GetWorkingDirectory();
@@ -362,9 +328,9 @@ void cmLocalNinjaGenerator::AppendCustomCommandLines(
 
     std::ostringstream cdCmd;
 #ifdef _WIN32
-        std::string cdStr = "cd /D ";
+    std::string cdStr = "cd /D ";
 #else
-        std::string cdStr = "cd ";
+    std::string cdStr = "cd ";
 #endif
     cdCmd << cdStr << this->ConvertToOutputFormat(wd, SHELL);
     cmdLines.push_back(cdCmd.str());
@@ -374,43 +340,39 @@ void cmLocalNinjaGenerator::AppendCustomCommandLines(
 
   for (unsigned i = 0; i != ccg.GetNumberOfCommands(); ++i) {
     cmdLines.push_back(launcher +
-      this->ConvertToOutputFormat(ccg.GetCommand(i), SHELL));
+                       this->ConvertToOutputFormat(ccg.GetCommand(i), SHELL));
 
     std::string& cmd = cmdLines.back();
     ccg.AppendArguments(i, cmd);
   }
 }
 
-void
-cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
-  cmCustomCommand const *cc, const cmNinjaDeps& orderOnlyDeps)
+void cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
+  cmCustomCommand const* cc, const cmNinjaDeps& orderOnlyDeps)
 {
   if (this->GetGlobalNinjaGenerator()->SeenCustomCommand(cc))
     return;
 
   cmCustomCommandGenerator ccg(*cc, this->GetConfigName(), this);
 
-  const std::vector<std::string> &outputs = ccg.GetOutputs();
-  const std::vector<std::string> &byproducts = ccg.GetByproducts();
-  cmNinjaDeps ninjaOutputs(outputs.size()+byproducts.size()), ninjaDeps;
+  const std::vector<std::string>& outputs = ccg.GetOutputs();
+  const std::vector<std::string>& byproducts = ccg.GetByproducts();
+  cmNinjaDeps ninjaOutputs(outputs.size() + byproducts.size()), ninjaDeps;
 
   bool symbolic = false;
   for (std::vector<std::string>::const_iterator o = outputs.begin();
-       !symbolic && o != outputs.end(); ++o)
-    {
-    if (cmSourceFile* sf = this->Makefile->GetSource(*o))
-      {
+       !symbolic && o != outputs.end(); ++o) {
+    if (cmSourceFile* sf = this->Makefile->GetSource(*o)) {
       symbolic = sf->GetPropertyAsBool("SYMBOLIC");
-      }
     }
+  }
 
 #if 0
 #error TODO: Once CC in an ExternalProject target must provide the \
     file of each imported target that has an add_dependencies pointing \
     at us.  How to know which ExternalProject step actually provides it?
 #endif
-  std::transform(outputs.begin(), outputs.end(),
-                 ninjaOutputs.begin(),
+  std::transform(outputs.begin(), outputs.end(), ninjaOutputs.begin(),
                  this->GetGlobalNinjaGenerator()->MapToNinjaPath());
   std::transform(byproducts.begin(), byproducts.end(),
                  ninjaOutputs.begin() + outputs.size(),
@@ -427,22 +389,13 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
   if (cmdLines.empty()) {
     this->GetGlobalNinjaGenerator()->WritePhonyBuild(
       this->GetBuildFileStream(),
-      "Phony custom command for " +
-      ninjaOutputs[0],
-      ninjaOutputs,
-      ninjaDeps,
-      cmNinjaDeps(),
-      orderOnlyDeps,
-      cmNinjaVars());
+      "Phony custom command for " + ninjaOutputs[0], ninjaOutputs, ninjaDeps,
+      cmNinjaDeps(), orderOnlyDeps, cmNinjaVars());
   } else {
     this->GetGlobalNinjaGenerator()->WriteCustomCommandBuild(
-      this->BuildCommandLine(cmdLines),
-      this->ConstructComment(ccg),
-      "Custom command for " + ninjaOutputs[0],
-      cc->GetUsesTerminal(),
-      /*restat*/!symbolic || !byproducts.empty(),
-      ninjaOutputs,
-      ninjaDeps,
+      this->BuildCommandLine(cmdLines), this->ConstructComment(ccg),
+      "Custom command for " + ninjaOutputs[0], cc->GetUsesTerminal(),
+      /*restat*/ !symbolic || !byproducts.empty(), ninjaOutputs, ninjaDeps,
       orderOnlyDeps);
   }
 }
@@ -451,20 +404,19 @@ void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc,
                                                    cmGeneratorTarget* target)
 {
   CustomCommandTargetMap::value_type v(cc, std::set<cmGeneratorTarget*>());
-  std::pair<CustomCommandTargetMap::iterator, bool>
-    ins = this->CustomCommandTargets.insert(v);
-  if (ins.second)
-    {
+  std::pair<CustomCommandTargetMap::iterator, bool> ins =
+    this->CustomCommandTargets.insert(v);
+  if (ins.second) {
     this->CustomCommands.push_back(cc);
-    }
+  }
   ins.first->second.insert(target);
 }
 
 void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements()
 {
   for (std::vector<cmCustomCommand const*>::iterator vi =
-       this->CustomCommands.begin(); vi != this->CustomCommands.end(); ++vi)
-    {
+         this->CustomCommands.begin();
+       vi != this->CustomCommands.end(); ++vi) {
     CustomCommandTargetMap::iterator i = this->CustomCommandTargets.find(*vi);
     assert(i != this->CustomCommandTargets.end());
 
@@ -504,8 +456,7 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
   const char* property = "RULE_LAUNCH_CUSTOM";
   const char* property_value = this->Makefile->GetProperty(property);
 
-  if(!property_value || !*property_value)
-  {
+  if (!property_value || !*property_value) {
     return std::string();
   }
 
@@ -515,8 +466,7 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
   vars.RuleLauncher = property;
   std::string output;
   const std::vector<std::string>& outputs = ccg.GetOutputs();
-  if(!outputs.empty())
-  {
+  if (!outputs.empty()) {
     RelativeRoot relative_root =
       ccg.GetWorkingDirectory().empty() ? START_OUTPUT : NONE;
 
@@ -526,8 +476,7 @@ std::string cmLocalNinjaGenerator::MakeCustomLauncher(
 
   std::string launcher;
   this->ExpandRuleVariables(launcher, vars);
-  if(!launcher.empty())
-  {
+  if (!launcher.empty()) {
     launcher += " ";
   }
 
diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h
index 9746a3c..afaa24c 100644
--- a/Source/cmLocalNinjaGenerator.h
+++ b/Source/cmLocalNinjaGenerator.h
@@ -38,8 +38,8 @@ public:
 
   virtual void Generate();
 
-  virtual
-  std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
+  virtual std::string GetTargetDirectory(
+    cmGeneratorTarget const* target) const;
 
   const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const;
   cmGlobalNinjaGenerator* GetGlobalNinjaGenerator();
@@ -50,14 +50,17 @@ public:
   /// @returns the relative path between the HomeOutputDirectory and this
   /// local generators StartOutputDirectory.
   std::string GetHomeRelativeOutputPath() const
-  { return this->HomeRelativeOutputPath; }
+  {
+    return this->HomeRelativeOutputPath;
+  }
 
   void ExpandRuleVariables(std::string& string,
-                           const RuleVariables& replaceValues) {
+                           const RuleVariables& replaceValues)
+  {
     cmLocalGenerator::ExpandRuleVariables(string, replaceValues);
   }
 
-  std::string BuildCommandLine(const std::vector<std::string> &cmdLines);
+  std::string BuildCommandLine(const std::vector<std::string>& cmdLines);
 
   void AppendTargetOutputs(cmGeneratorTarget* target, cmNinjaDeps& outputs);
   void AppendTargetDepends(cmGeneratorTarget* target, cmNinjaDeps& outputs);
@@ -65,24 +68,22 @@ public:
   void AddCustomCommandTarget(cmCustomCommand const* cc,
                               cmGeneratorTarget* target);
   void AppendCustomCommandLines(cmCustomCommandGenerator const& ccg,
-                                std::vector<std::string> &cmdLines);
+                                std::vector<std::string>& cmdLines);
   void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg,
-                               cmNinjaDeps &ninjaDeps);
+                               cmNinjaDeps& ninjaDeps);
 
   virtual std::string ConvertToLinkReference(std::string const& lib,
                                              OutputFormat format = SHELL);
 
   virtual void ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt = 0);
-
+    std::map<cmSourceFile const*, std::string>& mapping,
+    cmGeneratorTarget const* gt = 0);
 
 protected:
   virtual std::string ConvertToIncludeReference(std::string const& path,
                                                 OutputFormat format = SHELL,
                                                 bool forceFullPaths = false);
 
-
 private:
   cmGeneratedFileStream& GetBuildFileStream() const;
   cmGeneratedFileStream& GetRulesFileStream() const;
@@ -95,7 +96,7 @@ private:
   void WritePools(std::ostream& os);
 
   void WriteCustomCommandRule();
-  void WriteCustomCommandBuildStatement(cmCustomCommand const *cc,
+  void WriteCustomCommandBuildStatement(cmCustomCommand const* cc,
                                         const cmNinjaDeps& orderOnlyDeps);
 
   void WriteCustomCommandBuildStatements();
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 82220be..88c6d61 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -26,8 +26,8 @@
 // C/C++ scanner is needed for bootstrapping CMake.
 #include "cmDependsC.h"
 #ifdef CMAKE_BUILD_WITH_CMAKE
-# include "cmDependsFortran.h"
-# include "cmDependsJava.h"
+#include "cmDependsFortran.h"
+#include "cmDependsJava.h"
 #endif
 
 #include <cmsys/Terminal.h>
@@ -40,23 +40,31 @@
 class cmMakeSafe
 {
 public:
-  cmMakeSafe(const char* s): Data(s) {}
-  cmMakeSafe(std::string const& s): Data(s.c_str()) {}
+  cmMakeSafe(const char* s)
+    : Data(s)
+  {
+  }
+  cmMakeSafe(std::string const& s)
+    : Data(s.c_str())
+  {
+  }
+
 private:
   const char* Data;
-  friend std::ostream& operator<<(std::ostream& os,
-                                  cmMakeSafe const& self)
-    {
-    for(const char* c = self.Data; *c; ++c)
-      {
-      switch (*c)
-        {
-        case '=': os << "$(EQUALS)"; break;
-        default: os << *c; break;
-        }
+  friend std::ostream& operator<<(std::ostream& os, cmMakeSafe const& self)
+  {
+    for (const char* c = self.Data; *c; ++c) {
+      switch (*c) {
+        case '=':
+          os << "$(EQUALS)";
+          break;
+        default:
+          os << *c;
+          break;
       }
-    return os;
     }
+    return os;
+  }
 };
 
 // Helper function used below.
@@ -64,21 +72,18 @@ static std::string cmSplitExtension(std::string const& in, std::string& base)
 {
   std::string ext;
   std::string::size_type dot_pos = in.rfind(".");
-  if(dot_pos != std::string::npos)
-    {
+  if (dot_pos != std::string::npos) {
     // Remove the extension first in case &base == &in.
     ext = in.substr(dot_pos, std::string::npos);
     base = in.substr(0, dot_pos);
-    }
-  else
-    {
+  } else {
     base = in;
-    }
+  }
   return ext;
 }
 
-cmLocalUnixMakefileGenerator3::
-cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmMakefile* mf)
+cmLocalUnixMakefileGenerator3::cmLocalUnixMakefileGenerator3(
+  cmGlobalGenerator* gg, cmMakefile* mf)
   : cmLocalCommonGenerator(gg, mf)
 {
   this->MakefileVariableSize = 0;
@@ -99,10 +104,9 @@ void cmLocalUnixMakefileGenerator3::Generate()
 
   // Record whether some options are enabled to avoid checking many
   // times later.
-  if(!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile())
-    {
+  if (!this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile()) {
     this->ColorMakefile = this->Makefile->IsOn("CMAKE_COLOR_MAKEFILE");
-    }
+  }
   this->SkipPreprocessedSourceRules =
     this->Makefile->IsOn("CMAKE_SKIP_PREPROCESSED_SOURCE_RULES");
   this->SkipAssemblySourceRules =
@@ -112,21 +116,18 @@ void cmLocalUnixMakefileGenerator3::Generate()
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
-    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
+    if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
       cmMakefileTargetGenerator::New(*t));
-    if (tg.get())
-      {
+    if (tg.get()) {
       tg->WriteRuleFiles();
       gg->RecordTargetProgress(tg.get());
-      }
     }
+  }
 
   // write the local Makefile
   this->WriteLocalMakefile();
@@ -141,44 +142,40 @@ void cmLocalUnixMakefileGenerator3::ComputeHomeRelativeOutputPath()
   // directory from the top output directory.
   this->HomeRelativeOutputPath =
     this->Convert(this->GetCurrentBinaryDirectory(), HOME_OUTPUT);
-  if(this->HomeRelativeOutputPath == ".")
-    {
+  if (this->HomeRelativeOutputPath == ".") {
     this->HomeRelativeOutputPath = "";
-    }
-  if(!this->HomeRelativeOutputPath.empty())
-    {
+  }
+  if (!this->HomeRelativeOutputPath.empty()) {
     this->HomeRelativeOutputPath += "/";
-    }
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt)
+  std::map<cmSourceFile const*, std::string>& mapping,
+  cmGeneratorTarget const* gt)
 {
-  for(std::map<cmSourceFile const*, std::string>::iterator
-      si = mapping.begin(); si != mapping.end(); ++si)
-    {
+  for (std::map<cmSourceFile const*, std::string>::iterator si =
+         mapping.begin();
+       si != mapping.end(); ++si) {
     cmSourceFile const* sf = si->first;
-    si->second = this->GetObjectFileNameWithoutTarget(*sf,
-                                                      gt->ObjectDirectory);
-    }
+    si->second =
+      this->GetObjectFileNameWithoutTarget(*sf, gt->ObjectDirectory);
+  }
 }
 
-void cmLocalUnixMakefileGenerator3::
-GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
+void cmLocalUnixMakefileGenerator3::GetLocalObjectFiles(
+  std::map<std::string, LocalObjectInfo>& localObjectFiles)
 {
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
-      ti != targets.end(); ++ti)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator ti = targets.begin();
+       ti != targets.end(); ++ti) {
     cmGeneratorTarget* gt = *ti;
-    if (gt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (gt->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     std::vector<cmSourceFile const*> objectSources;
-    gt->GetObjectSources(objectSources, this->Makefile
-                                    ->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+    gt->GetObjectSources(
+      objectSources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
     // Compute full path to object file directory for this target.
     std::string dir;
     dir += gt->LocalGenerator->GetCurrentBinaryDirectory();
@@ -186,49 +183,42 @@ GetLocalObjectFiles(std::map<std::string, LocalObjectInfo> &localObjectFiles)
     dir += this->GetTargetDirectory(gt);
     dir += "/";
     // Compute the name of each object file.
-    for(std::vector<cmSourceFile const*>::iterator
-          si = objectSources.begin();
-        si != objectSources.end(); ++si)
-      {
+    for (std::vector<cmSourceFile const*>::iterator si = objectSources.begin();
+         si != objectSources.end(); ++si) {
       cmSourceFile const* sf = *si;
       bool hasSourceExtension = true;
-      std::string objectName = this->GetObjectFileNameWithoutTarget(*sf,
-                                                                    dir,
-                                                        &hasSourceExtension);
-      if(cmSystemTools::FileIsFullPath(objectName.c_str()))
-        {
+      std::string objectName =
+        this->GetObjectFileNameWithoutTarget(*sf, dir, &hasSourceExtension);
+      if (cmSystemTools::FileIsFullPath(objectName.c_str())) {
         objectName = cmSystemTools::GetFilenameName(objectName);
-        }
+      }
       LocalObjectInfo& info = localObjectFiles[objectName];
       info.HasSourceExtension = hasSourceExtension;
       info.push_back(LocalObjectEntry(gt, sf->GetLanguage()));
-      }
     }
+  }
 }
 
-void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets
-                                            (std::vector<std::string>& targets)
+void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets(
+  std::vector<std::string>& targets)
 {
   std::map<std::string, LocalObjectInfo> localObjectFiles;
   this->GetLocalObjectFiles(localObjectFiles);
   for (std::map<std::string, LocalObjectInfo>::iterator lo =
          localObjectFiles.begin();
-       lo != localObjectFiles.end(); ++lo)
-    {
+       lo != localObjectFiles.end(); ++lo) {
     targets.push_back(lo->first);
 
     std::string::size_type dot_pos = lo->first.rfind(".");
     std::string base = lo->first.substr(0, dot_pos);
-    if(lo->second.HasPreprocessRule)
-      {
+    if (lo->second.HasPreprocessRule) {
       targets.push_back(base + ".i");
-      }
+    }
 
-    if(lo->second.HasAssembleRule)
-      {
+    if (lo->second.HasAssembleRule) {
       targets.push_back(base + ".s");
-      }
     }
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
@@ -240,15 +230,13 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // rules may depend on this file itself.
   std::string ruleFileNameFull = this->ConvertToFullPath(ruleFileName);
   cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
-  if(!ruleFileStream)
-    {
+  if (!ruleFileStream) {
     return;
-    }
+  }
   // always write the top makefile
-  if (!this->IsRootMakefile())
-    {
+  if (!this->IsRootMakefile()) {
     ruleFileStream.SetCopyIfDifferent(true);
-    }
+  }
 
   // write the all rules
   this->WriteLocalAllRules(ruleFileStream);
@@ -256,23 +244,18 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // only write local targets unless at the top Keep track of targets already
   // listed.
   std::set<std::string> emittedTargets;
-  if (!this->IsRootMakefile())
-    {
+  if (!this->IsRootMakefile()) {
     // write our targets, and while doing it collect up the object
     // file rules
-    this->WriteLocalMakefileTargets(ruleFileStream,emittedTargets);
-    }
-  else
-    {
-    cmGlobalUnixMakefileGenerator3 *gg =
+    this->WriteLocalMakefileTargets(ruleFileStream, emittedTargets);
+  } else {
+    cmGlobalUnixMakefileGenerator3* gg =
       static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-    gg->WriteConvenienceRules(ruleFileStream,emittedTargets);
-    }
+    gg->WriteConvenienceRules(ruleFileStream, emittedTargets);
+  }
 
-  bool do_preprocess_rules =
-    this->GetCreatePreprocessedSourceRules();
-  bool do_assembly_rules =
-    this->GetCreateAssemblySourceRules();
+  bool do_preprocess_rules = this->GetCreatePreprocessedSourceRules();
+  bool do_assembly_rules = this->GetCreateAssemblySourceRules();
 
   std::map<std::string, LocalObjectInfo> localObjectFiles;
   this->GetLocalObjectFiles(localObjectFiles);
@@ -281,8 +264,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
   // for each object file name
   for (std::map<std::string, LocalObjectInfo>::iterator lo =
          localObjectFiles.begin();
-       lo != localObjectFiles.end(); ++lo)
-    {
+       lo != localObjectFiles.end(); ++lo) {
     // Add a convenience rule for building the object file.
     this->WriteObjectConvenienceRule(ruleFileStream,
                                      "target to build an object file",
@@ -293,66 +275,57 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
     bool lang_has_preprocessor = false;
     bool lang_has_assembly = false;
 
-    for(std::vector<LocalObjectEntry>::const_iterator ei =
-          lo->second.begin(); ei != lo->second.end(); ++ei)
-      {
-      if(ei->Language == "C" ||
-         ei->Language == "CXX" ||
-         ei->Language == "Fortran")
-        {
+    for (std::vector<LocalObjectEntry>::const_iterator ei = lo->second.begin();
+         ei != lo->second.end(); ++ei) {
+      if (ei->Language == "C" || ei->Language == "CXX" ||
+          ei->Language == "Fortran") {
         // Right now, C, C++ and Fortran have both a preprocessor and the
         // ability to generate assembly code
         lang_has_preprocessor = true;
         lang_has_assembly = true;
         break;
-        }
       }
+    }
 
     // Add convenience rules for preprocessed and assembly files.
-    if(lang_has_preprocessor && do_preprocess_rules)
-      {
+    if (lang_has_preprocessor && do_preprocess_rules) {
       std::string::size_type dot_pos = lo->first.rfind(".");
       std::string base = lo->first.substr(0, dot_pos);
-      this->WriteObjectConvenienceRule(
-        ruleFileStream, "target to preprocess a source file",
-       (base + ".i").c_str(), lo->second);
+      this->WriteObjectConvenienceRule(ruleFileStream,
+                                       "target to preprocess a source file",
+                                       (base + ".i").c_str(), lo->second);
       lo->second.HasPreprocessRule = true;
-      }
+    }
 
-    if(lang_has_assembly && do_assembly_rules)
-      {
+    if (lang_has_assembly && do_assembly_rules) {
       std::string::size_type dot_pos = lo->first.rfind(".");
       std::string base = lo->first.substr(0, dot_pos);
       this->WriteObjectConvenienceRule(
-       ruleFileStream, "target to generate assembly for a file",
-       (base + ".s").c_str(), lo->second);
+        ruleFileStream, "target to generate assembly for a file",
+        (base + ".s").c_str(), lo->second);
       lo->second.HasAssembleRule = true;
-      }
     }
+  }
 
   // add a help target as long as there isn;t a real target named help
-  if(emittedTargets.insert("help").second)
-    {
-    cmGlobalUnixMakefileGenerator3 *gg =
+  if (emittedTargets.insert("help").second) {
+    cmGlobalUnixMakefileGenerator3* gg =
       static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-    gg->WriteHelpRule(ruleFileStream,this);
-    }
+    gg->WriteHelpRule(ruleFileStream, this);
+  }
 
   this->WriteSpecialTargetsBottom(ruleFileStream);
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteObjectConvenienceRule(std::ostream& ruleFileStream,
-                             const char* comment, const char* output,
-                             LocalObjectInfo const& info)
+void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule(
+  std::ostream& ruleFileStream, const char* comment, const char* output,
+  LocalObjectInfo const& info)
 {
   // If the rule includes the source file extension then create a
   // version that has the extension removed.  The help should include
   // only the version without source extension.
   bool inHelp = true;
-  if(info.HasSourceExtension)
-    {
+  if (info.HasSourceExtension) {
     // Remove the last extension.  This should be kept.
     std::string outBase1 = output;
     std::string outExt1 = cmSplitExtension(outBase1, outBase1);
@@ -367,39 +340,34 @@ cmLocalUnixMakefileGenerator3
     std::vector<std::string> depends;
     depends.push_back(output);
     std::vector<std::string> no_commands;
-    this->WriteMakeRule(ruleFileStream, 0,
-                        outNoExt, depends, no_commands, true, true);
+    this->WriteMakeRule(ruleFileStream, 0, outNoExt, depends, no_commands,
+                        true, true);
     inHelp = false;
-    }
+  }
 
   // Recursively make the rule for each target using the object file.
   std::vector<std::string> commands;
-  for(std::vector<LocalObjectEntry>::const_iterator t = info.begin();
-      t != info.end(); ++t)
-    {
-    std::string tgtMakefileName =
-      this->GetRelativeTargetDirectory(t->Target);
+  for (std::vector<LocalObjectEntry>::const_iterator t = info.begin();
+       t != info.end(); ++t) {
+    std::string tgtMakefileName = this->GetRelativeTargetDirectory(t->Target);
     std::string targetName = tgtMakefileName;
     tgtMakefileName += "/build.make";
     targetName += "/";
     targetName += output;
     commands.push_back(
-      this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName)
-      );
-    }
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+      this->GetRecursiveMakeCall(tgtMakefileName.c_str(), targetName));
+  }
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
 
   // Write the rule to the makefile.
   std::vector<std::string> no_depends;
-  this->WriteMakeRule(ruleFileStream, comment,
-                      output, no_depends, commands, true, inHelp);
+  this->WriteMakeRule(ruleFileStream, comment, output, no_depends, commands,
+                      true, inHelp);
 }
 
-void cmLocalUnixMakefileGenerator3
-::WriteLocalMakefileTargets(std::ostream& ruleFileStream,
-                            std::set<std::string> &emitted)
+void cmLocalUnixMakefileGenerator3::WriteLocalMakefileTargets(
+  std::ostream& ruleFileStream, std::set<std::string>& emitted)
 {
   std::vector<std::string> depends;
   std::vector<std::string> commands;
@@ -408,16 +376,14 @@ void cmLocalUnixMakefileGenerator3
   // on the target
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
   std::string localName;
-  for(std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
-      t != targets.end(); ++t)
-    {
-    if(((*t)->GetType() == cmState::EXECUTABLE) ||
-       ((*t)->GetType() == cmState::STATIC_LIBRARY) ||
-       ((*t)->GetType() == cmState::SHARED_LIBRARY) ||
-       ((*t)->GetType() == cmState::MODULE_LIBRARY) ||
-       ((*t)->GetType() == cmState::OBJECT_LIBRARY) ||
-       ((*t)->GetType() == cmState::UTILITY))
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+       t != targets.end(); ++t) {
+    if (((*t)->GetType() == cmState::EXECUTABLE) ||
+        ((*t)->GetType() == cmState::STATIC_LIBRARY) ||
+        ((*t)->GetType() == cmState::SHARED_LIBRARY) ||
+        ((*t)->GetType() == cmState::MODULE_LIBRARY) ||
+        ((*t)->GetType() == cmState::OBJECT_LIBRARY) ||
+        ((*t)->GetType() == cmState::UTILITY)) {
       emitted.insert((*t)->GetName());
 
       // for subdirs add a rule to build this specific target by name.
@@ -429,64 +395,57 @@ void cmLocalUnixMakefileGenerator3
       // Build the target for this pass.
       std::string makefile2 = cmake::GetCMakeFilesDirectoryPostSlash();
       makefile2 += "Makefile2";
-      commands.push_back(this->GetRecursiveMakeCall
-                         (makefile2.c_str(),localName));
-      this->CreateCDCommand(commands,
-                            this->GetBinaryDirectory(),
+      commands.push_back(
+        this->GetRecursiveMakeCall(makefile2.c_str(), localName));
+      this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                             cmLocalGenerator::START_OUTPUT);
       this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                           localName, depends, commands, true);
 
       // Add a target with the canonical name (no prefix, suffix or path).
-      if(localName != (*t)->GetName())
-        {
+      if (localName != (*t)->GetName()) {
         commands.clear();
         depends.push_back(localName);
         this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                             (*t)->GetName(), depends, commands, true);
-        }
+      }
 
       // Add a fast rule to build the target
-      std::string makefileName =
-                         this->GetRelativeTargetDirectory(*t);
+      std::string makefileName = this->GetRelativeTargetDirectory(*t);
       makefileName += "/build.make";
       // make sure the makefile name is suitable for a makefile
-      std::string makeTargetName =
-        this->GetRelativeTargetDirectory(*t);
+      std::string makeTargetName = this->GetRelativeTargetDirectory(*t);
       makeTargetName += "/build";
       localName = (*t)->GetName();
       localName += "/fast";
       depends.clear();
       commands.clear();
-      commands.push_back(this->GetRecursiveMakeCall
-                         (makefileName.c_str(), makeTargetName));
-      this->CreateCDCommand(commands,
-                            this->GetBinaryDirectory(),
+      commands.push_back(
+        this->GetRecursiveMakeCall(makefileName.c_str(), makeTargetName));
+      this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                             cmLocalGenerator::START_OUTPUT);
       this->WriteMakeRule(ruleFileStream, "fast build rule for target.",
                           localName, depends, commands, true);
 
       // Add a local name for the rule to relink the target before
       // installation.
-      if((*t)->NeedRelinkBeforeInstall(this->ConfigName))
-        {
+      if ((*t)->NeedRelinkBeforeInstall(this->ConfigName)) {
         makeTargetName = this->GetRelativeTargetDirectory(*t);
         makeTargetName += "/preinstall";
         localName = (*t)->GetName();
         localName += "/preinstall";
         depends.clear();
         commands.clear();
-        commands.push_back(this->GetRecursiveMakeCall
-                           (makefile2.c_str(), makeTargetName));
-        this->CreateCDCommand(commands,
-                              this->GetBinaryDirectory(),
+        commands.push_back(
+          this->GetRecursiveMakeCall(makefile2.c_str(), makeTargetName));
+        this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                               cmLocalGenerator::START_OUTPUT);
         this->WriteMakeRule(ruleFileStream,
                             "Manual pre-install relink rule for target.",
                             localName, depends, commands, true);
-        }
       }
     }
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
@@ -497,10 +456,9 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
 
   // Open the output file.
   cmGeneratedFileStream infoFileStream(infoFileName.c_str());
-  if(!infoFileStream)
-    {
+  if (!infoFileStream) {
     return;
-    }
+  }
 
   infoFileStream.SetCopyIfDifferent(true);
   // Write the do not edit header.
@@ -520,43 +478,35 @@ void cmLocalUnixMakefileGenerator3::WriteDirectoryInformationFile()
   /* clang-format on */
 
   // Tell the dependency scanner to use unix paths if necessary.
-  if(cmSystemTools::GetForceUnixPaths())
-    {
+  if (cmSystemTools::GetForceUnixPaths()) {
     /* clang-format off */
     infoFileStream
       << "# Force unix paths in dependencies.\n"
       << "set(CMAKE_FORCE_UNIX_PATHS 1)\n"
       << "\n";
     /* clang-format on */
-    }
+  }
 
   // Store the include regular expressions for this directory.
-  infoFileStream
-    << "\n"
-    << "# The C and CXX include file regular expressions for "
-    << "this directory.\n";
-  infoFileStream
-    << "set(CMAKE_C_INCLUDE_REGEX_SCAN ";
+  infoFileStream << "\n"
+                 << "# The C and CXX include file regular expressions for "
+                 << "this directory.\n";
+  infoFileStream << "set(CMAKE_C_INCLUDE_REGEX_SCAN ";
   this->WriteCMakeArgument(infoFileStream,
                            this->Makefile->GetIncludeRegularExpression());
-  infoFileStream
-    << ")\n";
-  infoFileStream
-    << "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN ";
+  infoFileStream << ")\n";
+  infoFileStream << "set(CMAKE_C_INCLUDE_REGEX_COMPLAIN ";
   this->WriteCMakeArgument(infoFileStream,
                            this->Makefile->GetComplainRegularExpression());
-  infoFileStream
-    << ")\n";
+  infoFileStream << ")\n";
   infoFileStream
     << "set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})\n";
-  infoFileStream
-    << "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN "
-    "${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n";
+  infoFileStream << "set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN "
+                    "${CMAKE_C_INCLUDE_REGEX_COMPLAIN})\n";
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::ConvertToFullPath(const std::string& localPath)
+std::string cmLocalUnixMakefileGenerator3::ConvertToFullPath(
+  const std::string& localPath)
 {
   std::string dir = this->GetCurrentBinaryDirectory();
   dir += "/";
@@ -564,156 +514,126 @@ cmLocalUnixMakefileGenerator3
   return dir;
 }
 
-
-const std::string &cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
+const std::string& cmLocalUnixMakefileGenerator3::GetHomeRelativeOutputPath()
 {
   return this->HomeRelativeOutputPath;
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteMakeRule(std::ostream& os,
-                const char* comment,
-                const std::string& target,
-                const std::vector<std::string>& depends,
-                const std::vector<std::string>& commands,
-                bool symbolic,
-                bool in_help)
+void cmLocalUnixMakefileGenerator3::WriteMakeRule(
+  std::ostream& os, const char* comment, const std::string& target,
+  const std::vector<std::string>& depends,
+  const std::vector<std::string>& commands, bool symbolic, bool in_help)
 {
   // Make sure there is a target.
-  if(target.empty())
-    {
+  if (target.empty()) {
     cmSystemTools::Error("No target for WriteMakeRule! called with comment: ",
                          comment);
     return;
-    }
+  }
 
   std::string replace;
 
   // Write the comment describing the rule in the makefile.
-  if(comment)
-    {
+  if (comment) {
     replace = comment;
     std::string::size_type lpos = 0;
     std::string::size_type rpos;
-    while((rpos = replace.find('\n', lpos)) != std::string::npos)
-      {
-      os << "# " << replace.substr(lpos, rpos-lpos) << "\n";
-      lpos = rpos+1;
-      }
-    os << "# " << replace.substr(lpos) << "\n";
+    while ((rpos = replace.find('\n', lpos)) != std::string::npos) {
+      os << "# " << replace.substr(lpos, rpos - lpos) << "\n";
+      lpos = rpos + 1;
     }
+    os << "# " << replace.substr(lpos) << "\n";
+  }
 
   // Construct the left hand side of the rule.
   std::string tgt = this->Convert(target, HOME_OUTPUT, MAKERULE);
 
   const char* space = "";
-  if(tgt.size() == 1)
-    {
+  if (tgt.size() == 1) {
     // Add a space before the ":" to avoid drive letter confusion on
     // Windows.
     space = " ";
-    }
+  }
 
   // Mark the rule as symbolic if requested.
-  if(symbolic)
-    {
-    if(const char* sym =
-       this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE"))
-      {
+  if (symbolic) {
+    if (const char* sym =
+          this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE")) {
       os << cmMakeSafe(tgt) << space << ": " << sym << "\n";
-      }
     }
+  }
 
   // Write the rule.
-  if(depends.empty())
-    {
+  if (depends.empty()) {
     // No dependencies.  The commands will always run.
     os << cmMakeSafe(tgt) << space << ":\n";
-    }
-  else
-    {
+  } else {
     // Split dependencies into multiple rule lines.  This allows for
     // very long dependency lists even on older make implementations.
-    for(std::vector<std::string>::const_iterator dep = depends.begin();
-        dep != depends.end(); ++dep)
-      {
+    for (std::vector<std::string>::const_iterator dep = depends.begin();
+         dep != depends.end(); ++dep) {
       replace = *dep;
-      replace = this->Convert(replace,HOME_OUTPUT,MAKERULE);
+      replace = this->Convert(replace, HOME_OUTPUT, MAKERULE);
       os << cmMakeSafe(tgt) << space << ": " << cmMakeSafe(replace) << "\n";
-      }
     }
+  }
 
   // Write the list of commands.
   os << cmWrap("\t", commands, "", "\n") << "\n";
-  if(symbolic && !this->IsWatcomWMake())
-    {
+  if (symbolic && !this->IsWatcomWMake()) {
     os << ".PHONY : " << cmMakeSafe(tgt) << "\n";
-    }
+  }
   os << "\n";
   // Add the output to the local help if requested.
-  if(in_help)
-    {
+  if (in_help) {
     this->LocalHelp.push_back(target);
-    }
+  }
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::ConvertShellCommand(std::string const& cmd, RelativeRoot root)
+std::string cmLocalUnixMakefileGenerator3::ConvertShellCommand(
+  std::string const& cmd, RelativeRoot root)
 {
-  if(this->IsWatcomWMake() &&
-     cmSystemTools::FileIsFullPath(cmd.c_str()) &&
-     cmd.find_first_of("( )") != cmd.npos)
-    {
+  if (this->IsWatcomWMake() && cmSystemTools::FileIsFullPath(cmd.c_str()) &&
+      cmd.find_first_of("( )") != cmd.npos) {
     // On Watcom WMake use the windows short path for the command
     // name.  This is needed to avoid funny quoting problems on
     // lines with shell redirection operators.
     std::string scmd;
-    if(cmSystemTools::GetShortPath(cmd, scmd))
-      {
+    if (cmSystemTools::GetShortPath(cmd, scmd)) {
       return this->Convert(scmd, NONE, SHELL);
-      }
     }
+  }
   return this->Convert(cmd, root, SHELL);
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteMakeVariables(std::ostream& makefileStream)
+void cmLocalUnixMakefileGenerator3::WriteMakeVariables(
+  std::ostream& makefileStream)
 {
   this->WriteDivider(makefileStream);
-  makefileStream
-    << "# Set environment variables for the build.\n"
-    << "\n";
+  makefileStream << "# Set environment variables for the build.\n"
+                 << "\n";
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  if(gg->DefineWindowsNULL)
-    {
-    makefileStream
-      << "!IF \"$(OS)\" == \"Windows_NT\"\n"
-      << "NULL=\n"
-      << "!ELSE\n"
-      << "NULL=nul\n"
-      << "!ENDIF\n";
-    }
-  if(this->IsWindowsShell())
-    {
-     makefileStream
-       << "SHELL = cmd.exe\n"
-       << "\n";
-    }
-  else
-    {
+  if (gg->DefineWindowsNULL) {
+    makefileStream << "!IF \"$(OS)\" == \"Windows_NT\"\n"
+                   << "NULL=\n"
+                   << "!ELSE\n"
+                   << "NULL=nul\n"
+                   << "!ENDIF\n";
+  }
+  if (this->IsWindowsShell()) {
+    makefileStream << "SHELL = cmd.exe\n"
+                   << "\n";
+  } else {
 #if !defined(__VMS)
     /* clang-format off */
       makefileStream
         << "# The shell in which to execute make rules.\n"
         << "SHELL = /bin/sh\n"
         << "\n";
-    /* clang-format on */
+/* clang-format on */
 #endif
-    }
+  }
 
   /* clang-format off */
   makefileStream
@@ -747,14 +667,12 @@ cmLocalUnixMakefileGenerator3
   /* clang-format on */
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteSpecialTargetsTop(std::ostream& makefileStream)
+void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsTop(
+  std::ostream& makefileStream)
 {
   this->WriteDivider(makefileStream);
-  makefileStream
-    << "# Special targets provided by cmake.\n"
-    << "\n";
+  makefileStream << "# Special targets provided by cmake.\n"
+                 << "\n";
 
   std::vector<std::string> no_commands;
   std::vector<std::string> no_depends;
@@ -762,25 +680,23 @@ cmLocalUnixMakefileGenerator3
   // Special target to cleanup operation of make tool.
   // This should be the first target except for the default_target in
   // the interface Makefile.
-  this->WriteMakeRule(
-    makefileStream, "Disable implicit rules so canonical targets will work.",
-    ".SUFFIXES", no_depends, no_commands, false);
+  this->WriteMakeRule(makefileStream,
+                      "Disable implicit rules so canonical targets will work.",
+                      ".SUFFIXES", no_depends, no_commands, false);
 
-  if(!this->IsNMake()
-      && !this->IsWatcomWMake() && !this->BorlandMakeCurlyHack)
-    {
+  if (!this->IsNMake() && !this->IsWatcomWMake() &&
+      !this->BorlandMakeCurlyHack) {
     // turn off RCS and SCCS automatic stuff from gmake
     makefileStream
       << "# Remove some rules from gmake that .SUFFIXES does not remove.\n"
       << "SUFFIXES =\n\n";
-    }
+  }
   // Add a fake suffix to keep HP happy.  Must be max 32 chars for SGI make.
   std::vector<std::string> depends;
   depends.push_back(".hpux_make_needs_suffix_list");
-  this->WriteMakeRule(makefileStream, 0,
-                      ".SUFFIXES", depends, no_commands, false);
-  if(this->IsWatcomWMake())
-    {
+  this->WriteMakeRule(makefileStream, 0, ".SUFFIXES", depends, no_commands,
+                      false);
+  if (this->IsWatcomWMake()) {
     // Switch on WMake feature, if an error or interrupt occurs during
     // makefile processing, the current target being made may be deleted
     // without prompting (the same as command line -e option).
@@ -791,18 +707,16 @@ cmLocalUnixMakefileGenerator3
       "\n"
       ;
     /* clang-format on */
-    }
-  if(this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
-    {
+  }
+  if (this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")) {
     /* clang-format off */
     makefileStream
       << "# Produce verbose output by default.\n"
       << "VERBOSE = 1\n"
       << "\n";
     /* clang-format on */
-    }
-  if(this->IsWatcomWMake())
-    {
+  }
+  if (this->IsWatcomWMake()) {
     /* clang-format off */
     makefileStream <<
       "!ifndef VERBOSE\n"
@@ -811,9 +725,7 @@ cmLocalUnixMakefileGenerator3
       "\n"
       ;
     /* clang-format on */
-    }
-  else
-    {
+  } else {
     // Write special target to silence make output.  This must be after
     // the default target in case VERBOSE is set (which changes the
     // name).  The setting of CMAKE_VERBOSE_MAKEFILE to ON will cause a
@@ -822,89 +734,73 @@ cmLocalUnixMakefileGenerator3
     // the user.
     this->WriteMakeRule(makefileStream,
                         "Suppress display of executed commands.",
-                        "$(VERBOSE).SILENT",
-                        no_depends,
-                        no_commands, false);
-    }
+                        "$(VERBOSE).SILENT", no_depends, no_commands, false);
+  }
 
   // Work-around for makes that drop rules that have no dependencies
   // or commands.
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
   std::string hack = gg->GetEmptyRuleHackDepends();
-  if(!hack.empty())
-    {
+  if (!hack.empty()) {
     no_depends.push_back(hack);
-    }
+  }
   std::string hack_cmd = gg->GetEmptyRuleHackCommand();
-  if(!hack_cmd.empty())
-    {
+  if (!hack_cmd.empty()) {
     no_commands.push_back(hack_cmd);
-    }
+  }
 
   // Special symbolic target that never exists to force dependers to
   // run their rules.
-  this->WriteMakeRule
-    (makefileStream,
-     "A target that is always out of date.",
-     "cmake_force", no_depends, no_commands, true);
+  this->WriteMakeRule(makefileStream, "A target that is always out of date.",
+                      "cmake_force", no_depends, no_commands, true);
 
   // Variables for reference by other rules.
   this->WriteMakeVariables(makefileStream);
 }
 
-void cmLocalUnixMakefileGenerator3
-::WriteSpecialTargetsBottom(std::ostream& makefileStream)
+void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsBottom(
+  std::ostream& makefileStream)
 {
   this->WriteDivider(makefileStream);
-  makefileStream
-    << "# Special targets to cleanup operation of make.\n"
-    << "\n";
+  makefileStream << "# Special targets to cleanup operation of make.\n"
+                 << "\n";
 
   // Write special "cmake_check_build_system" target to run cmake with
   // the --check-build-system flag.
   {
-  // Build command to run CMake to check if anything needs regenerating.
-  std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
-  cmakefileName += "Makefile.cmake";
-  std::string runRule =
-    "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
-  runRule += " --check-build-system ";
-  runRule += this->Convert(cmakefileName,NONE,SHELL);
-  runRule += " 0";
+    // Build command to run CMake to check if anything needs regenerating.
+    std::string cmakefileName = cmake::GetCMakeFilesDirectoryPostSlash();
+    cmakefileName += "Makefile.cmake";
+    std::string runRule =
+      "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
+    runRule += " --check-build-system ";
+    runRule += this->Convert(cmakefileName, NONE, SHELL);
+    runRule += " 0";
 
-  std::vector<std::string> no_depends;
-  std::vector<std::string> commands;
-  commands.push_back(runRule);
-  if(!this->IsRootMakefile())
-    {
-    this->CreateCDCommand(commands,
-                          this->GetBinaryDirectory(),
-                          cmLocalGenerator::START_OUTPUT);
+    std::vector<std::string> no_depends;
+    std::vector<std::string> commands;
+    commands.push_back(runRule);
+    if (!this->IsRootMakefile()) {
+      this->CreateCDCommand(commands, this->GetBinaryDirectory(),
+                            cmLocalGenerator::START_OUTPUT);
     }
-  this->WriteMakeRule(makefileStream,
-                      "Special rule to run CMake to check the build system "
+    this->WriteMakeRule(
+      makefileStream, "Special rule to run CMake to check the build system "
                       "integrity.\n"
                       "No rule that depends on this can have "
                       "commands that come from listfiles\n"
                       "because they might be regenerated.",
-                      "cmake_check_build_system",
-                      no_depends,
-                      commands, true);
+      "cmake_check_build_system", no_depends, commands, true);
   }
 }
 
-
-
-void
-cmLocalUnixMakefileGenerator3
-::WriteConvenienceRule(std::ostream& ruleFileStream,
-                       const std::string& realTarget,
-                       const std::string& helpTarget)
+void cmLocalUnixMakefileGenerator3::WriteConvenienceRule(
+  std::ostream& ruleFileStream, const std::string& realTarget,
+  const std::string& helpTarget)
 {
   // A rule is only needed if the names are different.
-  if(realTarget != helpTarget)
-    {
+  if (realTarget != helpTarget) {
     // The helper target depends on the real target.
     std::vector<std::string> depends;
     depends.push_back(realTarget);
@@ -915,34 +811,28 @@ cmLocalUnixMakefileGenerator3
     // Write the rule.
     this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                         helpTarget, depends, no_commands, true);
-    }
+  }
 }
 
-
-std::string
-cmLocalUnixMakefileGenerator3
-::GetRelativeTargetDirectory(cmGeneratorTarget* target)
+std::string cmLocalUnixMakefileGenerator3::GetRelativeTargetDirectory(
+  cmGeneratorTarget* target)
 {
   std::string dir = this->HomeRelativeOutputPath;
   dir += this->GetTargetDirectory(target);
-  return this->Convert(dir,NONE,UNCHANGED);
+  return this->Convert(dir, NONE, UNCHANGED);
 }
 
-
-
 void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
                                                 const std::string& newFlags)
 {
-  if(this->IsWatcomWMake() && !newFlags.empty())
-    {
+  if (this->IsWatcomWMake() && !newFlags.empty()) {
     std::string newf = newFlags;
-    if(newf.find("\\\"") != newf.npos)
-      {
+    if (newf.find("\\\"") != newf.npos) {
       cmSystemTools::ReplaceString(newf, "\\\"", "\"");
       this->cmLocalGenerator::AppendFlags(flags, newf);
       return;
-      }
     }
+  }
   this->cmLocalGenerator::AppendFlags(flags, newFlags);
 }
 
@@ -952,203 +842,161 @@ void cmLocalUnixMakefileGenerator3::AppendFlags(std::string& flags,
   this->cmLocalGenerator::AppendFlags(flags, newFlags);
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendRuleDepend(std::vector<std::string>& depends,
-                   const char* ruleFileName)
+void cmLocalUnixMakefileGenerator3::AppendRuleDepend(
+  std::vector<std::string>& depends, const char* ruleFileName)
 {
   // Add a dependency on the rule file itself unless an option to skip
   // it is specifically enabled by the user or project.
   const char* nodep =
     this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
-  if(!nodep || cmSystemTools::IsOff(nodep))
-    {
+  if (!nodep || cmSystemTools::IsOff(nodep)) {
     depends.push_back(ruleFileName);
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendRuleDepends(std::vector<std::string>& depends,
-                    std::vector<std::string> const& ruleFiles)
+void cmLocalUnixMakefileGenerator3::AppendRuleDepends(
+  std::vector<std::string>& depends, std::vector<std::string> const& ruleFiles)
 {
   // Add a dependency on the rule file itself unless an option to skip
   // it is specifically enabled by the user or project.
-  if(!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY"))
-    {
+  if (!this->Makefile->IsOn("CMAKE_SKIP_RULE_DEPENDENCY")) {
     depends.insert(depends.end(), ruleFiles.begin(), ruleFiles.end());
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomDepends(std::vector<std::string>& depends,
-                      const std::vector<cmCustomCommand>& ccs)
+void cmLocalUnixMakefileGenerator3::AppendCustomDepends(
+  std::vector<std::string>& depends, const std::vector<cmCustomCommand>& ccs)
 {
-  for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
-      i != ccs.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
+       i != ccs.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
     this->AppendCustomDepend(depends, ccg);
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomDepend(std::vector<std::string>& depends,
-                     cmCustomCommandGenerator const& ccg)
+void cmLocalUnixMakefileGenerator3::AppendCustomDepend(
+  std::vector<std::string>& depends, cmCustomCommandGenerator const& ccg)
 {
-  for(std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
-      d != ccg.GetDepends().end(); ++d)
-    {
+  for (std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
+       d != ccg.GetDepends().end(); ++d) {
     // Lookup the real name of the dependency in case it is a CMake target.
     std::string dep;
-    if(this->GetRealDependency(*d, this->ConfigName,
-                               dep))
-      {
+    if (this->GetRealDependency(*d, this->ConfigName, dep)) {
       depends.push_back(dep);
-      }
     }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomCommands(std::vector<std::string>& commands,
-                       const std::vector<cmCustomCommand>& ccs,
-                       cmGeneratorTarget* target,
-                       cmLocalGenerator::RelativeRoot relative)
+void cmLocalUnixMakefileGenerator3::AppendCustomCommands(
+  std::vector<std::string>& commands, const std::vector<cmCustomCommand>& ccs,
+  cmGeneratorTarget* target, cmLocalGenerator::RelativeRoot relative)
 {
-  for(std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
-      i != ccs.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = ccs.begin();
+       i != ccs.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, this->ConfigName, this);
     this->AppendCustomCommand(commands, ccg, target, true, relative);
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCustomCommand(std::vector<std::string>& commands,
-                      cmCustomCommandGenerator const& ccg,
-                      cmGeneratorTarget* target,
-                      bool echo_comment,
-                      cmLocalGenerator::RelativeRoot relative,
-                      std::ostream* content)
+void cmLocalUnixMakefileGenerator3::AppendCustomCommand(
+  std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
+  cmGeneratorTarget* target, bool echo_comment,
+  cmLocalGenerator::RelativeRoot relative, std::ostream* content)
 {
   // Optionally create a command to display the custom command's
   // comment text.  This is used for pre-build, pre-link, and
   // post-build command comments.  Custom build step commands have
   // their comments generated elsewhere.
-  if(echo_comment)
-    {
+  if (echo_comment) {
     const char* comment = ccg.GetComment();
-    if(comment && *comment)
-      {
+    if (comment && *comment) {
       this->AppendEcho(commands, comment,
                        cmLocalUnixMakefileGenerator3::EchoGenerate);
-      }
     }
+  }
 
   // if the command specified a working directory use it.
-  std::string dir  = this->GetCurrentBinaryDirectory();
+  std::string dir = this->GetCurrentBinaryDirectory();
   std::string workingDir = ccg.GetWorkingDirectory();
-  if(!workingDir.empty())
-    {
+  if (!workingDir.empty()) {
     dir = workingDir;
-    }
-  if(content)
-    {
+  }
+  if (content) {
     *content << dir;
-    }
+  }
 
   // Add each command line to the set of commands.
   std::vector<std::string> commands1;
-  for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-    {
+  for (unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) {
     // Build the command line in a single string.
     std::string cmd = ccg.GetCommand(c);
-    if (!cmd.empty())
-      {
+    if (!cmd.empty()) {
       // Use "call " before any invocations of .bat or .cmd files
       // invoked as custom commands in the WindowsShell.
       //
       bool useCall = false;
 
-      if (this->IsWindowsShell())
-        {
+      if (this->IsWindowsShell()) {
         std::string suffix;
-        if (cmd.size() > 4)
-          {
-          suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size()-4));
-          if (suffix == ".bat" || suffix == ".cmd")
-            {
+        if (cmd.size() > 4) {
+          suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size() - 4));
+          if (suffix == ".bat" || suffix == ".cmd") {
             useCall = true;
-            }
           }
         }
+      }
 
       cmSystemTools::ReplaceString(cmd, "/./", "/");
       // Convert the command to a relative path only if the current
       // working directory will be the start-output directory.
       bool had_slash = cmd.find("/") != cmd.npos;
-      if(workingDir.empty())
-        {
-        cmd = this->Convert(cmd,START_OUTPUT);
-        }
+      if (workingDir.empty()) {
+        cmd = this->Convert(cmd, START_OUTPUT);
+      }
       bool has_slash = cmd.find("/") != cmd.npos;
-      if(had_slash && !has_slash)
-        {
+      if (had_slash && !has_slash) {
         // This command was specified as a path to a file in the
         // current directory.  Add a leading "./" so it can run
         // without the current directory being in the search path.
         cmd = "./" + cmd;
-        }
-      std::string launcher =
-        this->MakeLauncher(ccg, target,
-                           workingDir.empty()? START_OUTPUT : NONE);
+      }
+      std::string launcher = this->MakeLauncher(
+        ccg, target, workingDir.empty() ? START_OUTPUT : NONE);
       cmd = launcher + this->ConvertShellCommand(cmd, NONE);
 
       ccg.AppendArguments(c, cmd);
-      if(content)
-        {
+      if (content) {
         // Rule content does not include the launcher.
-        *content << (cmd.c_str()+launcher.size());
-        }
-      if(this->BorlandMakeCurlyHack)
-        {
+        *content << (cmd.c_str() + launcher.size());
+      }
+      if (this->BorlandMakeCurlyHack) {
         // Borland Make has a very strange bug.  If the first curly
         // brace anywhere in the command string is a left curly, it
         // must be written {{} instead of just {.  Otherwise some
         // curly braces are removed.  The hack can be skipped if the
         // first curly brace is the last character.
         std::string::size_type lcurly = cmd.find("{");
-        if(lcurly != cmd.npos && lcurly < (cmd.size()-1))
-          {
+        if (lcurly != cmd.npos && lcurly < (cmd.size() - 1)) {
           std::string::size_type rcurly = cmd.find("}");
-          if(rcurly == cmd.npos || rcurly > lcurly)
-            {
+          if (rcurly == cmd.npos || rcurly > lcurly) {
             // The first curly is a left curly.  Use the hack.
             std::string hack_cmd = cmd.substr(0, lcurly);
             hack_cmd += "{{}";
-            hack_cmd += cmd.substr(lcurly+1);
+            hack_cmd += cmd.substr(lcurly + 1);
             cmd = hack_cmd;
-            }
           }
         }
-      if (launcher.empty())
-        {
-        if (useCall)
-          {
+      }
+      if (launcher.empty()) {
+        if (useCall) {
           cmd = "call " + cmd;
-          }
-        else if (this->IsNMake() && cmd[0]=='"')
-          {
+        } else if (this->IsNMake() && cmd[0] == '"') {
           cmd = "echo >nul && " + cmd;
-          }
         }
-      commands1.push_back(cmd);
       }
+      commands1.push_back(cmd);
     }
+  }
 
   // Setup the proper working directory for the commands.
   this->CreateCDCommand(commands1, dir.c_str(), relative);
@@ -1157,18 +1005,16 @@ cmLocalUnixMakefileGenerator3
   commands.insert(commands.end(), commands1.begin(), commands1.end());
 }
 
-std::string
-cmLocalUnixMakefileGenerator3::MakeLauncher(
-  cmCustomCommandGenerator const& ccg,
-  cmGeneratorTarget* target, RelativeRoot relative)
+std::string cmLocalUnixMakefileGenerator3::MakeLauncher(
+  cmCustomCommandGenerator const& ccg, cmGeneratorTarget* target,
+  RelativeRoot relative)
 {
   // Short-circuit if there is no launcher.
   const char* prop = "RULE_LAUNCH_CUSTOM";
   const char* val = this->GetRuleLauncher(target, prop);
-  if(!(val && *val))
-    {
+  if (!(val && *val)) {
     return "";
-    }
+  }
 
   // Expand rules in the empty string.  It may insert the launcher and
   // perform replacements.
@@ -1177,65 +1023,56 @@ cmLocalUnixMakefileGenerator3::MakeLauncher(
   vars.CMTarget = target;
   std::string output;
   const std::vector<std::string>& outputs = ccg.GetOutputs();
-  if(!outputs.empty())
-    {
+  if (!outputs.empty()) {
     output = this->Convert(outputs[0], relative, SHELL);
-    }
+  }
   vars.Output = output.c_str();
 
   std::string launcher;
   this->ExpandRuleVariables(launcher, vars);
-  if(!launcher.empty())
-    {
+  if (!launcher.empty()) {
     launcher += " ";
-    }
+  }
   return launcher;
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::AppendCleanCommand(std::vector<std::string>& commands,
-                     const std::vector<std::string>& files,
-                     cmGeneratorTarget* target, const char* filename)
+void cmLocalUnixMakefileGenerator3::AppendCleanCommand(
+  std::vector<std::string>& commands, const std::vector<std::string>& files,
+  cmGeneratorTarget* target, const char* filename)
 {
   std::string cleanfile = this->GetCurrentBinaryDirectory();
   cleanfile += "/";
   cleanfile += this->GetTargetDirectory(target);
   cleanfile += "/cmake_clean";
-  if(filename)
-    {
+  if (filename) {
     cleanfile += "_";
     cleanfile += filename;
-    }
+  }
   cleanfile += ".cmake";
   std::string cleanfilePath = this->Convert(cleanfile, FULL);
   cmsys::ofstream fout(cleanfilePath.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("Could not create ", cleanfilePath.c_str());
-    }
-  if(!files.empty())
-    {
+  }
+  if (!files.empty()) {
     fout << "file(REMOVE_RECURSE\n";
-    for(std::vector<std::string>::const_iterator f = files.begin();
-        f != files.end(); ++f)
-      {
-      std::string fc = this->Convert(*f,START_OUTPUT,UNCHANGED);
+    for (std::vector<std::string>::const_iterator f = files.begin();
+         f != files.end(); ++f) {
+      std::string fc = this->Convert(*f, START_OUTPUT, UNCHANGED);
       fout << "  " << cmOutputConverter::EscapeForCMake(fc) << "\n";
-      }
-    fout << ")\n";
     }
+    fout << ")\n";
+  }
   std::string remove = "$(CMAKE_COMMAND) -P ";
   remove += this->Convert(cleanfile, START_OUTPUT, SHELL);
   commands.push_back(remove);
 
   // For the main clean rule add per-language cleaning.
-  if(!filename)
-    {
+  if (!filename) {
     // Get the set of source languages in the target.
     std::set<std::string> languages;
-    target->GetLanguages(languages,
-                      this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+    target->GetLanguages(
+      languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
     /* clang-format off */
     fout << "\n"
          << "# Per-language clean rules from dependency scanning.\n"
@@ -1244,23 +1081,19 @@ cmLocalUnixMakefileGenerator3
          << "/cmake_clean_${lang}.cmake OPTIONAL)\n"
          << "endforeach()\n";
     /* clang-format on */
-    }
+  }
 }
 
-void
-cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
-                                          std::string const& text,
-                                          EchoColor color,
-                                          EchoProgress const* progress)
+void cmLocalUnixMakefileGenerator3::AppendEcho(
+  std::vector<std::string>& commands, std::string const& text, EchoColor color,
+  EchoProgress const* progress)
 {
   // Choose the color for the text.
   std::string color_name;
-  if(this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile)
-    {
+  if (this->GlobalGenerator->GetToolSupportsColor() && this->ColorMakefile) {
     // See cmake::ExecuteEchoColor in cmake.cxx for these options.
     // This color set is readable on both black and white backgrounds.
-    switch(color)
-      {
+    switch (color) {
       case EchoNormal:
         break;
       case EchoDepend:
@@ -1278,47 +1111,39 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
       case EchoGlobal:
         color_name = "--cyan ";
         break;
-      }
     }
+  }
 
   // Echo one line at a time.
   std::string line;
   line.reserve(200);
-  for(const char* c = text.c_str();; ++c)
-    {
-    if(*c == '\n' || *c == '\0')
-      {
+  for (const char* c = text.c_str();; ++c) {
+    if (*c == '\n' || *c == '\0') {
       // Avoid writing a blank last line on end-of-string.
-      if(*c != '\0' || !line.empty())
-        {
+      if (*c != '\0' || !line.empty()) {
         // Add a command to echo this line.
         std::string cmd;
-        if(color_name.empty() && !progress)
-          {
+        if (color_name.empty() && !progress) {
           // Use the native echo command.
           cmd = "@echo ";
           cmd += this->EscapeForShell(line, false, true);
-          }
-        else
-          {
+        } else {
           // Use cmake to echo the text in color.
           cmd = "@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) ";
           cmd += color_name;
-          if (progress)
-            {
+          if (progress) {
             cmd += "--progress-dir=";
-            cmd += this->Convert(progress->Dir,
-                                 cmLocalGenerator::FULL,
+            cmd += this->Convert(progress->Dir, cmLocalGenerator::FULL,
                                  cmLocalGenerator::SHELL);
             cmd += " ";
             cmd += "--progress-num=";
             cmd += progress->Arg;
             cmd += " ";
-            }
-          cmd += this->EscapeForShell(line);
           }
-        commands.push_back(cmd);
+          cmd += this->EscapeForShell(line);
         }
+        commands.push_back(cmd);
+      }
 
       // Reset the line to emtpy.
       line = "";
@@ -1327,22 +1152,18 @@ cmLocalUnixMakefileGenerator3::AppendEcho(std::vector<std::string>& commands,
       progress = 0;
 
       // Terminate on end-of-string.
-      if(*c == '\0')
-        {
+      if (*c == '\0') {
         return;
-        }
       }
-    else if(*c != '\r')
-      {
+    } else if (*c != '\r') {
       // Append this character to the current line.
       line += *c;
-      }
     }
+  }
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::CreateMakeVariable(const std::string& sin, const std::string& s2in)
+std::string cmLocalUnixMakefileGenerator3::CreateMakeVariable(
+  const std::string& sin, const std::string& s2in)
 {
   std::string s = sin;
   std::string s2 = s2in;
@@ -1351,27 +1172,24 @@ cmLocalUnixMakefileGenerator3
   // if there is no restriction on the length of make variables
   // and there are no "." characters in the string, then return the
   // unmodified combination.
-  if((!this->MakefileVariableSize && unmodified.find('.') == s.npos)
-     && (!this->MakefileVariableSize && unmodified.find('+') == s.npos)
-     && (!this->MakefileVariableSize && unmodified.find('-') == s.npos))
-    {
+  if ((!this->MakefileVariableSize && unmodified.find('.') == s.npos) &&
+      (!this->MakefileVariableSize && unmodified.find('+') == s.npos) &&
+      (!this->MakefileVariableSize && unmodified.find('-') == s.npos)) {
     return unmodified;
-    }
+  }
 
   // see if the variable has been defined before and return
   // the modified version of the variable
   std::map<std::string, std::string>::iterator i =
     this->MakeVariableMap.find(unmodified);
-  if(i != this->MakeVariableMap.end())
-    {
+  if (i != this->MakeVariableMap.end()) {
     return i->second;
-    }
+  }
   // start with the unmodified variable
   std::string ret = unmodified;
   // if this there is no value for this->MakefileVariableSize then
   // the string must have bad characters in it
-  if(!this->MakefileVariableSize)
-    {
+  if (!this->MakefileVariableSize) {
     cmSystemTools::ReplaceString(ret, ".", "_");
     cmSystemTools::ReplaceString(ret, "-", "__");
     cmSystemTools::ReplaceString(ret, "+", "___");
@@ -1379,53 +1197,47 @@ cmLocalUnixMakefileGenerator3
     char buffer[5];
     // make sure the _ version is not already used, if
     // it is used then add number to the end of the variable
-    while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
-      {
+    while (this->ShortMakeVariableMap.count(ret) && ni < 1000) {
       ++ni;
       sprintf(buffer, "%04d", ni);
       ret = unmodified + buffer;
-      }
+    }
     this->ShortMakeVariableMap[ret] = "1";
     this->MakeVariableMap[unmodified] = ret;
     return ret;
-    }
+  }
 
   // if the string is greater than 32 chars it is an invalid variable name
   // for borland make
-  if(static_cast<int>(ret.size()) > this->MakefileVariableSize)
-    {
+  if (static_cast<int>(ret.size()) > this->MakefileVariableSize) {
     int keep = this->MakefileVariableSize - 8;
     int size = keep + 3;
     std::string str1 = s;
     std::string str2 = s2;
     // we must shorten the combined string by 4 characters
     // keep no more than 24 characters from the second string
-    if(static_cast<int>(str2.size()) > keep)
-      {
+    if (static_cast<int>(str2.size()) > keep) {
       str2 = str2.substr(0, keep);
-      }
-    if(static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size)
-      {
+    }
+    if (static_cast<int>(str1.size()) + static_cast<int>(str2.size()) > size) {
       str1 = str1.substr(0, size - str2.size());
-      }
+    }
     char buffer[5];
     int ni = 0;
     sprintf(buffer, "%04d", ni);
     ret = str1 + str2 + buffer;
-    while(this->ShortMakeVariableMap.count(ret) && ni < 1000)
-      {
+    while (this->ShortMakeVariableMap.count(ret) && ni < 1000) {
       ++ni;
       sprintf(buffer, "%04d", ni);
       ret = str1 + str2 + buffer;
-      }
-    if(ni == 1000)
-      {
+    }
+    if (ni == 1000) {
       cmSystemTools::Error("Borland makefile variable length too long");
       return unmodified;
-      }
+    }
     // once an unused variable is found
     this->ShortMakeVariableMap[ret] = "1";
-    }
+  }
   // always make an entry into the unmodified to variable map
   this->MakeVariableMap[unmodified] = ret;
   return ret;
@@ -1436,11 +1248,10 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
                                                        bool color)
 {
   // read in the target info file
-  if(!this->Makefile->ReadListFile(tgtInfo) ||
-     cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (!this->Makefile->ReadListFile(tgtInfo) ||
+      cmSystemTools::GetErrorOccuredFlag()) {
     cmSystemTools::Error("Target DependInfo.cmake file not found");
-    }
+  }
 
   // Check if any multiple output pairs have a missing file.
   this->CheckMultipleOutputs(verbose);
@@ -1457,19 +1268,16 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
   cmFileTimeComparison* ftc =
     this->GlobalGenerator->GetCMakeInstance()->GetFileComparison();
   {
-  int result;
-  if(!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) ||
-     result < 0)
-    {
-    if(verbose)
-      {
-      std::ostringstream msg;
-      msg << "Dependee \"" << tgtInfo
-          << "\" is newer than depender \""
-          << internalDependFile << "\"." << std::endl;
-      cmSystemTools::Stdout(msg.str().c_str());
+    int result;
+    if (!ftc->FileTimeCompare(internalDependFile.c_str(), tgtInfo, &result) ||
+        result < 0) {
+      if (verbose) {
+        std::ostringstream msg;
+        msg << "Dependee \"" << tgtInfo << "\" is newer than depender \""
+            << internalDependFile << "\"." << std::endl;
+        cmSystemTools::Stdout(msg.str().c_str());
       }
-    needRescanDependInfo = true;
+      needRescanDependInfo = true;
     }
   }
 
@@ -1480,19 +1288,17 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
   dirInfoFile += cmake::GetCMakeFilesDirectory();
   dirInfoFile += "/CMakeDirectoryInformation.cmake";
   {
-  int result;
-  if(!ftc->FileTimeCompare(internalDependFile.c_str(),
-                           dirInfoFile.c_str(), &result) || result < 0)
-    {
-    if(verbose)
-      {
-      std::ostringstream msg;
-      msg << "Dependee \"" << dirInfoFile
-          << "\" is newer than depender \""
-          << internalDependFile << "\"." << std::endl;
-      cmSystemTools::Stdout(msg.str().c_str());
+    int result;
+    if (!ftc->FileTimeCompare(internalDependFile.c_str(), dirInfoFile.c_str(),
+                              &result) ||
+        result < 0) {
+      if (verbose) {
+        std::ostringstream msg;
+        msg << "Dependee \"" << dirInfoFile << "\" is newer than depender \""
+            << internalDependFile << "\"." << std::endl;
+        cmSystemTools::Stdout(msg.str().c_str());
       }
-    needRescanDirInfo = true;
+      needRescanDirInfo = true;
     }
   }
 
@@ -1502,8 +1308,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
   // not be considered.
   std::map<std::string, cmDepends::DependencyVector> validDependencies;
   bool needRescanDependencies = false;
-  if (needRescanDirInfo == false)
-    {
+  if (needRescanDirInfo == false) {
     cmDependsC checker;
     checker.SetVerbose(verbose);
     checker.SetFileComparison(ftc);
@@ -1517,34 +1322,30 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
     // dependency vector. This means that in the normal case, when only
     // few or one file have been edited, then also only this one file is
     // actually scanned again, instead of all files for this target.
-    needRescanDependencies = !checker.Check(dependFile.c_str(),
-                                            internalDependFile.c_str(),
-                                            validDependencies);
-    }
+    needRescanDependencies = !checker.Check(
+      dependFile.c_str(), internalDependFile.c_str(), validDependencies);
+  }
 
-  if(needRescanDependInfo || needRescanDirInfo || needRescanDependencies)
-    {
+  if (needRescanDependInfo || needRescanDirInfo || needRescanDependencies) {
     // The dependencies must be regenerated.
     std::string targetName = cmSystemTools::GetFilenameName(dir);
-    targetName = targetName.substr(0, targetName.length()-4);
+    targetName = targetName.substr(0, targetName.length() - 4);
     std::string message = "Scanning dependencies of target ";
     message += targetName;
-    cmSystemTools::MakefileColorEcho(
-      cmsysTerminal_Color_ForegroundMagenta |
-      cmsysTerminal_Color_ForegroundBold,
-      message.c_str(), true, color);
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundMagenta |
+                                       cmsysTerminal_Color_ForegroundBold,
+                                     message.c_str(), true, color);
 
     return this->ScanDependencies(dir.c_str(), validDependencies);
-    }
+  }
 
   // The dependencies are already up-to-date.
   return true;
 }
 
-bool
-cmLocalUnixMakefileGenerator3
-::ScanDependencies(const char* targetDir,
-                 std::map<std::string, cmDepends::DependencyVector>& validDeps)
+bool cmLocalUnixMakefileGenerator3::ScanDependencies(
+  const char* targetDir,
+  std::map<std::string, cmDepends::DependencyVector>& validDeps)
 {
   // Read the directory information file.
   cmMakefile* mf = this->Makefile;
@@ -1552,42 +1353,34 @@ cmLocalUnixMakefileGenerator3
   std::string dirInfoFile = this->GetCurrentBinaryDirectory();
   dirInfoFile += cmake::GetCMakeFilesDirectory();
   dirInfoFile += "/CMakeDirectoryInformation.cmake";
-  if(mf->ReadListFile(dirInfoFile.c_str()) &&
-     !cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (mf->ReadListFile(dirInfoFile.c_str()) &&
+      !cmSystemTools::GetErrorOccuredFlag()) {
     haveDirectoryInfo = true;
-    }
+  }
 
   // Lookup useful directory information.
-  if(haveDirectoryInfo)
-    {
+  if (haveDirectoryInfo) {
     // Test whether we need to force Unix paths.
-    if(const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS"))
-      {
-      if(!cmSystemTools::IsOff(force))
-        {
+    if (const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS")) {
+      if (!cmSystemTools::IsOff(force)) {
         cmSystemTools::SetForceUnixPaths(true);
-        }
       }
+    }
 
     // Setup relative path top directories.
-    if(const char* relativePathTopSource =
-       mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE"))
-      {
-      this->StateSnapshot.GetDirectory()
-            .SetRelativePathTopSource(relativePathTopSource);
-      }
-    if(const char* relativePathTopBinary =
-       mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY"))
-      {
-      this->StateSnapshot.GetDirectory()
-            .SetRelativePathTopBinary(relativePathTopBinary);
-      }
+    if (const char* relativePathTopSource =
+          mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE")) {
+      this->StateSnapshot.GetDirectory().SetRelativePathTopSource(
+        relativePathTopSource);
     }
-  else
-    {
-    cmSystemTools::Error("Directory Information file not found");
+    if (const char* relativePathTopBinary =
+          mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY")) {
+      this->StateSnapshot.GetDirectory().SetRelativePathTopBinary(
+        relativePathTopBinary);
     }
+  } else {
+    cmSystemTools::Error("Directory Information file not found");
+  }
 
   // create the file stream for the depends file
   std::string dir = targetDir;
@@ -1598,67 +1391,59 @@ cmLocalUnixMakefileGenerator3
   ruleFileNameFull += "/depend.make";
   cmGeneratedFileStream ruleFileStream(ruleFileNameFull.c_str());
   ruleFileStream.SetCopyIfDifferent(true);
-  if(!ruleFileStream)
-    {
+  if (!ruleFileStream) {
     return false;
-    }
+  }
 
   // Open the cmake dependency tracking file.  This should not be
   // copy-if-different because dependencies are re-scanned when it is
   // older than the DependInfo.cmake.
   std::string internalRuleFileNameFull = dir;
   internalRuleFileNameFull += "/depend.internal";
-  cmGeneratedFileStream
-    internalRuleFileStream(internalRuleFileNameFull.c_str());
-  if(!internalRuleFileStream)
-    {
+  cmGeneratedFileStream internalRuleFileStream(
+    internalRuleFileNameFull.c_str());
+  if (!internalRuleFileStream) {
     return false;
-    }
+  }
 
   this->WriteDisclaimer(ruleFileStream);
   this->WriteDisclaimer(internalRuleFileStream);
 
   // for each language we need to scan, scan it
-  const char *langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
+  const char* langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
   std::vector<std::string> langs;
   cmSystemTools::ExpandListArgument(langStr, langs);
-  for (std::vector<std::string>::iterator li =
-         langs.begin(); li != langs.end(); ++li)
-    {
+  for (std::vector<std::string>::iterator li = langs.begin();
+       li != langs.end(); ++li) {
     // construct the checker
     std::string lang = *li;
 
     // Create the scanner for this language
-    cmDepends *scanner = 0;
-    if(lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM")
-      {
+    cmDepends* scanner = 0;
+    if (lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM") {
       // TODO: Handle RC (resource files) dependencies correctly.
       scanner = new cmDependsC(this, targetDir, lang, &validDeps);
-      }
+    }
 #ifdef CMAKE_BUILD_WITH_CMAKE
-    else if(lang == "Fortran")
-      {
+    else if (lang == "Fortran") {
       scanner = new cmDependsFortran(this);
-      }
-    else if(lang == "Java")
-      {
+    } else if (lang == "Java") {
       scanner = new cmDependsJava();
-      }
+    }
 #endif
 
-    if (scanner)
-      {
+    if (scanner) {
       scanner->SetLocalGenerator(this);
-      scanner->SetFileComparison
-        (this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
+      scanner->SetFileComparison(
+        this->GlobalGenerator->GetCMakeInstance()->GetFileComparison());
       scanner->SetLanguage(lang);
       scanner->SetTargetDirectory(dir.c_str());
       scanner->Write(ruleFileStream, internalRuleFileStream);
 
       // free the scanner for this language
       delete scanner;
-      }
     }
+  }
 
   return true;
 }
@@ -1669,68 +1454,62 @@ void cmLocalUnixMakefileGenerator3::CheckMultipleOutputs(bool verbose)
 
   // Get the string listing the multiple output pairs.
   const char* pairs_string = mf->GetDefinition("CMAKE_MULTIPLE_OUTPUT_PAIRS");
-  if(!pairs_string)
-    {
+  if (!pairs_string) {
     return;
-    }
+  }
 
   // Convert the string to a list and preserve empty entries.
   std::vector<std::string> pairs;
   cmSystemTools::ExpandListArgument(pairs_string, pairs, true);
-  for(std::vector<std::string>::const_iterator i = pairs.begin();
-      i != pairs.end() && (i+1) != pairs.end();)
-    {
+  for (std::vector<std::string>::const_iterator i = pairs.begin();
+       i != pairs.end() && (i + 1) != pairs.end();) {
     const std::string& depender = *i++;
     const std::string& dependee = *i++;
 
     // If the depender is missing then delete the dependee to make
     // sure both will be regenerated.
-    if(cmSystemTools::FileExists(dependee.c_str()) &&
-       !cmSystemTools::FileExists(depender.c_str()))
-      {
-      if(verbose)
-        {
+    if (cmSystemTools::FileExists(dependee.c_str()) &&
+        !cmSystemTools::FileExists(depender.c_str())) {
+      if (verbose) {
         std::ostringstream msg;
         msg << "Deleting primary custom command output \"" << dependee
-            << "\" because another output \""
-            << depender << "\" does not exist." << std::endl;
+            << "\" because another output \"" << depender
+            << "\" does not exist." << std::endl;
         cmSystemTools::Stdout(msg.str().c_str());
-        }
-      cmSystemTools::RemoveFile(dependee);
       }
+      cmSystemTools::RemoveFile(dependee);
     }
+  }
 }
 
-void cmLocalUnixMakefileGenerator3
-::WriteLocalAllRules(std::ostream& ruleFileStream)
+void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
+  std::ostream& ruleFileStream)
 {
   this->WriteDisclaimer(ruleFileStream);
 
   // Write the main entry point target.  This must be the VERY first
   // target so that make with no arguments will run it.
   {
-  // Just depend on the all target to drive the build.
-  std::vector<std::string> depends;
-  std::vector<std::string> no_commands;
-  depends.push_back("all");
+    // Just depend on the all target to drive the build.
+    std::vector<std::string> depends;
+    std::vector<std::string> no_commands;
+    depends.push_back("all");
 
-  // Write the rule.
-  this->WriteMakeRule(ruleFileStream,
-                      "Default target executed when no arguments are "
-                      "given to make.",
-                      "default_target",
-                      depends,
-                      no_commands, true);
-
-  // Help out users that try "gmake target1 target2 -j".
-  cmGlobalUnixMakefileGenerator3* gg =
-    static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  if(gg->AllowNotParallel())
-    {
-    std::vector<std::string> no_depends;
+    // Write the rule.
     this->WriteMakeRule(ruleFileStream,
-      "Allow only one \"make -f Makefile2\" at a time, but pass parallelism.",
-      ".NOTPARALLEL", no_depends, no_commands, false);
+                        "Default target executed when no arguments are "
+                        "given to make.",
+                        "default_target", depends, no_commands, true);
+
+    // Help out users that try "gmake target1 target2 -j".
+    cmGlobalUnixMakefileGenerator3* gg =
+      static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
+    if (gg->AllowNotParallel()) {
+      std::vector<std::string> no_depends;
+      this->WriteMakeRule(ruleFileStream, "Allow only one \"make -f "
+                                          "Makefile2\" at a time, but pass "
+                                          "parallelism.",
+                          ".NOTPARALLEL", no_depends, no_commands, false);
     }
   }
 
@@ -1739,25 +1518,21 @@ void cmLocalUnixMakefileGenerator3
   // Include the progress variables for the target.
   // Write all global targets
   this->WriteDivider(ruleFileStream);
-  ruleFileStream
-    << "# Targets provided globally by CMake.\n"
-    << "\n";
+  ruleFileStream << "# Targets provided globally by CMake.\n"
+                 << "\n";
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
   std::vector<cmGeneratorTarget*>::iterator glIt;
-  for ( glIt = targets.begin(); glIt != targets.end(); ++ glIt )
-    {
-    if ( (*glIt)->GetType() == cmState::GLOBAL_TARGET )
-      {
-      std::string targetString = "Special rule for the target " +
-          (*glIt)->GetName();
+  for (glIt = targets.begin(); glIt != targets.end(); ++glIt) {
+    if ((*glIt)->GetType() == cmState::GLOBAL_TARGET) {
+      std::string targetString =
+        "Special rule for the target " + (*glIt)->GetName();
       std::vector<std::string> commands;
       std::vector<std::string> depends;
 
       const char* text = (*glIt)->GetProperty("EchoString");
-      if ( !text )
-        {
+      if (!text) {
         text = "Running external command ...";
-        }
+      }
       depends.insert(depends.end(), (*glIt)->GetUtilities().begin(),
                      (*glIt)->GetUtilities().end());
       this->AppendEcho(commands, text,
@@ -1766,43 +1541,33 @@ void cmLocalUnixMakefileGenerator3
       cmGeneratorTarget* gt = *glIt;
 
       // Global targets store their rules in pre- and post-build commands.
-      this->AppendCustomDepends(depends,
-                                gt->GetPreBuildCommands());
-      this->AppendCustomDepends(depends,
-                                gt->GetPostBuildCommands());
-      this->AppendCustomCommands(commands,
-                                 gt->GetPreBuildCommands(),
-                                 gt,
+      this->AppendCustomDepends(depends, gt->GetPreBuildCommands());
+      this->AppendCustomDepends(depends, gt->GetPostBuildCommands());
+      this->AppendCustomCommands(commands, gt->GetPreBuildCommands(), gt,
                                  cmLocalGenerator::START_OUTPUT);
-      this->AppendCustomCommands(commands,
-                                 gt->GetPostBuildCommands(),
-                                 gt,
+      this->AppendCustomCommands(commands, gt->GetPostBuildCommands(), gt,
                                  cmLocalGenerator::START_OUTPUT);
       std::string targetName = gt->GetName();
-      this->WriteMakeRule(ruleFileStream, targetString.c_str(),
-                          targetName, depends, commands, true);
+      this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName,
+                          depends, commands, true);
 
       // Provide a "/fast" version of the target.
       depends.clear();
-      if((targetName == "install")
-          || (targetName == "install_local")
-          || (targetName == "install_strip"))
-        {
+      if ((targetName == "install") || (targetName == "install_local") ||
+          (targetName == "install_strip")) {
         // Provide a fast install target that does not depend on all
         // but has the same command.
         depends.push_back("preinstall/fast");
-        }
-      else
-        {
+      } else {
         // Just forward to the real target so at least it will work.
         depends.push_back(targetName);
         commands.clear();
-        }
-      targetName += "/fast";
-      this->WriteMakeRule(ruleFileStream, targetString.c_str(),
-                          targetName, depends, commands, true);
       }
+      targetName += "/fast";
+      this->WriteMakeRule(ruleFileStream, targetString.c_str(), targetName,
+                          depends, commands, true);
     }
+  }
 
   std::vector<std::string> depends;
   std::vector<std::string> commands;
@@ -1815,52 +1580,46 @@ void cmLocalUnixMakefileGenerator3
 
   std::string progressDir = this->GetBinaryDirectory();
   progressDir += cmake::GetCMakeFilesDirectory();
-    {
+  {
     std::ostringstream progCmd;
-    progCmd <<
-      "$(CMAKE_COMMAND) -E cmake_progress_start ";
-    progCmd << this->Convert(progressDir,
-                             cmLocalGenerator::FULL,
+    progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
+    progCmd << this->Convert(progressDir, cmLocalGenerator::FULL,
                              cmLocalGenerator::SHELL);
 
     std::string progressFile = cmake::GetCMakeFilesDirectory();
     progressFile += "/progress.marks";
-    std::string progressFileNameFull =
-      this->ConvertToFullPath(progressFile);
-    progCmd << " " << this->Convert(progressFileNameFull,
-                                    cmLocalGenerator::FULL,
-                                    cmLocalGenerator::SHELL);
+    std::string progressFileNameFull = this->ConvertToFullPath(progressFile);
+    progCmd << " "
+            << this->Convert(progressFileNameFull, cmLocalGenerator::FULL,
+                             cmLocalGenerator::SHELL);
     commands.push_back(progCmd.str());
-    }
+  }
   std::string mf2Dir = cmake::GetCMakeFilesDirectoryPostSlash();
   mf2Dir += "Makefile2";
-  commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
-                                                recursiveTarget));
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+  commands.push_back(
+    this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
-    {
+  {
     std::ostringstream progCmd;
     progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
-    progCmd << this->Convert(progressDir,
-                             cmLocalGenerator::FULL,
+    progCmd << this->Convert(progressDir, cmLocalGenerator::FULL,
                              cmLocalGenerator::SHELL);
     progCmd << " 0";
     commands.push_back(progCmd.str());
-    }
-  this->WriteMakeRule(ruleFileStream, "The main all target", "all",
-                      depends, commands, true);
+  }
+  this->WriteMakeRule(ruleFileStream, "The main all target", "all", depends,
+                      commands, true);
 
   // Write the clean rule.
   recursiveTarget = this->GetCurrentBinaryDirectory();
   recursiveTarget += "/clean";
   commands.clear();
   depends.clear();
-  commands.push_back(this->GetRecursiveMakeCall(mf2Dir.c_str(),
-                                                recursiveTarget));
-  this->CreateCDCommand(commands,
-                                this->GetBinaryDirectory(),
-                                cmLocalGenerator::START_OUTPUT);
+  commands.push_back(
+    this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
+                        cmLocalGenerator::START_OUTPUT);
   this->WriteMakeRule(ruleFileStream, "The main clean target", "clean",
                       depends, commands, true);
   commands.clear();
@@ -1876,20 +1635,16 @@ void cmLocalUnixMakefileGenerator3
   depends.clear();
   const char* noall =
     this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
-  if(!noall || cmSystemTools::IsOff(noall))
-    {
+  if (!noall || cmSystemTools::IsOff(noall)) {
     // Drive the build before installing.
     depends.push_back("all");
-    }
-  else
-    {
+  } else {
     // At least make sure the build system is up to date.
     depends.push_back("cmake_check_build_system");
-    }
-  commands.push_back
-    (this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+  }
+  commands.push_back(
+    this->GetRecursiveMakeCall(mf2Dir.c_str(), recursiveTarget));
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
   this->WriteMakeRule(ruleFileStream, "Prepare targets for installation.",
                       "preinstall", depends, commands, true);
@@ -1905,28 +1660,24 @@ void cmLocalUnixMakefileGenerator3
   std::string runRule =
     "$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)";
   runRule += " --check-build-system ";
-  runRule += this->Convert(cmakefileName,cmLocalGenerator::NONE,
+  runRule += this->Convert(cmakefileName, cmLocalGenerator::NONE,
                            cmLocalGenerator::SHELL);
   runRule += " 1";
   commands.push_back(runRule);
-  this->CreateCDCommand(commands,
-                        this->GetBinaryDirectory(),
+  this->CreateCDCommand(commands, this->GetBinaryDirectory(),
                         cmLocalGenerator::START_OUTPUT);
-  this->WriteMakeRule(ruleFileStream, "clear depends",
-                      "depend",
-                      depends, commands, true);
+  this->WriteMakeRule(ruleFileStream, "clear depends", "depend", depends,
+                      commands, true);
 }
 
-
 void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
                                                       bool verbose)
 {
   // Get the list of target files to check
   const char* infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES");
-  if(!infoDef)
-    {
+  if (!infoDef) {
     return;
-    }
+  }
   std::vector<std::string> files;
   cmSystemTools::ExpandListArgument(infoDef, files);
 
@@ -1934,9 +1685,8 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
   // dependencies for that target.
   cmDepends clearer;
   clearer.SetVerbose(verbose);
-  for(std::vector<std::string>::iterator l = files.begin();
-      l != files.end(); ++l)
-    {
+  for (std::vector<std::string>::iterator l = files.begin(); l != files.end();
+       ++l) {
     std::string dir = cmSystemTools::GetFilenamePath(*l);
 
     // Clear the implicit dependency makefile.
@@ -1947,64 +1697,60 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
     // regeneration.
     std::string internalDependFile = dir + "/depend.internal";
     cmSystemTools::RemoveFile(internalDependFile);
-    }
+  }
 }
 
-
-namespace
+namespace {
+// Helper predicate for removing absolute paths that don't point to the
+// source or binary directory. It is used when CMAKE_DEPENDS_IN_PROJECT_ONLY
+// is set ON, to only consider in-project dependencies during the build.
+class NotInProjectDir
 {
-  // Helper predicate for removing absolute paths that don't point to the
-  // source or binary directory. It is used when CMAKE_DEPENDS_IN_PROJECT_ONLY
-  // is set ON, to only consider in-project dependencies during the build.
-  class NotInProjectDir
+public:
+  // Constructor with the source and binary directory's path
+  NotInProjectDir(const std::string& sourceDir, const std::string& binaryDir)
+    : SourceDir(sourceDir)
+    , BinaryDir(binaryDir)
   {
-  public:
-    // Constructor with the source and binary directory's path
-    NotInProjectDir(const std::string& sourceDir,
-                    const std::string& binaryDir)
-      : SourceDir(sourceDir), BinaryDir(binaryDir) {}
-
-    // Operator evaluating the predicate
-    bool operator()(const std::string& path) const
-      {
-      // Keep all relative paths:
-      if(!cmSystemTools::FileIsFullPath(path))
-        {
-        return false;
-        }
-      // If it's an absolute path, check if it starts with the source
-      // direcotory:
-      return (!(IsInDirectory(SourceDir, path)||
-                IsInDirectory(BinaryDir, path)));
-      }
+  }
 
-  private:
-    // Helper function used by the predicate
-    static bool IsInDirectory(const std::string& baseDir,
-                              const std::string& testDir)
-      {
-      // First check if the test directory "starts with" the base directory:
-      if (testDir.find(baseDir) != 0)
-        {
-        return false;
-        }
-      // If it does, then check that it's either the same string, or that the
-      // next character is a slash:
-      return ((testDir.size() == baseDir.size())||
-              (testDir[baseDir.size()] == '/'));
-      }
+  // Operator evaluating the predicate
+  bool operator()(const std::string& path) const
+  {
+    // Keep all relative paths:
+    if (!cmSystemTools::FileIsFullPath(path)) {
+      return false;
+    }
+    // If it's an absolute path, check if it starts with the source
+    // direcotory:
+    return (
+      !(IsInDirectory(SourceDir, path) || IsInDirectory(BinaryDir, path)));
+  }
 
-    // The path to the source directory
-    std::string SourceDir;
-    // The path to the binary directory
-    std::string BinaryDir;
-  };
-}
+private:
+  // Helper function used by the predicate
+  static bool IsInDirectory(const std::string& baseDir,
+                            const std::string& testDir)
+  {
+    // First check if the test directory "starts with" the base directory:
+    if (testDir.find(baseDir) != 0) {
+      return false;
+    }
+    // If it does, then check that it's either the same string, or that the
+    // next character is a slash:
+    return ((testDir.size() == baseDir.size()) ||
+            (testDir[baseDir.size()] == '/'));
+  }
 
+  // The path to the source directory
+  std::string SourceDir;
+  // The path to the binary directory
+  std::string BinaryDir;
+};
+}
 
-void cmLocalUnixMakefileGenerator3
-::WriteDependLanguageInfo(std::ostream& cmakefileStream,
-                          cmGeneratorTarget* target)
+void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
+  std::ostream& cmakefileStream, cmGeneratorTarget* target)
 {
   ImplicitDependLanguageMap const& implicitLangs =
     this->GetImplicitDepends(target);
@@ -2012,36 +1758,30 @@ void cmLocalUnixMakefileGenerator3
   // list the languages
   cmakefileStream
     << "# The set of languages for which implicit dependencies are needed:\n";
-  cmakefileStream
-    << "set(CMAKE_DEPENDS_LANGUAGES\n";
-  for(ImplicitDependLanguageMap::const_iterator
-        l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
-    {
+  cmakefileStream << "set(CMAKE_DEPENDS_LANGUAGES\n";
+  for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin();
+       l != implicitLangs.end(); ++l) {
     cmakefileStream << "  \"" << l->first << "\"\n";
-    }
+  }
   cmakefileStream << "  )\n";
 
   // now list the files for each language
   cmakefileStream
     << "# The set of files for implicit dependencies of each language:\n";
-  for(ImplicitDependLanguageMap::const_iterator
-        l = implicitLangs.begin(); l != implicitLangs.end(); ++l)
-    {
-    cmakefileStream
-      << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n";
+  for (ImplicitDependLanguageMap::const_iterator l = implicitLangs.begin();
+       l != implicitLangs.end(); ++l) {
+    cmakefileStream << "set(CMAKE_DEPENDS_CHECK_" << l->first << "\n";
     ImplicitDependFileMap const& implicitPairs = l->second;
 
     // for each file pair
-    for(ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
-        pi != implicitPairs.end(); ++pi)
-      {
-      for(cmDepends::DependencyVector::const_iterator di = pi->second.begin();
-          di != pi->second.end(); ++ di)
-        {
+    for (ImplicitDependFileMap::const_iterator pi = implicitPairs.begin();
+         pi != implicitPairs.end(); ++pi) {
+      for (cmDepends::DependencyVector::const_iterator di = pi->second.begin();
+           di != pi->second.end(); ++di) {
         cmakefileStream << "  \"" << *di << "\" ";
         cmakefileStream << "\"" << pi->first << "\"\n";
-        }
       }
+    }
     cmakefileStream << "  )\n";
 
     // Tell the dependency scanner what compiler is used.
@@ -2049,138 +1789,112 @@ void cmLocalUnixMakefileGenerator3
     cidVar += l->first;
     cidVar += "_COMPILER_ID";
     const char* cid = this->Makefile->GetDefinition(cidVar);
-    if(cid && *cid)
-      {
-      cmakefileStream
-        << "set(CMAKE_" << l->first << "_COMPILER_ID \""
-        << cid << "\")\n";
-      }
+    if (cid && *cid) {
+      cmakefileStream << "set(CMAKE_" << l->first << "_COMPILER_ID \"" << cid
+                      << "\")\n";
+    }
 
     // Build a list of preprocessor definitions for the target.
     std::set<std::string> defines;
-    this->AddCompileDefinitions(defines, target,
-                                this->ConfigName, l->first);
-    if(!defines.empty())
-      {
+    this->AddCompileDefinitions(defines, target, this->ConfigName, l->first);
+    if (!defines.empty()) {
       /* clang-format off */
       cmakefileStream
         << "\n"
         << "# Preprocessor definitions for this target.\n"
         << "set(CMAKE_TARGET_DEFINITIONS_" << l->first << "\n";
       /* clang-format on */
-      for(std::set<std::string>::const_iterator di = defines.begin();
-          di != defines.end(); ++di)
-        {
-        cmakefileStream
-          << "  " << cmOutputConverter::EscapeForCMake(*di) << "\n";
-        }
-      cmakefileStream
-        << "  )\n";
+      for (std::set<std::string>::const_iterator di = defines.begin();
+           di != defines.end(); ++di) {
+        cmakefileStream << "  " << cmOutputConverter::EscapeForCMake(*di)
+                        << "\n";
       }
+      cmakefileStream << "  )\n";
+    }
 
     // Target-specific include directories:
-    cmakefileStream
-      << "\n"
-      << "# The include file search paths:\n";
-    cmakefileStream
-      << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
+    cmakefileStream << "\n"
+                    << "# The include file search paths:\n";
+    cmakefileStream << "set(CMAKE_" << l->first << "_TARGET_INCLUDE_PATH\n";
     std::vector<std::string> includes;
 
-
     const std::string& config =
       this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
-    this->GetIncludeDirectories(includes, target,
-                                l->first, config);
-    if(this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY"))
-      {
+    this->GetIncludeDirectories(includes, target, l->first, config);
+    if (this->Makefile->IsOn("CMAKE_DEPENDS_IN_PROJECT_ONLY")) {
       const char* sourceDir = this->GetState()->GetSourceDirectory();
       const char* binaryDir = this->GetState()->GetBinaryDirectory();
       std::vector<std::string>::iterator itr =
         std::remove_if(includes.begin(), includes.end(),
                        ::NotInProjectDir(sourceDir, binaryDir));
       includes.erase(itr, includes.end());
-      }
-    for(std::vector<std::string>::iterator i = includes.begin();
-        i != includes.end(); ++i)
-      {
-      cmakefileStream
-        << "  \""
-        << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT)
-        << "\"\n";
-      }
-    cmakefileStream
-      << "  )\n";
     }
+    for (std::vector<std::string>::iterator i = includes.begin();
+         i != includes.end(); ++i) {
+      cmakefileStream << "  \""
+                      << this->Convert(*i, cmLocalGenerator::HOME_OUTPUT)
+                      << "\"\n";
+    }
+    cmakefileStream << "  )\n";
+  }
 
   // Store include transform rule properties.  Write the directory
   // rules first because they may be overridden by later target rules.
   std::vector<std::string> transformRules;
-  if(const char* xform =
-     this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
-    {
+  if (const char* xform =
+        this->Makefile->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) {
     cmSystemTools::ExpandListArgument(xform, transformRules);
-    }
-  if(const char* xform =
-     target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM"))
-    {
+  }
+  if (const char* xform =
+        target->GetProperty("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM")) {
     cmSystemTools::ExpandListArgument(xform, transformRules);
+  }
+  if (!transformRules.empty()) {
+    cmakefileStream << "set(CMAKE_INCLUDE_TRANSFORMS\n";
+    for (std::vector<std::string>::const_iterator tri = transformRules.begin();
+         tri != transformRules.end(); ++tri) {
+      cmakefileStream << "  " << cmOutputConverter::EscapeForCMake(*tri)
+                      << "\n";
     }
-  if(!transformRules.empty())
-    {
-    cmakefileStream
-      << "set(CMAKE_INCLUDE_TRANSFORMS\n";
-    for(std::vector<std::string>::const_iterator tri = transformRules.begin();
-        tri != transformRules.end(); ++tri)
-      {
-      cmakefileStream << "  "
-          << cmOutputConverter::EscapeForCMake(*tri) << "\n";
-      }
-    cmakefileStream
-      << "  )\n";
-    }
+    cmakefileStream << "  )\n";
+  }
 }
 
 void cmLocalUnixMakefileGenerator3::WriteDisclaimer(std::ostream& os)
 {
-  os
-    << "# CMAKE generated file: DO NOT EDIT!\n"
-    << "# Generated by \"" << this->GlobalGenerator->GetName() << "\""
-    << " Generator, CMake Version "
-    << cmVersion::GetMajorVersion() << "."
-    << cmVersion::GetMinorVersion() << "\n\n";
+  os << "# CMAKE generated file: DO NOT EDIT!\n"
+     << "# Generated by \"" << this->GlobalGenerator->GetName() << "\""
+     << " Generator, CMake Version " << cmVersion::GetMajorVersion() << "."
+     << cmVersion::GetMinorVersion() << "\n\n";
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::GetRecursiveMakeCall(const char *makefile, const std::string& tgt)
+std::string cmLocalUnixMakefileGenerator3::GetRecursiveMakeCall(
+  const char* makefile, const std::string& tgt)
 {
   // Call make on the given file.
   std::string cmd;
   cmd += "$(MAKE) -f ";
-  cmd += this->Convert(makefile,NONE,SHELL);
+  cmd += this->Convert(makefile, NONE, SHELL);
   cmd += " ";
 
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
   // Pass down verbosity level.
-  if(!gg->MakeSilentFlag.empty())
-    {
+  if (!gg->MakeSilentFlag.empty()) {
     cmd += gg->MakeSilentFlag;
     cmd += " ";
-    }
+  }
 
   // Most unix makes will pass the command line flags to make down to
   // sub-invoked makes via an environment variable.  However, some
   // makes do not support that, so you have to pass the flags
   // explicitly.
-  if(gg->PassMakeflags)
-    {
+  if (gg->PassMakeflags) {
     cmd += "-$(MAKEFLAGS) ";
-    }
+  }
 
   // Add the target.
-  if (!tgt.empty())
-    {
+  if (!tgt.empty()) {
     // The make target is always relative to the top of the build tree.
     std::string tgt2 = this->Convert(tgt, HOME_OUTPUT);
 
@@ -2188,53 +1902,43 @@ cmLocalUnixMakefileGenerator3
     cmSystemTools::ConvertToOutputSlashes(tgt2);
 
     // Escape one extra time if the make tool requires it.
-    if(this->MakeCommandEscapeTargetTwice)
-      {
+    if (this->MakeCommandEscapeTargetTwice) {
       tgt2 = this->EscapeForShell(tgt2, true, false);
-      }
+    }
 
     // The target name is now a string that should be passed verbatim
     // on the command line.
     cmd += this->EscapeForShell(tgt2, true, false);
-    }
+  }
   return cmd;
 }
 
 void cmLocalUnixMakefileGenerator3::WriteDivider(std::ostream& os)
 {
-  os
-    << "#======================================"
-    << "=======================================\n";
+  os << "#======================================"
+     << "=======================================\n";
 }
 
-void
-cmLocalUnixMakefileGenerator3
-::WriteCMakeArgument(std::ostream& os, const char* s)
+void cmLocalUnixMakefileGenerator3::WriteCMakeArgument(std::ostream& os,
+                                                       const char* s)
 {
   // Write the given string to the stream with escaping to get it back
   // into CMake through the lexical scanner.
   os << "\"";
-  for(const char* c = s; *c; ++c)
-    {
-    if(*c == '\\')
-      {
+  for (const char* c = s; *c; ++c) {
+    if (*c == '\\') {
       os << "\\\\";
-      }
-    else if(*c == '"')
-      {
+    } else if (*c == '"') {
       os << "\\\"";
-      }
-    else
-      {
+    } else {
       os << *c;
-      }
     }
+  }
   os << "\"";
 }
 
-std::string
-cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p,
-                                                         bool useWatcomQuote)
+std::string cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(
+  const char* p, bool useWatcomQuote)
 {
   // Split the path into its components.
   std::vector<std::string> components;
@@ -2242,78 +1946,65 @@ cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p,
 
   // Open the quoted result.
   std::string result;
-  if(useWatcomQuote)
-    {
+  if (useWatcomQuote) {
 #if defined(_WIN32) && !defined(__CYGWIN__)
     result = "'";
 #else
     result = "\"'";
 #endif
-    }
-  else
-    {
+  } else {
     result = "\"";
-    }
+  }
 
   // Return an empty path if there are no components.
-  if(!components.empty())
-    {
+  if (!components.empty()) {
     // Choose a slash direction and fix root component.
     const char* slash = "/";
 #if defined(_WIN32) && !defined(__CYGWIN__)
-    if(!cmSystemTools::GetForceUnixPaths())
-      {
+    if (!cmSystemTools::GetForceUnixPaths()) {
       slash = "\\";
-      for(std::string::iterator i = components[0].begin();
-          i != components[0].end(); ++i)
-        {
-        if(*i == '/')
-          {
+      for (std::string::iterator i = components[0].begin();
+           i != components[0].end(); ++i) {
+        if (*i == '/') {
           *i = '\\';
-          }
         }
       }
+    }
 #endif
 
     // Begin the quoted result with the root component.
     result += components[0];
 
-    if (components.size() > 1)
-      {
+    if (components.size() > 1) {
       // Now add the rest of the components separated by the proper slash
       // direction for this platform.
-      std::vector<std::string>::const_iterator compEnd
-          = std::remove(components.begin() + 1, components.end() - 1,
-                          std::string());
-      std::vector<std::string>::const_iterator compStart
-          = components.begin() + 1;
+      std::vector<std::string>::const_iterator compEnd = std::remove(
+        components.begin() + 1, components.end() - 1, std::string());
+      std::vector<std::string>::const_iterator compStart =
+        components.begin() + 1;
       result += cmJoin(cmMakeRange(compStart, compEnd), slash);
       // Only the last component can be empty to avoid double slashes.
       result += slash;
       result += components.back();
-      }
     }
+  }
 
   // Close the quoted result.
-  if(useWatcomQuote)
-    {
+  if (useWatcomQuote) {
 #if defined(_WIN32) && !defined(__CYGWIN__)
     result += "'";
 #else
     result += "'\"";
 #endif
-    }
-  else
-    {
+  } else {
     result += "\"";
-    }
+  }
 
   return result;
 }
 
-std::string
-cmLocalUnixMakefileGenerator3
-::GetTargetDirectory(cmGeneratorTarget const* target) const
+std::string cmLocalUnixMakefileGenerator3::GetTargetDirectory(
+  cmGeneratorTarget const* target) const
 {
   std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
   dir += target->GetName();
@@ -2326,32 +2017,28 @@ cmLocalUnixMakefileGenerator3
 }
 
 cmLocalUnixMakefileGenerator3::ImplicitDependLanguageMap const&
-cmLocalUnixMakefileGenerator3::GetImplicitDepends(
-    const cmGeneratorTarget* tgt)
+cmLocalUnixMakefileGenerator3::GetImplicitDepends(const cmGeneratorTarget* tgt)
 {
   return this->ImplicitDepends[tgt->GetName()];
 }
 
-void
-cmLocalUnixMakefileGenerator3::AddImplicitDepends(const cmGeneratorTarget* tgt,
-                                                  const std::string& lang,
-                                                  const char* obj,
-                                                  const char* src)
+void cmLocalUnixMakefileGenerator3::AddImplicitDepends(
+  const cmGeneratorTarget* tgt, const std::string& lang, const char* obj,
+  const char* src)
 {
   this->ImplicitDepends[tgt->GetName()][lang][obj].push_back(src);
 }
 
-void cmLocalUnixMakefileGenerator3
-::CreateCDCommand(std::vector<std::string>& commands, const char *tgtDir,
-                  cmLocalGenerator::RelativeRoot relRetDir)
+void cmLocalUnixMakefileGenerator3::CreateCDCommand(
+  std::vector<std::string>& commands, const char* tgtDir,
+  cmLocalGenerator::RelativeRoot relRetDir)
 {
   const char* retDir = this->GetRelativeRootPath(relRetDir);
 
   // do we need to cd?
-  if (!strcmp(tgtDir,retDir))
-    {
+  if (!strcmp(tgtDir, retDir)) {
     return;
-    }
+  }
 
   // In a Windows shell we must change drive letter too.  The shell
   // used by NMake and Borland make does not support "cd /d" so this
@@ -2361,29 +2048,26 @@ void cmLocalUnixMakefileGenerator3
 
   cmGlobalUnixMakefileGenerator3* gg =
     static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
-  if(!gg->UnixCD)
-    {
+  if (!gg->UnixCD) {
     // On Windows we must perform each step separately and then change
     // back because the shell keeps the working directory between
     // commands.
     std::string cmd = cd_cmd;
     cmd += this->ConvertToOutputForExisting(tgtDir, relRetDir);
-    commands.insert(commands.begin(),cmd);
+    commands.insert(commands.begin(), cmd);
 
     // Change back to the starting directory.
     cmd = cd_cmd;
     cmd += this->ConvertToOutputForExisting(relRetDir, tgtDir);
     commands.push_back(cmd);
-    }
-  else
-    {
+  } else {
     // On UNIX we must construct a single shell command to change
     // directory and build because make resets the directory between
     // each command.
     std::string outputForExisting =
-                          this->ConvertToOutputForExisting(tgtDir, relRetDir);
+      this->ConvertToOutputForExisting(tgtDir, relRetDir);
     std::string prefix = cd_cmd + outputForExisting + " && ";
     std::transform(commands.begin(), commands.end(), commands.begin(),
                    std::bind1st(std::plus<std::string>(), prefix));
-    }
+  }
 }
diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h
index 8f69311..321edcb 100644
--- a/Source/cmLocalUnixMakefileGenerator3.h
+++ b/Source/cmLocalUnixMakefileGenerator3.h
@@ -44,15 +44,13 @@ public:
 
   // this returns the relative path between the HomeOutputDirectory and this
   // local generators StartOutputDirectory
-  const std::string &GetHomeRelativeOutputPath();
+  const std::string& GetHomeRelativeOutputPath();
 
   // Write out a make rule
-  void WriteMakeRule(std::ostream& os,
-                     const char* comment,
+  void WriteMakeRule(std::ostream& os, const char* comment,
                      const std::string& target,
                      const std::vector<std::string>& depends,
-                     const std::vector<std::string>& commands,
-                     bool symbolic,
+                     const std::vector<std::string>& commands, bool symbolic,
                      bool in_help = false);
 
   // write the main variables used by the makefiles
@@ -68,14 +66,15 @@ public:
    * extra level of escapes.
    */
   void SetMakeCommandEscapeTargetTwice(bool b)
-    { this->MakeCommandEscapeTargetTwice = b; }
+  {
+    this->MakeCommandEscapeTargetTwice = b;
+  }
 
   /**
    * Set whether the Borland curly brace command line hack should be
    * applied.
    */
-  void SetBorlandMakeCurlyHack(bool b)
-    { this->BorlandMakeCurlyHack = b; }
+  void SetBorlandMakeCurlyHack(bool b) { this->BorlandMakeCurlyHack = b; }
 
   // used in writing out Cmake files such as WriteDirectoryInformation
   static void WriteCMakeArgument(std::ostream& os, const char* s);
@@ -87,7 +86,7 @@ public:
   void WriteDivider(std::ostream& os);
 
   /** used to create a recursive make call */
-  std::string GetRecursiveMakeCall(const char *makefile,
+  std::string GetRecursiveMakeCall(const char* makefile,
                                    const std::string& tgt);
 
   // append flags to a string
@@ -95,21 +94,32 @@ public:
   virtual void AppendFlags(std::string& flags, const char* newFlags);
 
   // append an echo command
-  enum EchoColor { EchoNormal, EchoDepend, EchoBuild, EchoLink,
-                   EchoGenerate, EchoGlobal };
-  struct EchoProgress { std::string Dir; std::string Arg; };
+  enum EchoColor
+  {
+    EchoNormal,
+    EchoDepend,
+    EchoBuild,
+    EchoLink,
+    EchoGenerate,
+    EchoGlobal
+  };
+  struct EchoProgress
+  {
+    std::string Dir;
+    std::string Arg;
+  };
   void AppendEcho(std::vector<std::string>& commands, std::string const& text,
                   EchoColor color = EchoNormal, EchoProgress const* = 0);
 
   /** Get whether the makefile is to have color.  */
   bool GetColorMakefile() const { return this->ColorMakefile; }
 
-  virtual
-  std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
+  virtual std::string GetTargetDirectory(
+    cmGeneratorTarget const* target) const;
 
-    // create a command that cds to the start dir then runs the commands
+  // create a command that cds to the start dir then runs the commands
   void CreateCDCommand(std::vector<std::string>& commands,
-                       const char *targetDir,
+                       const char* targetDir,
                        cmLocalGenerator::RelativeRoot returnDir);
 
   static std::string ConvertToQuotedOutputPath(const char* p,
@@ -120,8 +130,8 @@ public:
 
   /** Called from command-line hook to bring dependencies up to date
       for a target.  */
-  virtual bool UpdateDependencies(const char* tgtInfo,
-                                  bool verbose, bool color);
+  virtual bool UpdateDependencies(const char* tgtInfo, bool verbose,
+                                  bool color);
 
   /** Called from command-line hook to clear dependencies.  */
   virtual void ClearDependencies(cmMakefile* mf, bool verbose);
@@ -134,18 +144,24 @@ public:
 
   // File pairs for implicit dependency scanning.  The key of the map
   // is the depender and the value is the explicit dependee.
-  struct ImplicitDependFileMap:
-    public std::map<std::string, cmDepends::DependencyVector> {};
-  struct ImplicitDependLanguageMap:
-    public std::map<std::string, ImplicitDependFileMap> {};
-  struct ImplicitDependTargetMap:
-    public std::map<std::string, ImplicitDependLanguageMap> {};
-  ImplicitDependLanguageMap const&
-  GetImplicitDepends(cmGeneratorTarget const* tgt);
+  struct ImplicitDependFileMap
+    : public std::map<std::string, cmDepends::DependencyVector>
+  {
+  };
+  struct ImplicitDependLanguageMap
+    : public std::map<std::string, ImplicitDependFileMap>
+  {
+  };
+  struct ImplicitDependTargetMap
+    : public std::map<std::string, ImplicitDependLanguageMap>
+  {
+  };
+  ImplicitDependLanguageMap const& GetImplicitDepends(
+    cmGeneratorTarget const* tgt);
 
   void AddImplicitDepends(cmGeneratorTarget const* tgt,
-                          const std::string& lang,
-                          const char* obj, const char* src);
+                          const std::string& lang, const char* obj,
+                          const char* src);
 
   // write the target rules for the local Makefile into the stream
   void WriteLocalAllRules(std::ostream& ruleFileStream);
@@ -156,13 +172,13 @@ public:
       assembly sources.  This could be converted to a variable lookup
       later.  */
   bool GetCreatePreprocessedSourceRules()
-    {
+  {
     return !this->SkipPreprocessedSourceRules;
-    }
+  }
   bool GetCreateAssemblySourceRules()
-    {
+  {
     return !this->SkipAssemblySourceRules;
-    }
+  }
 
   // Fill the vector with the target names for the object files,
   // preprocessed files and assembly files. Currently only used by the
@@ -172,18 +188,16 @@ public:
 protected:
   void WriteLocalMakefile();
 
-
   // write the target rules for the local Makefile into the stream
   void WriteLocalMakefileTargets(std::ostream& ruleFileStream,
-                                 std::set<std::string> &emitted);
+                                 std::set<std::string>& emitted);
 
   // this method Writes the Directory information files
   void WriteDirectoryInformationFile();
 
-
   // write the depend info
   void WriteDependLanguageInfo(std::ostream& cmakefileStream,
-                               cmGeneratorTarget *tgt);
+                               cmGeneratorTarget* tgt);
 
   // write the local help rule
   void WriteHelpRule(std::ostream& ruleFileStream);
@@ -192,7 +206,6 @@ protected:
   // into a full path
   std::string ConvertToFullPath(const std::string& localPath);
 
-
   void WriteConvenienceRule(std::ostream& ruleFileStream,
                             const std::string& realTarget,
                             const std::string& helpTarget);
@@ -214,25 +227,23 @@ protected:
                            const std::vector<cmCustomCommand>& ccs);
   void AppendCustomDepend(std::vector<std::string>& depends,
                           cmCustomCommandGenerator const& cc);
-  void AppendCustomCommands(std::vector<std::string>& commands,
-                            const std::vector<cmCustomCommand>& ccs,
-                            cmGeneratorTarget* target,
-                            cmLocalGenerator::RelativeRoot relative =
-                            cmLocalGenerator::HOME_OUTPUT);
-  void AppendCustomCommand(std::vector<std::string>& commands,
-                           cmCustomCommandGenerator const& ccg,
-                           cmGeneratorTarget* target,
-                           bool echo_comment=false,
-                           cmLocalGenerator::RelativeRoot relative =
-                           cmLocalGenerator::HOME_OUTPUT,
-                           std::ostream* content = 0);
+  void AppendCustomCommands(
+    std::vector<std::string>& commands,
+    const std::vector<cmCustomCommand>& ccs, cmGeneratorTarget* target,
+    cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT);
+  void AppendCustomCommand(
+    std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg,
+    cmGeneratorTarget* target, bool echo_comment = false,
+    cmLocalGenerator::RelativeRoot relative = cmLocalGenerator::HOME_OUTPUT,
+    std::ostream* content = 0);
   void AppendCleanCommand(std::vector<std::string>& commands,
                           const std::vector<std::string>& files,
-                          cmGeneratorTarget* target, const char* filename =0);
+                          cmGeneratorTarget* target, const char* filename = 0);
 
   // Helper methods for dependeny updates.
-  bool ScanDependencies(const char* targetDir,
-                std::map<std::string, cmDepends::DependencyVector>& validDeps);
+  bool ScanDependencies(
+    const char* targetDir,
+    std::map<std::string, cmDepends::DependencyVector>& validDeps);
   void CheckMultipleOutputs(bool verbose);
 
 private:
@@ -241,8 +252,8 @@ private:
                            cmGeneratorTarget* target, RelativeRoot relative);
 
   virtual void ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt = 0);
+    std::map<cmSourceFile const*, std::string>& mapping,
+    cmGeneratorTarget const* gt = 0);
 
   friend class cmMakefileTargetGenerator;
   friend class cmMakefileExecutableTargetGenerator;
@@ -258,20 +269,31 @@ private:
   {
     cmGeneratorTarget* Target;
     std::string Language;
-    LocalObjectEntry(): Target(0), Language() {}
-    LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang):
-      Target(t), Language(lang) {}
+    LocalObjectEntry()
+      : Target(0)
+      , Language()
+    {
+    }
+    LocalObjectEntry(cmGeneratorTarget* t, const std::string& lang)
+      : Target(t)
+      , Language(lang)
+    {
+    }
   };
-  struct LocalObjectInfo: public std::vector<LocalObjectEntry>
+  struct LocalObjectInfo : public std::vector<LocalObjectEntry>
   {
     bool HasSourceExtension;
     bool HasPreprocessRule;
     bool HasAssembleRule;
-    LocalObjectInfo():HasSourceExtension(false), HasPreprocessRule(false),
-                      HasAssembleRule(false) {}
+    LocalObjectInfo()
+      : HasSourceExtension(false)
+      , HasPreprocessRule(false)
+      , HasAssembleRule(false)
+    {
+    }
   };
   void GetLocalObjectFiles(
-                    std::map<std::string, LocalObjectInfo> &localObjectFiles);
+    std::map<std::string, LocalObjectInfo>& localObjectFiles);
 
   void WriteObjectConvenienceRule(std::ostream& ruleFileStream,
                                   const char* comment, const char* output,
diff --git a/Source/cmLocalVisualStudio10Generator.cxx b/Source/cmLocalVisualStudio10Generator.cxx
index 4025df4..37b5505 100644
--- a/Source/cmLocalVisualStudio10Generator.cxx
+++ b/Source/cmLocalVisualStudio10Generator.cxx
@@ -19,51 +19,44 @@
 
 class cmVS10XMLParser : public cmXMLParser
 {
-  public:
-  virtual void EndElement(const std::string& /* name */)
-    {
-    }
+public:
+  virtual void EndElement(const std::string& /* name */) {}
   virtual void CharacterDataHandler(const char* data, int length)
-    {
-      if(this->DoGUID )
-        {
-        this->GUID.assign(data+1, length-2);
-        this->DoGUID = false;
-        }
+  {
+    if (this->DoGUID) {
+      this->GUID.assign(data + 1, length - 2);
+      this->DoGUID = false;
     }
+  }
   virtual void StartElement(const std::string& name, const char**)
-    {
-      // once the GUID is found do nothing
-      if(!this->GUID.empty())
-        {
-        return;
-        }
-      if("ProjectGUID" == name || "ProjectGuid" == name)
-        {
-        this->DoGUID = true;
-        }
+  {
+    // once the GUID is found do nothing
+    if (!this->GUID.empty()) {
+      return;
     }
+    if ("ProjectGUID" == name || "ProjectGuid" == name) {
+      this->DoGUID = true;
+    }
+  }
   int InitializeParser()
-    {
-      this->DoGUID = false;
-      int ret = cmXMLParser::InitializeParser();
-      if(ret == 0)
-        {
-        return ret;
-        }
-      // visual studio projects have a strange encoding, but it is
-      // really utf-8
-      XML_SetEncoding(static_cast<XML_Parser>(this->Parser), "utf-8");
-      return 1;
+  {
+    this->DoGUID = false;
+    int ret = cmXMLParser::InitializeParser();
+    if (ret == 0) {
+      return ret;
     }
+    // visual studio projects have a strange encoding, but it is
+    // really utf-8
+    XML_SetEncoding(static_cast<XML_Parser>(this->Parser), "utf-8");
+    return 1;
+  }
   std::string GUID;
   bool DoGUID;
 };
 
-
-cmLocalVisualStudio10Generator
-::cmLocalVisualStudio10Generator(cmGlobalGenerator* gg, cmMakefile* mf):
-  cmLocalVisualStudio7Generator(gg, mf)
+cmLocalVisualStudio10Generator::cmLocalVisualStudio10Generator(
+  cmGlobalGenerator* gg, cmMakefile* mf)
+  : cmLocalVisualStudio7Generator(gg, mf)
 {
 }
 
@@ -75,51 +68,41 @@ void cmLocalVisualStudio10Generator::Generate()
 {
 
   std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); ++l)
-    {
-    if((*l)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); ++l) {
+    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
-    if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
-       ->TargetIsFortranOnly(*l))
-      {
+    }
+    if (static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
+          ->TargetIsFortranOnly(*l)) {
       this->CreateSingleVCProj((*l)->GetName().c_str(), *l);
-      }
-    else
-      {
+    } else {
       cmVisualStudio10TargetGenerator tg(
         *l, static_cast<cmGlobalVisualStudio10Generator*>(
-          this->GetGlobalGenerator()));
+              this->GetGlobalGenerator()));
       tg.Generate();
-      }
     }
+  }
   this->WriteStampFiles();
 }
 
-
-void cmLocalVisualStudio10Generator
-::ReadAndStoreExternalGUID(const std::string& name,
-                           const char* path)
+void cmLocalVisualStudio10Generator::ReadAndStoreExternalGUID(
+  const std::string& name, const char* path)
 {
   cmVS10XMLParser parser;
   parser.ParseFile(path);
 
   // if we can not find a GUID then we will generate one later
-  if(parser.GUID.empty())
-    {
+  if (parser.GUID.empty()) {
     return;
-    }
+  }
 
   std::string guidStoreName = name;
   guidStoreName += "_GUID_CMAKE";
   // save the GUID in the cache
-  this->GlobalGenerator->GetCMakeInstance()->
-    AddCacheEntry(guidStoreName.c_str(),
-                  parser.GUID.c_str(),
-                  "Stored GUID",
-                  cmState::INTERNAL);
+  this->GlobalGenerator->GetCMakeInstance()->AddCacheEntry(
+    guidStoreName.c_str(), parser.GUID.c_str(), "Stored GUID",
+    cmState::INTERNAL);
 }
 
 const char* cmLocalVisualStudio10Generator::ReportErrorLabel() const
diff --git a/Source/cmLocalVisualStudio10Generator.h b/Source/cmLocalVisualStudio10Generator.h
index e187590..6ec894c 100644
--- a/Source/cmLocalVisualStudio10Generator.h
+++ b/Source/cmLocalVisualStudio10Generator.h
@@ -14,7 +14,6 @@
 
 #include "cmLocalVisualStudio7Generator.h"
 
-
 /** \class cmLocalVisualStudio10Generator
  * \brief Write Visual Studio 10 project files.
  *
@@ -29,7 +28,6 @@ public:
 
   virtual ~cmLocalVisualStudio10Generator();
 
-
   /**
    * Generate the makefile for this directory.
    */
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index 897fce1..ad386f7 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -31,12 +31,15 @@ static bool cmLVS7G_IsFAT(const char* dir);
 class cmLocalVisualStudio7GeneratorInternals
 {
 public:
-  cmLocalVisualStudio7GeneratorInternals(cmLocalVisualStudio7Generator* e):
-    LocalGenerator(e) {}
+  cmLocalVisualStudio7GeneratorInternals(cmLocalVisualStudio7Generator* e)
+    : LocalGenerator(e)
+  {
+  }
   typedef cmComputeLinkInformation::ItemVector ItemVector;
   void OutputLibraries(std::ostream& fout, ItemVector const& libs);
   void OutputObjects(std::ostream& fout, cmGeneratorTarget* t,
                      const char* isep = 0);
+
 private:
   cmLocalVisualStudio7Generator* LocalGenerator;
 };
@@ -46,16 +49,15 @@ extern cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[];
 static void cmConvertToWindowsSlash(std::string& s)
 {
   std::string::size_type pos = 0;
-  while((pos = s.find('/', pos)) != std::string::npos)
-    {
+  while ((pos = s.find('/', pos)) != std::string::npos) {
     s[pos] = '\\';
     pos++;
-    }
+  }
 }
 
-cmLocalVisualStudio7Generator
-::cmLocalVisualStudio7Generator(cmGlobalGenerator* gg, cmMakefile* mf):
-  cmLocalVisualStudioGenerator(gg, mf)
+cmLocalVisualStudio7Generator::cmLocalVisualStudio7Generator(
+  cmGlobalGenerator* gg, cmMakefile* mf)
+  : cmLocalVisualStudioGenerator(gg, mf)
 {
   this->Internal = new cmLocalVisualStudio7GeneratorInternals(this);
 }
@@ -69,21 +71,16 @@ void cmLocalVisualStudio7Generator::AddHelperCommands()
 {
   // Now create GUIDs for targets
   std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); ++l)
-    {
-    if((*l)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); ++l) {
+    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     const char* path = (*l)->GetProperty("EXTERNAL_MSPROJECT");
-    if(path)
-      {
-      this->ReadAndStoreExternalGUID(
-        (*l)->GetName().c_str(), path);
-      }
+    if (path) {
+      this->ReadAndStoreExternalGUID((*l)->GetName().c_str(), path);
     }
-
+  }
 
   this->FixGlobalTargets();
 }
@@ -97,28 +94,23 @@ void cmLocalVisualStudio7Generator::Generate()
 void cmLocalVisualStudio7Generator::AddCMakeListsRules()
 {
   // Create the regeneration custom rule.
-  if(!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION"))
-    {
+  if (!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION")) {
     // Create a rule to regenerate the build system when the target
     // specification source changes.
-    if(cmSourceFile* sf = this->CreateVCProjBuildRule())
-      {
+    if (cmSourceFile* sf = this->CreateVCProjBuildRule()) {
       // Add the rule to targets that need it.
       std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
-      for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-          l != tgts.end(); ++l)
-        {
-        if ((*l)->GetType() == cmState::GLOBAL_TARGET)
-          {
+      for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+           l != tgts.end(); ++l) {
+        if ((*l)->GetType() == cmState::GLOBAL_TARGET) {
           continue;
-          }
-        if((*l)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET)
-          {
+        }
+        if ((*l)->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
           (*l)->AddSource(sf->GetFullPath());
-          }
         }
       }
     }
+  }
 }
 
 void cmLocalVisualStudio7Generator::FixGlobalTargets()
@@ -127,11 +119,9 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets()
   // commands for targets in which no sources are built.  Add dummy
   // rules to force these targets to build.
   std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); l++)
-    {
-    if((*l)->GetType() == cmState::GLOBAL_TARGET)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); l++) {
+    if ((*l)->GetType() == cmState::GLOBAL_TARGET) {
       std::vector<std::string> no_depends;
       cmCustomCommandLine force_command;
       force_command.push_back("cd");
@@ -144,15 +134,13 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets()
       force += "/";
       force += (*l)->GetName();
       force += "_force";
-      if(cmSourceFile* file =
-         this->Makefile->AddCustomCommandToOutput(
-           force.c_str(), no_depends, no_main_dependency,
-           force_commands, " ", 0, true))
-        {
+      if (cmSourceFile* file = this->Makefile->AddCustomCommandToOutput(
+            force.c_str(), no_depends, no_main_dependency, force_commands, " ",
+            0, true)) {
         (*l)->AddSource(file->GetFullPath());
-        }
       }
     }
+  }
 }
 
 // TODO
@@ -161,35 +149,29 @@ void cmLocalVisualStudio7Generator::FixGlobalTargets()
 void cmLocalVisualStudio7Generator::WriteProjectFiles()
 {
   // If not an in source build, then create the output directory
-  if(strcmp(this->GetCurrentBinaryDirectory(),
-            this->GetSourceDirectory()) != 0)
-    {
-    if(!cmSystemTools::MakeDirectory
-       (this->GetCurrentBinaryDirectory()))
-      {
+  if (strcmp(this->GetCurrentBinaryDirectory(), this->GetSourceDirectory()) !=
+      0) {
+    if (!cmSystemTools::MakeDirectory(this->GetCurrentBinaryDirectory())) {
       cmSystemTools::Error("Error creating directory ",
                            this->GetCurrentBinaryDirectory());
-      }
     }
+  }
 
   // Get the set of targets in this directory.
   std::vector<cmGeneratorTarget*> tgts = this->GetGeneratorTargets();
 
   // Create the project file for each target.
-  for(std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
-      l != tgts.end(); l++)
-    {
-    if((*l)->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+  for (std::vector<cmGeneratorTarget*>::iterator l = tgts.begin();
+       l != tgts.end(); l++) {
+    if ((*l)->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     // INCLUDE_EXTERNAL_MSPROJECT command only affects the workspace
     // so don't build a projectfile for it
-    if(!(*l)->GetProperty("EXTERNAL_MSPROJECT"))
-      {
+    if (!(*l)->GetProperty("EXTERNAL_MSPROJECT")) {
       this->CreateSingleVCProj((*l)->GetName().c_str(), *l);
-      }
     }
+  }
 }
 
 void cmLocalVisualStudio7Generator::WriteStampFiles()
@@ -215,55 +197,49 @@ void cmLocalVisualStudio7Generator::WriteStampFiles()
   cmsys::ofstream depFile(depName.c_str());
   depFile << "# CMake generation dependency list for this directory.\n";
   std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
-  for(std::vector<std::string>::const_iterator lf = listFiles.begin();
-      lf != listFiles.end(); ++lf)
-    {
+  for (std::vector<std::string>::const_iterator lf = listFiles.begin();
+       lf != listFiles.end(); ++lf) {
     depFile << *lf << std::endl;
-    }
+  }
 }
 
-void cmLocalVisualStudio7Generator
-::CreateSingleVCProj(const std::string& lname, cmGeneratorTarget *target)
+void cmLocalVisualStudio7Generator::CreateSingleVCProj(
+  const std::string& lname, cmGeneratorTarget* target)
 {
-  cmGlobalVisualStudioGenerator* gg
-      = static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
+  cmGlobalVisualStudioGenerator* gg =
+    static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
   this->FortranProject = gg->TargetIsFortranOnly(target);
   this->WindowsCEProject = gg->TargetsWindowsCE();
 
   // Intel Fortran for VS10 uses VS9 format ".vfproj" files.
   cmGlobalVisualStudioGenerator::VSVersion realVersion = gg->GetVersion();
-  if(this->FortranProject
-      && gg->GetVersion() >= cmGlobalVisualStudioGenerator::VS10)
-    {
+  if (this->FortranProject &&
+      gg->GetVersion() >= cmGlobalVisualStudioGenerator::VS10) {
     gg->SetVersion(cmGlobalVisualStudioGenerator::VS9);
-    }
+  }
 
   // add to the list of projects
-  target->Target->SetProperty("GENERATOR_FILE_NAME",lname.c_str());
+  target->Target->SetProperty("GENERATOR_FILE_NAME", lname.c_str());
   // create the dsp.cmake file
   std::string fname;
   fname = this->GetCurrentBinaryDirectory();
   fname += "/";
   fname += lname;
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     fname += ".vfproj";
-    }
-  else
-    {
+  } else {
     fname += ".vcproj";
-    }
+  }
 
   // Generate the project file and replace it atomically with
   // copy-if-different.  We use a separate timestamp so that the IDE
   // does not reload project files unnecessarily.
   cmGeneratedFileStream fout(fname.c_str());
   fout.SetCopyIfDifferent(true);
-  this->WriteVCProjFile(fout,lname,target);
-  if (fout.Close())
-    {
+  this->WriteVCProjFile(fout, lname, target);
+  if (fout.Close()) {
     this->GlobalGenerator->FileReplacedDuringGenerate(fname);
-    }
+  }
 
   gg->SetVersion(realVersion);
 }
@@ -280,10 +256,9 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
   makefileIn += "/";
   makefileIn += "CMakeLists.txt";
   makefileIn = cmSystemTools::CollapseFullPath(makefileIn.c_str());
-  if(!cmSystemTools::FileExists(makefileIn.c_str()))
-    {
+  if (!cmSystemTools::FileExists(makefileIn.c_str())) {
     return 0;
-    }
+  }
   std::string comment = "Building Custom Rule ";
   comment += makefileIn;
   std::string args;
@@ -294,8 +269,7 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
   args += this->GetBinaryDirectory();
   commandLine.push_back(args);
   commandLine.push_back("--check-stamp-file");
-  std::string stampFilename = this->Convert(stampName.c_str(), FULL,
-                                            SHELL);
+  std::string stampFilename = this->Convert(stampName.c_str(), FULL, SHELL);
   commandLine.push_back(stampFilename.c_str());
 
   std::vector<std::string> const& listFiles = this->Makefile->GetListFiles();
@@ -303,337 +277,322 @@ cmSourceFile* cmLocalVisualStudio7Generator::CreateVCProjBuildRule()
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
   const char* no_working_directory = 0;
-  std::string fullpathStampName = this->Convert(stampName.c_str(), FULL,
-                                            UNCHANGED);
-  this->Makefile->AddCustomCommandToOutput(fullpathStampName.c_str(),
-                                           listFiles, makefileIn.c_str(),
-                                           commandLines, comment.c_str(),
-                                           no_working_directory, true);
-  if(cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str()))
-    {
+  std::string fullpathStampName =
+    this->Convert(stampName.c_str(), FULL, UNCHANGED);
+  this->Makefile->AddCustomCommandToOutput(
+    fullpathStampName.c_str(), listFiles, makefileIn.c_str(), commandLines,
+    comment.c_str(), no_working_directory, true);
+  if (cmSourceFile* file = this->Makefile->GetSource(makefileIn.c_str())) {
     return file;
-    }
-  else
-    {
+  } else {
     cmSystemTools::Error("Error adding rule for ", makefileIn.c_str());
     return 0;
-    }
+  }
 }
 
 void cmLocalVisualStudio7Generator::WriteConfigurations(
-    std::ostream& fout,
-    std::vector<std::string> const& configs,
-  const std::string& libName, cmGeneratorTarget *target
-  )
+  std::ostream& fout, std::vector<std::string> const& configs,
+  const std::string& libName, cmGeneratorTarget* target)
 {
   fout << "\t<Configurations>\n";
   for (std::vector<std::string>::const_iterator i = configs.begin();
-       i != configs.end(); ++i)
-    {
+       i != configs.end(); ++i) {
     this->WriteConfiguration(fout, i->c_str(), libName, target);
-    }
+  }
   fout << "\t</Configurations>\n";
 }
-cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranFlagTable[] =
-{
-  {"Preprocess", "fpp", "Run Preprocessor on files", "preprocessYes", 0},
-  {"SuppressStartupBanner", "nologo", "SuppressStartupBanner", "true", 0},
-  {"SourceFileFormat", "fixed", "Use Fixed Format", "fileFormatFixed", 0},
-  {"SourceFileFormat", "free", "Use Free Format", "fileFormatFree", 0},
-  {"DebugInformationFormat", "Zi", "full debug", "debugEnabled", 0},
-  {"DebugInformationFormat", "debug:full", "full debug", "debugEnabled", 0},
-  {"DebugInformationFormat", "Z7", "c7 compat", "debugOldStyleInfo", 0},
-  {"DebugInformationFormat", "Zd", "line numbers", "debugLineInfoOnly", 0},
-  {"Optimization", "Od", "disable optimization", "optimizeDisabled", 0},
-  {"Optimization", "O1", "min space", "optimizeMinSpace", 0},
-  {"Optimization", "O3", "full optimize", "optimizeFull", 0},
-  {"GlobalOptimizations", "Og", "global optimize", "true", 0},
-  {"InlineFunctionExpansion", "Ob0", "", "expandDisable", 0},
-  {"InlineFunctionExpansion", "Ob1", "", "expandOnlyInline", 0},
-  {"FavorSizeOrSpeed", "Os", "", "favorSize", 0},
-  {"OmitFramePointers", "Oy-", "", "false", 0},
-  {"OptimizeForProcessor", "GB", "", "procOptimizeBlended", 0},
-  {"OptimizeForProcessor", "G5", "", "procOptimizePentium", 0},
-  {"OptimizeForProcessor", "G6", "", "procOptimizePentiumProThruIII", 0},
-  {"UseProcessorExtensions", "QzxK", "", "codeForStreamingSIMD", 0},
-  {"OptimizeForProcessor", "QaxN", "", "codeForPentium4", 0},
-  {"OptimizeForProcessor", "QaxB", "", "codeForPentiumM", 0},
-  {"OptimizeForProcessor", "QaxP", "", "codeForCodeNamedPrescott", 0},
-  {"OptimizeForProcessor", "QaxT", "", "codeForCore2Duo", 0},
-  {"OptimizeForProcessor", "QxK", "", "codeExclusivelyStreamingSIMD", 0},
-  {"OptimizeForProcessor", "QxN", "", "codeExclusivelyPentium4", 0},
-  {"OptimizeForProcessor", "QxB", "", "codeExclusivelyPentiumM", 0},
-  {"OptimizeForProcessor", "QxP", "", "codeExclusivelyCodeNamedPrescott", 0},
-  {"OptimizeForProcessor", "QxT", "", "codeExclusivelyCore2Duo", 0},
-  {"OptimizeForProcessor", "QxO", "", "codeExclusivelyCore2StreamingSIMD", 0},
-  {"OptimizeForProcessor", "QxS", "", "codeExclusivelyCore2StreamingSIMD4", 0},
-  {"OpenMP", "Qopenmp", "", "OpenMPParallelCode", 0},
-  {"OpenMP", "Qopenmp-stubs", "", "OpenMPSequentialCode", 0},
-  {"Traceback", "traceback", "", "true", 0},
-  {"Traceback", "notraceback", "", "false", 0},
-  {"FloatingPointExceptionHandling", "fpe:0", "", "fpe0", 0},
-  {"FloatingPointExceptionHandling", "fpe:1", "", "fpe1", 0},
-  {"FloatingPointExceptionHandling", "fpe:3", "", "fpe3", 0},
-
-  {"MultiProcessorCompilation", "MP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"ProcessorNumber", "MP", "Multi-processor Compilation", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  {"ModulePath", "module:", "", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"LoopUnrolling", "Qunroll:", "", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"AutoParallelThreshold", "Qpar-threshold:", "", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"HeapArrays", "heap-arrays:", "", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"ObjectText", "bintext:", "", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"Parallelization", "Qparallel", "", "true", 0},
-  {"PrefetchInsertion", "Qprefetch-", "", "false", 0},
-  {"BufferedIO", "assume:buffered_io", "", "true", 0},
-  {"CallingConvention", "iface:stdcall", "", "callConventionStdCall", 0},
-  {"CallingConvention", "iface:cref", "", "callConventionCRef", 0},
-  {"CallingConvention", "iface:stdref", "", "callConventionStdRef", 0},
-  {"CallingConvention", "iface:stdcall", "", "callConventionStdCall", 0},
-  {"CallingConvention", "iface:cvf", "", "callConventionCVF", 0},
-  {"EnableRecursion", "recursive", "", "true", 0},
-  {"ReentrantCode", "reentrancy", "", "true", 0},
+cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranFlagTable[] = {
+  { "Preprocess", "fpp", "Run Preprocessor on files", "preprocessYes", 0 },
+  { "SuppressStartupBanner", "nologo", "SuppressStartupBanner", "true", 0 },
+  { "SourceFileFormat", "fixed", "Use Fixed Format", "fileFormatFixed", 0 },
+  { "SourceFileFormat", "free", "Use Free Format", "fileFormatFree", 0 },
+  { "DebugInformationFormat", "Zi", "full debug", "debugEnabled", 0 },
+  { "DebugInformationFormat", "debug:full", "full debug", "debugEnabled", 0 },
+  { "DebugInformationFormat", "Z7", "c7 compat", "debugOldStyleInfo", 0 },
+  { "DebugInformationFormat", "Zd", "line numbers", "debugLineInfoOnly", 0 },
+  { "Optimization", "Od", "disable optimization", "optimizeDisabled", 0 },
+  { "Optimization", "O1", "min space", "optimizeMinSpace", 0 },
+  { "Optimization", "O3", "full optimize", "optimizeFull", 0 },
+  { "GlobalOptimizations", "Og", "global optimize", "true", 0 },
+  { "InlineFunctionExpansion", "Ob0", "", "expandDisable", 0 },
+  { "InlineFunctionExpansion", "Ob1", "", "expandOnlyInline", 0 },
+  { "FavorSizeOrSpeed", "Os", "", "favorSize", 0 },
+  { "OmitFramePointers", "Oy-", "", "false", 0 },
+  { "OptimizeForProcessor", "GB", "", "procOptimizeBlended", 0 },
+  { "OptimizeForProcessor", "G5", "", "procOptimizePentium", 0 },
+  { "OptimizeForProcessor", "G6", "", "procOptimizePentiumProThruIII", 0 },
+  { "UseProcessorExtensions", "QzxK", "", "codeForStreamingSIMD", 0 },
+  { "OptimizeForProcessor", "QaxN", "", "codeForPentium4", 0 },
+  { "OptimizeForProcessor", "QaxB", "", "codeForPentiumM", 0 },
+  { "OptimizeForProcessor", "QaxP", "", "codeForCodeNamedPrescott", 0 },
+  { "OptimizeForProcessor", "QaxT", "", "codeForCore2Duo", 0 },
+  { "OptimizeForProcessor", "QxK", "", "codeExclusivelyStreamingSIMD", 0 },
+  { "OptimizeForProcessor", "QxN", "", "codeExclusivelyPentium4", 0 },
+  { "OptimizeForProcessor", "QxB", "", "codeExclusivelyPentiumM", 0 },
+  { "OptimizeForProcessor", "QxP", "", "codeExclusivelyCodeNamedPrescott", 0 },
+  { "OptimizeForProcessor", "QxT", "", "codeExclusivelyCore2Duo", 0 },
+  { "OptimizeForProcessor", "QxO", "", "codeExclusivelyCore2StreamingSIMD",
+    0 },
+  { "OptimizeForProcessor", "QxS", "", "codeExclusivelyCore2StreamingSIMD4",
+    0 },
+  { "OpenMP", "Qopenmp", "", "OpenMPParallelCode", 0 },
+  { "OpenMP", "Qopenmp-stubs", "", "OpenMPSequentialCode", 0 },
+  { "Traceback", "traceback", "", "true", 0 },
+  { "Traceback", "notraceback", "", "false", 0 },
+  { "FloatingPointExceptionHandling", "fpe:0", "", "fpe0", 0 },
+  { "FloatingPointExceptionHandling", "fpe:1", "", "fpe1", 0 },
+  { "FloatingPointExceptionHandling", "fpe:3", "", "fpe3", 0 },
+
+  { "MultiProcessorCompilation", "MP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "ProcessorNumber", "MP", "Multi-processor Compilation", "",
+    cmVS7FlagTable::UserValueRequired },
+
+  { "ModulePath", "module:", "", "", cmVS7FlagTable::UserValueRequired },
+  { "LoopUnrolling", "Qunroll:", "", "", cmVS7FlagTable::UserValueRequired },
+  { "AutoParallelThreshold", "Qpar-threshold:", "", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "HeapArrays", "heap-arrays:", "", "", cmVS7FlagTable::UserValueRequired },
+  { "ObjectText", "bintext:", "", "", cmVS7FlagTable::UserValueRequired },
+  { "Parallelization", "Qparallel", "", "true", 0 },
+  { "PrefetchInsertion", "Qprefetch-", "", "false", 0 },
+  { "BufferedIO", "assume:buffered_io", "", "true", 0 },
+  { "CallingConvention", "iface:stdcall", "", "callConventionStdCall", 0 },
+  { "CallingConvention", "iface:cref", "", "callConventionCRef", 0 },
+  { "CallingConvention", "iface:stdref", "", "callConventionStdRef", 0 },
+  { "CallingConvention", "iface:stdcall", "", "callConventionStdCall", 0 },
+  { "CallingConvention", "iface:cvf", "", "callConventionCVF", 0 },
+  { "EnableRecursion", "recursive", "", "true", 0 },
+  { "ReentrantCode", "reentrancy", "", "true", 0 },
   // done up to Language
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
 // fill the table here currently the comment field is not used for
 // anything other than documentation NOTE: Make sure the longer
 // commandFlag comes FIRST!
-cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[] =
-{
+cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[] = {
   // option flags (some flags map to the same option)
-  {"BasicRuntimeChecks", "GZ", "Stack frame checks", "1", 0},
-  {"BasicRuntimeChecks", "RTCsu",
-   "Both stack and uninitialized checks", "3", 0},
-  {"BasicRuntimeChecks", "RTCs", "Stack frame checks", "1", 0},
-  {"BasicRuntimeChecks", "RTCu", "Uninitialized Variables ", "2", 0},
-  {"BasicRuntimeChecks", "RTC1",
-   "Both stack and uninitialized checks", "3", 0},
-  {"DebugInformationFormat", "Z7", "debug format", "1", 0},
-  {"DebugInformationFormat", "Zd", "debug format", "2", 0},
-  {"DebugInformationFormat", "Zi", "debug format", "3", 0},
-  {"DebugInformationFormat", "ZI", "debug format", "4", 0},
-  {"EnableEnhancedInstructionSet", "arch:SSE2",
-   "Use sse2 instructions", "2", 0},
-  {"EnableEnhancedInstructionSet", "arch:SSE",
-   "Use sse instructions",   "1", 0},
-  {"FloatingPointModel", "fp:precise",
-   "Use precise floating point model", "0", 0},
-  {"FloatingPointModel", "fp:strict",
-   "Use strict floating point model", "1", 0},
-  {"FloatingPointModel", "fp:fast", "Use fast floating point model", "2", 0},
-  {"FavorSizeOrSpeed",  "Ot", "Favor fast code",  "1", 0},
-  {"FavorSizeOrSpeed",  "Os", "Favor small code", "2", 0},
-  {"CompileAs", "TC", "Compile as c code",        "1", 0},
-  {"CompileAs", "TP", "Compile as c++ code",      "2", 0},
-  {"Optimization", "Od", "Non Debug",        "0", 0},
-  {"Optimization", "O1", "Min Size",         "1", 0},
-  {"Optimization", "O2", "Max Speed",        "2", 0},
-  {"Optimization", "Ox", "Max Optimization", "3", 0},
-  {"OptimizeForProcessor", "GB", "Blended processor mode", "0", 0},
-  {"OptimizeForProcessor", "G5", "Pentium",                "1", 0},
-  {"OptimizeForProcessor", "G6", "PPro PII PIII",          "2", 0},
-  {"OptimizeForProcessor", "G7", "Pentium 4 or Athlon",    "3", 0},
-  {"InlineFunctionExpansion", "Ob0", "no inlines",              "0", 0},
-  {"InlineFunctionExpansion", "Ob1", "when inline keyword",     "1", 0},
-  {"InlineFunctionExpansion", "Ob2", "any time you can inline", "2", 0},
-  {"RuntimeLibrary", "MTd", "Multithreaded debug",     "1", 0},
-  {"RuntimeLibrary", "MT", "Multithreaded", "0", 0},
-  {"RuntimeLibrary", "MDd", "Multithreaded dll debug", "3", 0},
-  {"RuntimeLibrary", "MD", "Multithreaded dll",        "2", 0},
-  {"RuntimeLibrary", "MLd", "Single Thread debug",    "5", 0},
-  {"RuntimeLibrary", "ML", "Single Thread",           "4", 0},
-  {"StructMemberAlignment", "Zp16", "struct align 16 byte ",   "5", 0},
-  {"StructMemberAlignment", "Zp1", "struct align 1 byte ",     "1", 0},
-  {"StructMemberAlignment", "Zp2", "struct align 2 byte ",     "2", 0},
-  {"StructMemberAlignment", "Zp4", "struct align 4 byte ",     "3", 0},
-  {"StructMemberAlignment", "Zp8", "struct align 8 byte ",     "4", 0},
-  {"WarningLevel", "W0", "Warning level", "0", 0},
-  {"WarningLevel", "W1", "Warning level", "1", 0},
-  {"WarningLevel", "W2", "Warning level", "2", 0},
-  {"WarningLevel", "W3", "Warning level", "3", 0},
-  {"WarningLevel", "W4", "Warning level", "4", 0},
-  {"DisableSpecificWarnings", "wd", "Disable specific warnings", "",
-   cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "BasicRuntimeChecks", "GZ", "Stack frame checks", "1", 0 },
+  { "BasicRuntimeChecks", "RTCsu", "Both stack and uninitialized checks", "3",
+    0 },
+  { "BasicRuntimeChecks", "RTCs", "Stack frame checks", "1", 0 },
+  { "BasicRuntimeChecks", "RTCu", "Uninitialized Variables ", "2", 0 },
+  { "BasicRuntimeChecks", "RTC1", "Both stack and uninitialized checks", "3",
+    0 },
+  { "DebugInformationFormat", "Z7", "debug format", "1", 0 },
+  { "DebugInformationFormat", "Zd", "debug format", "2", 0 },
+  { "DebugInformationFormat", "Zi", "debug format", "3", 0 },
+  { "DebugInformationFormat", "ZI", "debug format", "4", 0 },
+  { "EnableEnhancedInstructionSet", "arch:SSE2", "Use sse2 instructions", "2",
+    0 },
+  { "EnableEnhancedInstructionSet", "arch:SSE", "Use sse instructions", "1",
+    0 },
+  { "FloatingPointModel", "fp:precise", "Use precise floating point model",
+    "0", 0 },
+  { "FloatingPointModel", "fp:strict", "Use strict floating point model", "1",
+    0 },
+  { "FloatingPointModel", "fp:fast", "Use fast floating point model", "2", 0 },
+  { "FavorSizeOrSpeed", "Ot", "Favor fast code", "1", 0 },
+  { "FavorSizeOrSpeed", "Os", "Favor small code", "2", 0 },
+  { "CompileAs", "TC", "Compile as c code", "1", 0 },
+  { "CompileAs", "TP", "Compile as c++ code", "2", 0 },
+  { "Optimization", "Od", "Non Debug", "0", 0 },
+  { "Optimization", "O1", "Min Size", "1", 0 },
+  { "Optimization", "O2", "Max Speed", "2", 0 },
+  { "Optimization", "Ox", "Max Optimization", "3", 0 },
+  { "OptimizeForProcessor", "GB", "Blended processor mode", "0", 0 },
+  { "OptimizeForProcessor", "G5", "Pentium", "1", 0 },
+  { "OptimizeForProcessor", "G6", "PPro PII PIII", "2", 0 },
+  { "OptimizeForProcessor", "G7", "Pentium 4 or Athlon", "3", 0 },
+  { "InlineFunctionExpansion", "Ob0", "no inlines", "0", 0 },
+  { "InlineFunctionExpansion", "Ob1", "when inline keyword", "1", 0 },
+  { "InlineFunctionExpansion", "Ob2", "any time you can inline", "2", 0 },
+  { "RuntimeLibrary", "MTd", "Multithreaded debug", "1", 0 },
+  { "RuntimeLibrary", "MT", "Multithreaded", "0", 0 },
+  { "RuntimeLibrary", "MDd", "Multithreaded dll debug", "3", 0 },
+  { "RuntimeLibrary", "MD", "Multithreaded dll", "2", 0 },
+  { "RuntimeLibrary", "MLd", "Single Thread debug", "5", 0 },
+  { "RuntimeLibrary", "ML", "Single Thread", "4", 0 },
+  { "StructMemberAlignment", "Zp16", "struct align 16 byte ", "5", 0 },
+  { "StructMemberAlignment", "Zp1", "struct align 1 byte ", "1", 0 },
+  { "StructMemberAlignment", "Zp2", "struct align 2 byte ", "2", 0 },
+  { "StructMemberAlignment", "Zp4", "struct align 4 byte ", "3", 0 },
+  { "StructMemberAlignment", "Zp8", "struct align 8 byte ", "4", 0 },
+  { "WarningLevel", "W0", "Warning level", "0", 0 },
+  { "WarningLevel", "W1", "Warning level", "1", 0 },
+  { "WarningLevel", "W2", "Warning level", "2", 0 },
+  { "WarningLevel", "W3", "Warning level", "3", 0 },
+  { "WarningLevel", "W4", "Warning level", "4", 0 },
+  { "DisableSpecificWarnings", "wd", "Disable specific warnings", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
   // Precompiled header and related options.  Note that the
   // UsePrecompiledHeader entries are marked as "Continue" so that the
   // corresponding PrecompiledHeaderThrough entry can be found.
-  {"UsePrecompiledHeader", "Yc", "Create Precompiled Header", "1",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeaderThrough", "Yc", "Precompiled Header Name", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderFile", "Fp", "Generated Precompiled Header", "",
-   cmVS7FlagTable::UserValue},
+  { "UsePrecompiledHeader", "Yc", "Create Precompiled Header", "1",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeaderThrough", "Yc", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderFile", "Fp", "Generated Precompiled Header", "",
+    cmVS7FlagTable::UserValue },
   // The YX and Yu options are in a per-global-generator table because
   // their values differ based on the VS IDE version.
-  {"ForcedIncludeFiles", "FI", "Forced include files", "",
-   cmVS7FlagTable::UserValueRequired | cmVS7FlagTable::SemicolonAppendable},
+  { "ForcedIncludeFiles", "FI", "Forced include files", "",
+    cmVS7FlagTable::UserValueRequired | cmVS7FlagTable::SemicolonAppendable },
 
-  {"AssemblerListingLocation", "Fa", "ASM List Location", "",
-   cmVS7FlagTable::UserValue},
-  {"ProgramDataBaseFileName", "Fd", "Program Database File Name", "",
-   cmVS7FlagTable::UserValue},
+  { "AssemblerListingLocation", "Fa", "ASM List Location", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDataBaseFileName", "Fd", "Program Database File Name", "",
+    cmVS7FlagTable::UserValue },
 
   // boolean flags
-  {"BufferSecurityCheck", "GS", "Buffer security check", "true", 0},
-  {"BufferSecurityCheck", "GS-", "Turn off Buffer security check", "false", 0},
-  {"Detect64BitPortabilityProblems", "Wp64",
-   "Detect 64-bit Portability Problems", "true", 0},
-  {"EnableFiberSafeOptimizations", "GT", "Enable Fiber-safe Optimizations",
-   "true", 0},
-  {"EnableFunctionLevelLinking", "Gy",
-   "EnableFunctionLevelLinking", "true", 0},
-  {"EnableIntrinsicFunctions", "Oi", "EnableIntrinsicFunctions", "true", 0},
-  {"GlobalOptimizations", "Og", "Global Optimize", "true", 0},
-  {"ImproveFloatingPointConsistency", "Op",
-   "ImproveFloatingPointConsistency", "true", 0},
-  {"MinimalRebuild", "Gm", "minimal rebuild", "true", 0},
-  {"OmitFramePointers", "Oy", "OmitFramePointers", "true", 0},
-  {"OptimizeForWindowsApplication", "GA", "Optimize for windows", "true", 0},
-  {"RuntimeTypeInfo", "GR",
-   "Turn on Run time type information for c++", "true", 0},
-  {"RuntimeTypeInfo", "GR-",
-   "Turn off Run time type information for c++", "false", 0},
-  {"SmallerTypeCheck", "RTCc", "smaller type check", "true", 0},
-  {"SuppressStartupBanner", "nologo", "SuppressStartupBanner", "true", 0},
-  {"WholeProgramOptimization", "GL",
-   "Enables whole program optimization", "true", 0},
-  {"WholeProgramOptimization", "GL-",
-   "Disables whole program optimization", "false", 0},
-  {"WarnAsError", "WX", "Treat warnings as errors", "true", 0},
-  {"BrowseInformation", "FR", "Generate browse information", "1", 0},
-  {"StringPooling", "GF", "Enable StringPooling", "true", 0},
-  {0,0,0,0,0}
+  { "BufferSecurityCheck", "GS", "Buffer security check", "true", 0 },
+  { "BufferSecurityCheck", "GS-", "Turn off Buffer security check", "false",
+    0 },
+  { "Detect64BitPortabilityProblems", "Wp64",
+    "Detect 64-bit Portability Problems", "true", 0 },
+  { "EnableFiberSafeOptimizations", "GT", "Enable Fiber-safe Optimizations",
+    "true", 0 },
+  { "EnableFunctionLevelLinking", "Gy", "EnableFunctionLevelLinking", "true",
+    0 },
+  { "EnableIntrinsicFunctions", "Oi", "EnableIntrinsicFunctions", "true", 0 },
+  { "GlobalOptimizations", "Og", "Global Optimize", "true", 0 },
+  { "ImproveFloatingPointConsistency", "Op", "ImproveFloatingPointConsistency",
+    "true", 0 },
+  { "MinimalRebuild", "Gm", "minimal rebuild", "true", 0 },
+  { "OmitFramePointers", "Oy", "OmitFramePointers", "true", 0 },
+  { "OptimizeForWindowsApplication", "GA", "Optimize for windows", "true", 0 },
+  { "RuntimeTypeInfo", "GR", "Turn on Run time type information for c++",
+    "true", 0 },
+  { "RuntimeTypeInfo", "GR-", "Turn off Run time type information for c++",
+    "false", 0 },
+  { "SmallerTypeCheck", "RTCc", "smaller type check", "true", 0 },
+  { "SuppressStartupBanner", "nologo", "SuppressStartupBanner", "true", 0 },
+  { "WholeProgramOptimization", "GL", "Enables whole program optimization",
+    "true", 0 },
+  { "WholeProgramOptimization", "GL-", "Disables whole program optimization",
+    "false", 0 },
+  { "WarnAsError", "WX", "Treat warnings as errors", "true", 0 },
+  { "BrowseInformation", "FR", "Generate browse information", "1", 0 },
+  { "StringPooling", "GF", "Enable StringPooling", "true", 0 },
+  { 0, 0, 0, 0, 0 }
 };
 
-
-
-cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] =
-{
+cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] = {
   // option flags (some flags map to the same option)
-  {"GenerateManifest", "MANIFEST:NO",
-   "disable manifest generation", "false", 0},
-  {"GenerateManifest", "MANIFEST", "enable manifest generation", "true", 0},
-  {"LinkIncremental", "INCREMENTAL:NO", "link incremental", "1", 0},
-  {"LinkIncremental", "INCREMENTAL:YES", "link incremental", "2", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0},
-  {"DataExecutionPrevention", "NXCOMPAT:NO",
-   "Not known to work with Windows Data Execution Prevention", "1", 0},
-  {"DataExecutionPrevention", "NXCOMPAT",
-   "Known to work with Windows Data Execution Prevention", "2", 0},
-  {"DelaySign", "DELAYSIGN:NO", "", "false", 0},
-  {"DelaySign", "DELAYSIGN", "", "true", 0},
-  {"EntryPointSymbol", "ENTRY:", "sets the starting address", "",
-   cmVS7FlagTable::UserValue},
-  {"IgnoreDefaultLibraryNames", "NODEFAULTLIB:", "default libs to ignore", "",
-  cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "ignore all default libs",
-   "true", 0},
-  {"FixedBaseAddress", "FIXED:NO", "Generate a relocation section", "1", 0},
-  {"FixedBaseAddress", "FIXED", "Image must be loaded at a fixed address",
-   "2", 0},
-  {"EnableCOMDATFolding", "OPT:NOICF", "Do not remove redundant COMDATs",
-   "1", 0},
-  {"EnableCOMDATFolding", "OPT:ICF", "Remove redundant COMDATs", "2", 0},
-  {"ResourceOnlyDLL", "NOENTRY", "Create DLL with no entry point", "true", 0},
-  {"OptimizeReferences", "OPT:NOREF", "Keep unreferenced data", "1", 0},
-  {"OptimizeReferences", "OPT:REF", "Eliminate unreferenced data", "2", 0},
-  {"Profile", "PROFILE", "", "true", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE:NO",
-   "Image may not be rebased at load-time", "1", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE",
-   "Image may be rebased at load-time", "2", 0},
-  {"SetChecksum", "RELEASE", "Enable setting checksum in header", "true", 0},
-  {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0},
-  {"TargetMachine", "MACHINE:I386", "Machine x86", "1", 0},
-  {"TargetMachine", "MACHINE:X86", "Machine x86", "1", 0},
-  {"TargetMachine", "MACHINE:AM33", "Machine AM33", "2", 0},
-  {"TargetMachine", "MACHINE:ARM", "Machine ARM", "3", 0},
-  {"TargetMachine", "MACHINE:EBC", "Machine EBC", "4", 0},
-  {"TargetMachine", "MACHINE:IA64", "Machine IA64", "5", 0},
-  {"TargetMachine", "MACHINE:M32R", "Machine M32R", "6", 0},
-  {"TargetMachine", "MACHINE:MIPS", "Machine MIPS", "7", 0},
-  {"TargetMachine", "MACHINE:MIPS16", "Machine MIPS16", "8", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU)", "Machine MIPSFPU", "9", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16", "Machine MIPSFPU16", "10", 0},
-  {"TargetMachine", "MACHINE:MIPSR41XX", "Machine MIPSR41XX", "11", 0},
-  {"TargetMachine", "MACHINE:SH3", "Machine SH3", "12", 0},
-  {"TargetMachine", "MACHINE:SH3DSP", "Machine SH3DSP", "13", 0},
-  {"TargetMachine", "MACHINE:SH4", "Machine SH4", "14", 0},
-  {"TargetMachine", "MACHINE:SH5", "Machine SH5", "15", 0},
-  {"TargetMachine", "MACHINE:THUMB", "Machine THUMB", "16", 0},
-  {"TargetMachine", "MACHINE:X64", "Machine x64", "17", 0},
-  {"TurnOffAssemblyGeneration", "NOASSEMBLY",
-   "No assembly even if CLR information is present in objects.", "true", 0},
-  {"ModuleDefinitionFile", "DEF:", "add an export def file", "",
-   cmVS7FlagTable::UserValue},
-  {"GenerateMapFile", "MAP", "enable generation of map file", "true", 0},
-  {0,0,0,0,0}
+  { "GenerateManifest", "MANIFEST:NO", "disable manifest generation", "false",
+    0 },
+  { "GenerateManifest", "MANIFEST", "enable manifest generation", "true", 0 },
+  { "LinkIncremental", "INCREMENTAL:NO", "link incremental", "1", 0 },
+  { "LinkIncremental", "INCREMENTAL:YES", "link incremental", "2", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT:NO",
+    "Not known to work with Windows Data Execution Prevention", "1", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT",
+    "Known to work with Windows Data Execution Prevention", "2", 0 },
+  { "DelaySign", "DELAYSIGN:NO", "", "false", 0 },
+  { "DelaySign", "DELAYSIGN", "", "true", 0 },
+  { "EntryPointSymbol", "ENTRY:", "sets the starting address", "",
+    cmVS7FlagTable::UserValue },
+  { "IgnoreDefaultLibraryNames", "NODEFAULTLIB:", "default libs to ignore", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "ignore all default libs",
+    "true", 0 },
+  { "FixedBaseAddress", "FIXED:NO", "Generate a relocation section", "1", 0 },
+  { "FixedBaseAddress", "FIXED", "Image must be loaded at a fixed address",
+    "2", 0 },
+  { "EnableCOMDATFolding", "OPT:NOICF", "Do not remove redundant COMDATs", "1",
+    0 },
+  { "EnableCOMDATFolding", "OPT:ICF", "Remove redundant COMDATs", "2", 0 },
+  { "ResourceOnlyDLL", "NOENTRY", "Create DLL with no entry point", "true",
+    0 },
+  { "OptimizeReferences", "OPT:NOREF", "Keep unreferenced data", "1", 0 },
+  { "OptimizeReferences", "OPT:REF", "Eliminate unreferenced data", "2", 0 },
+  { "Profile", "PROFILE", "", "true", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE:NO",
+    "Image may not be rebased at load-time", "1", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE",
+    "Image may be rebased at load-time", "2", 0 },
+  { "SetChecksum", "RELEASE", "Enable setting checksum in header", "true", 0 },
+  { "SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0 },
+  { "TargetMachine", "MACHINE:I386", "Machine x86", "1", 0 },
+  { "TargetMachine", "MACHINE:X86", "Machine x86", "1", 0 },
+  { "TargetMachine", "MACHINE:AM33", "Machine AM33", "2", 0 },
+  { "TargetMachine", "MACHINE:ARM", "Machine ARM", "3", 0 },
+  { "TargetMachine", "MACHINE:EBC", "Machine EBC", "4", 0 },
+  { "TargetMachine", "MACHINE:IA64", "Machine IA64", "5", 0 },
+  { "TargetMachine", "MACHINE:M32R", "Machine M32R", "6", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "Machine MIPS", "7", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "Machine MIPS16", "8", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU)", "Machine MIPSFPU", "9", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "Machine MIPSFPU16", "10", 0 },
+  { "TargetMachine", "MACHINE:MIPSR41XX", "Machine MIPSR41XX", "11", 0 },
+  { "TargetMachine", "MACHINE:SH3", "Machine SH3", "12", 0 },
+  { "TargetMachine", "MACHINE:SH3DSP", "Machine SH3DSP", "13", 0 },
+  { "TargetMachine", "MACHINE:SH4", "Machine SH4", "14", 0 },
+  { "TargetMachine", "MACHINE:SH5", "Machine SH5", "15", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "Machine THUMB", "16", 0 },
+  { "TargetMachine", "MACHINE:X64", "Machine x64", "17", 0 },
+  { "TurnOffAssemblyGeneration", "NOASSEMBLY",
+    "No assembly even if CLR information is present in objects.", "true", 0 },
+  { "ModuleDefinitionFile", "DEF:", "add an export def file", "",
+    cmVS7FlagTable::UserValue },
+  { "GenerateMapFile", "MAP", "enable generation of map file", "true", 0 },
+  { 0, 0, 0, 0, 0 }
 };
 
-cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranLinkFlagTable[] =
-{
-  {"LinkIncremental", "INCREMENTAL:NO", "link incremental",
-   "linkIncrementalNo", 0},
-  {"LinkIncremental", "INCREMENTAL:YES", "link incremental",
-   "linkIncrementalYes", 0},
-  {0,0,0,0,0}
+cmVS7FlagTable cmLocalVisualStudio7GeneratorFortranLinkFlagTable[] = {
+  { "LinkIncremental", "INCREMENTAL:NO", "link incremental",
+    "linkIncrementalNo", 0 },
+  { "LinkIncremental", "INCREMENTAL:YES", "link incremental",
+    "linkIncrementalYes", 0 },
+  { 0, 0, 0, 0, 0 }
 };
 
 // Helper class to write build event <Tool .../> elements.
 class cmLocalVisualStudio7Generator::EventWriter
 {
 public:
-  EventWriter(cmLocalVisualStudio7Generator* lg,
-              const std::string& config, std::ostream& os):
-    LG(lg), Config(config), Stream(os), First(true) {}
+  EventWriter(cmLocalVisualStudio7Generator* lg, const std::string& config,
+              std::ostream& os)
+    : LG(lg)
+    , Config(config)
+    , Stream(os)
+    , First(true)
+  {
+  }
   void Start(const char* tool)
-    {
+  {
     this->First = true;
     this->Stream << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"";
-    }
-  void Finish()
-    {
-    this->Stream << (this->First? "" : "\"") << "/>\n";
-    }
+  }
+  void Finish() { this->Stream << (this->First ? "" : "\"") << "/>\n"; }
   void Write(std::vector<cmCustomCommand> const& ccs)
-    {
-    for(std::vector<cmCustomCommand>::const_iterator ci = ccs.begin();
-        ci != ccs.end(); ++ci)
-      {
+  {
+    for (std::vector<cmCustomCommand>::const_iterator ci = ccs.begin();
+         ci != ccs.end(); ++ci) {
       this->Write(*ci);
-      }
     }
+  }
   void Write(cmCustomCommand const& cc)
-    {
+  {
     cmCustomCommandGenerator ccg(cc, this->Config, this->LG);
-    if(this->First)
-      {
+    if (this->First) {
       const char* comment = ccg.GetComment();
-      if(comment && *comment)
-        {
-        this->Stream << "\nDescription=\""
-                     << this->LG->EscapeForXML(comment) << "\"";
-        }
+      if (comment && *comment) {
+        this->Stream << "\nDescription=\"" << this->LG->EscapeForXML(comment)
+                     << "\"";
+      }
       this->Stream << "\nCommandLine=\"";
       this->First = false;
-      }
-    else
-      {
+    } else {
       this->Stream << this->LG->EscapeForXML("\n");
-      }
+    }
     std::string script = this->LG->ConstructScript(ccg);
     this->Stream << this->LG->EscapeForXML(script.c_str());
-    }
+  }
+
 private:
   cmLocalVisualStudio7Generator* LG;
   std::string Config;
@@ -641,21 +600,19 @@ private:
   bool First;
 };
 
-void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
-                                                const std::string& configName,
-                                                const std::string& libName,
-                                                cmGeneratorTarget *target)
+void cmLocalVisualStudio7Generator::WriteConfiguration(
+  std::ostream& fout, const std::string& configName,
+  const std::string& libName, cmGeneratorTarget* target)
 {
   const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
-  if(!mfcFlag)
-    {
+  if (!mfcFlag) {
     mfcFlag = "0";
-    }
+  }
   cmGlobalVisualStudio7Generator* gg =
     static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
   fout << "\t\t<Configuration\n"
-       << "\t\t\tName=\"" << configName
-       << "|" << gg->GetPlatformName() << "\"\n";
+       << "\t\t\tName=\"" << configName << "|" << gg->GetPlatformName()
+       << "\"\n";
   // This is an internal type to Visual Studio, it seems that:
   // 4 == static library
   // 2 == dll
@@ -665,8 +622,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   const char* projectType = 0;
   bool targetBuilds = true;
 
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::OBJECT_LIBRARY:
       targetBuilds = false; // no manifest tool for object library
     case cmState::STATIC_LIBRARY:
@@ -687,72 +643,66 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
     default:
       targetBuilds = false;
       break;
-    }
-  if(this->FortranProject && projectType)
-    {
+  }
+  if (this->FortranProject && projectType) {
     configType = projectType;
-    }
+  }
   std::string flags;
-  if(strcmp(configType, "10") != 0)
-    {
-    const std::string& linkLanguage = (this->FortranProject?
-                                       std::string("Fortran"):
-                                target->GetLinkerLanguage(configName));
-    if(linkLanguage.empty())
-      {
-      cmSystemTools::Error
-        ("CMake can not determine linker language for target: ",
-         target->GetName().c_str());
+  if (strcmp(configType, "10") != 0) {
+    const std::string& linkLanguage =
+      (this->FortranProject ? std::string("Fortran")
+                            : target->GetLinkerLanguage(configName));
+    if (linkLanguage.empty()) {
+      cmSystemTools::Error(
+        "CMake can not determine linker language for target: ",
+        target->GetName().c_str());
       return;
-      }
-    if(linkLanguage == "C" || linkLanguage == "CXX"
-      || linkLanguage == "Fortran")
-      {
+    }
+    if (linkLanguage == "C" || linkLanguage == "CXX" ||
+        linkLanguage == "Fortran") {
       std::string baseFlagVar = "CMAKE_";
       baseFlagVar += linkLanguage;
       baseFlagVar += "_FLAGS";
       flags = this->Makefile->GetRequiredDefinition(baseFlagVar.c_str());
-      std::string flagVar = baseFlagVar + std::string("_") +
-        cmSystemTools::UpperCase(configName);
+      std::string flagVar =
+        baseFlagVar + std::string("_") + cmSystemTools::UpperCase(configName);
       flags += " ";
       flags += this->Makefile->GetRequiredDefinition(flagVar.c_str());
-      }
+    }
     // set the correct language
-    if(linkLanguage == "C")
-      {
+    if (linkLanguage == "C") {
       flags += " /TC ";
-      }
-    if(linkLanguage == "CXX")
-      {
+    }
+    if (linkLanguage == "CXX") {
       flags += " /TP ";
-      }
+    }
 
     // Add the target-specific flags.
     this->AddCompileOptions(flags, target, linkLanguage, configName);
-    }
+  }
 
-  if(this->FortranProject)
-    {
-    switch(this->GetFortranFormat(target->GetProperty("Fortran_FORMAT")))
-      {
-      case FortranFormatFixed: flags += " -fixed"; break;
-      case FortranFormatFree: flags += " -free"; break;
-      default: break;
-      }
+  if (this->FortranProject) {
+    switch (this->GetFortranFormat(target->GetProperty("Fortran_FORMAT"))) {
+      case FortranFormatFixed:
+        flags += " -fixed";
+        break;
+      case FortranFormatFree:
+        flags += " -free";
+        break;
+      default:
+        break;
     }
+  }
 
   // Get preprocessor definitions for this directory.
   std::string defineFlags = this->Makefile->GetDefineFlags();
   Options::Tool t = Options::Compiler;
   cmVS7FlagTable const* table = cmLocalVisualStudio7GeneratorFlagTable;
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     t = Options::FortranCompiler;
     table = cmLocalVisualStudio7GeneratorFortranFlagTable;
-    }
-  Options targetOptions(this, t,
-                        table,
-                        gg->ExtraFlagTable);
+  }
+  Options targetOptions(this, t, table, gg->ExtraFlagTable);
   targetOptions.FixExceptionHandlingDefault();
   std::string asmLocation = configName + "/";
   targetOptions.AddFlag("AssemblerListingLocation", asmLocation.c_str());
@@ -772,10 +722,9 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   targetOptions.AddDefine(configDefine);
 
   // Add the export symbol definition for shared library objects.
-  if(const char* exportMacro = target->GetExportMacro())
-    {
+  if (const char* exportMacro = target->GetExportMacro()) {
     targetOptions.AddDefine(exportMacro);
-    }
+  }
 
   // The intermediate directory name consists of a directory for the
   // target and a subdirectory for the configuration name.
@@ -783,16 +732,15 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   intermediateDir += "/";
   intermediateDir += configName;
 
-  if (target->GetType() < cmState::UTILITY)
-    {
-    std::string const& outDir =
-      target->GetType() == cmState::OBJECT_LIBRARY?
-      intermediateDir : target->GetDirectory(configName);
+  if (target->GetType() < cmState::UTILITY) {
+    std::string const& outDir = target->GetType() == cmState::OBJECT_LIBRARY
+      ? intermediateDir
+      : target->GetDirectory(configName);
     /* clang-format off */
     fout << "\t\t\tOutputDirectory=\""
          << this->ConvertToXMLOutputPathSingle(outDir.c_str()) << "\"\n";
     /* clang-format on */
-    }
+  }
 
   /* clang-format off */
   fout << "\t\t\tIntermediateDirectory=\""
@@ -803,8 +751,7 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
        << "\t\t\tATLMinimizesCRunTimeLibraryUsage=\"false\"\n";
   /* clang-format on */
 
-  if (this->FortranProject)
-    {
+  if (this->FortranProject) {
     // Intel Fortran >= 15.0 uses TargetName property.
     std::string targetNameFull = target->GetFullName(configName);
     std::string targetName =
@@ -817,86 +764,69 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
       "\t\t\tTargetExt=\"" << this->EscapeForXML(targetExt) << "\"\n"
       ;
     /* clang-format on */
-    }
+  }
 
   // If unicode is enabled change the character set to unicode, if not
   // then default to MBCS.
-  if(targetOptions.UsingUnicode())
-    {
+  if (targetOptions.UsingUnicode()) {
     fout << "\t\t\tCharacterSet=\"1\">\n";
-    }
-  else if(targetOptions.UsingSBCS())
-    {
+  } else if (targetOptions.UsingSBCS()) {
     fout << "\t\t\tCharacterSet=\"0\">\n";
-    }
-  else
-    {
+  } else {
     fout << "\t\t\tCharacterSet=\"2\">\n";
-    }
+  }
   const char* tool = "VCCLCompilerTool";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     tool = "VFFortranCompilerTool";
-    }
+  }
   fout << "\t\t\t<Tool\n"
        << "\t\t\t\tName=\"" << tool << "\"\n";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     const char* target_mod_dir =
       target->GetProperty("Fortran_MODULE_DIRECTORY");
     std::string modDir;
-    if(target_mod_dir)
-      {
-      modDir = this->Convert(target_mod_dir,
-                             cmLocalGenerator::START_OUTPUT,
+    if (target_mod_dir) {
+      modDir = this->Convert(target_mod_dir, cmLocalGenerator::START_OUTPUT,
                              cmLocalGenerator::UNCHANGED);
-      }
-    else
-      {
+    } else {
       modDir = ".";
-      }
+    }
     fout << "\t\t\t\tModulePath=\""
          << this->ConvertToXMLOutputPath(modDir.c_str())
          << "\\$(ConfigurationName)\"\n";
-    }
+  }
   targetOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
   fout << "\t\t\t\tAdditionalIncludeDirectories=\"";
   std::vector<std::string> includes;
   this->GetIncludeDirectories(includes, target, "C", configName);
   std::vector<std::string>::iterator i = includes.begin();
-  for(;i != includes.end(); ++i)
-    {
+  for (; i != includes.end(); ++i) {
     // output the include path
     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
     fout << ipath << ";";
     // if this is fortran then output the include with
     // a ConfigurationName on the end of it.
-    if(this->FortranProject)
-      {
+    if (this->FortranProject) {
       ipath = i->c_str();
       ipath += "/$(ConfigurationName)";
       ipath = this->ConvertToXMLOutputPath(ipath.c_str());
       fout << ipath << ";";
-      }
     }
+  }
   fout << "\"\n";
   targetOptions.OutputFlagMap(fout, "\t\t\t\t");
   targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n", "CXX");
   fout << "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n";
-  if(target->GetType() <= cmState::OBJECT_LIBRARY)
-    {
+  if (target->GetType() <= cmState::OBJECT_LIBRARY) {
     // Specify the compiler program database file if configured.
     std::string pdb = target->GetCompilePDBPath(configName);
-    if(!pdb.empty())
-      {
-      fout <<  "\t\t\t\tProgramDataBaseFileName=\""
-           << this->ConvertToXMLOutputPathSingle(pdb.c_str())
-           << "\"\n";
-      }
+    if (!pdb.empty()) {
+      fout << "\t\t\t\tProgramDataBaseFileName=\""
+           << this->ConvertToXMLOutputPathSingle(pdb.c_str()) << "\"\n";
     }
-  fout << "/>\n";  // end of <Tool Name=VCCLCompilerTool
-  if(gg->IsMasmEnabled() && !this->FortranProject)
-    {
+  }
+  fout << "/>\n"; // end of <Tool Name=VCCLCompilerTool
+  if (gg->IsMasmEnabled() && !this->FortranProject) {
     Options masmOptions(this, Options::MasmCompiler, 0, 0);
     /* clang-format off */
     fout <<
@@ -906,13 +836,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
       ;
     /* clang-format on */
     const char* sep = "";
-    for(i = includes.begin(); i != includes.end(); ++i)
-      {
+    for (i = includes.begin(); i != includes.end(); ++i) {
       std::string inc = *i;
       cmConvertToWindowsSlash(inc);
       fout << sep << this->EscapeForXML(inc);
       sep = ";";
-      }
+    }
     fout << "\"\n";
     // Use same preprocessor definitions as VCCLCompilerTool.
     targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n",
@@ -923,55 +852,45 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
       "\t\t\t\tObjectFile=\"$(IntDir)\\\"\n"
       "\t\t\t/>\n";
     /* clang-format on */
-    }
+  }
   tool = "VCCustomBuildTool";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     tool = "VFCustomBuildTool";
-    }
+  }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"/>\n";
   tool = "VCResourceCompilerTool";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     tool = "VFResourceCompilerTool";
-    }
+  }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n"
        << "\t\t\t\tAdditionalIncludeDirectories=\"";
-  for(i = includes.begin();i != includes.end(); ++i)
-    {
+  for (i = includes.begin(); i != includes.end(); ++i) {
     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
     fout << ipath << ";";
-    }
+  }
   // add the -D flags to the RC tool
   fout << "\"";
   targetOptions.OutputPreprocessorDefinitions(fout, "\n\t\t\t\t", "", "RC");
   fout << "/>\n";
   tool = "VCMIDLTool";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     tool = "VFMIDLTool";
-    }
+  }
   fout << "\t\t\t<Tool\n\t\t\t\tName=\"" << tool << "\"\n";
   fout << "\t\t\t\tAdditionalIncludeDirectories=\"";
-  for(i = includes.begin(); i != includes.end(); ++i)
-    {
+  for (i = includes.begin(); i != includes.end(); ++i) {
     std::string ipath = this->ConvertToXMLOutputPath(i->c_str());
     fout << ipath << ";";
-    }
+  }
   fout << "\"\n";
   fout << "\t\t\t\tMkTypLibCompatible=\"false\"\n";
-  if( gg->GetPlatformName() == "x64" )
-    {
+  if (gg->GetPlatformName() == "x64") {
     fout << "\t\t\t\tTargetEnvironment=\"3\"\n";
-    }
-  else if( gg->GetPlatformName() == "ia64" )
-    {
+  } else if (gg->GetPlatformName() == "ia64") {
     fout << "\t\t\t\tTargetEnvironment=\"2\"\n";
-    }
-  else
-    {
+  } else {
     fout << "\t\t\t\tTargetEnvironment=\"1\"\n";
-    }
+  }
   fout << "\t\t\t\tGenerateStublessProxies=\"true\"\n";
   fout << "\t\t\t\tTypeLibraryName=\"$(InputName).tlb\"\n";
   fout << "\t\t\t\tOutputDirectory=\"$(IntDir)\"\n";
@@ -982,13 +901,12 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   // end of <Tool Name=VCMIDLTool
 
   // Add manifest tool settings.
-  if(targetBuilds && this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8)
-    {
-    const char* manifestTool  = "VCManifestTool";
-    if (this->FortranProject)
-      {
+  if (targetBuilds &&
+      this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8) {
+    const char* manifestTool = "VCManifestTool";
+    if (this->FortranProject) {
       manifestTool = "VFManifestTool";
-      }
+    }
     /* clang-format off */
     fout <<
       "\t\t\t<Tool\n"
@@ -997,30 +915,28 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
 
     std::vector<cmSourceFile const*> manifest_srcs;
     target->GetManifests(manifest_srcs, configName);
-    if (!manifest_srcs.empty())
-      {
+    if (!manifest_srcs.empty()) {
       fout << "\n\t\t\t\tAdditionalManifestFiles=\"";
-      for (std::vector<cmSourceFile const*>::const_iterator
-             mi = manifest_srcs.begin(); mi != manifest_srcs.end(); ++mi)
-        {
+      for (std::vector<cmSourceFile const*>::const_iterator mi =
+             manifest_srcs.begin();
+           mi != manifest_srcs.end(); ++mi) {
         std::string m = (*mi)->GetFullPath();
         fout << this->ConvertToXMLOutputPath(m.c_str()) << ";";
-        }
-      fout << "\"";
       }
+      fout << "\"";
+    }
 
     // Check if we need the FAT32 workaround.
     // Check the filesystem type where the target will be written.
-    if (cmLVS7G_IsFAT(target->GetDirectory(configName).c_str()))
-      {
+    if (cmLVS7G_IsFAT(target->GetDirectory(configName).c_str())) {
       // Add a flag telling the manifest tool to use a workaround
       // for FAT32 file systems, which can cause an empty manifest
       // to be embedded into the resulting executable.  See CMake
       // bug #2617.
       fout << "\n\t\t\t\tUseFAT32Workaround=\"true\"";
-      }
-    fout << "/>\n";
     }
+    fout << "/>\n";
+  }
 
   this->OutputTargetRules(fout, configName, target, libName);
   this->OutputBuildTool(fout, configName, target, targetOptions);
@@ -1028,96 +944,83 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
   fout << "\t\t</Configuration>\n";
 }
 
-std::string
-cmLocalVisualStudio7Generator
-::GetBuildTypeLinkerFlags(std::string rootLinkerFlags,
-                          const std::string& configName)
+std::string cmLocalVisualStudio7Generator::GetBuildTypeLinkerFlags(
+  std::string rootLinkerFlags, const std::string& configName)
 {
   std::string configTypeUpper = cmSystemTools::UpperCase(configName);
   std::string extraLinkOptionsBuildTypeDef =
     rootLinkerFlags + "_" + configTypeUpper;
 
   std::string extraLinkOptionsBuildType =
-    this->Makefile->GetRequiredDefinition
-    (extraLinkOptionsBuildTypeDef.c_str());
+    this->Makefile->GetRequiredDefinition(
+      extraLinkOptionsBuildTypeDef.c_str());
 
   return extraLinkOptionsBuildType;
 }
 
-void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
-  const std::string& configName, cmGeneratorTarget* target,
+void cmLocalVisualStudio7Generator::OutputBuildTool(
+  std::ostream& fout, const std::string& configName, cmGeneratorTarget* target,
   const Options& targetOptions)
 {
   cmGlobalVisualStudio7Generator* gg =
     static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
   std::string temp;
   std::string extraLinkOptions;
-  if(target->GetType() == cmState::EXECUTABLE)
-    {
+  if (target->GetType() == cmState::EXECUTABLE) {
     extraLinkOptions =
-      this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS")
-      + std::string(" ")
-      + GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName);
-    }
-  if(target->GetType() == cmState::SHARED_LIBRARY)
-    {
+      this->Makefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS") +
+      std::string(" ") +
+      GetBuildTypeLinkerFlags("CMAKE_EXE_LINKER_FLAGS", configName);
+  }
+  if (target->GetType() == cmState::SHARED_LIBRARY) {
     extraLinkOptions =
-      this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS")
-      + std::string(" ")
-      + GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName);
-    }
-  if(target->GetType() == cmState::MODULE_LIBRARY)
-    {
+      this->Makefile->GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS") +
+      std::string(" ") +
+      GetBuildTypeLinkerFlags("CMAKE_SHARED_LINKER_FLAGS", configName);
+  }
+  if (target->GetType() == cmState::MODULE_LIBRARY) {
     extraLinkOptions =
-      this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS")
-      + std::string(" ")
-      + GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName);
-    }
+      this->Makefile->GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS") +
+      std::string(" ") +
+      GetBuildTypeLinkerFlags("CMAKE_MODULE_LINKER_FLAGS", configName);
+  }
 
   const char* targetLinkFlags = target->GetProperty("LINK_FLAGS");
-  if(targetLinkFlags)
-    {
+  if (targetLinkFlags) {
     extraLinkOptions += " ";
     extraLinkOptions += targetLinkFlags;
-    }
+  }
   std::string configTypeUpper = cmSystemTools::UpperCase(configName);
   std::string linkFlagsConfig = "LINK_FLAGS_";
   linkFlagsConfig += configTypeUpper;
   targetLinkFlags = target->GetProperty(linkFlagsConfig.c_str());
-  if(targetLinkFlags)
-    {
+  if (targetLinkFlags) {
     extraLinkOptions += " ";
     extraLinkOptions += targetLinkFlags;
-    }
+  }
   Options linkOptions(this, Options::Linker);
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     linkOptions.AddTable(cmLocalVisualStudio7GeneratorFortranLinkFlagTable);
-    }
+  }
   linkOptions.AddTable(cmLocalVisualStudio7GeneratorLinkFlagTable);
 
   linkOptions.Parse(extraLinkOptions.c_str());
-  if(!this->ModuleDefinitionFile.empty())
-    {
+  if (!this->ModuleDefinitionFile.empty()) {
     std::string defFile =
       this->ConvertToOutputFormat(this->ModuleDefinitionFile, SHELL);
     linkOptions.AddFlag("ModuleDefinitionFile", defFile.c_str());
-    }
+  }
 
   if (target->GetType() == cmState::SHARED_LIBRARY &&
-      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
-    {
-    if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
+      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) {
+    if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) {
       linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)/exportall.def");
-      }
     }
-  switch(target->GetType())
-    {
+  }
+  switch (target->GetType()) {
     case cmState::UNKNOWN_LIBRARY:
       break;
-    case cmState::OBJECT_LIBRARY:
-      {
+    case cmState::OBJECT_LIBRARY: {
       std::string libpath = this->GetTargetDirectory(target);
       libpath += "/";
       libpath += configName;
@@ -1125,274 +1028,237 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(std::ostream& fout,
       libpath += target->GetName();
       libpath += ".lib";
       const char* tool =
-        this->FortranProject? "VFLibrarianTool":"VCLibrarianTool";
+        this->FortranProject ? "VFLibrarianTool" : "VCLibrarianTool";
       fout << "\t\t\t<Tool\n"
            << "\t\t\t\tName=\"" << tool << "\"\n";
       fout << "\t\t\t\tOutputFile=\""
            << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n";
       break;
-      }
-    case cmState::STATIC_LIBRARY:
-    {
-    std::string targetNameFull = target->GetFullName(configName);
-    std::string libpath = target->GetDirectory(configName);
-    libpath += "/";
-    libpath += targetNameFull;
-    const char* tool = "VCLibrarianTool";
-    if(this->FortranProject)
-      {
-      tool = "VFLibrarianTool";
-      }
-    fout << "\t\t\t<Tool\n"
-         << "\t\t\t\tName=\"" << tool << "\"\n";
-
-    if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
-        || this->FortranProject)
-      {
-      std::ostringstream libdeps;
-      this->Internal->OutputObjects(libdeps, target);
-      if(!libdeps.str().empty())
-        {
-        fout << "\t\t\t\tAdditionalDependencies=\"" << libdeps.str() << "\"\n";
-        }
-      }
-    std::string libflags;
-    this->GetStaticLibraryFlags(libflags, configTypeUpper, target);
-    if(!libflags.empty())
-      {
-      fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n";
-      }
-    fout << "\t\t\t\tOutputFile=\""
-         << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n";
-    break;
     }
-    case cmState::SHARED_LIBRARY:
-    case cmState::MODULE_LIBRARY:
-    {
-    std::string targetName;
-    std::string targetNameSO;
-    std::string targetNameFull;
-    std::string targetNameImport;
-    std::string targetNamePDB;
-    target->GetLibraryNames(targetName, targetNameSO, targetNameFull,
-                           targetNameImport, targetNamePDB, configName);
-
-    // Compute the link library and directory information.
-    cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
-    if(!pcli)
-      {
-      return;
-      }
-    cmComputeLinkInformation& cli = *pcli;
-    std::string linkLanguage = cli.GetLinkLanguage();
-
-    // Compute the variable name to lookup standard libraries for this
-    // language.
-    std::string standardLibsVar = "CMAKE_";
-    standardLibsVar += linkLanguage;
-    standardLibsVar += "_STANDARD_LIBRARIES";
-    const char* tool = "VCLinkerTool";
-    if(this->FortranProject)
-      {
-      tool = "VFLinkerTool";
-      }
-    fout << "\t\t\t<Tool\n"
-         << "\t\t\t\tName=\"" << tool << "\"\n";
-    if(!gg->NeedLinkLibraryDependencies(target))
-      {
-      fout << "\t\t\t\tLinkLibraryDependencies=\"false\"\n";
-      }
-    linkOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
-    // Use the NOINHERIT macro to avoid getting VS project default
-    // libraries which may be set by the user to something bad.
-    fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
-         << this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
-    if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
-        || this->FortranProject)
-      {
-      this->Internal->OutputObjects(fout, target, " ");
-      }
-    fout << " ";
-    this->Internal->OutputLibraries(fout, cli.GetItems());
-    fout << "\"\n";
-    temp = target->GetDirectory(configName);
-    temp += "/";
-    temp += targetNameFull;
-    fout << "\t\t\t\tOutputFile=\""
-         << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
-    this->WriteTargetVersionAttribute(fout, target);
-    linkOptions.OutputFlagMap(fout, "\t\t\t\t");
-    fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
-    this->OutputLibraryDirectories(fout, cli.GetDirectories());
-    fout << "\"\n";
-    temp = target->GetPDBDirectory(configName);
-    temp += "/";
-    temp += targetNamePDB;
-    fout << "\t\t\t\tProgramDatabaseFile=\"" <<
-      this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
-    if(targetOptions.IsDebug())
-      {
-      fout << "\t\t\t\tGenerateDebugInformation=\"true\"\n";
+    case cmState::STATIC_LIBRARY: {
+      std::string targetNameFull = target->GetFullName(configName);
+      std::string libpath = target->GetDirectory(configName);
+      libpath += "/";
+      libpath += targetNameFull;
+      const char* tool = "VCLibrarianTool";
+      if (this->FortranProject) {
+        tool = "VFLibrarianTool";
       }
-    if(this->WindowsCEProject)
-      {
-      if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS9)
-        {
-        fout << "\t\t\t\tSubSystem=\"9\"\n";
-        }
-      else
-        {
-        fout << "\t\t\t\tSubSystem=\"8\"\n";
+      fout << "\t\t\t<Tool\n"
+           << "\t\t\t\tName=\"" << tool << "\"\n";
+
+      if (this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 ||
+          this->FortranProject) {
+        std::ostringstream libdeps;
+        this->Internal->OutputObjects(libdeps, target);
+        if (!libdeps.str().empty()) {
+          fout << "\t\t\t\tAdditionalDependencies=\"" << libdeps.str()
+               << "\"\n";
         }
       }
-    std::string stackVar = "CMAKE_";
-    stackVar += linkLanguage;
-    stackVar += "_STACK_SIZE";
-    const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
-    if(stackVal)
-      {
-      fout << "\t\t\t\tStackReserveSize=\"" << stackVal  << "\"\n";
+      std::string libflags;
+      this->GetStaticLibraryFlags(libflags, configTypeUpper, target);
+      if (!libflags.empty()) {
+        fout << "\t\t\t\tAdditionalOptions=\"" << libflags << "\"\n";
       }
-    temp = target->GetDirectory(configName, true);
-    temp += "/";
-    temp += targetNameImport;
-    fout << "\t\t\t\tImportLibrary=\""
-         << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"";
-    if(this->FortranProject)
-      {
-      fout << "\n\t\t\t\tLinkDLL=\"true\"";
-      }
-    fout << "/>\n";
+      fout << "\t\t\t\tOutputFile=\""
+           << this->ConvertToXMLOutputPathSingle(libpath.c_str()) << "\"/>\n";
+      break;
     }
-    break;
-    case cmState::EXECUTABLE:
-    {
-    std::string targetName;
-    std::string targetNameFull;
-    std::string targetNameImport;
-    std::string targetNamePDB;
-    target->GetExecutableNames(targetName, targetNameFull,
+    case cmState::SHARED_LIBRARY:
+    case cmState::MODULE_LIBRARY: {
+      std::string targetName;
+      std::string targetNameSO;
+      std::string targetNameFull;
+      std::string targetNameImport;
+      std::string targetNamePDB;
+      target->GetLibraryNames(targetName, targetNameSO, targetNameFull,
                               targetNameImport, targetNamePDB, configName);
 
-    // Compute the link library and directory information.
-    cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
-    if(!pcli)
-      {
-      return;
+      // Compute the link library and directory information.
+      cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
+      if (!pcli) {
+        return;
       }
-    cmComputeLinkInformation& cli = *pcli;
-    std::string linkLanguage = cli.GetLinkLanguage();
-
-    bool isWin32Executable = target->GetPropertyAsBool("WIN32_EXECUTABLE");
-
-    // Compute the variable name to lookup standard libraries for this
-    // language.
-    std::string standardLibsVar = "CMAKE_";
-    standardLibsVar += linkLanguage;
-    standardLibsVar += "_STANDARD_LIBRARIES";
-    const char* tool = "VCLinkerTool";
-    if(this->FortranProject)
-      {
-      tool = "VFLinkerTool";
+      cmComputeLinkInformation& cli = *pcli;
+      std::string linkLanguage = cli.GetLinkLanguage();
+
+      // Compute the variable name to lookup standard libraries for this
+      // language.
+      std::string standardLibsVar = "CMAKE_";
+      standardLibsVar += linkLanguage;
+      standardLibsVar += "_STANDARD_LIBRARIES";
+      const char* tool = "VCLinkerTool";
+      if (this->FortranProject) {
+        tool = "VFLinkerTool";
       }
-    fout << "\t\t\t<Tool\n"
-         << "\t\t\t\tName=\"" << tool << "\"\n";
-    if(!gg->NeedLinkLibraryDependencies(target))
-      {
-      fout << "\t\t\t\tLinkLibraryDependencies=\"false\"\n";
+      fout << "\t\t\t<Tool\n"
+           << "\t\t\t\tName=\"" << tool << "\"\n";
+      if (!gg->NeedLinkLibraryDependencies(target)) {
+        fout << "\t\t\t\tLinkLibraryDependencies=\"false\"\n";
+      }
+      linkOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
+      // Use the NOINHERIT macro to avoid getting VS project default
+      // libraries which may be set by the user to something bad.
+      fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
+           << this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
+      if (this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 ||
+          this->FortranProject) {
+        this->Internal->OutputObjects(fout, target, " ");
+      }
+      fout << " ";
+      this->Internal->OutputLibraries(fout, cli.GetItems());
+      fout << "\"\n";
+      temp = target->GetDirectory(configName);
+      temp += "/";
+      temp += targetNameFull;
+      fout << "\t\t\t\tOutputFile=\""
+           << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
+      this->WriteTargetVersionAttribute(fout, target);
+      linkOptions.OutputFlagMap(fout, "\t\t\t\t");
+      fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
+      this->OutputLibraryDirectories(fout, cli.GetDirectories());
+      fout << "\"\n";
+      temp = target->GetPDBDirectory(configName);
+      temp += "/";
+      temp += targetNamePDB;
+      fout << "\t\t\t\tProgramDatabaseFile=\""
+           << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
+      if (targetOptions.IsDebug()) {
+        fout << "\t\t\t\tGenerateDebugInformation=\"true\"\n";
+      }
+      if (this->WindowsCEProject) {
+        if (this->GetVersion() < cmGlobalVisualStudioGenerator::VS9) {
+          fout << "\t\t\t\tSubSystem=\"9\"\n";
+        } else {
+          fout << "\t\t\t\tSubSystem=\"8\"\n";
+        }
       }
-    linkOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
-    // Use the NOINHERIT macro to avoid getting VS project default
-    // libraries which may be set by the user to something bad.
-    fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
-         << this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
-    if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS8
-        || this->FortranProject)
-      {
-      this->Internal->OutputObjects(fout, target, " ");
+      std::string stackVar = "CMAKE_";
+      stackVar += linkLanguage;
+      stackVar += "_STACK_SIZE";
+      const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
+      if (stackVal) {
+        fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"\n";
+      }
+      temp = target->GetDirectory(configName, true);
+      temp += "/";
+      temp += targetNameImport;
+      fout << "\t\t\t\tImportLibrary=\""
+           << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"";
+      if (this->FortranProject) {
+        fout << "\n\t\t\t\tLinkDLL=\"true\"";
+      }
+      fout << "/>\n";
+    } break;
+    case cmState::EXECUTABLE: {
+      std::string targetName;
+      std::string targetNameFull;
+      std::string targetNameImport;
+      std::string targetNamePDB;
+      target->GetExecutableNames(targetName, targetNameFull, targetNameImport,
+                                 targetNamePDB, configName);
+
+      // Compute the link library and directory information.
+      cmComputeLinkInformation* pcli = target->GetLinkInformation(configName);
+      if (!pcli) {
+        return;
       }
-    fout << " ";
-    this->Internal->OutputLibraries(fout, cli.GetItems());
-    fout << "\"\n";
-    temp = target->GetDirectory(configName);
-    temp += "/";
-    temp += targetNameFull;
-    fout << "\t\t\t\tOutputFile=\""
-         << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
-    this->WriteTargetVersionAttribute(fout, target);
-    linkOptions.OutputFlagMap(fout, "\t\t\t\t");
-    fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
-    this->OutputLibraryDirectories(fout, cli.GetDirectories());
-    fout << "\"\n";
-    std::string path = this->ConvertToXMLOutputPathSingle(
-      target->GetPDBDirectory(configName).c_str());
-    fout << "\t\t\t\tProgramDatabaseFile=\""
-         << path << "/" << targetNamePDB
-         << "\"\n";
-    if(targetOptions.IsDebug())
-      {
-      fout << "\t\t\t\tGenerateDebugInformation=\"true\"\n";
+      cmComputeLinkInformation& cli = *pcli;
+      std::string linkLanguage = cli.GetLinkLanguage();
+
+      bool isWin32Executable = target->GetPropertyAsBool("WIN32_EXECUTABLE");
+
+      // Compute the variable name to lookup standard libraries for this
+      // language.
+      std::string standardLibsVar = "CMAKE_";
+      standardLibsVar += linkLanguage;
+      standardLibsVar += "_STANDARD_LIBRARIES";
+      const char* tool = "VCLinkerTool";
+      if (this->FortranProject) {
+        tool = "VFLinkerTool";
       }
-    if ( this->WindowsCEProject )
-      {
-      if(this->GetVersion() < cmGlobalVisualStudioGenerator::VS9)
-        {
-        fout << "\t\t\t\tSubSystem=\"9\"\n";
-        }
-      else
-        {
-        fout << "\t\t\t\tSubSystem=\"8\"\n";
+      fout << "\t\t\t<Tool\n"
+           << "\t\t\t\tName=\"" << tool << "\"\n";
+      if (!gg->NeedLinkLibraryDependencies(target)) {
+        fout << "\t\t\t\tLinkLibraryDependencies=\"false\"\n";
+      }
+      linkOptions.OutputAdditionalOptions(fout, "\t\t\t\t", "\n");
+      // Use the NOINHERIT macro to avoid getting VS project default
+      // libraries which may be set by the user to something bad.
+      fout << "\t\t\t\tAdditionalDependencies=\"$(NOINHERIT) "
+           << this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
+      if (this->GetVersion() < cmGlobalVisualStudioGenerator::VS8 ||
+          this->FortranProject) {
+        this->Internal->OutputObjects(fout, target, " ");
+      }
+      fout << " ";
+      this->Internal->OutputLibraries(fout, cli.GetItems());
+      fout << "\"\n";
+      temp = target->GetDirectory(configName);
+      temp += "/";
+      temp += targetNameFull;
+      fout << "\t\t\t\tOutputFile=\""
+           << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"\n";
+      this->WriteTargetVersionAttribute(fout, target);
+      linkOptions.OutputFlagMap(fout, "\t\t\t\t");
+      fout << "\t\t\t\tAdditionalLibraryDirectories=\"";
+      this->OutputLibraryDirectories(fout, cli.GetDirectories());
+      fout << "\"\n";
+      std::string path = this->ConvertToXMLOutputPathSingle(
+        target->GetPDBDirectory(configName).c_str());
+      fout << "\t\t\t\tProgramDatabaseFile=\"" << path << "/" << targetNamePDB
+           << "\"\n";
+      if (targetOptions.IsDebug()) {
+        fout << "\t\t\t\tGenerateDebugInformation=\"true\"\n";
+      }
+      if (this->WindowsCEProject) {
+        if (this->GetVersion() < cmGlobalVisualStudioGenerator::VS9) {
+          fout << "\t\t\t\tSubSystem=\"9\"\n";
+        } else {
+          fout << "\t\t\t\tSubSystem=\"8\"\n";
         }
 
-      if(!linkOptions.GetFlag("EntryPointSymbol"))
-        {
-        const char* entryPointSymbol = targetOptions.UsingUnicode() ?
-          (isWin32Executable ? "wWinMainCRTStartup" : "mainWCRTStartup") :
-          (isWin32Executable ? "WinMainCRTStartup" : "mainACRTStartup");
-        fout << "\t\t\t\tEntryPointSymbol=\"" << entryPointSymbol << "\"\n";
+        if (!linkOptions.GetFlag("EntryPointSymbol")) {
+          const char* entryPointSymbol = targetOptions.UsingUnicode()
+            ? (isWin32Executable ? "wWinMainCRTStartup" : "mainWCRTStartup")
+            : (isWin32Executable ? "WinMainCRTStartup" : "mainACRTStartup");
+          fout << "\t\t\t\tEntryPointSymbol=\"" << entryPointSymbol << "\"\n";
         }
-      }
-    else if ( this->FortranProject )
-      {
-      fout << "\t\t\t\tSubSystem=\""
-           << (isWin32Executable ? "subSystemWindows" : "subSystemConsole")
-           << "\"\n";
-      }
-    else
-      {
-      fout << "\t\t\t\tSubSystem=\""
-           << (isWin32Executable ? "2" : "1")
-           << "\"\n";
-      }
-    std::string stackVar = "CMAKE_";
-    stackVar += linkLanguage;
-    stackVar += "_STACK_SIZE";
-    const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
-    if(stackVal)
-      {
-      fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"";
-      }
-    temp = target->GetDirectory(configName, true);
-    temp += "/";
-    temp += targetNameImport;
-    fout << "\t\t\t\tImportLibrary=\""
-         << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"/>\n";
-    break;
+      } else if (this->FortranProject) {
+        fout << "\t\t\t\tSubSystem=\""
+             << (isWin32Executable ? "subSystemWindows" : "subSystemConsole")
+             << "\"\n";
+      } else {
+        fout << "\t\t\t\tSubSystem=\"" << (isWin32Executable ? "2" : "1")
+             << "\"\n";
+      }
+      std::string stackVar = "CMAKE_";
+      stackVar += linkLanguage;
+      stackVar += "_STACK_SIZE";
+      const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str());
+      if (stackVal) {
+        fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"";
+      }
+      temp = target->GetDirectory(configName, true);
+      temp += "/";
+      temp += targetNameImport;
+      fout << "\t\t\t\tImportLibrary=\""
+           << this->ConvertToXMLOutputPathSingle(temp.c_str()) << "\"/>\n";
+      break;
     }
     case cmState::UTILITY:
     case cmState::GLOBAL_TARGET:
     case cmState::INTERFACE_LIBRARY:
       break;
-    }
+  }
 }
 
 void cmLocalVisualStudio7Generator::OutputDeploymentDebuggerTool(
   std::ostream& fout, std::string const& config, cmGeneratorTarget* target)
 {
-  if (this->WindowsCEProject)
-    {
-    if (const char* dir = target->GetProperty("DEPLOYMENT_REMOTE_DIRECTORY"))
-      {
+  if (this->WindowsCEProject) {
+    if (const char* dir = target->GetProperty("DEPLOYMENT_REMOTE_DIRECTORY")) {
       /* clang-format off */
       fout <<
         "\t\t\t<DeploymentTool\n"
@@ -1412,13 +1278,12 @@ void cmLocalVisualStudio7Generator::OutputDeploymentDebuggerTool(
         "\t\t\t/>\n"
         ;
       /* clang-format on */
-      }
     }
+  }
 }
 
-void
-cmLocalVisualStudio7Generator
-::WriteTargetVersionAttribute(std::ostream& fout, cmGeneratorTarget* gt)
+void cmLocalVisualStudio7Generator::WriteTargetVersionAttribute(
+  std::ostream& fout, cmGeneratorTarget* gt)
 {
   int major;
   int minor;
@@ -1426,86 +1291,72 @@ cmLocalVisualStudio7Generator
   fout << "\t\t\t\tVersion=\"" << major << "." << minor << "\"\n";
 }
 
-void
-cmLocalVisualStudio7GeneratorInternals
-::OutputLibraries(std::ostream& fout, ItemVector const& libs)
+void cmLocalVisualStudio7GeneratorInternals::OutputLibraries(
+  std::ostream& fout, ItemVector const& libs)
 {
   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
-  for(ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l)
-    {
-    if(l->IsPath)
-      {
-      std::string rel = lg->Convert(l->Value.c_str(),
-                                    cmLocalGenerator::START_OUTPUT,
-                                    cmLocalGenerator::UNCHANGED);
+  for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
+    if (l->IsPath) {
+      std::string rel =
+        lg->Convert(l->Value.c_str(), cmLocalGenerator::START_OUTPUT,
+                    cmLocalGenerator::UNCHANGED);
       fout << lg->ConvertToXMLOutputPath(rel.c_str()) << " ";
-      }
-    else if (!l->Target
-        || l->Target->GetType() != cmState::INTERFACE_LIBRARY)
-      {
+    } else if (!l->Target ||
+               l->Target->GetType() != cmState::INTERFACE_LIBRARY) {
       fout << l->Value << " ";
-      }
     }
+  }
 }
 
-void
-cmLocalVisualStudio7GeneratorInternals
-::OutputObjects(std::ostream& fout, cmGeneratorTarget* gt, const char* isep)
+void cmLocalVisualStudio7GeneratorInternals::OutputObjects(
+  std::ostream& fout, cmGeneratorTarget* gt, const char* isep)
 {
   // VS < 8 does not support per-config source locations so we
   // list object library content on the link line instead.
   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
   std::vector<std::string> objs;
   gt->UseObjectLibraries(objs, "");
-  const char* sep = isep? isep : "";
-  for(std::vector<std::string>::const_iterator
-        oi = objs.begin(); oi != objs.end(); ++oi)
-    {
-    std::string rel = lg->Convert(oi->c_str(),
-                                  cmLocalGenerator::START_OUTPUT,
+  const char* sep = isep ? isep : "";
+  for (std::vector<std::string>::const_iterator oi = objs.begin();
+       oi != objs.end(); ++oi) {
+    std::string rel = lg->Convert(oi->c_str(), cmLocalGenerator::START_OUTPUT,
                                   cmLocalGenerator::UNCHANGED);
     fout << sep << lg->ConvertToXMLOutputPath(rel.c_str());
     sep = " ";
-    }
+  }
 }
 
-void
-cmLocalVisualStudio7Generator
-::OutputLibraryDirectories(std::ostream& fout,
-                           std::vector<std::string> const& dirs)
+void cmLocalVisualStudio7Generator::OutputLibraryDirectories(
+  std::ostream& fout, std::vector<std::string> const& dirs)
 {
   const char* comma = "";
-  for(std::vector<std::string>::const_iterator d = dirs.begin();
-      d != dirs.end(); ++d)
-    {
+  for (std::vector<std::string>::const_iterator d = dirs.begin();
+       d != dirs.end(); ++d) {
     // Remove any trailing slash and skip empty paths.
     std::string dir = *d;
-    if(dir[dir.size()-1] == '/')
-      {
-      dir = dir.substr(0, dir.size()-1);
-      }
-    if(dir.empty())
-      {
+    if (dir[dir.size() - 1] == '/') {
+      dir = dir.substr(0, dir.size() - 1);
+    }
+    if (dir.empty()) {
       continue;
-      }
+    }
 
     // Switch to a relative path specification if it is shorter.
-    if(cmSystemTools::FileIsFullPath(dir.c_str()))
-      {
+    if (cmSystemTools::FileIsFullPath(dir.c_str())) {
       std::string rel = this->Convert(dir.c_str(), START_OUTPUT, UNCHANGED);
-      if(rel.size() < dir.size())
-        {
+      if (rel.size() < dir.size()) {
         dir = rel;
-        }
       }
+    }
 
     // First search a configuration-specific subdirectory and then the
     // original directory.
     fout << comma
-         << this->ConvertToXMLOutputPath((dir+"/$(ConfigurationName)").c_str())
+         << this->ConvertToXMLOutputPath(
+              (dir + "/$(ConfigurationName)").c_str())
          << "," << this->ConvertToXMLOutputPath(dir.c_str());
     comma = ",";
-    }
+  }
 }
 
 void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
@@ -1521,27 +1372,23 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
   // get the classes from the source lists then add them to the groups
   this->ModuleDefinitionFile = "";
   std::vector<cmSourceFile*> classes;
-  if (!target->GetConfigCommonSourceFiles(classes))
-    {
+  if (!target->GetConfigCommonSourceFiles(classes)) {
     return;
-    }
-  for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
-      i != classes.end(); i++)
-    {
-    if (!(*i)->GetObjectLibrary().empty())
-      {
+  }
+  for (std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+       i != classes.end(); i++) {
+    if (!(*i)->GetObjectLibrary().empty()) {
       continue;
-      }
+    }
     // Add the file to the list of sources.
     std::string source = (*i)->GetFullPath();
-    if(cmSystemTools::UpperCase((*i)->GetExtension()) == "DEF")
-      {
+    if (cmSystemTools::UpperCase((*i)->GetExtension()) == "DEF") {
       this->ModuleDefinitionFile = (*i)->GetFullPath();
-      }
+    }
     cmSourceGroup* sourceGroup =
       this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
     sourceGroup->AssignSource(*i);
-    }
+  }
 
   // open the project
   this->WriteProjectStart(fout, libName, target, sourceGroups);
@@ -1550,34 +1397,29 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
 
   fout << "\t<Files>\n";
 
-
   // Loop through every source group.
-  for(unsigned int i = 0; i < sourceGroups.size(); ++i)
-    {
+  for (unsigned int i = 0; i < sourceGroups.size(); ++i) {
     cmSourceGroup sg = sourceGroups[i];
     this->WriteGroup(&sg, target, fout, libName, configs);
-    }
+  }
 
-  if(this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8
-      && !this->FortranProject)
-    {
+  if (this->GetVersion() >= cmGlobalVisualStudioGenerator::VS8 &&
+      !this->FortranProject) {
     // VS >= 8 support per-config source locations so we
     // list object library content as external objects.
     std::vector<std::string> objs;
     target->UseObjectLibraries(objs, "");
-    if(!objs.empty())
-      {
+    if (!objs.empty()) {
       // TODO: Separate sub-filter for each object library used?
       fout << "\t\t<Filter Name=\"Object Libraries\">\n";
-      for(std::vector<std::string>::const_iterator
-            oi = objs.begin(); oi != objs.end(); ++oi)
-        {
+      for (std::vector<std::string>::const_iterator oi = objs.begin();
+           oi != objs.end(); ++oi) {
         std::string o = this->ConvertToXMLOutputPathSingle(oi->c_str());
         fout << "\t\t\t<File RelativePath=\"" << o << "\" />\n";
-        }
-      fout << "\t\t</Filter>\n";
       }
+      fout << "\t\t</Filter>\n";
     }
+  }
 
   fout << "\t</Files>\n";
 
@@ -1605,39 +1447,31 @@ public:
   std::map<std::string, cmLVS7GFileConfig> FileConfigMap;
 };
 
-cmLocalVisualStudio7GeneratorFCInfo
-::cmLocalVisualStudio7GeneratorFCInfo(cmLocalVisualStudio7Generator* lg,
-                                      cmGeneratorTarget* gt,
-                                      cmSourceFile const& sf,
-                                      std::vector<std::string> const& configs)
+cmLocalVisualStudio7GeneratorFCInfo::cmLocalVisualStudio7GeneratorFCInfo(
+  cmLocalVisualStudio7Generator* lg, cmGeneratorTarget* gt,
+  cmSourceFile const& sf, std::vector<std::string> const& configs)
 {
   std::string objectName;
-  if(gt->HasExplicitObjectName(&sf))
-    {
+  if (gt->HasExplicitObjectName(&sf)) {
     objectName = gt->GetObjectName(&sf);
-    }
+  }
 
   // Compute per-source, per-config information.
-  for(std::vector<std::string>::const_iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = configs.begin();
+       i != configs.end(); ++i) {
     std::string configUpper = cmSystemTools::UpperCase(*i);
     cmLVS7GFileConfig fc;
     bool needfc = false;
-    if(!objectName.empty())
-      {
+    if (!objectName.empty()) {
       fc.ObjectName = objectName;
       needfc = true;
-      }
-    if(const char* cflags = sf.GetProperty("COMPILE_FLAGS"))
-      {
+    }
+    if (const char* cflags = sf.GetProperty("COMPILE_FLAGS")) {
       fc.CompileFlags = cflags;
       needfc = true;
-      }
-    if(lg->FortranProject)
-      {
-      switch(lg->GetFortranFormat(sf.GetProperty("Fortran_FORMAT")))
-        {
+    }
+    if (lg->FortranProject) {
+      switch (lg->GetFortranFormat(sf.GetProperty("Fortran_FORMAT"))) {
         case cmLocalGenerator::FortranFormatFixed:
           fc.CompileFlags = "-fixed " + fc.CompileFlags;
           needfc = true;
@@ -1646,101 +1480,86 @@ cmLocalVisualStudio7GeneratorFCInfo
           fc.CompileFlags = "-free " + fc.CompileFlags;
           needfc = true;
           break;
-        default: break;
-        }
+        default:
+          break;
       }
-    if(const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS"))
-      {
+    }
+    if (const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS")) {
       fc.CompileDefs = cdefs;
       needfc = true;
-      }
+    }
     std::string defPropName = "COMPILE_DEFINITIONS_";
     defPropName += configUpper;
-    if(const char* ccdefs = sf.GetProperty(defPropName.c_str()))
-      {
+    if (const char* ccdefs = sf.GetProperty(defPropName.c_str())) {
       fc.CompileDefsConfig = ccdefs;
       needfc = true;
-      }
+    }
 
     // Check for extra object-file dependencies.
-    if(const char* deps = sf.GetProperty("OBJECT_DEPENDS"))
-      {
+    if (const char* deps = sf.GetProperty("OBJECT_DEPENDS")) {
       std::vector<std::string> depends;
       cmSystemTools::ExpandListArgument(deps, depends);
       const char* sep = "";
-      for(std::vector<std::string>::iterator j = depends.begin();
-          j != depends.end(); ++j)
-        {
+      for (std::vector<std::string>::iterator j = depends.begin();
+           j != depends.end(); ++j) {
         fc.AdditionalDeps += sep;
         fc.AdditionalDeps += lg->ConvertToXMLOutputPath(j->c_str());
         sep = ";";
         needfc = true;
-        }
       }
+    }
 
     std::string lang =
-      lg->GlobalGenerator->GetLanguageFromExtension
-      (sf.GetExtension().c_str());
+      lg->GlobalGenerator->GetLanguageFromExtension(sf.GetExtension().c_str());
     const std::string& sourceLang = lg->GetSourceFileLanguage(sf);
     const std::string& linkLanguage = gt->GetLinkerLanguage(i->c_str());
     bool needForceLang = false;
     // source file does not match its extension language
-    if(lang != sourceLang)
-      {
+    if (lang != sourceLang) {
       needForceLang = true;
       lang = sourceLang;
-      }
+    }
     // If HEADER_FILE_ONLY is set, we must suppress this generation in
     // the project file
-    fc.ExcludedFromBuild =
-      (sf.GetPropertyAsBool("HEADER_FILE_ONLY"));
-    if(fc.ExcludedFromBuild)
-      {
+    fc.ExcludedFromBuild = (sf.GetPropertyAsBool("HEADER_FILE_ONLY"));
+    if (fc.ExcludedFromBuild) {
       needfc = true;
-      }
+    }
 
     // if the source file does not match the linker language
     // then force c or c++
-    if(needForceLang || (linkLanguage != lang))
-      {
-      if(lang == "CXX")
-        {
+    if (needForceLang || (linkLanguage != lang)) {
+      if (lang == "CXX") {
         // force a C++ file type
         fc.CompileFlags += " /TP ";
         needfc = true;
-        }
-      else if(lang == "C")
-        {
+      } else if (lang == "C") {
         // force to c
         fc.CompileFlags += " /TC ";
         needfc = true;
-        }
       }
+    }
 
-    if(needfc)
-      {
+    if (needfc) {
       this->FileConfigMap[*i] = fc;
-      }
     }
+  }
 }
 
-std::string
-cmLocalVisualStudio7Generator
-::ComputeLongestObjectDirectory(cmGeneratorTarget const* target) const
+std::string cmLocalVisualStudio7Generator::ComputeLongestObjectDirectory(
+  cmGeneratorTarget const* target) const
 {
   std::vector<std::string> configs;
   target->Target->GetMakefile()->GetConfigurations(configs);
 
   // Compute the maximum length configuration name.
   std::string config_max;
-  for(std::vector<std::string>::iterator i = configs.begin();
-      i != configs.end(); ++i)
-    {
-    if(i->size() > config_max.size())
-      {
+  for (std::vector<std::string>::iterator i = configs.begin();
+       i != configs.end(); ++i) {
+    if (i->size() > config_max.size()) {
       config_max = *i;
-      }
     }
+  }
 
   // Compute the maximum length full path to the intermediate
   // files directory for any configuration.  This is used to construct
@@ -1755,216 +1574,178 @@ cmLocalVisualStudio7Generator
   return dir_max;
 }
 
-bool cmLocalVisualStudio7Generator
-::WriteGroup(const cmSourceGroup *sg, cmGeneratorTarget* target,
-             std::ostream &fout, const std::string& libName,
-             std::vector<std::string> const& configs)
+bool cmLocalVisualStudio7Generator::WriteGroup(
+  const cmSourceGroup* sg, cmGeneratorTarget* target, std::ostream& fout,
+  const std::string& libName, std::vector<std::string> const& configs)
 {
   cmGlobalVisualStudio7Generator* gg =
-    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
-  const std::vector<const cmSourceFile *> &sourceFiles =
-    sg->GetSourceFiles();
-  std::vector<cmSourceGroup> const& children  = sg->GetGroupChildren();
+    static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
+  const std::vector<const cmSourceFile*>& sourceFiles = sg->GetSourceFiles();
+  std::vector<cmSourceGroup> const& children = sg->GetGroupChildren();
 
   // Write the children to temporary output.
   bool hasChildrenWithSources = false;
   std::ostringstream tmpOut;
-  for(unsigned int i=0;i<children.size();++i)
-    {
-    if(this->WriteGroup(&children[i], target, tmpOut, libName, configs))
-      {
+  for (unsigned int i = 0; i < children.size(); ++i) {
+    if (this->WriteGroup(&children[i], target, tmpOut, libName, configs)) {
       hasChildrenWithSources = true;
-      }
     }
+  }
 
   // If the group is empty, don't write it at all.
-  if(sourceFiles.empty() && !hasChildrenWithSources)
-    {
+  if (sourceFiles.empty() && !hasChildrenWithSources) {
     return false;
-    }
+  }
 
   // If the group has a name, write the header.
   std::string name = sg->GetName();
-  if(name != "")
-    {
+  if (name != "") {
     this->WriteVCProjBeginGroup(fout, name.c_str(), "");
-    }
+  }
 
   // Loop through each source in the source group.
-  for(std::vector<const cmSourceFile *>::const_iterator sf =
-        sourceFiles.begin(); sf != sourceFiles.end(); ++sf)
-    {
+  for (std::vector<const cmSourceFile*>::const_iterator sf =
+         sourceFiles.begin();
+       sf != sourceFiles.end(); ++sf) {
     std::string source = (*sf)->GetFullPath();
     FCInfo fcinfo(this, target, *(*sf), configs);
 
     if (source != libName || target->GetType() == cmState::UTILITY ||
-      target->GetType() == cmState::GLOBAL_TARGET )
-      {
+        target->GetType() == cmState::GLOBAL_TARGET) {
       fout << "\t\t\t<File\n";
       std::string d = this->ConvertToXMLOutputPathSingle(source.c_str());
       // Tell MS-Dev what the source is.  If the compiler knows how to
       // build it, then it will.
       fout << "\t\t\t\tRelativePath=\"" << d << "\">\n";
-      if(cmCustomCommand const* command = (*sf)->GetCustomCommand())
-        {
-        this->WriteCustomRule(fout, configs, source.c_str(),
-                              *command, fcinfo);
-        }
-      else if(!fcinfo.FileConfigMap.empty())
-        {
+      if (cmCustomCommand const* command = (*sf)->GetCustomCommand()) {
+        this->WriteCustomRule(fout, configs, source.c_str(), *command, fcinfo);
+      } else if (!fcinfo.FileConfigMap.empty()) {
         const char* aCompilerTool = "VCCLCompilerTool";
         const char* ppLang = "CXX";
-        if(this->FortranProject)
-          {
+        if (this->FortranProject) {
           aCompilerTool = "VFFortranCompilerTool";
-          }
+        }
         std::string const& lang = (*sf)->GetLanguage();
         std::string ext = (*sf)->GetExtension();
         ext = cmSystemTools::LowerCase(ext);
-        if(ext == "idl")
-          {
+        if (ext == "idl") {
           aCompilerTool = "VCMIDLTool";
-          if(this->FortranProject)
-            {
+          if (this->FortranProject) {
             aCompilerTool = "VFMIDLTool";
-            }
           }
-        if(ext == "rc")
-          {
+        }
+        if (ext == "rc") {
           aCompilerTool = "VCResourceCompilerTool";
           ppLang = "RC";
-          if(this->FortranProject)
-            {
+          if (this->FortranProject) {
             aCompilerTool = "VFResourceCompilerTool";
-            }
           }
-        if(ext == "def")
-          {
+        }
+        if (ext == "def") {
           aCompilerTool = "VCCustomBuildTool";
-          if(this->FortranProject)
-            {
+          if (this->FortranProject) {
             aCompilerTool = "VFCustomBuildTool";
-            }
           }
+        }
         if (gg->IsMasmEnabled() && !this->FortranProject &&
-            lang == "ASM_MASM")
-          {
+            lang == "ASM_MASM") {
           aCompilerTool = "MASM";
-          }
-        for(std::map<std::string, cmLVS7GFileConfig>::const_iterator
-              fci = fcinfo.FileConfigMap.begin();
-            fci != fcinfo.FileConfigMap.end(); ++fci)
-          {
+        }
+        for (std::map<std::string, cmLVS7GFileConfig>::const_iterator fci =
+               fcinfo.FileConfigMap.begin();
+             fci != fcinfo.FileConfigMap.end(); ++fci) {
           cmLVS7GFileConfig const& fc = fci->second;
           fout << "\t\t\t\t<FileConfiguration\n"
-               << "\t\t\t\t\tName=\""  << fci->first
-               << "|" << gg->GetPlatformName() << "\"";
-          if(fc.ExcludedFromBuild)
-            {
+               << "\t\t\t\t\tName=\"" << fci->first << "|"
+               << gg->GetPlatformName() << "\"";
+          if (fc.ExcludedFromBuild) {
             fout << " ExcludedFromBuild=\"true\"";
-            }
+          }
           fout << ">\n";
           fout << "\t\t\t\t\t<Tool\n"
                << "\t\t\t\t\tName=\"" << aCompilerTool << "\"\n";
-          if(!fc.CompileFlags.empty() ||
-             !fc.CompileDefs.empty() ||
-             !fc.CompileDefsConfig.empty())
-            {
+          if (!fc.CompileFlags.empty() || !fc.CompileDefs.empty() ||
+              !fc.CompileDefsConfig.empty()) {
             Options::Tool tool = Options::Compiler;
             cmVS7FlagTable const* table =
               cmLocalVisualStudio7GeneratorFlagTable;
-            if(this->FortranProject)
-              {
+            if (this->FortranProject) {
               tool = Options::FortranCompiler;
               table = cmLocalVisualStudio7GeneratorFortranFlagTable;
-              }
-            Options fileOptions(this, tool, table,
-                                gg->ExtraFlagTable);
+            }
+            Options fileOptions(this, tool, table, gg->ExtraFlagTable);
             fileOptions.Parse(fc.CompileFlags.c_str());
             fileOptions.AddDefines(fc.CompileDefs.c_str());
             fileOptions.AddDefines(fc.CompileDefsConfig.c_str());
             fileOptions.OutputAdditionalOptions(fout, "\t\t\t\t\t", "\n");
             fileOptions.OutputFlagMap(fout, "\t\t\t\t\t");
-            fileOptions.OutputPreprocessorDefinitions(fout,
-                                                      "\t\t\t\t\t", "\n",
+            fileOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t\t", "\n",
                                                       ppLang);
-            }
-          if(!fc.AdditionalDeps.empty())
-            {
+          }
+          if (!fc.AdditionalDeps.empty()) {
             fout << "\t\t\t\t\tAdditionalDependencies=\""
                  << fc.AdditionalDeps.c_str() << "\"\n";
-            }
-          if(!fc.ObjectName.empty())
-            {
+          }
+          if (!fc.ObjectName.empty()) {
             fout << "\t\t\t\t\tObjectFile=\"$(IntDir)/"
                  << fc.ObjectName.c_str() << "\"\n";
-            }
+          }
           fout << "\t\t\t\t\t/>\n"
                << "\t\t\t\t</FileConfiguration>\n";
-          }
         }
-      fout << "\t\t\t</File>\n";
       }
+      fout << "\t\t\t</File>\n";
     }
+  }
 
   // If the group has children with source files, write the children.
-  if(hasChildrenWithSources)
-    {
+  if (hasChildrenWithSources) {
     fout << tmpOut.str();
-    }
+  }
 
   // If the group has a name, write the footer.
-  if(name != "")
-    {
+  if (name != "") {
     this->WriteVCProjEndGroup(fout);
-    }
+  }
 
   return true;
 }
 
-void cmLocalVisualStudio7Generator::
-WriteCustomRule(std::ostream& fout,
-                std::vector<std::string> const& configs,
-                const char* source,
-                const cmCustomCommand& command,
-                FCInfo& fcinfo)
+void cmLocalVisualStudio7Generator::WriteCustomRule(
+  std::ostream& fout, std::vector<std::string> const& configs,
+  const char* source, const cmCustomCommand& command, FCInfo& fcinfo)
 {
   cmGlobalVisualStudio7Generator* gg =
-    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
+    static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
 
   // Write the rule for each configuration.
   const char* compileTool = "VCCLCompilerTool";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     compileTool = "VFCLCompilerTool";
-    }
+  }
   const char* customTool = "VCCustomBuildTool";
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     customTool = "VFCustomBuildTool";
-    }
+  }
   for (std::vector<std::string>::const_iterator i = configs.begin();
-       i != configs.end(); ++i)
-    {
+       i != configs.end(); ++i) {
     cmCustomCommandGenerator ccg(command, *i, this);
     cmLVS7GFileConfig const& fc = fcinfo.FileConfigMap[*i];
     fout << "\t\t\t\t<FileConfiguration\n";
-    fout << "\t\t\t\t\tName=\"" << *i << "|"
-         << gg->GetPlatformName() << "\">\n";
-    if(!fc.CompileFlags.empty())
-      {
+    fout << "\t\t\t\t\tName=\"" << *i << "|" << gg->GetPlatformName()
+         << "\">\n";
+    if (!fc.CompileFlags.empty()) {
       fout << "\t\t\t\t\t<Tool\n"
            << "\t\t\t\t\tName=\"" << compileTool << "\"\n"
            << "\t\t\t\t\tAdditionalOptions=\""
            << this->EscapeForXML(fc.CompileFlags.c_str()) << "\"/>\n";
-      }
+    }
 
     std::string comment = this->ConstructComment(ccg);
     std::string script = this->ConstructScript(ccg);
-    if(this->FortranProject)
-      {
+    if (this->FortranProject) {
       cmSystemTools::ReplaceString(script, "$(Configuration)", i->c_str());
-      }
+    }
     /* clang-format off */
     fout << "\t\t\t\t\t<Tool\n"
          << "\t\t\t\t\tName=\"" << customTool << "\"\n"
@@ -1974,62 +1755,48 @@ WriteCustomRule(std::ostream& fout,
          << this->EscapeForXML(script.c_str()) << "\"\n"
          << "\t\t\t\t\tAdditionalDependencies=\"";
     /* clang-format on */
-    if(ccg.GetDepends().empty())
-      {
+    if (ccg.GetDepends().empty()) {
       // There are no real dependencies.  Produce an artificial one to
       // make sure the rule runs reliably.
-      if(!cmSystemTools::FileExists(source))
-        {
+      if (!cmSystemTools::FileExists(source)) {
         cmsys::ofstream depout(source);
         depout << "Artificial dependency for a custom command.\n";
-        }
-      fout << this->ConvertToXMLOutputPath(source);
       }
-    else
-      {
+      fout << this->ConvertToXMLOutputPath(source);
+    } else {
       // Write out the dependencies for the rule.
-      for(std::vector<std::string>::const_iterator d =
-          ccg.GetDepends().begin();
-          d != ccg.GetDepends().end();
-          ++d)
-        {
+      for (std::vector<std::string>::const_iterator d =
+             ccg.GetDepends().begin();
+           d != ccg.GetDepends().end(); ++d) {
         // Get the real name of the dependency in case it is a CMake target.
         std::string dep;
-        if(this->GetRealDependency(d->c_str(), i->c_str(), dep))
-          {
-          fout << this->ConvertToXMLOutputPath(dep.c_str())
-               << ";";
-          }
+        if (this->GetRealDependency(d->c_str(), i->c_str(), dep)) {
+          fout << this->ConvertToXMLOutputPath(dep.c_str()) << ";";
         }
       }
+    }
     fout << "\"\n";
     fout << "\t\t\t\t\tOutputs=\"";
-    if(ccg.GetOutputs().empty())
-      {
+    if (ccg.GetOutputs().empty()) {
       fout << source << "_force";
-      }
-    else
-      {
+    } else {
       // Write a rule for the output generated by this command.
       const char* sep = "";
-      for(std::vector<std::string>::const_iterator o =
-          ccg.GetOutputs().begin();
-          o != ccg.GetOutputs().end();
-          ++o)
-        {
+      for (std::vector<std::string>::const_iterator o =
+             ccg.GetOutputs().begin();
+           o != ccg.GetOutputs().end(); ++o) {
         fout << sep << this->ConvertToXMLOutputPathSingle(o->c_str());
         sep = ";";
-        }
       }
+    }
     fout << "\"/>\n";
     fout << "\t\t\t\t</FileConfiguration>\n";
-    }
+  }
 }
 
-
 void cmLocalVisualStudio7Generator::WriteVCProjBeginGroup(std::ostream& fout,
                                                           const char* group,
-                                                          const char* )
+                                                          const char*)
 {
   /* clang-format off */
   fout << "\t\t<Filter\n"
@@ -2038,67 +1805,56 @@ void cmLocalVisualStudio7Generator::WriteVCProjBeginGroup(std::ostream& fout,
   /* clang-format on */
 }
 
-
 void cmLocalVisualStudio7Generator::WriteVCProjEndGroup(std::ostream& fout)
 {
   fout << "\t\t</Filter>\n";
 }
 
-
 // look for custom rules on a target and collect them together
-void cmLocalVisualStudio7Generator
-::OutputTargetRules(std::ostream& fout,
-                    const std::string& configName,
-                    cmGeneratorTarget *target,
-                    const std::string& /*libName*/)
+void cmLocalVisualStudio7Generator::OutputTargetRules(
+  std::ostream& fout, const std::string& configName, cmGeneratorTarget* target,
+  const std::string& /*libName*/)
 {
-  if (target->GetType() > cmState::GLOBAL_TARGET)
-    {
+  if (target->GetType() > cmState::GLOBAL_TARGET) {
     return;
-    }
+  }
   EventWriter event(this, configName, fout);
 
   // Add pre-build event.
   const char* tool =
-    this->FortranProject? "VFPreBuildEventTool":"VCPreBuildEventTool";
+    this->FortranProject ? "VFPreBuildEventTool" : "VCPreBuildEventTool";
   event.Start(tool);
   event.Write(target->GetPreBuildCommands());
   event.Finish();
 
   // Add pre-link event.
-  tool = this->FortranProject? "VFPreLinkEventTool":"VCPreLinkEventTool";
+  tool = this->FortranProject ? "VFPreLinkEventTool" : "VCPreLinkEventTool";
   event.Start(tool);
   bool addedPrelink = false;
   if (target->GetType() == cmState::SHARED_LIBRARY &&
-      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
-    {
-    if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
+      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) {
+    if (target->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) {
       addedPrelink = true;
-      std::vector<cmCustomCommand> commands =
-        target->GetPreLinkCommands();
-      cmGlobalVisualStudioGenerator* gg
-        = static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
-      gg->AddSymbolExportCommand(
-        target, commands, configName);
+      std::vector<cmCustomCommand> commands = target->GetPreLinkCommands();
+      cmGlobalVisualStudioGenerator* gg =
+        static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
+      gg->AddSymbolExportCommand(target, commands, configName);
       event.Write(commands);
-      }
     }
-  if (!addedPrelink)
-    {
+  }
+  if (!addedPrelink) {
     event.Write(target->GetPreLinkCommands());
-    }
+  }
   cmsys::auto_ptr<cmCustomCommand> pcc(
-    this->MaybeCreateImplibDir(target,
-                               configName, this->FortranProject));
-  if(pcc.get())
-    {
+    this->MaybeCreateImplibDir(target, configName, this->FortranProject));
+  if (pcc.get()) {
     event.Write(*pcc);
-    }
+  }
   event.Finish();
 
   // Add post-build event.
-  tool = this->FortranProject? "VFPostBuildEventTool":"VCPostBuildEventTool";
+  tool =
+    this->FortranProject ? "VFPostBuildEventTool" : "VCPostBuildEventTool";
   event.Start(tool);
   event.Write(target->GetPostBuildCommands());
   event.Finish();
@@ -2113,8 +1869,7 @@ void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout,
   const char* vsLocalpath = target->GetProperty("VS_SCC_LOCALPATH");
   const char* vsProvider = target->GetProperty("VS_SCC_PROVIDER");
 
-  if(vsProvider && vsLocalpath && vsProjectname)
-    {
+  if (vsProvider && vsLocalpath && vsProjectname) {
     /* clang-format off */
     fout << "\tSccProjectName=\"" << vsProjectname << "\"\n"
          << "\tSccLocalPath=\"" << vsLocalpath << "\"\n"
@@ -2122,22 +1877,18 @@ void cmLocalVisualStudio7Generator::WriteProjectSCC(std::ostream& fout,
     /* clang-format on */
 
     const char* vsAuxPath = target->GetProperty("VS_SCC_AUXPATH");
-    if(vsAuxPath)
-      {
+    if (vsAuxPath) {
       fout << "\tSccAuxPath=\"" << vsAuxPath << "\"\n";
-      }
     }
+  }
 }
 
-void
-cmLocalVisualStudio7Generator
-::WriteProjectStartFortran(std::ostream& fout,
-                           const std::string& libName,
-                           cmGeneratorTarget *target)
+void cmLocalVisualStudio7Generator::WriteProjectStartFortran(
+  std::ostream& fout, const std::string& libName, cmGeneratorTarget* target)
 {
 
   cmGlobalVisualStudio7Generator* gg =
-    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
+    static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
   /* clang-format off */
   fout << "<?xml version=\"1.0\" encoding = \""
        << gg->Encoding() << "\"?>\n"
@@ -2146,44 +1897,38 @@ cmLocalVisualStudio7Generator
        << "\tVersion=\"" << gg->GetIntelProjectVersion() << "\"\n";
   /* clang-format on */
   const char* keyword = target->GetProperty("VS_KEYWORD");
-  if(!keyword)
-    {
+  if (!keyword) {
     keyword = "Console Application";
-    }
+  }
   const char* projectType = 0;
-  switch(target->GetType())
-    {
+  switch (target->GetType()) {
     case cmState::STATIC_LIBRARY:
       projectType = "typeStaticLibrary";
-      if(keyword)
-        {
+      if (keyword) {
         keyword = "Static Library";
-        }
+      }
       break;
     case cmState::SHARED_LIBRARY:
     case cmState::MODULE_LIBRARY:
       projectType = "typeDynamicLibrary";
-      if(!keyword)
-        {
+      if (!keyword) {
         keyword = "Dll";
-        }
+      }
       break;
     case cmState::EXECUTABLE:
-      if(!keyword)
-        {
+      if (!keyword) {
         keyword = "Console Application";
-        }
+      }
       projectType = 0;
       break;
     case cmState::UTILITY:
     case cmState::GLOBAL_TARGET:
     default:
       break;
-    }
-  if(projectType)
-    {
+  }
+  if (projectType) {
     fout << "\tProjectType=\"" << projectType << "\"\n";
-    }
+  }
   this->WriteProjectSCC(fout, target);
   /* clang-format off */
   fout<< "\tKeyword=\"" << keyword << "\">\n"
@@ -2194,21 +1939,17 @@ cmLocalVisualStudio7Generator
   /* clang-format on */
 }
 
-
-void
-cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
-                                                 const std::string& libName,
-                                                 cmGeneratorTarget *target,
-                                                 std::vector<cmSourceGroup> &)
+void cmLocalVisualStudio7Generator::WriteProjectStart(
+  std::ostream& fout, const std::string& libName, cmGeneratorTarget* target,
+  std::vector<cmSourceGroup>&)
 {
-  if(this->FortranProject)
-    {
+  if (this->FortranProject) {
     this->WriteProjectStartFortran(fout, libName, target);
     return;
-    }
+  }
 
   cmGlobalVisualStudio7Generator* gg =
-    static_cast<cmGlobalVisualStudio7Generator *>(this->GlobalGenerator);
+    static_cast<cmGlobalVisualStudio7Generator*>(this->GlobalGenerator);
 
   /* clang-format off */
   fout << "<?xml version=\"1.0\" encoding = \""
@@ -2216,43 +1957,35 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
        << "<VisualStudioProject\n"
        << "\tProjectType=\"Visual C++\"\n";
   /* clang-format on */
-  if(gg->GetVersion() == cmGlobalVisualStudioGenerator::VS71)
-    {
+  if (gg->GetVersion() == cmGlobalVisualStudioGenerator::VS71) {
     fout << "\tVersion=\"7.10\"\n";
-    }
-  else
-    {
-    fout <<  "\tVersion=\"" << (gg->GetVersion()/10) << ".00\"\n";
-    }
+  } else {
+    fout << "\tVersion=\"" << (gg->GetVersion() / 10) << ".00\"\n";
+  }
   const char* projLabel = target->GetProperty("PROJECT_LABEL");
-  if(!projLabel)
-    {
+  if (!projLabel) {
     projLabel = libName.c_str();
-    }
+  }
   const char* keyword = target->GetProperty("VS_KEYWORD");
-  if(!keyword)
-    {
+  if (!keyword) {
     keyword = "Win32Proj";
-    }
+  }
   fout << "\tName=\"" << projLabel << "\"\n";
-  if(gg->GetVersion() >= cmGlobalVisualStudioGenerator::VS8)
-    {
+  if (gg->GetVersion() >= cmGlobalVisualStudioGenerator::VS8) {
     fout << "\tProjectGUID=\"{" << gg->GetGUID(libName.c_str()) << "}\"\n";
-    }
+  }
   this->WriteProjectSCC(fout, target);
-  if(const char* targetFrameworkVersion =
-     target->GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION"))
-    {
+  if (const char* targetFrameworkVersion =
+        target->GetProperty("VS_DOTNET_TARGET_FRAMEWORK_VERSION")) {
     fout << "\tTargetFrameworkVersion=\"" << targetFrameworkVersion << "\"\n";
-    }
+  }
   /* clang-format off */
   fout << "\tKeyword=\"" << keyword << "\">\n"
        << "\t<Platforms>\n"
        << "\t\t<Platform\n\t\t\tName=\"" << gg->GetPlatformName() << "\"/>\n"
        << "\t</Platforms>\n";
   /* clang-format on */
-  if(gg->IsMasmEnabled())
-    {
+  if (gg->IsMasmEnabled()) {
     /* clang-format off */
     fout <<
       "\t<ToolFiles>\n"
@@ -2262,34 +1995,29 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
       "\t</ToolFiles>\n"
       ;
     /* clang-format on */
-    }
+  }
 }
 
-
 void cmLocalVisualStudio7Generator::WriteVCProjFooter(
-    std::ostream& fout,
-    cmGeneratorTarget *target)
+  std::ostream& fout, cmGeneratorTarget* target)
 {
   fout << "\t<Globals>\n";
 
   std::vector<std::string> const& props = target->GetPropertyKeys();
-  for(std::vector<std::string>::const_iterator i = props.begin();
-      i != props.end(); ++i)
-    {
-    if(i->find("VS_GLOBAL_") == 0)
-      {
+  for (std::vector<std::string>::const_iterator i = props.begin();
+       i != props.end(); ++i) {
+    if (i->find("VS_GLOBAL_") == 0) {
       std::string name = i->substr(10);
-      if(name != "")
-        {
+      if (name != "") {
         /* clang-format off */
         fout << "\t\t<Global\n"
              << "\t\t\tName=\"" << name << "\"\n"
              << "\t\t\tValue=\"" << target->GetProperty(*i) << "\"\n"
              << "\t\t/>\n";
         /* clang-format on */
-        }
       }
     }
+  }
 
   fout << "\t</Globals>\n"
        << "</VisualStudioProject>\n";
@@ -2311,8 +2039,8 @@ std::string cmLocalVisualStudio7Generator::EscapeForXML(const std::string& s)
   return cmLocalVisualStudio7GeneratorEscapeForXML(s);
 }
 
-std::string cmLocalVisualStudio7Generator
-::ConvertToXMLOutputPath(const char* path)
+std::string cmLocalVisualStudio7Generator::ConvertToXMLOutputPath(
+  const char* path)
 {
   std::string ret = this->ConvertToOutputFormat(path, SHELL);
   cmSystemTools::ReplaceString(ret, "&", "&amp;");
@@ -2322,8 +2050,8 @@ std::string cmLocalVisualStudio7Generator
   return ret;
 }
 
-std::string cmLocalVisualStudio7Generator
-::ConvertToXMLOutputPathSingle(const char* path)
+std::string cmLocalVisualStudio7Generator::ConvertToXMLOutputPathSingle(
+  const char* path)
 {
   std::string ret = this->ConvertToOutputFormat(path, SHELL);
   cmSystemTools::ReplaceString(ret, "\"", "");
@@ -2333,83 +2061,67 @@ std::string cmLocalVisualStudio7Generator
   return ret;
 }
 
-
 // This class is used to parse an existing vs 7 project
 // and extract the GUID
 class cmVS7XMLParser : public cmXMLParser
 {
 public:
-  virtual void EndElement(const std::string& /* name */)
-    {
-    }
+  virtual void EndElement(const std::string& /* name */) {}
   virtual void StartElement(const std::string& name, const char** atts)
-    {
-      // once the GUID is found do nothing
-      if(!this->GUID.empty())
-        {
-        return;
-        }
-      int i =0;
-      if("VisualStudioProject" == name)
-        {
-        while(atts[i])
-          {
-          if(strcmp(atts[i], "ProjectGUID") == 0)
-            {
-            if(atts[i+1])
-              {
-              this->GUID =  atts[i+1];
-              this->GUID = this->GUID.substr(1, this->GUID.size()-2);
-              }
-            else
-              {
-              this->GUID = "";
-              }
-            return;
-            }
-          ++i;
+  {
+    // once the GUID is found do nothing
+    if (!this->GUID.empty()) {
+      return;
+    }
+    int i = 0;
+    if ("VisualStudioProject" == name) {
+      while (atts[i]) {
+        if (strcmp(atts[i], "ProjectGUID") == 0) {
+          if (atts[i + 1]) {
+            this->GUID = atts[i + 1];
+            this->GUID = this->GUID.substr(1, this->GUID.size() - 2);
+          } else {
+            this->GUID = "";
           }
+          return;
         }
+        ++i;
+      }
     }
+  }
   int InitializeParser()
-    {
-      int ret = cmXMLParser::InitializeParser();
-      if(ret == 0)
-        {
-        return ret;
-        }
-      // visual studio projects have a strange encoding, but it is
-      // really utf-8
-      XML_SetEncoding(static_cast<XML_Parser>(this->Parser), "utf-8");
-      return 1;
-    }
+  {
+    int ret = cmXMLParser::InitializeParser();
+    if (ret == 0) {
+      return ret;
+    }
+    // visual studio projects have a strange encoding, but it is
+    // really utf-8
+    XML_SetEncoding(static_cast<XML_Parser>(this->Parser), "utf-8");
+    return 1;
+  }
   std::string GUID;
 };
 
 void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID(
-  const std::string& name,
-  const char* path)
+  const std::string& name, const char* path)
 {
   cmVS7XMLParser parser;
   parser.ParseFile(path);
   // if we can not find a GUID then we will generate one later
-  if(parser.GUID.empty())
-    {
+  if (parser.GUID.empty()) {
     return;
-    }
+  }
   std::string guidStoreName = name;
   guidStoreName += "_GUID_CMAKE";
   // save the GUID in the cache
-  this->GlobalGenerator->GetCMakeInstance()->
-    AddCacheEntry(guidStoreName.c_str(),
-                  parser.GUID.c_str(),
-                  "Stored GUID",
-                  cmState::INTERNAL);
+  this->GlobalGenerator->GetCMakeInstance()->AddCacheEntry(
+    guidStoreName.c_str(), parser.GUID.c_str(), "Stored GUID",
+    cmState::INTERNAL);
 }
 
-
-std::string cmLocalVisualStudio7Generator
-::GetTargetDirectory(cmGeneratorTarget const* target) const
+std::string cmLocalVisualStudio7Generator::GetTargetDirectory(
+  cmGeneratorTarget const* target) const
 {
   std::string dir;
   dir += target->GetName();
@@ -2420,16 +2132,14 @@ std::string cmLocalVisualStudio7Generator
 #include <windows.h>
 static bool cmLVS7G_IsFAT(const char* dir)
 {
-  if(dir[0] && dir[1] == ':')
-    {
+  if (dir[0] && dir[1] == ':') {
     char volRoot[4] = "_:/";
     volRoot[0] = dir[0];
     char fsName[16];
-    if(GetVolumeInformationA(volRoot, 0, 0, 0, 0, 0, fsName, 16) &&
-       strstr(fsName, "FAT") != 0)
-      {
+    if (GetVolumeInformationA(volRoot, 0, 0, 0, 0, 0, fsName, 16) &&
+        strstr(fsName, "FAT") != 0) {
       return true;
-      }
     }
+  }
   return false;
 }
diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h
index 5d9a634..6d1d0fb 100644
--- a/Source/cmLocalVisualStudio7Generator.h
+++ b/Source/cmLocalVisualStudio7Generator.h
@@ -20,7 +20,6 @@ class cmSourceFile;
 class cmCustomCommand;
 class cmSourceGroup;
 
-
 class cmLocalVisualStudio7GeneratorOptions;
 class cmLocalVisualStudio7GeneratorFCInfo;
 class cmLocalVisualStudio7GeneratorInternals;
@@ -46,26 +45,34 @@ public:
    */
   virtual void Generate();
 
-  enum BuildType {STATIC_LIBRARY, DLL, EXECUTABLE, WIN32_EXECUTABLE, UTILITY};
+  enum BuildType
+  {
+    STATIC_LIBRARY,
+    DLL,
+    EXECUTABLE,
+    WIN32_EXECUTABLE,
+    UTILITY
+  };
 
   /**
    * Specify the type of the build: static, dll, or executable.
    */
-  void SetBuildType(BuildType,const std::string& name);
+  void SetBuildType(BuildType, const std::string& name);
 
-  virtual
-  std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
+  virtual std::string GetTargetDirectory(
+    cmGeneratorTarget const* target) const;
   cmSourceFile* CreateVCProjBuildRule();
   void WriteStampFiles();
-  virtual std::string
-  ComputeLongestObjectDirectory(cmGeneratorTarget const*) const;
+  virtual std::string ComputeLongestObjectDirectory(
+    cmGeneratorTarget const*) const;
 
   virtual void ReadAndStoreExternalGUID(const std::string& name,
                                         const char* path);
   virtual void AddCMakeListsRules();
+
 protected:
-  void CreateSingleVCProj(const std::string& lname,
-                          cmGeneratorTarget *tgt);
+  void CreateSingleVCProj(const std::string& lname, cmGeneratorTarget* tgt);
+
 private:
   typedef cmVisualStudioGeneratorOptions Options;
   typedef cmLocalVisualStudio7GeneratorFCInfo FCInfo;
@@ -75,15 +82,14 @@ private:
   void WriteProjectFiles();
   void WriteVCProjHeader(std::ostream& fout, const std::string& libName,
                          cmGeneratorTarget* tgt,
-                         std::vector<cmSourceGroup> &sgs);
+                         std::vector<cmSourceGroup>& sgs);
   void WriteVCProjFooter(std::ostream& fout, cmGeneratorTarget* target);
   void WriteVCProjFile(std::ostream& fout, const std::string& libName,
                        cmGeneratorTarget* tgt);
   void WriteConfigurations(std::ostream& fout,
                            std::vector<std::string> const& configs,
                            const std::string& libName, cmGeneratorTarget* tgt);
-  void WriteConfiguration(std::ostream& fout,
-                          const std::string& configName,
+  void WriteConfiguration(std::ostream& fout, const std::string& configName,
                           const std::string& libName, cmGeneratorTarget* tgt);
   std::string EscapeForXML(const std::string& s);
   std::string ConvertToXMLOutputPath(const char* path);
@@ -98,28 +104,24 @@ private:
                                     cmGeneratorTarget* target);
   void OutputLibraryDirectories(std::ostream& fout,
                                 std::vector<std::string> const& dirs);
-  void WriteProjectSCC(std::ostream& fout, cmGeneratorTarget *target);
+  void WriteProjectSCC(std::ostream& fout, cmGeneratorTarget* target);
   void WriteProjectStart(std::ostream& fout, const std::string& libName,
                          cmGeneratorTarget* tgt,
-                         std::vector<cmSourceGroup> &sgs);
+                         std::vector<cmSourceGroup>& sgs);
   void WriteProjectStartFortran(std::ostream& fout, const std::string& libName,
                                 cmGeneratorTarget* tgt);
-  void WriteVCProjBeginGroup(std::ostream& fout,
-                          const char* group,
-                          const char* filter);
+  void WriteVCProjBeginGroup(std::ostream& fout, const char* group,
+                             const char* filter);
   void WriteVCProjEndGroup(std::ostream& fout);
 
   void WriteCustomRule(std::ostream& fout,
                        std::vector<std::string> const& configs,
-                       const char* source,
-                       const cmCustomCommand& command,
+                       const char* source, const cmCustomCommand& command,
                        FCInfo& fcinfo);
-  void WriteTargetVersionAttribute(std::ostream& fout,
-                                   cmGeneratorTarget* gt);
+  void WriteTargetVersionAttribute(std::ostream& fout, cmGeneratorTarget* gt);
 
-  bool WriteGroup(const cmSourceGroup *sg,
-                  cmGeneratorTarget* target, std::ostream &fout,
-                  const std::string& libName,
+  bool WriteGroup(const cmSourceGroup* sg, cmGeneratorTarget* target,
+                  std::ostream& fout, const std::string& libName,
                   std::vector<std::string> const& configs);
 
   friend class cmLocalVisualStudio7GeneratorFCInfo;
@@ -134,6 +136,4 @@ private:
   cmLocalVisualStudio7GeneratorInternals* Internal;
 };
 
-
 #endif
-
diff --git a/Source/cmLocalVisualStudioGenerator.cxx b/Source/cmLocalVisualStudioGenerator.cxx
index b12ea49..85ab615 100644
--- a/Source/cmLocalVisualStudioGenerator.cxx
+++ b/Source/cmLocalVisualStudioGenerator.cxx
@@ -18,8 +18,8 @@
 #include "cmSystemTools.h"
 #include "windows.h"
 
-cmLocalVisualStudioGenerator
-::cmLocalVisualStudioGenerator(cmGlobalGenerator* gg, cmMakefile* mf)
+cmLocalVisualStudioGenerator::cmLocalVisualStudioGenerator(
+  cmGlobalGenerator* gg, cmMakefile* mf)
   : cmLocalGenerator(gg, mf)
 {
 }
@@ -37,8 +37,8 @@ cmLocalVisualStudioGenerator::GetVersion() const
 }
 
 void cmLocalVisualStudioGenerator::ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt)
+  std::map<cmSourceFile const*, std::string>& mapping,
+  cmGeneratorTarget const* gt)
 {
   std::string dir_max = this->ComputeLongestObjectDirectory(gt);
 
@@ -46,33 +46,32 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames(
   // windows file names are not case sensitive.
   std::map<std::string, int> counts;
 
-  for(std::map<cmSourceFile const*, std::string>::iterator
-      si = mapping.begin(); si != mapping.end(); ++si)
-    {
+  for (std::map<cmSourceFile const*, std::string>::iterator si =
+         mapping.begin();
+       si != mapping.end(); ++si) {
     cmSourceFile const* sf = si->first;
     std::string objectNameLower = cmSystemTools::LowerCase(
       cmSystemTools::GetFilenameWithoutLastExtension(sf->GetFullPath()));
     objectNameLower += this->GlobalGenerator->GetLanguageOutputExtension(*sf);
     counts[objectNameLower] += 1;
-    }
+  }
 
   // For all source files producing duplicate names we need unique
   // object name computation.
 
-  for(std::map<cmSourceFile const*, std::string>::iterator
-      si = mapping.begin(); si != mapping.end(); ++si)
-    {
+  for (std::map<cmSourceFile const*, std::string>::iterator si =
+         mapping.begin();
+       si != mapping.end(); ++si) {
     cmSourceFile const* sf = si->first;
     std::string objectName =
       cmSystemTools::GetFilenameWithoutLastExtension(sf->GetFullPath());
     objectName += this->GlobalGenerator->GetLanguageOutputExtension(*sf);
-    if(counts[cmSystemTools::LowerCase(objectName)] > 1)
-      {
+    if (counts[cmSystemTools::LowerCase(objectName)] > 1) {
       const_cast<cmGeneratorTarget*>(gt)->AddExplicitObjectName(sf);
       objectName = this->GetObjectFileNameWithoutTarget(*sf, dir_max);
-      }
-    si->second = objectName;
     }
+    si->second = objectName;
+  }
 }
 
 cmsys::auto_ptr<cmCustomCommand>
@@ -85,12 +84,15 @@ cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target,
   // If an executable exports symbols then VS wants to create an
   // import library but forgets to create the output directory.
   // The Intel Fortran plugin always forgets to the directory.
-  if(target->GetType() != cmState::EXECUTABLE &&
-     !(isFortran && target->GetType() == cmState::SHARED_LIBRARY))
-    { return pcc; }
+  if (target->GetType() != cmState::EXECUTABLE &&
+      !(isFortran && target->GetType() == cmState::SHARED_LIBRARY)) {
+    return pcc;
+  }
   std::string outDir = target->GetDirectory(config, false);
   std::string impDir = target->GetDirectory(config, true);
-  if(impDir == outDir) { return pcc; }
+  if (impDir == outDir) {
+    return pcc;
+  }
 
   // Add a pre-build event to create the directory.
   cmCustomCommandLine command;
@@ -103,8 +105,8 @@ cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target,
   std::vector<std::string> no_depends;
   cmCustomCommandLines commands;
   commands.push_back(command);
-  pcc.reset(new cmCustomCommand(0, no_output, no_byproducts,
-                                no_depends, commands, 0, 0));
+  pcc.reset(new cmCustomCommand(0, no_output, no_byproducts, no_depends,
+                                commands, 0, 0));
   pcc->SetEscapeOldStyle(false);
   pcc->SetEscapeAllowMakeVars(true);
   return pcc;
@@ -120,43 +122,36 @@ const char* cmLocalVisualStudioGenerator::GetReportErrorLabel() const
   return this->ReportErrorLabel();
 }
 
-std::string
-cmLocalVisualStudioGenerator
-::ConstructScript(cmCustomCommandGenerator const& ccg,
-                  const std::string& newline_text)
+std::string cmLocalVisualStudioGenerator::ConstructScript(
+  cmCustomCommandGenerator const& ccg, const std::string& newline_text)
 {
   bool useLocal = this->CustomCommandUseLocal();
   std::string workingDirectory = ccg.GetWorkingDirectory();
-  RelativeRoot relativeRoot = workingDirectory.empty()? START_OUTPUT : NONE;
+  RelativeRoot relativeRoot = workingDirectory.empty() ? START_OUTPUT : NONE;
 
   // Avoid leading or trailing newlines.
   std::string newline = "";
 
   // Line to check for error between commands.
   std::string check_error = newline_text;
-  if(useLocal)
-    {
+  if (useLocal) {
     check_error += "if %errorlevel% neq 0 goto :cmEnd";
-    }
-  else
-    {
+  } else {
     check_error += "if errorlevel 1 goto ";
     check_error += this->GetReportErrorLabel();
-    }
+  }
 
   // Store the script in a string.
   std::string script;
 
   // Open a local context.
-  if(useLocal)
-    {
+  if (useLocal) {
     script += newline;
     newline = newline_text;
     script += "setlocal";
-    }
+  }
 
-  if(!workingDirectory.empty())
-    {
+  if (!workingDirectory.empty()) {
     // Change the working directory.
     script += newline;
     newline = newline_text;
@@ -165,35 +160,31 @@ cmLocalVisualStudioGenerator
     script += check_error;
 
     // Change the working drive.
-    if(workingDirectory.size() > 1 && workingDirectory[1] == ':')
-      {
+    if (workingDirectory.size() > 1 && workingDirectory[1] == ':') {
       script += newline;
       newline = newline_text;
       script += workingDirectory[0];
       script += workingDirectory[1];
       script += check_error;
-      }
     }
+  }
 
   // for visual studio IDE add extra stuff to the PATH
   // if CMAKE_MSVCIDE_RUN_PATH is set.
-  if(this->Makefile->GetDefinition("MSVC_IDE"))
-    {
+  if (this->Makefile->GetDefinition("MSVC_IDE")) {
     const char* extraPath =
       this->Makefile->GetDefinition("CMAKE_MSVCIDE_RUN_PATH");
-    if(extraPath)
-      {
+    if (extraPath) {
       script += newline;
       newline = newline_text;
       script += "set PATH=";
       script += extraPath;
       script += ";%PATH%";
-      }
     }
+  }
 
   // Write each command on a single line.
-  for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-    {
+  for (unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c) {
     // Start a new line.
     script += newline;
     newline = newline_text;
@@ -205,14 +196,12 @@ cmLocalVisualStudioGenerator
     // invoked as custom commands.
     //
     std::string suffix;
-    if (cmd.size() > 4)
-      {
-      suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size()-4));
-      if (suffix == ".bat" || suffix == ".cmd")
-        {
+    if (cmd.size() > 4) {
+      suffix = cmSystemTools::LowerCase(cmd.substr(cmd.size() - 4));
+      if (suffix == ".bat" || suffix == ".cmd") {
         script += "call ";
-        }
       }
+    }
 
     script += this->Convert(cmd.c_str(), relativeRoot, SHELL);
     ccg.AppendArguments(c, script);
@@ -222,11 +211,10 @@ cmLocalVisualStudioGenerator
     // skipping the run of any subsequent commands in this
     // sequence.
     script += check_error;
-    }
+  }
 
   // Close the local context.
-  if(useLocal)
-    {
+  if (useLocal) {
     script += newline;
     script += ":cmEnd";
     script += newline;
@@ -240,7 +228,7 @@ cmLocalVisualStudioGenerator
     script += newline;
     script += "if %errorlevel% neq 0 goto ";
     script += this->GetReportErrorLabel();
-    }
+  }
 
   return script;
 }
diff --git a/Source/cmLocalVisualStudioGenerator.h b/Source/cmLocalVisualStudioGenerator.h
index caffff7..c24d813 100644
--- a/Source/cmLocalVisualStudioGenerator.h
+++ b/Source/cmLocalVisualStudioGenerator.h
@@ -45,24 +45,22 @@ public:
 
   cmGlobalVisualStudioGenerator::VSVersion GetVersion() const;
 
-  virtual std::string
-  ComputeLongestObjectDirectory(cmGeneratorTarget const*) const = 0;
+  virtual std::string ComputeLongestObjectDirectory(
+    cmGeneratorTarget const*) const = 0;
 
   virtual void AddCMakeListsRules() = 0;
 
   virtual void ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* = 0);
+    std::map<cmSourceFile const*, std::string>& mapping,
+    cmGeneratorTarget const* = 0);
 
 protected:
   virtual const char* ReportErrorLabel() const;
   virtual bool CustomCommandUseLocal() const { return false; }
 
   /** Construct a custom command to make exe import lib dir.  */
-  cmsys::auto_ptr<cmCustomCommand>
-  MaybeCreateImplibDir(cmGeneratorTarget *target,
-                       const std::string& config,
-                       bool isFortran);
+  cmsys::auto_ptr<cmCustomCommand> MaybeCreateImplibDir(
+    cmGeneratorTarget* target, const std::string& config, bool isFortran);
 };
 
 #endif
diff --git a/Source/cmLocalXCodeGenerator.cxx b/Source/cmLocalXCodeGenerator.cxx
index 18eccdd..db87946 100644
--- a/Source/cmLocalXCodeGenerator.cxx
+++ b/Source/cmLocalXCodeGenerator.cxx
@@ -28,8 +28,8 @@ cmLocalXCodeGenerator::~cmLocalXCodeGenerator()
 {
 }
 
-std::string
-cmLocalXCodeGenerator::GetTargetDirectory(cmGeneratorTarget const*) const
+std::string cmLocalXCodeGenerator::GetTargetDirectory(
+  cmGeneratorTarget const*) const
 {
   // No per-target directory for this generator (yet).
   return "";
@@ -48,11 +48,10 @@ void cmLocalXCodeGenerator::Generate()
   cmLocalGenerator::Generate();
 
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin();
-      iter != targets.end(); ++iter)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator iter = targets.begin();
+       iter != targets.end(); ++iter) {
     (*iter)->HasMacOSXRpathInstallNameDir("");
-    }
+  }
 }
 
 void cmLocalXCodeGenerator::GenerateInstallRules()
@@ -60,25 +59,24 @@ void cmLocalXCodeGenerator::GenerateInstallRules()
   cmLocalGenerator::GenerateInstallRules();
 
   std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
-  for(std::vector<cmGeneratorTarget*>::iterator iter = targets.begin();
-      iter != targets.end(); ++iter)
-    {
+  for (std::vector<cmGeneratorTarget*>::iterator iter = targets.begin();
+       iter != targets.end(); ++iter) {
     (*iter)->HasMacOSXRpathInstallNameDir("");
-    }
+  }
 }
 
 void cmLocalXCodeGenerator::ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const*)
+  std::map<cmSourceFile const*, std::string>& mapping,
+  cmGeneratorTarget const*)
 {
   // Count the number of object files with each name. Warn about duplicate
   // names since Xcode names them uniquely automatically with a numeric suffix
   // to avoid exact duplicate file names. Note that Mac file names are not
   // typically case sensitive, hence the LowerCase.
   std::map<std::string, int> counts;
-  for(std::map<cmSourceFile const*, std::string>::iterator
-      si = mapping.begin(); si != mapping.end(); ++si)
-    {
+  for (std::map<cmSourceFile const*, std::string>::iterator si =
+         mapping.begin();
+       si != mapping.end(); ++si) {
     cmSourceFile const* sf = si->first;
     std::string objectName =
       cmSystemTools::GetFilenameWithoutLastExtension(sf->GetFullPath());
@@ -86,10 +84,9 @@ void cmLocalXCodeGenerator::ComputeObjectFilenames(
 
     std::string objectNameLower = cmSystemTools::LowerCase(objectName);
     counts[objectNameLower] += 1;
-    if (2 == counts[objectNameLower])
-      {
+    if (2 == counts[objectNameLower]) {
       // TODO: emit warning about duplicate name?
-      }
-    si->second = objectName;
     }
+    si->second = objectName;
+  }
 }
diff --git a/Source/cmLocalXCodeGenerator.h b/Source/cmLocalXCodeGenerator.h
index 4381a6d..da3558e 100644
--- a/Source/cmLocalXCodeGenerator.h
+++ b/Source/cmLocalXCodeGenerator.h
@@ -24,22 +24,20 @@ class cmLocalXCodeGenerator : public cmLocalGenerator
 {
 public:
   ///! Set cache only and recurse to false by default.
-  cmLocalXCodeGenerator(cmGlobalGenerator* gg,
-                        cmMakefile* mf);
+  cmLocalXCodeGenerator(cmGlobalGenerator* gg, cmMakefile* mf);
 
   virtual ~cmLocalXCodeGenerator();
-  virtual
-  std::string GetTargetDirectory(cmGeneratorTarget const* target) const;
+  virtual std::string GetTargetDirectory(
+    cmGeneratorTarget const* target) const;
   virtual void AppendFlagEscape(std::string& flags,
                                 const std::string& rawFlag);
   virtual void Generate();
   virtual void GenerateInstallRules();
   virtual void ComputeObjectFilenames(
-                        std::map<cmSourceFile const*, std::string>& mapping,
-                        cmGeneratorTarget const* gt = 0);
-private:
+    std::map<cmSourceFile const*, std::string>& mapping,
+    cmGeneratorTarget const* gt = 0);
 
+private:
 };
 
 #endif
-
diff --git a/Source/cmLocale.h b/Source/cmLocale.h
index 69640f6..e69c32e 100644
--- a/Source/cmLocale.h
+++ b/Source/cmLocale.h
@@ -19,15 +19,14 @@
 class cmLocaleRAII
 {
   const char* OldLocale;
+
 public:
-  cmLocaleRAII(): OldLocale(setlocale(LC_CTYPE, 0))
-    {
+  cmLocaleRAII()
+    : OldLocale(setlocale(LC_CTYPE, 0))
+  {
     setlocale(LC_CTYPE, "");
-    }
-  ~cmLocaleRAII()
-    {
-    setlocale(LC_CTYPE, this->OldLocale);
-    }
+  }
+  ~cmLocaleRAII() { setlocale(LC_CTYPE, this->OldLocale); }
 };
 
 #endif
diff --git a/Source/cmMachO.cxx b/Source/cmMachO.cxx
index 147979d..314760e 100644
--- a/Source/cmMachO.cxx
+++ b/Source/cmMachO.cxx
@@ -43,48 +43,43 @@
 
 namespace {
 
-  // peek in the file
-  template <typename T>
-  bool peek(cmsys::ifstream& fin, T &v)
-    {
-    std::streampos p = fin.tellg();
-    if(!fin.read(reinterpret_cast<char*>(&v), sizeof(T)))
-      {
-      return false;
-      }
-    fin.seekg(p);
-    return fin.good();
-    }
+// peek in the file
+template <typename T>
+bool peek(cmsys::ifstream& fin, T& v)
+{
+  std::streampos p = fin.tellg();
+  if (!fin.read(reinterpret_cast<char*>(&v), sizeof(T))) {
+    return false;
+  }
+  fin.seekg(p);
+  return fin.good();
+}
 
-  // read from the file and fill a data structure
-  template <typename T>
-  bool read(cmsys::ifstream& fin, T& v)
-    {
-    if(!fin.read(reinterpret_cast<char*>(&v), sizeof(T)))
-      {
-      return false;
-      }
-    return true;
-    }
+// read from the file and fill a data structure
+template <typename T>
+bool read(cmsys::ifstream& fin, T& v)
+{
+  if (!fin.read(reinterpret_cast<char*>(&v), sizeof(T))) {
+    return false;
+  }
+  return true;
+}
 
-  // read from the file and fill multiple data structures where
-  // the vector has been resized
-  template <typename T>
-  bool read(cmsys::ifstream& fin, std::vector<T>& v)
-    {
-    // nothing to read
-    if(v.empty())
-      {
-      return true;
-      }
-    if(!fin.read(reinterpret_cast<char*>(&v[0]), sizeof(T) * v.size()))
-      {
-      return false;
-      }
+// read from the file and fill multiple data structures where
+// the vector has been resized
+template <typename T>
+bool read(cmsys::ifstream& fin, std::vector<T>& v)
+{
+  // nothing to read
+  if (v.empty()) {
     return true;
-    }
+  }
+  if (!fin.read(reinterpret_cast<char*>(&v[0]), sizeof(T) * v.size())) {
+    return false;
+  }
+  return true;
+}
 }
-
 
 // Contains header and load commands for a single Mach-O file
 class cmMachOHeaderAndLoadCommands
@@ -92,45 +87,41 @@ class cmMachOHeaderAndLoadCommands
 public:
   // A load_command and its associated data
   struct RawLoadCommand
-    {
+  {
     uint32_t type(const cmMachOHeaderAndLoadCommands* m) const
-      {
-      if(this->LoadCommand.size() < sizeof(load_command))
-        {
+    {
+      if (this->LoadCommand.size() < sizeof(load_command)) {
         return 0;
-        }
+      }
       const load_command* cmd =
         reinterpret_cast<const load_command*>(&this->LoadCommand[0]);
       return m->swap(cmd->cmd);
-      }
+    }
     std::vector<char> LoadCommand;
-    };
+  };
 
   cmMachOHeaderAndLoadCommands(bool _swap)
     : Swap(_swap)
-    {
-    }
-  virtual ~cmMachOHeaderAndLoadCommands()
-    {
-    }
+  {
+  }
+  virtual ~cmMachOHeaderAndLoadCommands() {}
 
   virtual bool read_mach_o(cmsys::ifstream& fin) = 0;
 
   const std::vector<RawLoadCommand>& load_commands() const
-    {
+  {
     return this->LoadCommands;
-    }
+  }
 
   uint32_t swap(uint32_t v) const
-    {
-    if(this->Swap)
-      {
+  {
+    if (this->Swap) {
       char* c = reinterpret_cast<char*>(&v);
       std::swap(c[0], c[3]);
       std::swap(c[1], c[2]);
-      }
-    return v;
     }
+    return v;
+  }
 
 protected:
   bool read_load_commands(uint32_t ncmds, uint32_t sizeofcmds,
@@ -148,14 +139,13 @@ class cmMachOHeaderAndLoadCommandsImpl : public cmMachOHeaderAndLoadCommands
 public:
   cmMachOHeaderAndLoadCommandsImpl(bool _swap)
     : cmMachOHeaderAndLoadCommands(_swap)
-    {
-    }
+  {
+  }
   bool read_mach_o(cmsys::ifstream& fin)
-    {
-    if(!read(fin, this->Header))
-      {
+  {
+    if (!read(fin, this->Header)) {
       return false;
-      }
+    }
     this->Header.cputype = swap(this->Header.cputype);
     this->Header.cpusubtype = swap(this->Header.cpusubtype);
     this->Header.filetype = swap(this->Header.filetype);
@@ -163,45 +153,40 @@ public:
     this->Header.sizeofcmds = swap(this->Header.sizeofcmds);
     this->Header.flags = swap(this->Header.flags);
 
-    return read_load_commands(this->Header.ncmds,
-                              this->Header.sizeofcmds,
+    return read_load_commands(this->Header.ncmds, this->Header.sizeofcmds,
                               fin);
-    }
+  }
+
 protected:
   T Header;
 };
 
-
 bool cmMachOHeaderAndLoadCommands::read_load_commands(uint32_t ncmds,
                                                       uint32_t sizeofcmds,
                                                       cmsys::ifstream& fin)
 {
   uint32_t size_read = 0;
   this->LoadCommands.resize(ncmds);
-  for(uint32_t i = 0; i<ncmds; i++)
-    {
+  for (uint32_t i = 0; i < ncmds; i++) {
     load_command lc;
-    if(!peek(fin, lc))
-      {
+    if (!peek(fin, lc)) {
       return false;
-      }
+    }
     lc.cmd = swap(lc.cmd);
     lc.cmdsize = swap(lc.cmdsize);
     size_read += lc.cmdsize;
 
     RawLoadCommand& c = this->LoadCommands[i];
     c.LoadCommand.resize(lc.cmdsize);
-    if(!read(fin, c.LoadCommand))
-      {
+    if (!read(fin, c.LoadCommand)) {
       return false;
-      }
     }
+  }
 
-  if(size_read != sizeofcmds)
-    {
+  if (size_read != sizeofcmds) {
     this->LoadCommands.clear();
     return false;
-    }
+  }
 
   return true;
 }
@@ -233,126 +218,100 @@ cmMachOInternal::cmMachOInternal(const char* fname)
   : Fin(fname)
 {
   // Quit now if the file could not be opened.
-  if(!this->Fin || !this->Fin.get() )
-    {
+  if (!this->Fin || !this->Fin.get()) {
     this->ErrorMessage = "Error opening input file.";
     return;
-    }
+  }
 
-  if(!this->Fin.seekg(0))
-    {
+  if (!this->Fin.seekg(0)) {
     this->ErrorMessage = "Error seeking to beginning of file.";
     return;
-    }
+  }
 
   // Read the binary identification block.
   uint32_t magic = 0;
-  if(!peek(this->Fin, magic))
-    {
+  if (!peek(this->Fin, magic)) {
     this->ErrorMessage = "Error reading Mach-O identification.";
     return;
-    }
+  }
 
   // Verify the binary identification.
-  if(!(magic == MH_CIGAM ||
-       magic == MH_MAGIC ||
-       magic == MH_CIGAM_64 ||
-       magic == MH_MAGIC_64 ||
-       magic == FAT_CIGAM ||
-       magic == FAT_MAGIC))
-    {
+  if (!(magic == MH_CIGAM || magic == MH_MAGIC || magic == MH_CIGAM_64 ||
+        magic == MH_MAGIC_64 || magic == FAT_CIGAM || magic == FAT_MAGIC)) {
     this->ErrorMessage = "File does not have a valid Mach-O identification.";
     return;
-    }
+  }
 
-  if(magic == FAT_MAGIC || magic == FAT_CIGAM)
-    {
+  if (magic == FAT_MAGIC || magic == FAT_CIGAM) {
     // this is a universal binary
     fat_header header;
-    if(!read(this->Fin, header))
-      {
+    if (!read(this->Fin, header)) {
       this->ErrorMessage = "Error reading fat header.";
       return;
-      }
+    }
 
     // read fat_archs
     this->FatArchs.resize(OSSwapBigToHostInt32(header.nfat_arch));
-    if(!read(this->Fin, this->FatArchs))
-      {
+    if (!read(this->Fin, this->FatArchs)) {
       this->ErrorMessage = "Error reading fat header archs.";
       return;
-      }
+    }
 
     // parse each Mach-O file
-    for(size_t i=0; i<this->FatArchs.size(); i++)
-      {
+    for (size_t i = 0; i < this->FatArchs.size(); i++) {
       const fat_arch& arch = this->FatArchs[i];
-      if(!this->read_mach_o(OSSwapBigToHostInt32(arch.offset)))
-        {
+      if (!this->read_mach_o(OSSwapBigToHostInt32(arch.offset))) {
         return;
-        }
       }
     }
-  else
-    {
+  } else {
     // parse Mach-O file at the beginning of the file
     this->read_mach_o(0);
-    }
+  }
 }
 
 cmMachOInternal::~cmMachOInternal()
 {
-  for(size_t i=0; i<this->MachOList.size(); i++)
-    {
+  for (size_t i = 0; i < this->MachOList.size(); i++) {
     delete this->MachOList[i];
-    }
+  }
 }
 
 bool cmMachOInternal::read_mach_o(uint32_t file_offset)
 {
-  if(!this->Fin.seekg(file_offset))
-    {
+  if (!this->Fin.seekg(file_offset)) {
     this->ErrorMessage = "Failed to locate Mach-O content.";
     return false;
-    }
+  }
 
   uint32_t magic;
-  if(!peek(this->Fin, magic))
-    {
+  if (!peek(this->Fin, magic)) {
     this->ErrorMessage = "Error reading Mach-O identification.";
     return false;
-    }
+  }
 
   cmMachOHeaderAndLoadCommands* f = NULL;
-  if(magic == MH_CIGAM || magic == MH_MAGIC)
-    {
+  if (magic == MH_CIGAM || magic == MH_MAGIC) {
     bool swap = false;
-    if(magic == MH_CIGAM)
-      {
+    if (magic == MH_CIGAM) {
       swap = true;
-      }
-    f = new cmMachOHeaderAndLoadCommandsImpl<mach_header>(swap);
     }
-  else if(magic == MH_CIGAM_64 || magic == MH_MAGIC_64)
-    {
+    f = new cmMachOHeaderAndLoadCommandsImpl<mach_header>(swap);
+  } else if (magic == MH_CIGAM_64 || magic == MH_MAGIC_64) {
     bool swap = false;
-    if(magic == MH_CIGAM_64)
-      {
+    if (magic == MH_CIGAM_64) {
       swap = true;
-      }
-    f = new cmMachOHeaderAndLoadCommandsImpl<mach_header_64>(swap);
     }
+    f = new cmMachOHeaderAndLoadCommandsImpl<mach_header_64>(swap);
+  }
 
-  if(f && f->read_mach_o(this->Fin))
-    {
+  if (f && f->read_mach_o(this->Fin)) {
     this->MachOList.push_back(f);
-    }
-  else
-    {
+  } else {
     delete f;
     this->ErrorMessage = "Failed to read Mach-O header.";
     return false;
-    }
+  }
 
   return true;
 }
@@ -360,10 +319,10 @@ bool cmMachOInternal::read_mach_o(uint32_t file_offset)
 //============================================================================
 // External class implementation.
 
-cmMachO::cmMachO(const char* fname): Internal(0)
+cmMachO::cmMachO(const char* fname)
+  : Internal(0)
 {
   this->Internal = new cmMachOInternal(fname);
-
 }
 
 cmMachO::~cmMachO()
@@ -383,30 +342,25 @@ bool cmMachO::Valid() const
 
 bool cmMachO::GetInstallName(std::string& install_name)
 {
-  if(this->Internal->MachOList.empty())
-    {
+  if (this->Internal->MachOList.empty()) {
     return false;
-    }
+  }
 
   // grab the first Mach-O and get the install name from that one
   cmMachOHeaderAndLoadCommands* macho = this->Internal->MachOList[0];
-  for(size_t i=0; i<macho->load_commands().size(); i++)
-    {
-    const cmMachOHeaderAndLoadCommands::RawLoadCommand &cmd =
+  for (size_t i = 0; i < macho->load_commands().size(); i++) {
+    const cmMachOHeaderAndLoadCommands::RawLoadCommand& cmd =
       macho->load_commands()[i];
     uint32_t lc_cmd = cmd.type(macho);
-    if(lc_cmd == LC_ID_DYLIB ||
-       lc_cmd == LC_LOAD_WEAK_DYLIB ||
-       lc_cmd == LC_LOAD_DYLIB)
-      {
-      if(sizeof(dylib_command) < cmd.LoadCommand.size())
-        {
+    if (lc_cmd == LC_ID_DYLIB || lc_cmd == LC_LOAD_WEAK_DYLIB ||
+        lc_cmd == LC_LOAD_DYLIB) {
+      if (sizeof(dylib_command) < cmd.LoadCommand.size()) {
         uint32_t namelen = cmd.LoadCommand.size() - sizeof(dylib_command);
         install_name.assign(&cmd.LoadCommand[sizeof(dylib_command)], namelen);
         return true;
-        }
       }
     }
+  }
 
   return false;
 }
diff --git a/Source/cmMachO.h b/Source/cmMachO.h
index f06f8de..327c1ce 100644
--- a/Source/cmMachO.h
+++ b/Source/cmMachO.h
@@ -13,7 +13,7 @@
 #define cmMachO_h
 
 #if !defined(CMAKE_USE_MACH_PARSER)
-# error "This file may be included only if CMAKE_USE_MACH_PARSER is enabled."
+#error "This file may be included only if CMAKE_USE_MACH_PARSER is enabled."
 #endif
 
 class cmMachOInternal;
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index 36831fe..2caa401 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -29,17 +29,14 @@ public:
    * cmMacroHelperCommand and cmFunctionHelperCommand
    * which cannot provide appropriate documentation.
    */
-  virtual bool ShouldAppearInDocumentation() const
-    {
-    return false;
-    }
+  virtual bool ShouldAppearInDocumentation() const { return false; }
 
   /**
    * This is a virtual constructor for the command.
    */
   virtual cmCommand* Clone()
   {
-    cmMacroHelperCommand *newC = new cmMacroHelperCommand;
+    cmMacroHelperCommand* newC = new cmMacroHelperCommand;
     // we must copy when we clone
     newC->Args = this->Args;
     newC->Functions = this->Functions;
@@ -58,10 +55,12 @@ public:
    * the CMakeLists.txt file.
    */
   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) { return false; }
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * The name of the command as specified in CMakeList.txt.
@@ -76,10 +75,8 @@ public:
   std::string FilePath;
 };
 
-
-bool cmMacroHelperCommand::InvokeInitialPass
-(const std::vector<cmListFileArgument>& args,
- cmExecutionStatus &inStatus)
+bool cmMacroHelperCommand::InvokeInitialPass(
+  const std::vector<cmListFileArgument>& args, cmExecutionStatus& inStatus)
 {
   // Expand the argument list to the macro.
   std::vector<std::string> expandedArgs;
@@ -87,17 +84,15 @@ bool cmMacroHelperCommand::InvokeInitialPass
 
   // make sure the number of arguments passed is at least the number
   // required by the signature
-  if (expandedArgs.size() < this->Args.size() - 1)
-    {
+  if (expandedArgs.size() < this->Args.size() - 1) {
     std::string errorMsg =
       "Macro invoked with incorrect arguments for macro named: ";
     errorMsg += this->Args[0];
     this->SetError(errorMsg);
     return false;
-    }
+  }
 
-  cmMakefile::MacroPushPop macroScope(this->Makefile,
-                                      this->FilePath,
+  cmMakefile::MacroPushPop macroScope(this->Makefile, this->FilePath,
                                       this->Policies);
 
   // set the value of argc
@@ -105,29 +100,26 @@ bool cmMacroHelperCommand::InvokeInitialPass
   argcDefStream << expandedArgs.size();
   std::string argcDef = argcDefStream.str();
 
-  std::vector<std::string>::const_iterator eit
-      = expandedArgs.begin() + (this->Args.size() - 1);
+  std::vector<std::string>::const_iterator eit =
+    expandedArgs.begin() + (this->Args.size() - 1);
   std::string expandedArgn = cmJoin(cmMakeRange(eit, expandedArgs.end()), ";");
   std::string expandedArgv = cmJoin(expandedArgs, ";");
   std::vector<std::string> variables;
   variables.reserve(this->Args.size() - 1);
-  for (unsigned int j = 1; j < this->Args.size(); ++j)
-    {
+  for (unsigned int j = 1; j < this->Args.size(); ++j) {
     variables.push_back("${" + this->Args[j] + "}");
-    }
+  }
   std::vector<std::string> argVs;
   argVs.reserve(expandedArgs.size());
   char argvName[60];
-  for (unsigned int j = 0; j < expandedArgs.size(); ++j)
-    {
-    sprintf(argvName,"${ARGV%i}",j);
+  for (unsigned int j = 0; j < expandedArgs.size(); ++j) {
+    sprintf(argvName, "${ARGV%i}", j);
     argVs.push_back(argvName);
-    }
+  }
   // Invoke all the functions that were collected in the block.
   cmListFileFunction newLFF;
   // for each function
-  for(unsigned int c = 0; c < this->Functions.size(); ++c)
-    {
+  for (unsigned int c = 0; c < this->Functions.size(); ++c) {
     // Replace the formal arguments and then invoke the command.
     newLFF.Arguments.clear();
     newLFF.Arguments.reserve(this->Functions[c].Arguments.size());
@@ -137,18 +129,15 @@ bool cmMacroHelperCommand::InvokeInitialPass
     // for each argument of the current function
     for (std::vector<cmListFileArgument>::iterator k =
            this->Functions[c].Arguments.begin();
-         k != this->Functions[c].Arguments.end(); ++k)
-      {
+         k != this->Functions[c].Arguments.end(); ++k) {
       cmListFileArgument arg;
       arg.Value = k->Value;
-      if(k->Delim != cmListFileArgument::Bracket)
-        {
+      if (k->Delim != cmListFileArgument::Bracket) {
         // replace formal arguments
-        for (unsigned int j = 0; j < variables.size(); ++j)
-          {
+        for (unsigned int j = 0; j < variables.size(); ++j) {
           cmSystemTools::ReplaceString(arg.Value, variables[j],
                                        expandedArgs[j]);
-          }
+        }
         // replace argc
         cmSystemTools::ReplaceString(arg.Value, "${ARGC}", argcDef);
 
@@ -157,61 +146,51 @@ bool cmMacroHelperCommand::InvokeInitialPass
 
         // if the current argument of the current function has ${ARGV in it
         // then try replacing ARGV values
-        if (arg.Value.find("${ARGV") != std::string::npos)
-          {
-          for (unsigned int t = 0; t < expandedArgs.size(); ++t)
-            {
-            cmSystemTools::ReplaceString(arg.Value, argVs[t],
-                                         expandedArgs[t]);
-            }
+        if (arg.Value.find("${ARGV") != std::string::npos) {
+          for (unsigned int t = 0; t < expandedArgs.size(); ++t) {
+            cmSystemTools::ReplaceString(arg.Value, argVs[t], expandedArgs[t]);
           }
         }
+      }
       arg.Delim = k->Delim;
       arg.Line = k->Line;
       newLFF.Arguments.push_back(arg);
-      }
+    }
     cmExecutionStatus status;
-    if(!this->Makefile->ExecuteCommand(newLFF, status) ||
-       status.GetNestedError())
-      {
+    if (!this->Makefile->ExecuteCommand(newLFF, status) ||
+        status.GetNestedError()) {
       // The error message should have already included the call stack
       // so we do not need to report an error here.
       macroScope.Quiet();
       inStatus.SetNestedError(true);
       return false;
-      }
-    if (status.GetReturnInvoked())
-      {
+    }
+    if (status.GetReturnInvoked()) {
       inStatus.SetReturnInvoked(true);
       return true;
-      }
-    if (status.GetBreakInvoked())
-      {
+    }
+    if (status.GetBreakInvoked()) {
       inStatus.SetBreakInvoked(true);
       return true;
-      }
     }
+  }
   return true;
 }
 
-bool cmMacroFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
-                  cmExecutionStatus &)
+bool cmMacroFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
+                                               cmMakefile& mf,
+                                               cmExecutionStatus&)
 {
   // record commands until we hit the ENDMACRO
   // at the ENDMACRO call we shift gears and start looking for invocations
-  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"macro"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "macro")) {
     this->Depth++;
-    }
-  else if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
-    {
+  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endmacro")) {
     // if this is the endmacro for this macro then execute
-    if (!this->Depth)
-      {
+    if (!this->Depth) {
       mf.AppendProperty("MACROS", this->Args[0].c_str());
       // create a new command and add it to cmake
-      cmMacroHelperCommand *f = new cmMacroHelperCommand();
+      cmMacroHelperCommand* f = new cmMacroHelperCommand();
       f->Args = this->Args;
       f->Functions = this->Functions;
       f->FilePath = this->GetStartingContext().FilePath;
@@ -223,13 +202,11 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
       // remove the function blocker now that the macro is defined
       mf.RemoveFunctionBlocker(this, lff);
       return true;
-      }
-    else
-      {
+    } else {
       // decrement for each nested macro that ends
       this->Depth--;
-      }
     }
+  }
 
   // if it wasn't an endmacro and we are not executing then we must be
   // recording
@@ -237,40 +214,35 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
   return true;
 }
 
-
-bool cmMacroFunctionBlocker::
-ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf)
+bool cmMacroFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
+                                          cmMakefile& mf)
 {
-  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endmacro"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endmacro")) {
     std::vector<std::string> expandedArguments;
     mf.ExpandArguments(lff.Arguments, expandedArguments,
                        this->GetStartingContext().FilePath.c_str());
     // if the endmacro has arguments make sure they
     // match the arguments of the macro
     if ((expandedArguments.empty() ||
-         (expandedArguments[0] == this->Args[0])))
-      {
+         (expandedArguments[0] == this->Args[0]))) {
       return true;
-      }
     }
+  }
 
   return false;
 }
 
 bool cmMacroCommand::InitialPass(std::vector<std::string> const& args,
-                                 cmExecutionStatus &)
+                                 cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // create a function blocker
-  cmMacroFunctionBlocker *f = new cmMacroFunctionBlocker();
+  cmMacroFunctionBlocker* f = new cmMacroFunctionBlocker();
   f->Args.insert(f->Args.end(), args.begin(), args.end());
   this->Makefile->AddFunctionBlocker(f);
   return true;
 }
-
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index 6f1ae9e..11d2e1c 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -19,12 +19,11 @@
 class cmMacroFunctionBlocker : public cmFunctionBlocker
 {
 public:
-  cmMacroFunctionBlocker() {this->Depth=0;}
+  cmMacroFunctionBlocker() { this->Depth = 0; }
   virtual ~cmMacroFunctionBlocker() {}
-  virtual bool IsFunctionBlocked(const cmListFileFunction&,
-                                 cmMakefile &mf,
-                                 cmExecutionStatus &);
-  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf,
+                                 cmExecutionStatus&);
+  virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf);
 
   std::vector<std::string> Args;
   std::vector<cmListFileFunction> Functions;
@@ -38,17 +37,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmMacroCommand;
-    }
+  virtual cmCommand* Clone() { return new cmMacroCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -58,10 +54,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "macro";}
+  virtual std::string GetName() const { return "macro"; }
 
   cmTypeMacro(cmMacroCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmMakeDirectoryCommand.cxx b/Source/cmMakeDirectoryCommand.cxx
index cc871c9..574dbf0 100644
--- a/Source/cmMakeDirectoryCommand.cxx
+++ b/Source/cmMakeDirectoryCommand.cxx
@@ -12,23 +12,20 @@
 #include "cmMakeDirectoryCommand.h"
 
 // cmMakeDirectoryCommand
-bool cmMakeDirectoryCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmMakeDirectoryCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if(args.size() != 1 )
-    {
+  if (args.size() != 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
-    if ( !this->Makefile->CanIWriteThisFile(args[0].c_str()) )
-      {
-      std::string e = "attempted to create a directory: " + args[0]
-        + " into a source directory.";
-      this->SetError(e);
-      cmSystemTools::SetFatalErrorOccured();
-      return false;
-      }
+  }
+  if (!this->Makefile->CanIWriteThisFile(args[0].c_str())) {
+    std::string e = "attempted to create a directory: " + args[0] +
+      " into a source directory.";
+    this->SetError(e);
+    cmSystemTools::SetFatalErrorOccured();
+    return false;
+  }
   cmSystemTools::MakeDirectory(args[0].c_str());
   return true;
 }
-
diff --git a/Source/cmMakeDirectoryCommand.h b/Source/cmMakeDirectoryCommand.h
index 617f1fe..1a86398 100644
--- a/Source/cmMakeDirectoryCommand.h
+++ b/Source/cmMakeDirectoryCommand.h
@@ -29,22 +29,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmMakeDirectoryCommand;
-    }
+  virtual cmCommand* Clone() { return new cmMakeDirectoryCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "make_directory";}
+  virtual std::string GetName() const { return "make_directory"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -54,6 +51,4 @@ public:
   cmTypeMacro(cmMakeDirectoryCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 251d748..7e99f2c 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -27,7 +27,7 @@
 #include "cmTest.h"
 #include "cmVersion.h"
 #ifdef CMAKE_BUILD_WITH_CMAKE
-#  include "cmVariableWatch.h"
+#include "cmVariableWatch.h"
 #endif
 #include "cmAlgorithms.h"
 #include "cmInstallGenerator.h"
@@ -46,9 +46,9 @@
 // default is not to be building executables
 cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator,
                        cmState::Snapshot const& snapshot)
-  : GlobalGenerator(globalGenerator),
-    StateSnapshot(snapshot),
-    Backtrace(snapshot)
+  : GlobalGenerator(globalGenerator)
+  , StateSnapshot(snapshot)
+  , Backtrace(snapshot)
 {
   this->IsSourceFileTryCompile = false;
 
@@ -67,8 +67,9 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator,
   this->cmAtVarRegex.compile("(@[A-Za-z_0-9/.+-]+@)");
   this->cmNamedCurly.compile("^[A-Za-z0-9/_.+-]+{");
 
-  this->StateSnapshot = this->StateSnapshot.GetState()
-      ->CreatePolicyScopeSnapshot(this->StateSnapshot);
+  this->StateSnapshot =
+    this->StateSnapshot.GetState()->CreatePolicyScopeSnapshot(
+      this->StateSnapshot);
 
   // Enter a policy level for this directory.
   this->PushPolicy();
@@ -82,10 +83,9 @@ cmMakefile::cmMakefile(cmGlobalGenerator* globalGenerator,
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   this->AddSourceGroup("", "^.*$");
-  this->AddSourceGroup
-    ("Source Files",
-     "\\.(C|M|c|c\\+\\+|cc|cpp|cxx|f|f90|for|fpp"
-     "|ftn|m|mm|rc|def|r|odl|idl|hpj|bat)$");
+  this->AddSourceGroup("Source Files",
+                       "\\.(C|M|c|c\\+\\+|cc|cpp|cxx|f|f90|for|fpp"
+                       "|ftn|m|mm|rc|def|r|odl|idl|hpj|bat)$");
   this->AddSourceGroup("Header Files", CM_HEADER_REGEX);
   this->AddSourceGroup("CMake Rules", "\\.rule$");
   this->AddSourceGroup("Resources", "\\.plist$");
@@ -105,18 +105,15 @@ cmMakefile::~cmMakefile()
   cmDeleteAll(this->EvaluationFiles);
 }
 
-void cmMakefile::IssueMessage(cmake::MessageType t,
-                              std::string const& text,
+void cmMakefile::IssueMessage(cmake::MessageType t, std::string const& text,
                               bool force) const
 {
   // Collect context information.
-  if(!this->ExecutionStatusStack.empty())
-    {
-    if((t == cmake::FATAL_ERROR) || (t == cmake::INTERNAL_ERROR))
-      {
+  if (!this->ExecutionStatusStack.empty()) {
+    if ((t == cmake::FATAL_ERROR) || (t == cmake::INTERNAL_ERROR)) {
       this->ExecutionStatusStack.back()->SetNestedError(true);
-      }
     }
+  }
   this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace(), force);
 }
 
@@ -128,7 +125,7 @@ cmStringRange cmMakefile::GetIncludeDirectoriesEntries() const
 cmBacktraceRange cmMakefile::GetIncludeDirectoriesBacktraces() const
 {
   return this->StateSnapshot.GetDirectory()
-      .GetIncludeDirectoriesEntryBacktraces();
+    .GetIncludeDirectoriesEntryBacktraces();
 }
 
 cmStringRange cmMakefile::GetCompileOptionsEntries() const
@@ -149,7 +146,7 @@ cmStringRange cmMakefile::GetCompileDefinitionsEntries() const
 cmBacktraceRange cmMakefile::GetCompileDefinitionsBacktraces() const
 {
   return this->StateSnapshot.GetDirectory()
-      .GetCompileDefinitionsEntryBacktraces();
+    .GetCompileDefinitionsEntryBacktraces();
 }
 
 cmListFileBacktrace cmMakefile::GetBacktrace() const
@@ -183,21 +180,18 @@ void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff) const
   msg << lff.Name << "(";
   bool expand = this->GetCMakeInstance()->GetTraceExpand();
   std::string temp;
-  for(std::vector<cmListFileArgument>::const_iterator i =
-        lff.Arguments.begin(); i != lff.Arguments.end(); ++i)
-    {
-    if (expand)
-      {
+  for (std::vector<cmListFileArgument>::const_iterator i =
+         lff.Arguments.begin();
+       i != lff.Arguments.end(); ++i) {
+    if (expand) {
       temp = i->Value;
       this->ExpandVariablesInString(temp);
       msg << temp;
-      }
-    else
-      {
+    } else {
       msg << i->Value;
-      }
-    msg << " ";
     }
+    msg << " ";
+  }
   msg << ")";
   cmSystemTools::Message(msg.str().c_str());
 }
@@ -207,35 +201,35 @@ class cmMakefileCall
 {
 public:
   cmMakefileCall(cmMakefile* mf, cmCommandContext const& cc,
-                 cmExecutionStatus& status): Makefile(mf)
-    {
-    cmListFileContext const& lfc =
-      cmListFileContext::FromCommandContext(
-        cc, this->Makefile->StateSnapshot.GetExecutionListFile());
+                 cmExecutionStatus& status)
+    : Makefile(mf)
+  {
+    cmListFileContext const& lfc = cmListFileContext::FromCommandContext(
+      cc, this->Makefile->StateSnapshot.GetExecutionListFile());
     this->Makefile->Backtrace = this->Makefile->Backtrace.Push(lfc);
     this->Makefile->ExecutionStatusStack.push_back(&status);
-    }
+  }
 
   ~cmMakefileCall()
-    {
+  {
     this->Makefile->ExecutionStatusStack.pop_back();
     this->Makefile->Backtrace = this->Makefile->Backtrace.Pop();
-    }
+  }
+
 private:
   cmMakefile* Makefile;
 };
 
 bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
-                                cmExecutionStatus &status)
+                                cmExecutionStatus& status)
 {
   bool result = true;
 
   // quick return if blocked
-  if(this->IsFunctionBlocked(lff,status))
-    {
+  if (this->IsFunctionBlocked(lff, status)) {
     // No error.
     return result;
-    }
+  }
 
   std::string name = lff.Name;
 
@@ -244,67 +238,56 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
   static_cast<void>(stack_manager);
 
   // Lookup the command prototype.
-  if(cmCommand* proto = this->GetState()->GetCommand(name))
-    {
+  if (cmCommand* proto = this->GetState()->GetCommand(name)) {
     // Clone the prototype.
     cmsys::auto_ptr<cmCommand> pcmd(proto->Clone());
     pcmd->SetMakefile(this);
 
     // Decide whether to invoke the command.
-    if(pcmd->GetEnabled() && !cmSystemTools::GetFatalErrorOccured()  &&
-       (this->GetCMakeInstance()->GetWorkingMode() != cmake::SCRIPT_MODE
-       || pcmd->IsScriptable()))
+    if (pcmd->GetEnabled() && !cmSystemTools::GetFatalErrorOccured() &&
+        (this->GetCMakeInstance()->GetWorkingMode() != cmake::SCRIPT_MODE ||
+         pcmd->IsScriptable()))
 
-      {
+    {
       // if trace is enabled, print out invoke information
-      if(this->GetCMakeInstance()->GetTrace())
-        {
+      if (this->GetCMakeInstance()->GetTrace()) {
         this->PrintCommandTrace(lff);
-        }
+      }
       // Try invoking the command.
-      if(!pcmd->InvokeInitialPass(lff.Arguments,status) ||
-         status.GetNestedError())
-        {
-        if(!status.GetNestedError())
-          {
+      if (!pcmd->InvokeInitialPass(lff.Arguments, status) ||
+          status.GetNestedError()) {
+        if (!status.GetNestedError()) {
           // The command invocation requested that we report an error.
           this->IssueMessage(cmake::FATAL_ERROR, pcmd->GetError());
-          }
+        }
         result = false;
-        if ( this->GetCMakeInstance()->GetWorkingMode() != cmake::NORMAL_MODE)
-          {
+        if (this->GetCMakeInstance()->GetWorkingMode() != cmake::NORMAL_MODE) {
           cmSystemTools::SetFatalErrorOccured();
-          }
         }
-      else if(pcmd->HasFinalPass())
-        {
+      } else if (pcmd->HasFinalPass()) {
         // use the command
         this->FinalPassCommands.push_back(pcmd.release());
-        }
       }
-    else if ( this->GetCMakeInstance()->GetWorkingMode() == cmake::SCRIPT_MODE
-              && !pcmd->IsScriptable() )
-      {
+    } else if (this->GetCMakeInstance()->GetWorkingMode() ==
+                 cmake::SCRIPT_MODE &&
+               !pcmd->IsScriptable()) {
       std::string error = "Command ";
       error += pcmd->GetName();
       error += "() is not scriptable";
       this->IssueMessage(cmake::FATAL_ERROR, error);
       result = false;
       cmSystemTools::SetFatalErrorOccured();
-      }
     }
-  else
-    {
-    if(!cmSystemTools::GetFatalErrorOccured())
-      {
+  } else {
+    if (!cmSystemTools::GetFatalErrorOccured()) {
       std::string error = "Unknown CMake command \"";
       error += lff.Name;
       error += "\".";
       this->IssueMessage(cmake::FATAL_ERROR, error);
       result = false;
       cmSystemTools::SetFatalErrorOccured();
-      }
     }
+  }
 
   return result;
 }
@@ -326,24 +309,22 @@ private:
 
 cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
                                        std::string const& filenametoread,
-                                       bool noPolicyScope):
-  Makefile(mf), NoPolicyScope(noPolicyScope),
-  CheckCMP0011(false), ReportError(true)
+                                       bool noPolicyScope)
+  : Makefile(mf)
+  , NoPolicyScope(noPolicyScope)
+  , CheckCMP0011(false)
+  , ReportError(true)
 {
-  this->Makefile->Backtrace =
-    this->Makefile->Backtrace.Push(filenametoread);
+  this->Makefile->Backtrace = this->Makefile->Backtrace.Push(filenametoread);
 
   this->Makefile->PushFunctionBlockerBarrier();
 
   this->Makefile->StateSnapshot =
-      this->Makefile->GetState()->CreateIncludeFileSnapshot(
-        this->Makefile->StateSnapshot,
-        filenametoread);
-  if(!this->NoPolicyScope)
-    {
+    this->Makefile->GetState()->CreateIncludeFileSnapshot(
+      this->Makefile->StateSnapshot, filenametoread);
+  if (!this->NoPolicyScope) {
     // Check CMP0011 to determine the policy scope type.
-    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0011))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0011)) {
       case cmPolicies::WARN:
         // We need to push a scope to detect whether the script sets
         // any policies that would affect the includer and therefore
@@ -365,34 +346,31 @@ cmMakefile::IncludeScope::IncludeScope(cmMakefile* mf,
         // NEW behavior is to push a (strong) scope.
         this->Makefile->PushPolicy();
         break;
-      }
     }
+  }
 }
 
 cmMakefile::IncludeScope::~IncludeScope()
 {
-  if(!this->NoPolicyScope)
-    {
+  if (!this->NoPolicyScope) {
     // If we need to enforce policy CMP0011 then the top entry is the
     // one we pushed above.  If the entry is empty, then the included
     // script did not set any policies that might affect the includer so
     // we do not need to enforce the policy.
-    if(this->CheckCMP0011
-       && !this->Makefile->StateSnapshot.HasDefinedPolicyCMP0011())
-      {
+    if (this->CheckCMP0011 &&
+        !this->Makefile->StateSnapshot.HasDefinedPolicyCMP0011()) {
       this->CheckCMP0011 = false;
-      }
+    }
 
     // Pop the scope we pushed for the script.
     this->Makefile->PopPolicy();
 
     // We enforce the policy after the script's policy stack entry has
     // been removed.
-    if(this->CheckCMP0011)
-      {
+    if (this->CheckCMP0011) {
       this->EnforceCMP0011();
-      }
     }
+  }
   this->Makefile->PopSnapshot(this->ReportError);
 
   this->Makefile->PopFunctionBlockerBarrier(this->ReportError);
@@ -404,24 +382,22 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
 {
   // We check the setting of this policy again because the included
   // script might actually set this policy for its includer.
-  switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0011))
-    {
+  switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0011)) {
     case cmPolicies::WARN:
       // Warn because the user did not set this policy.
       {
-      std::ostringstream w;
-      w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0011) << "\n"
-        << "The included script\n  "
-        << this->Makefile->GetExecutionFilePath() << "\n"
-        << "affects policy settings.  "
-        << "CMake is implying the NO_POLICY_SCOPE option for compatibility, "
-        << "so the effects are applied to the including context.";
-      this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
+        std::ostringstream w;
+        w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0011) << "\n"
+          << "The included script\n  "
+          << this->Makefile->GetExecutionFilePath() << "\n"
+          << "affects policy settings.  "
+          << "CMake is implying the NO_POLICY_SCOPE option for compatibility, "
+          << "so the effects are applied to the including context.";
+        this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
       }
       break;
     case cmPolicies::REQUIRED_IF_USED:
-    case cmPolicies::REQUIRED_ALWAYS:
-      {
+    case cmPolicies::REQUIRED_ALWAYS: {
       std::ostringstream e;
       /* clang-format off */
       e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0011) << "\n"
@@ -430,38 +406,34 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
         << "affects policy settings, so it requires this policy to be set.";
       /* clang-format on */
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
-      }
-      break;
+    } break;
     case cmPolicies::OLD:
     case cmPolicies::NEW:
       // The script set this policy.  We assume the purpose of the
       // script is to initialize policies for its includer, and since
       // the policy is now set for later scripts, we do not warn.
       break;
-    }
+  }
 }
 
 bool cmMakefile::ReadDependentFile(const char* filename, bool noPolicyScope)
 {
   this->AddDefinition("CMAKE_PARENT_LIST_FILE",
                       this->GetDefinition("CMAKE_CURRENT_LIST_FILE"));
-  std::string filenametoread =
-    cmSystemTools::CollapseFullPath(filename,
-                                    this->GetCurrentSourceDirectory());
+  std::string filenametoread = cmSystemTools::CollapseFullPath(
+    filename, this->GetCurrentSourceDirectory());
 
   IncludeScope incScope(this, filenametoread, noPolicyScope);
 
   cmListFile listFile;
-  if (!listFile.ParseFile(filenametoread.c_str(), false, this))
-    {
+  if (!listFile.ParseFile(filenametoread.c_str(), false, this)) {
     return false;
-    }
+  }
 
   this->ReadListFile(listFile, filenametoread);
-  if(cmSystemTools::GetFatalErrorOccured())
-    {
+  if (cmSystemTools::GetFatalErrorOccured()) {
     incScope.Quiet();
-    }
+  }
   return true;
 }
 
@@ -469,14 +441,14 @@ class cmMakefile::ListFileScope
 {
 public:
   ListFileScope(cmMakefile* mf, std::string const& filenametoread)
-    : Makefile(mf), ReportError(true)
+    : Makefile(mf)
+    , ReportError(true)
   {
-    this->Makefile->Backtrace =
-      this->Makefile->Backtrace.Push(filenametoread);
+    this->Makefile->Backtrace = this->Makefile->Backtrace.Push(filenametoread);
 
     this->Makefile->StateSnapshot =
-        this->Makefile->GetState()->CreateInlineListFileSnapshot(
-          this->Makefile->StateSnapshot, filenametoread);
+      this->Makefile->GetState()->CreateInlineListFileSnapshot(
+        this->Makefile->StateSnapshot, filenametoread);
     assert(this->Makefile->StateSnapshot.IsValid());
 
     this->Makefile->PushFunctionBlockerBarrier();
@@ -497,23 +469,20 @@ private:
 
 bool cmMakefile::ReadListFile(const char* filename)
 {
-  std::string filenametoread =
-    cmSystemTools::CollapseFullPath(filename,
-                                    this->GetCurrentSourceDirectory());
+  std::string filenametoread = cmSystemTools::CollapseFullPath(
+    filename, this->GetCurrentSourceDirectory());
 
   ListFileScope scope(this, filenametoread);
 
   cmListFile listFile;
-  if (!listFile.ParseFile(filenametoread.c_str(), false, this))
-    {
+  if (!listFile.ParseFile(filenametoread.c_str(), false, this)) {
     return false;
-    }
+  }
 
   this->ReadListFile(listFile, filenametoread);
-  if(cmSystemTools::GetFatalErrorOccured())
-    {
+  if (cmSystemTools::GetFatalErrorOccured()) {
     scope.Quiet();
-    }
+  }
   return true;
 }
 
@@ -523,14 +492,13 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
   // add this list file to the list of dependencies
   this->ListFiles.push_back(filenametoread);
 
-  std::string currentParentFile
-      = this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE");
-  std::string currentFile
-    = this->GetSafeDefinition("CMAKE_CURRENT_LIST_FILE");
+  std::string currentParentFile =
+    this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE");
+  std::string currentFile = this->GetSafeDefinition("CMAKE_CURRENT_LIST_FILE");
 
   this->AddDefinition("CMAKE_CURRENT_LIST_FILE", filenametoread.c_str());
   this->AddDefinition("CMAKE_CURRENT_LIST_DIR",
-                       cmSystemTools::GetFilenamePath(filenametoread).c_str());
+                      cmSystemTools::GetFilenamePath(filenametoread).c_str());
 
   this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
   this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
@@ -538,20 +506,17 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
 
   // Run the parsed commands.
   const size_t numberFunctions = listFile.Functions.size();
-  for(size_t i =0; i < numberFunctions; ++i)
-    {
+  for (size_t i = 0; i < numberFunctions; ++i) {
     cmExecutionStatus status;
-    this->ExecuteCommand(listFile.Functions[i],status);
-    if(cmSystemTools::GetFatalErrorOccured())
-      {
+    this->ExecuteCommand(listFile.Functions[i], status);
+    if (cmSystemTools::GetFatalErrorOccured()) {
       break;
-      }
-    if(status.GetReturnInvoked())
-      {
+    }
+    if (status.GetReturnInvoked()) {
       // Exit early due to return command.
       break;
-      }
     }
+  }
   this->CheckForUnusedVariables();
 
   this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str());
@@ -566,22 +531,18 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
 void cmMakefile::EnforceDirectoryLevelRules() const
 {
   // Diagnose a violation of CMP0000 if necessary.
-  if(this->CheckCMP0000)
-    {
+  if (this->CheckCMP0000) {
     std::ostringstream msg;
     msg << "No cmake_minimum_required command is present.  "
         << "A line of code such as\n"
-        << "  cmake_minimum_required(VERSION "
-        << cmVersion::GetMajorVersion() << "."
-        << cmVersion::GetMinorVersion()
-        << ")\n"
+        << "  cmake_minimum_required(VERSION " << cmVersion::GetMajorVersion()
+        << "." << cmVersion::GetMinorVersion() << ")\n"
         << "should be added at the top of the file.  "
         << "The version specified may be lower if you wish to "
         << "support older CMake versions for this project.  "
         << "For more information run "
         << "\"cmake --help-policy CMP0000\".";
-    switch (this->GetPolicyStatus(cmPolicies::CMP0000))
-      {
+    switch (this->GetPolicyStatus(cmPolicies::CMP0000)) {
       case cmPolicies::WARN:
         // Warn because the user did not provide a mimimum required
         // version.
@@ -597,19 +558,18 @@ void cmMakefile::EnforceDirectoryLevelRules() const
         this->IssueMessage(cmake::FATAL_ERROR, msg.str());
         cmSystemTools::SetFatalErrorOccured();
         return;
-      }
     }
+  }
 }
 
-void cmMakefile::AddEvaluationFile(const std::string& inputFile,
-                     cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
-                     cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
-                     bool inputIsContent)
+void cmMakefile::AddEvaluationFile(
+  const std::string& inputFile,
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
+  cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
+  bool inputIsContent)
 {
-  this->EvaluationFiles.push_back(
-              new cmGeneratorExpressionEvaluationFile(inputFile, outputName,
-                                                      condition,
-                                                      inputIsContent));
+  this->EvaluationFiles.push_back(new cmGeneratorExpressionEvaluationFile(
+    inputFile, outputName, condition, inputIsContent));
 }
 
 std::vector<cmGeneratorExpressionEvaluationFile*>
@@ -625,15 +585,14 @@ cmMakefile::GetExportBuildFileGenerators() const
 }
 
 void cmMakefile::RemoveExportBuildFileGeneratorCMP0024(
-    cmExportBuildFileGenerator* gen)
+  cmExportBuildFileGenerator* gen)
 {
   std::vector<cmExportBuildFileGenerator*>::iterator it =
-      std::find(this->ExportBuildFileGenerators.begin(),
-                this->ExportBuildFileGenerators.end(), gen);
-  if(it != this->ExportBuildFileGenerators.end())
-    {
+    std::find(this->ExportBuildFileGenerators.begin(),
+              this->ExportBuildFileGenerators.end(), gen);
+  if (it != this->ExportBuildFileGenerators.end()) {
     this->ExportBuildFileGenerators.erase(it);
-    }
+  }
 }
 
 void cmMakefile::AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen)
@@ -641,16 +600,15 @@ void cmMakefile::AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen)
   this->ExportBuildFileGenerators.push_back(gen);
 }
 
-namespace
+namespace {
+struct file_not_persistent
 {
-  struct file_not_persistent
+  bool operator()(const std::string& path) const
   {
-    bool operator()(const std::string& path) const
-      {
-      return !(path.find("CMakeTmp") == path.npos &&
-               cmSystemTools::FileExists(path.c_str()));
-      }
-  };
+    return !(path.find("CMakeTmp") == path.npos &&
+             cmSystemTools::FileExists(path.c_str()));
+  }
+};
 }
 
 void cmMakefile::FinalPass()
@@ -660,76 +618,63 @@ void cmMakefile::FinalPass()
 
   // give all the commands a chance to do something
   // after the file has been parsed before generation
-  for(std::vector<cmCommand*>::iterator i = this->FinalPassCommands.begin();
-      i != this->FinalPassCommands.end(); ++i)
-    {
+  for (std::vector<cmCommand*>::iterator i = this->FinalPassCommands.begin();
+       i != this->FinalPassCommands.end(); ++i) {
     (*i)->FinalPass();
-    }
+  }
 
-  //go through all configured files and see which ones still exist.
-  //we don't want cmake to re-run if a configured file is created and deleted
-  //during processing as that would make it a transient file that can't
-  //influence the build process
+  // go through all configured files and see which ones still exist.
+  // we don't want cmake to re-run if a configured file is created and deleted
+  // during processing as that would make it a transient file that can't
+  // influence the build process
 
-  //remove_if will move all items that don't have a valid file name to the
-  //back of the vector
+  // remove_if will move all items that don't have a valid file name to the
+  // back of the vector
   std::vector<std::string>::iterator new_output_files_end = std::remove_if(
-                                                     this->OutputFiles.begin(),
-                                                     this->OutputFiles.end(),
-                                                     file_not_persistent() );
-  //we just have to erase all items at the back
-  this->OutputFiles.erase(new_output_files_end, this->OutputFiles.end() );
-
-  //if a configured file is used as input for another configured file,
-  //and then deleted it will show up in the input list files so we
-  //need to scan those too
+    this->OutputFiles.begin(), this->OutputFiles.end(), file_not_persistent());
+  // we just have to erase all items at the back
+  this->OutputFiles.erase(new_output_files_end, this->OutputFiles.end());
+
+  // if a configured file is used as input for another configured file,
+  // and then deleted it will show up in the input list files so we
+  // need to scan those too
   std::vector<std::string>::iterator new_list_files_end = std::remove_if(
-                                                   this->ListFiles.begin(),
-                                                   this->ListFiles.end(),
-                                                   file_not_persistent() );
+    this->ListFiles.begin(), this->ListFiles.end(), file_not_persistent());
 
-  this->ListFiles.erase(new_list_files_end, this->ListFiles.end() );
+  this->ListFiles.erase(new_list_files_end, this->ListFiles.end());
 }
 
 // Generate the output file
 void cmMakefile::ConfigureFinalPass()
 {
   this->FinalPass();
-  const char* oldValue
-    = this->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
-  if (oldValue && cmSystemTools::VersionCompare(
-        cmSystemTools::OP_LESS, oldValue, "2.4"))
-    {
+  const char* oldValue = this->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
+  if (oldValue &&
+      cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, oldValue, "2.4")) {
     this->IssueMessage(
       cmake::FATAL_ERROR,
       "You have set CMAKE_BACKWARDS_COMPATIBILITY to a CMake version less "
       "than 2.4. This version of CMake only supports backwards compatibility "
       "with CMake 2.4 or later. For compatibility with older versions please "
       "use any CMake 2.8.x release or lower.");
-    }
+  }
 }
 
-void
-cmMakefile::AddCustomCommandToTarget(const std::string& target,
-                                   const std::vector<std::string>& byproducts,
-                                     const std::vector<std::string>& depends,
-                                     const cmCustomCommandLines& commandLines,
-                                     cmTarget::CustomCommandType type,
-                                     const char* comment,
-                                     const char* workingDir,
-                                     bool escapeOldStyle,
-                                     bool uses_terminal)
+void cmMakefile::AddCustomCommandToTarget(
+  const std::string& target, const std::vector<std::string>& byproducts,
+  const std::vector<std::string>& depends,
+  const cmCustomCommandLines& commandLines, cmTarget::CustomCommandType type,
+  const char* comment, const char* workingDir, bool escapeOldStyle,
+  bool uses_terminal)
 {
   // Find the target to which to add the custom command.
   cmTargets::iterator ti = this->Targets.find(target);
 
-  if(ti == this->Targets.end())
-    {
+  if (ti == this->Targets.end()) {
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
     bool issueMessage = false;
     std::ostringstream e;
-    switch(this->GetPolicyStatus(cmPolicies::CMP0040))
-      {
+    switch (this->GetPolicyStatus(cmPolicies::CMP0040)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0040) << "\n";
         issueMessage = true;
@@ -740,70 +685,59 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target,
       case cmPolicies::REQUIRED_ALWAYS:
         issueMessage = true;
         messageType = cmake::FATAL_ERROR;
-      }
+    }
 
-    if(issueMessage)
-      {
-      if (cmTarget const* t = this->FindTargetToUse(target))
-        {
-        if (t->IsImported())
-          {
+    if (issueMessage) {
+      if (cmTarget const* t = this->FindTargetToUse(target)) {
+        if (t->IsImported()) {
           e << "TARGET '" << target
             << "' is IMPORTED and does not build here.";
-          }
-        else
-          {
-          e << "TARGET '" << target
-            << "' was not created in this directory.";
-          }
+        } else {
+          e << "TARGET '" << target << "' was not created in this directory.";
         }
-      else
-        {
+      } else {
         e << "No TARGET '" << target
           << "' has been created in this directory.";
-        }
-      IssueMessage(messageType, e.str());
       }
-
-      return;
+      IssueMessage(messageType, e.str());
     }
 
-  if(ti->second.GetType() == cmState::OBJECT_LIBRARY)
-    {
+    return;
+  }
+
+  if (ti->second.GetType() == cmState::OBJECT_LIBRARY) {
     std::ostringstream e;
-    e << "Target \"" << target << "\" is an OBJECT library "
-      "that may not have PRE_BUILD, PRE_LINK, or POST_BUILD commands.";
+    e << "Target \"" << target
+      << "\" is an OBJECT library "
+         "that may not have PRE_BUILD, PRE_LINK, or POST_BUILD commands.";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
-  if(ti->second.GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  }
+  if (ti->second.GetType() == cmState::INTERFACE_LIBRARY) {
     std::ostringstream e;
-    e << "Target \"" << target << "\" is an INTERFACE library "
-      "that may not have PRE_BUILD, PRE_LINK, or POST_BUILD commands.";
+    e << "Target \"" << target
+      << "\" is an INTERFACE library "
+         "that may not have PRE_BUILD, PRE_LINK, or POST_BUILD commands.";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
+  }
 
   // Always create the byproduct sources and mark them generated.
-  for(std::vector<std::string>::const_iterator o = byproducts.begin();
-      o != byproducts.end(); ++o)
-    {
-    if(cmSourceFile* out = this->GetOrCreateSource(*o, true))
-      {
+  for (std::vector<std::string>::const_iterator o = byproducts.begin();
+       o != byproducts.end(); ++o) {
+    if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
       out->SetProperty("GENERATED", "1");
-      }
     }
+  }
 
   // Add the command to the appropriate build step for the target.
   std::vector<std::string> no_output;
-  cmCustomCommand cc(this, no_output, byproducts, depends,
-                     commandLines, comment, workingDir);
+  cmCustomCommand cc(this, no_output, byproducts, depends, commandLines,
+                     comment, workingDir);
   cc.SetEscapeOldStyle(escapeOldStyle);
   cc.SetEscapeAllowMakeVars(true);
   cc.SetUsesTerminal(uses_terminal);
-  switch(type)
-    {
+  switch (type) {
     case cmTarget::PRE_BUILD:
       ti->second.AddPreBuildCommand(cc);
       break;
@@ -813,74 +747,59 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target,
     case cmTarget::POST_BUILD:
       ti->second.AddPostBuildCommand(cc);
       break;
-    }
+  }
 }
 
-cmSourceFile*
-cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
-                                  const std::vector<std::string>& byproducts,
-                                     const std::vector<std::string>& depends,
-                                     const std::string& main_dependency,
-                                     const cmCustomCommandLines& commandLines,
-                                     const char* comment,
-                                     const char* workingDir,
-                                     bool replace,
-                                     bool escapeOldStyle,
-                                     bool uses_terminal)
+cmSourceFile* cmMakefile::AddCustomCommandToOutput(
+  const std::vector<std::string>& outputs,
+  const std::vector<std::string>& byproducts,
+  const std::vector<std::string>& depends, const std::string& main_dependency,
+  const cmCustomCommandLines& commandLines, const char* comment,
+  const char* workingDir, bool replace, bool escapeOldStyle,
+  bool uses_terminal)
 {
   // Make sure there is at least one output.
-  if(outputs.empty())
-    {
+  if (outputs.empty()) {
     cmSystemTools::Error("Attempt to add a custom rule with no output!");
     return 0;
-    }
+  }
 
   // Validate custom commands.  TODO: More strict?
-  for(cmCustomCommandLines::const_iterator i=commandLines.begin();
-      i != commandLines.end(); ++i)
-    {
+  for (cmCustomCommandLines::const_iterator i = commandLines.begin();
+       i != commandLines.end(); ++i) {
     cmCustomCommandLine const& cl = *i;
-    if(!cl.empty() && !cl[0].empty() && cl[0][0] == '"')
-      {
+    if (!cl.empty() && !cl[0].empty() && cl[0][0] == '"') {
       std::ostringstream e;
       e << "COMMAND may not contain literal quotes:\n  " << cl[0] << "\n";
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return 0;
-      }
     }
+  }
 
   // Choose a source file on which to store the custom command.
   cmSourceFile* file = 0;
-  if(!commandLines.empty() && !main_dependency.empty())
-    {
+  if (!commandLines.empty() && !main_dependency.empty()) {
     // The main dependency was specified.  Use it unless a different
     // custom command already used it.
     file = this->GetSource(main_dependency);
-    if(file && file->GetCustomCommand() && !replace)
-      {
+    if (file && file->GetCustomCommand() && !replace) {
       // The main dependency already has a custom command.
-      if(commandLines == file->GetCustomCommand()->GetCommandLines())
-        {
+      if (commandLines == file->GetCustomCommand()->GetCommandLines()) {
         // The existing custom command is identical.  Silently ignore
         // the duplicate.
         return file;
-        }
-      else
-        {
+      } else {
         // The existing custom command is different.  We need to
         // generate a rule file for this new command.
         file = 0;
-        }
       }
-    else if (!file)
-      {
+    } else if (!file) {
       file = this->CreateSource(main_dependency);
-      }
     }
+  }
 
   // Generate a rule file if the main dependency is not available.
-  if(!file)
-    {
+  if (!file) {
     cmGlobalGenerator* gg = this->GetGlobalGenerator();
 
     // Construct a rule file associated with the first output produced.
@@ -888,84 +807,70 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
 
     // Check if the rule file already exists.
     file = this->GetSource(outName);
-    if(file && file->GetCustomCommand() && !replace)
-      {
+    if (file && file->GetCustomCommand() && !replace) {
       // The rule file already exists.
-      if(commandLines != file->GetCustomCommand()->GetCommandLines())
-        {
+      if (commandLines != file->GetCustomCommand()->GetCommandLines()) {
         cmSystemTools::Error("Attempt to add a custom rule to output \"",
                              outName.c_str(),
                              "\" which already has a custom rule.");
-        }
-      return file;
       }
+      return file;
+    }
 
     // Create a cmSourceFile for the rule file.
-    if (!file)
-      {
+    if (!file) {
       file = this->CreateSource(outName, true);
-      }
-    file->SetProperty("__CMAKE_RULE", "1");
     }
+    file->SetProperty("__CMAKE_RULE", "1");
+  }
 
   // Always create the output sources and mark them generated.
-  for(std::vector<std::string>::const_iterator o = outputs.begin();
-      o != outputs.end(); ++o)
-    {
-    if(cmSourceFile* out = this->GetOrCreateSource(*o, true))
-      {
+  for (std::vector<std::string>::const_iterator o = outputs.begin();
+       o != outputs.end(); ++o) {
+    if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
       out->SetProperty("GENERATED", "1");
-      }
     }
-  for(std::vector<std::string>::const_iterator o = byproducts.begin();
-      o != byproducts.end(); ++o)
-    {
-    if(cmSourceFile* out = this->GetOrCreateSource(*o, true))
-      {
+  }
+  for (std::vector<std::string>::const_iterator o = byproducts.begin();
+       o != byproducts.end(); ++o) {
+    if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
       out->SetProperty("GENERATED", "1");
-      }
     }
+  }
 
   // Attach the custom command to the file.
-  if(file)
-    {
+  if (file) {
     // Construct a complete list of dependencies.
     std::vector<std::string> depends2(depends);
-    if(!main_dependency.empty())
-      {
+    if (!main_dependency.empty()) {
       depends2.push_back(main_dependency);
-      }
+    }
 
-    cmCustomCommand* cc =
-      new cmCustomCommand(this, outputs, byproducts, depends2,
-                          commandLines, comment, workingDir);
+    cmCustomCommand* cc = new cmCustomCommand(
+      this, outputs, byproducts, depends2, commandLines, comment, workingDir);
     cc->SetEscapeOldStyle(escapeOldStyle);
     cc->SetEscapeAllowMakeVars(true);
     cc->SetUsesTerminal(uses_terminal);
     file->SetCustomCommand(cc);
     this->UpdateOutputToSourceMap(outputs, file);
-    }
+  }
   return file;
 }
 
-void
-cmMakefile::UpdateOutputToSourceMap(std::vector<std::string> const& outputs,
-                                    cmSourceFile* source)
+void cmMakefile::UpdateOutputToSourceMap(
+  std::vector<std::string> const& outputs, cmSourceFile* source)
 {
-  for(std::vector<std::string>::const_iterator o = outputs.begin();
-      o != outputs.end(); ++o)
-    {
+  for (std::vector<std::string>::const_iterator o = outputs.begin();
+       o != outputs.end(); ++o) {
     this->UpdateOutputToSourceMap(*o, source);
-    }
+  }
 }
 
-void
-cmMakefile::UpdateOutputToSourceMap(std::string const& output,
-                                    cmSourceFile* source)
+void cmMakefile::UpdateOutputToSourceMap(std::string const& output,
+                                         cmSourceFile* source)
 {
   OutputToSourceMap::iterator i = this->OutputToSource.find(output);
-  if(i != this->OutputToSource.end())
-    {
+  if (i != this->OutputToSource.end()) {
     // Multiple custom commands produce the same output but may
     // be attached to a different source file (MAIN_DEPENDENCY).
     // LinearGetSourceFileWithOutput would return the first one,
@@ -975,131 +880,103 @@ cmMakefile::UpdateOutputToSourceMap(std::string const& output,
     // triggers it for separate generate.stamp rules in ZERO_CHECK and
     // individual targets.
     return;
-    }
+  }
   this->OutputToSource[output] = source;
 }
 
-cmSourceFile*
-cmMakefile::AddCustomCommandToOutput(const std::string& output,
-                                     const std::vector<std::string>& depends,
-                                     const std::string& main_dependency,
-                                     const cmCustomCommandLines& commandLines,
-                                     const char* comment,
-                                     const char* workingDir,
-                                     bool replace,
-                                     bool escapeOldStyle,
-                                     bool uses_terminal)
+cmSourceFile* cmMakefile::AddCustomCommandToOutput(
+  const std::string& output, const std::vector<std::string>& depends,
+  const std::string& main_dependency, const cmCustomCommandLines& commandLines,
+  const char* comment, const char* workingDir, bool replace,
+  bool escapeOldStyle, bool uses_terminal)
 {
   std::vector<std::string> outputs;
   outputs.push_back(output);
   std::vector<std::string> no_byproducts;
-  return this->AddCustomCommandToOutput(outputs, no_byproducts,
-                                        depends, main_dependency,
-                                        commandLines, comment, workingDir,
-                                        replace, escapeOldStyle,
-                                        uses_terminal);
+  return this->AddCustomCommandToOutput(
+    outputs, no_byproducts, depends, main_dependency, commandLines, comment,
+    workingDir, replace, escapeOldStyle, uses_terminal);
 }
 
-void
-cmMakefile::AddCustomCommandOldStyle(const std::string& target,
-                                     const std::vector<std::string>& outputs,
-                                     const std::vector<std::string>& depends,
-                                     const std::string& source,
-                                     const cmCustomCommandLines& commandLines,
-                                     const char* comment)
+void cmMakefile::AddCustomCommandOldStyle(
+  const std::string& target, const std::vector<std::string>& outputs,
+  const std::vector<std::string>& depends, const std::string& source,
+  const cmCustomCommandLines& commandLines, const char* comment)
 {
   // Translate the old-style signature to one of the new-style
   // signatures.
-  if(source == target)
-    {
+  if (source == target) {
     // In the old-style signature if the source and target were the
     // same then it added a post-build rule to the target.  Preserve
     // this behavior.
     std::vector<std::string> no_byproducts;
-    this->AddCustomCommandToTarget(target, no_byproducts,
-                                   depends, commandLines,
-                                   cmTarget::POST_BUILD, comment, 0);
+    this->AddCustomCommandToTarget(target, no_byproducts, depends,
+                                   commandLines, cmTarget::POST_BUILD, comment,
+                                   0);
     return;
-    }
+  }
 
   // Each output must get its own copy of this rule.
   cmsys::RegularExpression sourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|"
                                        "rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|"
                                        "hm|hpp|hxx|in|txx|inl)$");
-  for(std::vector<std::string>::const_iterator oi = outputs.begin();
-      oi != outputs.end(); ++oi)
-    {
+  for (std::vector<std::string>::const_iterator oi = outputs.begin();
+       oi != outputs.end(); ++oi) {
     // Get the name of this output.
     const char* output = oi->c_str();
     cmSourceFile* sf;
 
     // Choose whether to use a main dependency.
-    if(sourceFiles.find(source))
-      {
+    if (sourceFiles.find(source)) {
       // The source looks like a real file.  Use it as the main dependency.
       sf = this->AddCustomCommandToOutput(output, depends, source,
                                           commandLines, comment, 0);
-      }
-    else
-      {
+    } else {
       // The source may not be a real file.  Do not use a main dependency.
       std::string no_main_dependency = "";
       std::vector<std::string> depends2 = depends;
       depends2.push_back(source);
       sf = this->AddCustomCommandToOutput(output, depends2, no_main_dependency,
                                           commandLines, comment, 0);
-      }
+    }
 
     // If the rule was added to the source (and not a .rule file),
     // then add the source to the target to make sure the rule is
     // included.
-    if(sf && !sf->GetPropertyAsBool("__CMAKE_RULE"))
-      {
-      if (this->Targets.find(target) != this->Targets.end())
-        {
+    if (sf && !sf->GetPropertyAsBool("__CMAKE_RULE")) {
+      if (this->Targets.find(target) != this->Targets.end()) {
         this->Targets[target].AddSource(sf->GetFullPath());
-        }
-      else
-        {
+      } else {
         cmSystemTools::Error("Attempt to add a custom rule to a target "
                              "that does not exist yet for target ",
                              target.c_str());
         return;
-        }
       }
     }
+  }
 }
 
-cmTarget*
-cmMakefile::AddUtilityCommand(const std::string& utilityName,
-                              bool excludeFromAll,
-                              const std::vector<std::string>& depends,
-                              const char* workingDirectory,
-                              const char* command,
-                              const char* arg1,
-                              const char* arg2,
-                              const char* arg3,
-                              const char* arg4)
+cmTarget* cmMakefile::AddUtilityCommand(
+  const std::string& utilityName, bool excludeFromAll,
+  const std::vector<std::string>& depends, const char* workingDirectory,
+  const char* command, const char* arg1, const char* arg2, const char* arg3,
+  const char* arg4)
 {
   // Construct the command line for the custom command.
   cmCustomCommandLine commandLine;
   commandLine.push_back(command);
-  if(arg1)
-    {
+  if (arg1) {
     commandLine.push_back(arg1);
-    }
-  if(arg2)
-    {
+  }
+  if (arg2) {
     commandLine.push_back(arg2);
-    }
-  if(arg3)
-    {
+  }
+  if (arg3) {
     commandLine.push_back(arg3);
-    }
-  if(arg4)
-    {
+  }
+  if (arg4) {
     commandLine.push_back(arg4);
-    }
+  }
   cmCustomCommandLines commandLines;
   commandLines.push_back(commandLine);
 
@@ -1108,14 +985,11 @@ cmMakefile::AddUtilityCommand(const std::string& utilityName,
                                  depends, commandLines);
 }
 
-cmTarget*
-cmMakefile::AddUtilityCommand(const std::string& utilityName,
-                              bool excludeFromAll,
-                              const char* workingDirectory,
-                              const std::vector<std::string>& depends,
-                              const cmCustomCommandLines& commandLines,
-                              bool escapeOldStyle, const char* comment,
-                              bool uses_terminal)
+cmTarget* cmMakefile::AddUtilityCommand(
+  const std::string& utilityName, bool excludeFromAll,
+  const char* workingDirectory, const std::vector<std::string>& depends,
+  const cmCustomCommandLines& commandLines, bool escapeOldStyle,
+  const char* comment, bool uses_terminal)
 {
   std::vector<std::string> no_byproducts;
   return this->AddUtilityCommand(utilityName, excludeFromAll, workingDirectory,
@@ -1123,31 +997,25 @@ cmMakefile::AddUtilityCommand(const std::string& utilityName,
                                  escapeOldStyle, comment, uses_terminal);
 }
 
-cmTarget*
-cmMakefile::AddUtilityCommand(const std::string& utilityName,
-                              bool excludeFromAll,
-                              const char* workingDirectory,
-                              const std::vector<std::string>& byproducts,
-                              const std::vector<std::string>& depends,
-                              const cmCustomCommandLines& commandLines,
-                              bool escapeOldStyle, const char* comment,
-                              bool uses_terminal)
+cmTarget* cmMakefile::AddUtilityCommand(
+  const std::string& utilityName, bool excludeFromAll,
+  const char* workingDirectory, const std::vector<std::string>& byproducts,
+  const std::vector<std::string>& depends,
+  const cmCustomCommandLines& commandLines, bool escapeOldStyle,
+  const char* comment, bool uses_terminal)
 {
   // Create a target instance for this utility.
   cmTarget* target = this->AddNewTarget(cmState::UTILITY, utilityName);
-  if (excludeFromAll)
-    {
+  if (excludeFromAll) {
     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
-    }
-  if(!comment)
-    {
+  }
+  if (!comment) {
     // Use an empty comment to avoid generation of default comment.
     comment = "";
-    }
+  }
 
   // Store the custom command in the target.
-  if (!commandLines.empty() || !depends.empty())
-    {
+  if (!commandLines.empty() || !depends.empty()) {
     std::string force = this->GetCurrentBinaryDirectory();
     force += cmake::GetCMakeFilesDirectory();
     force += "/";
@@ -1156,52 +1024,43 @@ cmMakefile::AddUtilityCommand(const std::string& utilityName,
     forced.push_back(force);
     std::string no_main_dependency = "";
     bool no_replace = false;
-    this->AddCustomCommandToOutput(forced, byproducts,
-                                   depends, no_main_dependency,
-                                   commandLines, comment,
-                                   workingDirectory, no_replace,
-                                   escapeOldStyle, uses_terminal);
+    this->AddCustomCommandToOutput(
+      forced, byproducts, depends, no_main_dependency, commandLines, comment,
+      workingDirectory, no_replace, escapeOldStyle, uses_terminal);
     cmSourceFile* sf = target->AddSourceCMP0049(force);
 
     // The output is not actually created so mark it symbolic.
-    if(sf)
-      {
+    if (sf) {
       sf->SetProperty("SYMBOLIC", "1");
-      }
-    else
-      {
+    } else {
       cmSystemTools::Error("Could not get source file entry for ",
-                          force.c_str());
-      }
+                           force.c_str());
+    }
 
     // Always create the byproduct sources and mark them generated.
-    for(std::vector<std::string>::const_iterator o = byproducts.begin();
-        o != byproducts.end(); ++o)
-      {
-      if(cmSourceFile* out = this->GetOrCreateSource(*o, true))
-        {
+    for (std::vector<std::string>::const_iterator o = byproducts.begin();
+         o != byproducts.end(); ++o) {
+      if (cmSourceFile* out = this->GetOrCreateSource(*o, true)) {
         out->SetProperty("GENERATED", "1");
-        }
       }
     }
+  }
   return target;
 }
 
 void cmMakefile::AddDefineFlag(const char* flag)
 {
-  if (!flag)
-    {
+  if (!flag) {
     return;
-    }
+  }
 
   // Update the string used for the old DEFINITIONS property.
   this->AddDefineFlag(flag, this->DefineFlagsOrig);
 
   // If this is really a definition, update COMPILE_DEFINITIONS.
-  if(this->ParseDefineFlag(flag, false))
-    {
+  if (this->ParseDefineFlag(flag, false)) {
     return;
-    }
+  }
 
   // Add this flag that does not look like a definition.
   this->AddDefineFlag(flag, this->DefineFlags);
@@ -1217,49 +1076,41 @@ void cmMakefile::AddDefineFlag(const char* flag, std::string& dflags)
   std::replace(flagStart, dflags.end(), '\r', ' ');
 }
 
-
 void cmMakefile::RemoveDefineFlag(const char* flag)
 {
   // Check the length of the flag to remove.
   std::string::size_type len = strlen(flag);
-  if(len < 1)
-    {
+  if (len < 1) {
     return;
-    }
+  }
 
   // Update the string used for the old DEFINITIONS property.
   this->RemoveDefineFlag(flag, len, this->DefineFlagsOrig);
 
   // If this is really a definition, update COMPILE_DEFINITIONS.
-  if(this->ParseDefineFlag(flag, true))
-    {
+  if (this->ParseDefineFlag(flag, true)) {
     return;
-    }
+  }
 
   // Remove this flag that does not look like a definition.
   this->RemoveDefineFlag(flag, len, this->DefineFlags);
 }
 
-void cmMakefile::RemoveDefineFlag(const char* flag,
-                                  std::string::size_type len,
+void cmMakefile::RemoveDefineFlag(const char* flag, std::string::size_type len,
                                   std::string& dflags)
 {
   // Remove all instances of the flag that are surrounded by
   // whitespace or the beginning/end of the string.
-  for(std::string::size_type lpos = dflags.find(flag, 0);
-      lpos != std::string::npos; lpos = dflags.find(flag, lpos))
-    {
+  for (std::string::size_type lpos = dflags.find(flag, 0);
+       lpos != std::string::npos; lpos = dflags.find(flag, lpos)) {
     std::string::size_type rpos = lpos + len;
-    if((lpos <= 0 || isspace(dflags[lpos-1])) &&
-       (rpos >= dflags.size() || isspace(dflags[rpos])))
-      {
+    if ((lpos <= 0 || isspace(dflags[lpos - 1])) &&
+        (rpos >= dflags.size() || isspace(dflags[rpos]))) {
       dflags.erase(lpos, len);
-      }
-    else
-      {
+    } else {
       ++lpos;
-      }
     }
+  }
 }
 
 void cmMakefile::AddCompileOption(const char* option)
@@ -1270,28 +1121,22 @@ void cmMakefile::AddCompileOption(const char* option)
 bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
 {
   // Create a regular expression to match valid definitions.
-  static cmsys::RegularExpression
-    valid("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=.*)?$");
+  static cmsys::RegularExpression valid("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=.*)?$");
 
   // Make sure the definition matches.
-  if(!valid.find(def.c_str()))
-    {
+  if (!valid.find(def.c_str())) {
     return false;
-    }
+  }
 
   // Definitions with non-trivial values require a policy check.
-  static cmsys::RegularExpression
-    trivial("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=[A-Za-z0-9_.]+)?$");
-  if(!trivial.find(def.c_str()))
-    {
+  static cmsys::RegularExpression trivial(
+    "^[-/]D[A-Za-z_][A-Za-z0-9_]*(=[A-Za-z0-9_.]+)?$");
+  if (!trivial.find(def.c_str())) {
     // This definition has a non-trivial value.
-    switch(this->GetPolicyStatus(cmPolicies::CMP0005))
-      {
+    switch (this->GetPolicyStatus(cmPolicies::CMP0005)) {
       case cmPolicies::WARN:
-        this->IssueMessage(
-          cmake::AUTHOR_WARNING,
-          cmPolicies::GetPolicyWarning(cmPolicies::CMP0005)
-          );
+        this->IssueMessage(cmake::AUTHOR_WARNING,
+                           cmPolicies::GetPolicyWarning(cmPolicies::CMP0005));
       case cmPolicies::OLD:
         // OLD behavior is to not escape the value.  We should not
         // convert the definition to use the property.
@@ -1300,43 +1145,37 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
       case cmPolicies::REQUIRED_ALWAYS:
         this->IssueMessage(
           cmake::FATAL_ERROR,
-          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0005)
-          );
+          cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0005));
         return false;
       case cmPolicies::NEW:
         // NEW behavior is to escape the value.  Proceed to convert it
         // to an entry in the property.
         break;
-      }
     }
+  }
 
   // Get the definition part after the flag.
   const char* define = def.c_str() + 2;
 
-  if(remove)
-    {
-    if(const char* cdefs = this->GetProperty("COMPILE_DEFINITIONS"))
-      {
+  if (remove) {
+    if (const char* cdefs = this->GetProperty("COMPILE_DEFINITIONS")) {
       // Expand the list.
       std::vector<std::string> defs;
       cmSystemTools::ExpandListArgument(cdefs, defs);
 
       // Recompose the list without the definition.
       std::vector<std::string>::const_iterator defEnd =
-          std::remove(defs.begin(), defs.end(), define);
-      std::vector<std::string>::const_iterator defBegin =
-          defs.begin();
+        std::remove(defs.begin(), defs.end(), define);
+      std::vector<std::string>::const_iterator defBegin = defs.begin();
       std::string ndefs = cmJoin(cmMakeRange(defBegin, defEnd), ";");
 
       // Store the new list.
       this->SetProperty("COMPILE_DEFINITIONS", ndefs.c_str());
-      }
     }
-  else
-    {
+  } else {
     // Append the definition to the directory property.
     this->AppendProperty("COMPILE_DEFINITIONS", define);
-    }
+  }
 
   return true;
 }
@@ -1355,17 +1194,14 @@ void cmMakefile::AddLinkLibraryForTarget(const std::string& target,
                                          cmTargetLinkLibraryType llt)
 {
   cmTargets::iterator i = this->Targets.find(target);
-  if ( i != this->Targets.end())
-    {
+  if (i != this->Targets.end()) {
     cmTarget* tgt = this->GetGlobalGenerator()->FindTarget(lib);
-    if(tgt)
-      {
+    if (tgt) {
       // if it is not a static or shared library then you can not link to it
-      if(!((tgt->GetType() == cmState::STATIC_LIBRARY) ||
-           (tgt->GetType() == cmState::SHARED_LIBRARY) ||
-           (tgt->GetType() == cmState::INTERFACE_LIBRARY) ||
-           tgt->IsExecutableWithExports()))
-        {
+      if (!((tgt->GetType() == cmState::STATIC_LIBRARY) ||
+            (tgt->GetType() == cmState::SHARED_LIBRARY) ||
+            (tgt->GetType() == cmState::INTERFACE_LIBRARY) ||
+            tgt->IsExecutableWithExports())) {
         std::ostringstream e;
         e << "Target \"" << lib << "\" of type "
           << cmState::GetTargetTypeName(tgt->GetType())
@@ -1373,47 +1209,40 @@ void cmMakefile::AddLinkLibraryForTarget(const std::string& target,
           << "One may link only to STATIC or SHARED libraries, or "
           << "to executables with the ENABLE_EXPORTS property set.";
         this->IssueMessage(cmake::FATAL_ERROR, e.str());
-        }
       }
-    i->second.AddLinkLibrary( *this, target, lib, llt );
     }
-  else
-    {
+    i->second.AddLinkLibrary(*this, target, lib, llt);
+  } else {
     std::ostringstream e;
-    e << "Attempt to add link library \""
-      << lib << "\" to target \""
-      << target << "\" which is not built in this directory.";
+    e << "Attempt to add link library \"" << lib << "\" to target \"" << target
+      << "\" which is not built in this directory.";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
+  }
 }
 
 void cmMakefile::AddLinkDirectoryForTarget(const std::string& target,
                                            const std::string& d)
 {
   cmTargets::iterator i = this->Targets.find(target);
-  if ( i != this->Targets.end())
-    {
-    if(this->IsAlias(target))
-      {
+  if (i != this->Targets.end()) {
+    if (this->IsAlias(target)) {
       std::ostringstream e;
       e << "ALIAS target \"" << target << "\" "
         << "may not be linked into another target.";
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
-    i->second.AddLinkDirectory( d );
-    }
-  else
-    {
-    cmSystemTools::Error
-      ("Attempt to add link directories to non-existent target: ",
-       target.c_str(), " for directory ", d.c_str());
     }
+    i->second.AddLinkDirectory(d);
+  } else {
+    cmSystemTools::Error(
+      "Attempt to add link directories to non-existent target: ",
+      target.c_str(), " for directory ", d.c_str());
+  }
 }
 
 void cmMakefile::AddLinkLibrary(const std::string& lib)
 {
-  this->AddLinkLibrary(lib,GENERAL_LibraryType);
+  this->AddLinkLibrary(lib, GENERAL_LibraryType);
 }
 
 void cmMakefile::InitializeFromParent(cmMakefile* parent)
@@ -1426,27 +1255,25 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent)
 
   // Include transform property.  There is no per-config version.
   {
-  const char* prop = "IMPLICIT_DEPENDS_INCLUDE_TRANSFORM";
-  this->SetProperty(prop, parent->GetProperty(prop));
+    const char* prop = "IMPLICIT_DEPENDS_INCLUDE_TRANSFORM";
+    this->SetProperty(prop, parent->GetProperty(prop));
   }
 
   // compile definitions property and per-config versions
   cmPolicies::PolicyStatus polSt = this->GetPolicyStatus(cmPolicies::CMP0043);
-  if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD)
-    {
+  if (polSt == cmPolicies::WARN || polSt == cmPolicies::OLD) {
     this->SetProperty("COMPILE_DEFINITIONS",
                       parent->GetProperty("COMPILE_DEFINITIONS"));
     std::vector<std::string> configs;
     this->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);
       const char* prop = parent->GetProperty(defPropName);
       this->SetProperty(defPropName, prop);
-      }
     }
+  }
 
   // link libraries
   this->LinkLibraries = parent->LinkLibraries;
@@ -1468,9 +1295,8 @@ void cmMakefile::InitializeFromParent(cmMakefile* parent)
 void cmMakefile::PushFunctionScope(std::string const& fileName,
                                    const cmPolicies::PolicyMap& pm)
 {
-  this->StateSnapshot =
-      this->GetState()->CreateFunctionCallSnapshot(
-        this->StateSnapshot, fileName);
+  this->StateSnapshot = this->GetState()->CreateFunctionCallSnapshot(
+    this->StateSnapshot, fileName);
   assert(this->StateSnapshot.IsValid());
 
   this->PushLoopBlockBarrier();
@@ -1505,8 +1331,7 @@ void cmMakefile::PushMacroScope(std::string const& fileName,
                                 const cmPolicies::PolicyMap& pm)
 {
   this->StateSnapshot =
-      this->GetState()->CreateMacroCallSnapshot(
-        this->StateSnapshot, fileName);
+    this->GetState()->CreateMacroCallSnapshot(this->StateSnapshot, fileName);
   assert(this->StateSnapshot.IsValid());
 
   this->PushFunctionBlockerBarrier();
@@ -1531,14 +1356,16 @@ class cmMakefile::BuildsystemFileScope
 {
 public:
   BuildsystemFileScope(cmMakefile* mf)
-    : Makefile(mf), ReportError(true)
+    : Makefile(mf)
+    , ReportError(true)
   {
     std::string currentStart =
-        this->Makefile->StateSnapshot.GetDirectory().GetCurrentSource();
+      this->Makefile->StateSnapshot.GetDirectory().GetCurrentSource();
     currentStart += "/CMakeLists.txt";
     this->Makefile->StateSnapshot.SetListFile(currentStart);
-    this->Makefile->StateSnapshot = this->Makefile->StateSnapshot.GetState()
-        ->CreatePolicyScopeSnapshot(this->Makefile->StateSnapshot);
+    this->Makefile->StateSnapshot =
+      this->Makefile->StateSnapshot.GetState()->CreatePolicyScopeSnapshot(
+        this->Makefile->StateSnapshot);
     this->Makefile->PushFunctionBlockerBarrier();
 
     this->GG = mf->GetGlobalGenerator();
@@ -1574,7 +1401,7 @@ private:
 void cmMakefile::Configure()
 {
   std::string currentStart =
-      this->StateSnapshot.GetDirectory().GetCurrentSource();
+    this->StateSnapshot.GetDirectory().GetCurrentSource();
   currentStart += "/CMakeLists.txt";
 
   // Add the bottom of all backtraces within this directory.
@@ -1593,44 +1420,40 @@ void cmMakefile::Configure()
   this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart.c_str());
 
   cmListFile listFile;
-  if (!listFile.ParseFile(currentStart.c_str(), this->IsRootMakefile(), this))
-    {
+  if (!listFile.ParseFile(currentStart.c_str(), this->IsRootMakefile(),
+                          this)) {
     return;
-    }
+  }
   this->ReadListFile(listFile, currentStart);
-  if(cmSystemTools::GetFatalErrorOccured())
-    {
+  if (cmSystemTools::GetFatalErrorOccured()) {
     scope.Quiet();
-    }
+  }
 
-   // at the end handle any old style subdirs
+  // at the end handle any old style subdirs
   std::vector<cmMakefile*> subdirs = this->UnConfiguredDirectories;
 
   // for each subdir recurse
   std::vector<cmMakefile*>::iterator sdi = subdirs.begin();
-  for (; sdi != subdirs.end(); ++sdi)
-    {
+  for (; sdi != subdirs.end(); ++sdi) {
     (*sdi)->StateSnapshot.InitializeFromParent_ForSubdirsCommand();
     this->ConfigureSubDirectory(*sdi);
-    }
+  }
 
   this->AddCMakeDependFilesFromUser();
 }
 
-void cmMakefile::ConfigureSubDirectory(cmMakefile *mf)
+void cmMakefile::ConfigureSubDirectory(cmMakefile* mf)
 {
   mf->InitializeFromParent(this);
   std::string currentStart = mf->GetCurrentSourceDirectory();
-  if (this->GetCMakeInstance()->GetDebugOutput())
-    {
-    std::string msg="   Entering             ";
+  if (this->GetCMakeInstance()->GetDebugOutput()) {
+    std::string msg = "   Entering             ";
     msg += currentStart;
     cmSystemTools::Message(msg.c_str());
-    }
+  }
 
   std::string const currentStartFile = currentStart + "/CMakeLists.txt";
-  if (!cmSystemTools::FileExists(currentStartFile, true))
-    {
+  if (!cmSystemTools::FileExists(currentStartFile, true)) {
     // The file is missing.  Check policy CMP0014.
     std::ostringstream e;
     /* clang-format off */
@@ -1638,8 +1461,7 @@ void cmMakefile::ConfigureSubDirectory(cmMakefile *mf)
       << "  " << currentStart << "\n"
       << "does not contain a CMakeLists.txt file.";
     /* clang-format on */
-    switch (this->GetPolicyStatus(cmPolicies::CMP0014))
-      {
+    switch (this->GetPolicyStatus(cmPolicies::CMP0014)) {
       case cmPolicies::WARN:
         // Print the warning.
         /* clang-format off */
@@ -1656,38 +1478,34 @@ void cmMakefile::ConfigureSubDirectory(cmMakefile *mf)
         break;
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::REQUIRED_ALWAYS:
-        e << "\n"
-          << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0014);
+        e << "\n" << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0014);
       case cmPolicies::NEW:
         // NEW behavior prints the error.
         this->IssueMessage(cmake::FATAL_ERROR, e.str());
-      }
-    return;
     }
+    return;
+  }
   // finally configure the subdir
   mf->Configure();
 
-  if (this->GetCMakeInstance()->GetDebugOutput())
-    {
-    std::string msg="   Returning to         ";
+  if (this->GetCMakeInstance()->GetDebugOutput()) {
+    std::string msg = "   Returning to         ";
     msg += this->GetCurrentSourceDirectory();
     cmSystemTools::Message(msg.c_str());
-    }
+  }
 }
 
 void cmMakefile::AddSubDirectory(const std::string& srcPath,
                                  const std::string& binPath,
-                                 bool excludeFromAll,
-                                 bool immediate)
+                                 bool excludeFromAll, bool immediate)
 {
   // Make sure the binary directory is unique.
-  if(!this->EnforceUniqueDir(srcPath, binPath))
-    {
+  if (!this->EnforceUniqueDir(srcPath, binPath)) {
     return;
-    }
+  }
 
-  cmState::Snapshot newSnapshot = this->GetState()
-      ->CreateBuildsystemDirectorySnapshot(this->StateSnapshot);
+  cmState::Snapshot newSnapshot =
+    this->GetState()->CreateBuildsystemDirectorySnapshot(this->StateSnapshot);
 
   newSnapshot.GetDirectory().SetCurrentSource(srcPath);
   newSnapshot.GetDirectory().SetCurrentBinary(binPath);
@@ -1697,19 +1515,15 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath,
   cmMakefile* subMf = new cmMakefile(this->GlobalGenerator, newSnapshot);
   this->GetGlobalGenerator()->AddMakefile(subMf);
 
-  if(excludeFromAll)
-    {
+  if (excludeFromAll) {
     subMf->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
-    }
+  }
 
-  if (immediate)
-    {
+  if (immediate) {
     this->ConfigureSubDirectory(subMf);
-    }
-  else
-    {
+  } else {
     this->UnConfiguredDirectories.push_back(subMf);
-    }
+  }
 }
 
 const char* cmMakefile::GetCurrentSourceDirectory() const
@@ -1727,166 +1541,137 @@ std::vector<cmTarget*> cmMakefile::GetImportedTargets() const
   std::vector<cmTarget*> tgts;
   tgts.reserve(this->ImportedTargets.size());
   for (TargetMap::const_iterator it = this->ImportedTargets.begin();
-       it != this->ImportedTargets.end(); ++it)
-    {
+       it != this->ImportedTargets.end(); ++it) {
     tgts.push_back(it->second);
-    }
+  }
   return tgts;
 }
 
-void cmMakefile::AddIncludeDirectories(const std::vector<std::string> &incs,
+void cmMakefile::AddIncludeDirectories(const std::vector<std::string>& incs,
                                        bool before)
 {
-  if (incs.empty())
-    {
+  if (incs.empty()) {
     return;
-    }
+  }
 
   cmListFileBacktrace lfbt = this->GetBacktrace();
   std::string entryString = cmJoin(incs, ";");
-  if (before)
-    {
-    this->StateSnapshot.GetDirectory()
-          .PrependIncludeDirectoriesEntry(entryString, lfbt);
-    }
-  else
-    {
-    this->StateSnapshot.GetDirectory()
-          .AppendIncludeDirectoriesEntry(entryString, lfbt);
-    }
+  if (before) {
+    this->StateSnapshot.GetDirectory().PrependIncludeDirectoriesEntry(
+      entryString, lfbt);
+  } else {
+    this->StateSnapshot.GetDirectory().AppendIncludeDirectoriesEntry(
+      entryString, lfbt);
+  }
 
   // Property on each target:
-  for (cmTargets::iterator l = this->Targets.begin();
-       l != this->Targets.end(); ++l)
-    {
-    cmTarget &t = l->second;
+  for (cmTargets::iterator l = this->Targets.begin(); l != this->Targets.end();
+       ++l) {
+    cmTarget& t = l->second;
     t.InsertInclude(entryString, lfbt, before);
-    }
+  }
 }
 
-void
-cmMakefile::AddSystemIncludeDirectories(const std::set<std::string> &incs)
+void cmMakefile::AddSystemIncludeDirectories(const std::set<std::string>& incs)
 {
   this->SystemIncludeDirectories.insert(incs.begin(), incs.end());
 
-  for (cmTargets::iterator l = this->Targets.begin();
-       l != this->Targets.end(); ++l)
-    {
-    cmTarget &t = l->second;
+  for (cmTargets::iterator l = this->Targets.begin(); l != this->Targets.end();
+       ++l) {
+    cmTarget& t = l->second;
     t.AddSystemIncludeDirectories(incs);
-    }
+  }
 }
 
 void cmMakefile::AddDefinition(const std::string& name, const char* value)
 {
-  if (!value )
-    {
+  if (!value) {
     return;
-    }
+  }
 
-  if (this->VariableInitialized(name))
-    {
+  if (this->VariableInitialized(name)) {
     this->LogUnused("changing definition", name);
-    }
+  }
   this->StateSnapshot.SetDefinition(name, value);
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
-  if ( vv )
-    {
-    vv->VariableAccessed(name,
-                         cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
-                         value,
-                         this);
-    }
+  if (vv) {
+    vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
+                         value, this);
+  }
 #endif
 }
 
-
 void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
                                     const char* doc,
-                                    cmState::CacheEntryType type,
-                                    bool force)
+                                    cmState::CacheEntryType type, bool force)
 {
-  const char* existingValue =
-    this->GetState()->GetInitializedCacheValue(name);
+  const char* existingValue = this->GetState()->GetInitializedCacheValue(name);
   // must be outside the following if() to keep it alive long enough
   std::string nvalue;
 
-  if(existingValue
-      && (this->GetState()->GetCacheEntryType(name)
-                                            == cmState::UNINITIALIZED))
-    {
+  if (existingValue &&
+      (this->GetState()->GetCacheEntryType(name) == cmState::UNINITIALIZED)) {
     // if this is not a force, then use the value from the cache
     // if it is a force, then use the value being passed in
-    if(!force)
-      {
+    if (!force) {
       value = existingValue;
-      }
-    if ( type == cmState::PATH || type == cmState::FILEPATH )
-      {
+    }
+    if (type == cmState::PATH || type == cmState::FILEPATH) {
       std::vector<std::string>::size_type cc;
       std::vector<std::string> files;
       nvalue = value ? value : "";
 
       cmSystemTools::ExpandListArgument(nvalue, files);
       nvalue = "";
-      for ( cc = 0; cc < files.size(); cc ++ )
-        {
-        if(!cmSystemTools::IsOff(files[cc].c_str()))
-          {
+      for (cc = 0; cc < files.size(); cc++) {
+        if (!cmSystemTools::IsOff(files[cc].c_str())) {
           files[cc] = cmSystemTools::CollapseFullPath(files[cc]);
-          }
-        if ( cc > 0 )
-          {
+        }
+        if (cc > 0) {
           nvalue += ";";
-          }
-        nvalue += files[cc];
         }
+        nvalue += files[cc];
+      }
 
       this->GetCMakeInstance()->AddCacheEntry(name, nvalue.c_str(), doc, type);
       nvalue = this->GetState()->GetInitializedCacheValue(name);
       value = nvalue.c_str();
-      }
-
     }
+  }
   this->GetCMakeInstance()->AddCacheEntry(name, value, doc, type);
   // if there was a definition then remove it
   this->StateSnapshot.RemoveDefinition(name);
 }
 
-
 void cmMakefile::AddDefinition(const std::string& name, bool value)
 {
-  if (this->VariableInitialized(name))
-    {
+  if (this->VariableInitialized(name)) {
     this->LogUnused("changing definition", name);
-    }
+  }
 
   this->StateSnapshot.SetDefinition(name, value ? "ON" : "OFF");
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
-  if ( vv )
-    {
+  if (vv) {
     vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
-      value?"ON":"OFF", this);
-    }
+                         value ? "ON" : "OFF", this);
+  }
 #endif
 }
 
 void cmMakefile::CheckForUnusedVariables() const
 {
-  if (!this->WarnUnused)
-    {
+  if (!this->WarnUnused) {
     return;
-    }
+  }
   const std::vector<std::string>& unused = this->StateSnapshot.UnusedKeys();
   std::vector<std::string>::const_iterator it = unused.begin();
-  for (; it != unused.end(); ++it)
-    {
+  for (; it != unused.end(); ++it) {
     this->LogUnused("out of scope", *it);
-    }
+  }
 }
 
 void cmMakefile::MarkVariableAsUsed(const std::string& var)
@@ -1899,51 +1684,41 @@ bool cmMakefile::VariableInitialized(const std::string& var) const
   return this->StateSnapshot.IsInitialized(var);
 }
 
-void cmMakefile::LogUnused(const char* reason,
-                                const std::string& name) const
+void cmMakefile::LogUnused(const char* reason, const std::string& name) const
 {
-  if (this->WarnUnused)
-    {
+  if (this->WarnUnused) {
     std::string path;
-    if (!this->ExecutionStatusStack.empty())
-      {
+    if (!this->ExecutionStatusStack.empty()) {
       path = this->GetExecutionContext().FilePath;
-      }
-    else
-      {
+    } else {
       path = this->GetCurrentSourceDirectory();
       path += "/CMakeLists.txt";
-      }
+    }
 
     if (this->CheckSystemVars ||
-        cmSystemTools::IsSubDirectory(path,
-                                      this->GetHomeDirectory()) ||
-        (cmSystemTools::IsSubDirectory(path,
-                                      this->GetHomeOutputDirectory()) &&
-        !cmSystemTools::IsSubDirectory(path,
-                                cmake::GetCMakeFilesDirectory())))
-      {
+        cmSystemTools::IsSubDirectory(path, this->GetHomeDirectory()) ||
+        (cmSystemTools::IsSubDirectory(path, this->GetHomeOutputDirectory()) &&
+         !cmSystemTools::IsSubDirectory(path,
+                                        cmake::GetCMakeFilesDirectory()))) {
       std::ostringstream msg;
       msg << "unused variable (" << reason << ") \'" << name << "\'";
       this->IssueMessage(cmake::AUTHOR_WARNING, msg.str());
-      }
     }
+  }
 }
 
 void cmMakefile::RemoveDefinition(const std::string& name)
 {
-  if (this->VariableInitialized(name))
-    {
+  if (this->VariableInitialized(name)) {
     this->LogUnused("unsetting", name);
-    }
+  }
   this->StateSnapshot.RemoveDefinition(name);
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
-  if ( vv )
-    {
-    vv->VariableAccessed(name, cmVariableWatch::VARIABLE_REMOVED_ACCESS,
-      0, this);
-    }
+  if (vv) {
+    vv->VariableAccessed(name, cmVariableWatch::VARIABLE_REMOVED_ACCESS, 0,
+                         this);
+  }
 #endif
 }
 
@@ -1961,94 +1736,81 @@ void cmMakefile::AddGlobalLinkInformation(const std::string& name,
                                           cmTarget& target)
 {
   // for these targets do not add anything
-  switch(target.GetType())
-    {
+  switch (target.GetType()) {
     case cmState::UTILITY:
     case cmState::GLOBAL_TARGET:
     case cmState::INTERFACE_LIBRARY:
       return;
     default:;
-    }
-  if (const char* linkDirsProp = this->GetProperty("LINK_DIRECTORIES"))
-    {
+  }
+  if (const char* linkDirsProp = this->GetProperty("LINK_DIRECTORIES")) {
     std::vector<std::string> linkDirs;
     cmSystemTools::ExpandListArgument(linkDirsProp, linkDirs);
 
-    for(std::vector<std::string>::iterator j = linkDirs.begin();
-        j != linkDirs.end(); ++j)
-      {
+    for (std::vector<std::string>::iterator j = linkDirs.begin();
+         j != linkDirs.end(); ++j) {
       std::string newdir = *j;
       // remove trailing slashes
-      if(*j->rbegin() == '/')
-        {
-        newdir = j->substr(0, j->size()-1);
-        }
-      if(std::find(this->LinkDirectories.begin(),
-                   this->LinkDirectories.end(), newdir)
-          == this->LinkDirectories.end())
-        {
+      if (*j->rbegin() == '/') {
+        newdir = j->substr(0, j->size() - 1);
+      }
+      if (std::find(this->LinkDirectories.begin(), this->LinkDirectories.end(),
+                    newdir) == this->LinkDirectories.end()) {
         target.AddLinkDirectory(*j);
-        }
       }
     }
-  target.MergeLinkLibraries( *this, name, this->LinkLibraries );
+  }
+  target.MergeLinkLibraries(*this, name, this->LinkLibraries);
 }
 
-
-void cmMakefile::AddAlias(const std::string& lname,
-                          std::string const& tgtName)
+void cmMakefile::AddAlias(const std::string& lname, std::string const& tgtName)
 {
   this->AliasTargets[lname] = tgtName;
   this->GetGlobalGenerator()->AddAlias(lname, tgtName);
 }
 
 cmTarget* cmMakefile::AddLibrary(const std::string& lname,
-                            cmState::TargetType type,
-                            const std::vector<std::string> &srcs,
-                            bool excludeFromAll)
+                                 cmState::TargetType type,
+                                 const std::vector<std::string>& srcs,
+                                 bool excludeFromAll)
 {
   // wrong type ? default to STATIC
-  if (    (type != cmState::STATIC_LIBRARY)
-       && (type != cmState::SHARED_LIBRARY)
-       && (type != cmState::MODULE_LIBRARY)
-       && (type != cmState::OBJECT_LIBRARY)
-       && (type != cmState::INTERFACE_LIBRARY))
-    {
+  if ((type != cmState::STATIC_LIBRARY) && (type != cmState::SHARED_LIBRARY) &&
+      (type != cmState::MODULE_LIBRARY) && (type != cmState::OBJECT_LIBRARY) &&
+      (type != cmState::INTERFACE_LIBRARY)) {
     this->IssueMessage(cmake::INTERNAL_ERROR,
                        "cmMakefile::AddLibrary given invalid target type.");
     type = cmState::STATIC_LIBRARY;
-    }
+  }
 
   cmTarget* target = this->AddNewTarget(type, lname);
   // Clear its dependencies. Otherwise, dependencies might persist
   // over changes in CMakeLists.txt, making the information stale and
   // hence useless.
-  target->ClearDependencyInformation( *this, lname );
-  if(excludeFromAll)
-    {
+  target->ClearDependencyInformation(*this, lname);
+  if (excludeFromAll) {
     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
-    }
+  }
   target->AddSources(srcs);
   this->AddGlobalLinkInformation(lname, *target);
   return target;
 }
 
-cmTarget* cmMakefile::AddExecutable(const char *exeName,
-                                    const std::vector<std::string> &srcs,
+cmTarget* cmMakefile::AddExecutable(const char* exeName,
+                                    const std::vector<std::string>& srcs,
                                     bool excludeFromAll)
 {
   cmTarget* target = this->AddNewTarget(cmState::EXECUTABLE, exeName);
-  if(excludeFromAll)
-    {
+  if (excludeFromAll) {
     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
-    }
+  }
   target->AddSources(srcs);
   this->AddGlobalLinkInformation(exeName, *target);
   return target;
 }
 
-cmTarget*
-cmMakefile::AddNewTarget(cmState::TargetType type, const std::string& name)
+cmTarget* cmMakefile::AddNewTarget(cmState::TargetType type,
+                                   const std::string& name)
 {
   cmTargets::iterator it =
     this->Targets.insert(cmTargets::value_type(name, cmTarget())).first;
@@ -2059,96 +1821,84 @@ cmMakefile::AddNewTarget(cmState::TargetType type, const std::string& name)
   return &it->second;
 }
 
-cmSourceFile*
-cmMakefile::LinearGetSourceFileWithOutput(const std::string& name) const
+cmSourceFile* cmMakefile::LinearGetSourceFileWithOutput(
+  const std::string& name) const
 {
   std::string out;
 
   // look through all the source files that have custom commands
   // and see if the custom command has the passed source file as an output
-  for(std::vector<cmSourceFile*>::const_iterator i =
-        this->SourceFiles.begin(); i != this->SourceFiles.end(); ++i)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator i =
+         this->SourceFiles.begin();
+       i != this->SourceFiles.end(); ++i) {
     // does this source file have a custom command?
-    if ((*i)->GetCustomCommand())
-      {
+    if ((*i)->GetCustomCommand()) {
       // Does the output of the custom command match the source file name?
       const std::vector<std::string>& outputs =
         (*i)->GetCustomCommand()->GetOutputs();
-      for(std::vector<std::string>::const_iterator o = outputs.begin();
-          o != outputs.end(); ++o)
-        {
+      for (std::vector<std::string>::const_iterator o = outputs.begin();
+           o != outputs.end(); ++o) {
         out = *o;
         std::string::size_type pos = out.rfind(name);
         // If the output matches exactly
-        if (pos != out.npos &&
-            pos == out.size() - name.size() &&
-            (pos ==0 || out[pos-1] == '/'))
-          {
+        if (pos != out.npos && pos == out.size() - name.size() &&
+            (pos == 0 || out[pos - 1] == '/')) {
           return *i;
-          }
         }
       }
     }
+  }
 
   // otherwise return NULL
   return 0;
 }
 
-cmSourceFile *cmMakefile::GetSourceFileWithOutput(
-                                                const std::string& name) const
+cmSourceFile* cmMakefile::GetSourceFileWithOutput(
+  const std::string& name) const
 {
   // If the queried path is not absolute we use the backward compatible
   // linear-time search for an output with a matching suffix.
-  if(!cmSystemTools::FileIsFullPath(name.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(name.c_str())) {
     return this->LinearGetSourceFileWithOutput(name);
-    }
+  }
   // Otherwise we use an efficient lookup map.
   OutputToSourceMap::const_iterator o = this->OutputToSource.find(name);
-  if (o != this->OutputToSource.end())
-    {
+  if (o != this->OutputToSource.end()) {
     return (*o).second;
-    }
+  }
   return 0;
 }
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-cmSourceGroup*
-cmMakefile::GetSourceGroup(const std::vector<std::string>&name) const
+cmSourceGroup* cmMakefile::GetSourceGroup(
+  const std::vector<std::string>& name) const
 {
   cmSourceGroup* sg = 0;
 
   // first look for source group starting with the same as the one we want
-  for (std::vector<cmSourceGroup>::const_iterator
-      sgIt = this->SourceGroups.begin();
-      sgIt != this->SourceGroups.end(); ++sgIt)
-    {
+  for (std::vector<cmSourceGroup>::const_iterator sgIt =
+         this->SourceGroups.begin();
+       sgIt != this->SourceGroups.end(); ++sgIt) {
     std::string sgName = sgIt->GetName();
-    if(sgName == name[0])
-      {
+    if (sgName == name[0]) {
       sg = const_cast<cmSourceGroup*>(&(*sgIt));
       break;
-      }
     }
+  }
 
-  if(sg != 0)
-    {
+  if (sg != 0) {
     // iterate through its children to find match source group
-    for(unsigned int i=1; i<name.size(); ++i)
-      {
+    for (unsigned int i = 1; i < name.size(); ++i) {
       sg = sg->LookupChild(name[i].c_str());
-      if(sg == 0)
-        {
+      if (sg == 0) {
         break;
-        }
       }
     }
+  }
   return sg;
 }
 
-void cmMakefile::AddSourceGroup(const std::string& name,
-                                 const char* regex)
+void cmMakefile::AddSourceGroup(const std::string& name, const char* regex)
 {
   std::vector<std::string> nameVector;
   nameVector.push_back(name);
@@ -2161,48 +1911,40 @@ void cmMakefile::AddSourceGroup(const std::vector<std::string>& name,
   cmSourceGroup* sg = 0;
   std::vector<std::string> currentName;
   int i = 0;
-  const int lastElement = static_cast<int>(name.size()-1);
-  for(i=lastElement; i>=0; --i)
-    {
-    currentName.assign(name.begin(), name.begin()+i+1);
+  const int lastElement = static_cast<int>(name.size() - 1);
+  for (i = lastElement; i >= 0; --i) {
+    currentName.assign(name.begin(), name.begin() + i + 1);
     sg = this->GetSourceGroup(currentName);
-    if(sg != 0)
-      {
+    if (sg != 0) {
       break;
-      }
     }
+  }
 
   // i now contains the index of the last found component
-  if(i==lastElement)
-    {
+  if (i == lastElement) {
     // group already exists, replace its regular expression
-    if ( regex && sg)
-      {
+    if (regex && sg) {
       // We only want to set the regular expression.  If there are already
       // source files in the group, we don't want to remove them.
       sg->SetGroupRegex(regex);
-      }
-    return;
     }
-  else if(i==-1)
-    {
+    return;
+  } else if (i == -1) {
     // group does not exist nor belong to any existing group
     // add its first component
     this->SourceGroups.push_back(cmSourceGroup(name[0].c_str(), regex));
     sg = this->GetSourceGroup(currentName);
     i = 0; // last component found
-    }
-  if(!sg)
-    {
+  }
+  if (!sg) {
     cmSystemTools::Error("Could not create source group ");
     return;
-    }
+  }
   // build the whole source group path
-  for(++i; i<=lastElement; ++i)
-    {
+  for (++i; i <= lastElement; ++i) {
     sg->AddChild(cmSourceGroup(name[i].c_str(), 0, sg->GetFullName()));
     sg = sg->LookupChild(name[i].c_str());
-    }
+  }
 
   sg->SetGroupRegex(regex);
 }
@@ -2211,104 +1953,90 @@ void cmMakefile::AddSourceGroup(const std::vector<std::string>& name,
 
 static bool mightExpandVariablesCMP0019(const char* s)
 {
-  return s && *s && strstr(s,"${") && strchr(s,'}');
+  return s && *s && strstr(s, "${") && strchr(s, '}');
 }
 
 void cmMakefile::ExpandVariablesCMP0019()
 {
   // Drop this ancient compatibility behavior with a policy.
   cmPolicies::PolicyStatus pol = this->GetPolicyStatus(cmPolicies::CMP0019);
-  if(pol != cmPolicies::OLD && pol != cmPolicies::WARN)
-    {
+  if (pol != cmPolicies::OLD && pol != cmPolicies::WARN) {
     return;
-    }
+  }
   std::ostringstream w;
 
-  const char *includeDirs = this->GetProperty("INCLUDE_DIRECTORIES");
-  if(mightExpandVariablesCMP0019(includeDirs))
-    {
+  const char* includeDirs = this->GetProperty("INCLUDE_DIRECTORIES");
+  if (mightExpandVariablesCMP0019(includeDirs)) {
     std::string dirs = includeDirs;
     this->ExpandVariablesInString(dirs, true, true);
-    if(pol == cmPolicies::WARN && dirs != includeDirs)
-      {
+    if (pol == cmPolicies::WARN && dirs != includeDirs) {
       /* clang-format off */
       w << "Evaluated directory INCLUDE_DIRECTORIES\n"
         << "  " << includeDirs << "\n"
         << "as\n"
         << "  " << dirs << "\n";
       /* clang-format on */
-      }
-    this->SetProperty("INCLUDE_DIRECTORIES", dirs.c_str());
     }
+    this->SetProperty("INCLUDE_DIRECTORIES", dirs.c_str());
+  }
 
   // Also for each target's INCLUDE_DIRECTORIES property:
-  for (cmTargets::iterator l = this->Targets.begin();
-       l != this->Targets.end(); ++l)
-    {
-    cmTarget &t = l->second;
-    if (t.GetType() == cmState::INTERFACE_LIBRARY
-        || t.GetType() == cmState::GLOBAL_TARGET)
-      {
+  for (cmTargets::iterator l = this->Targets.begin(); l != this->Targets.end();
+       ++l) {
+    cmTarget& t = l->second;
+    if (t.GetType() == cmState::INTERFACE_LIBRARY ||
+        t.GetType() == cmState::GLOBAL_TARGET) {
       continue;
-      }
+    }
     includeDirs = t.GetProperty("INCLUDE_DIRECTORIES");
-    if(mightExpandVariablesCMP0019(includeDirs))
-      {
+    if (mightExpandVariablesCMP0019(includeDirs)) {
       std::string dirs = includeDirs;
       this->ExpandVariablesInString(dirs, true, true);
-      if(pol == cmPolicies::WARN && dirs != includeDirs)
-        {
+      if (pol == cmPolicies::WARN && dirs != includeDirs) {
         /* clang-format off */
         w << "Evaluated target " << t.GetName() << " INCLUDE_DIRECTORIES\n"
           << "  " << includeDirs << "\n"
           << "as\n"
           << "  " << dirs << "\n";
         /* clang-format on */
-        }
-      t.SetProperty("INCLUDE_DIRECTORIES", dirs.c_str());
       }
+      t.SetProperty("INCLUDE_DIRECTORIES", dirs.c_str());
     }
+  }
 
-  if (const char* linkDirsProp = this->GetProperty("LINK_DIRECTORIES"))
-    {
-    if(mightExpandVariablesCMP0019(linkDirsProp))
-      {
+  if (const char* linkDirsProp = this->GetProperty("LINK_DIRECTORIES")) {
+    if (mightExpandVariablesCMP0019(linkDirsProp)) {
       std::string d = linkDirsProp;
       std::string orig = linkDirsProp;
       this->ExpandVariablesInString(d, true, true);
-      if(pol == cmPolicies::WARN && d != orig)
-        {
+      if (pol == cmPolicies::WARN && d != orig) {
         /* clang-format off */
         w << "Evaluated link directories\n"
           << "  " << orig << "\n"
           << "as\n"
           << "  " << d << "\n";
         /* clang-format on */
-        }
       }
     }
-  for(cmTarget::LinkLibraryVectorType::iterator l =
-        this->LinkLibraries.begin();
-      l != this->LinkLibraries.end(); ++l)
-    {
-    if(mightExpandVariablesCMP0019(l->first.c_str()))
-      {
+  }
+  for (cmTarget::LinkLibraryVectorType::iterator l =
+         this->LinkLibraries.begin();
+       l != this->LinkLibraries.end(); ++l) {
+    if (mightExpandVariablesCMP0019(l->first.c_str())) {
       std::string orig = l->first;
       this->ExpandVariablesInString(l->first, true, true);
-      if(pol == cmPolicies::WARN && l->first != orig)
-        {
+      if (pol == cmPolicies::WARN && l->first != orig) {
         /* clang-format off */
         w << "Evaluated link library\n"
           << "  " << orig << "\n"
           << "as\n"
           << "  " << l->first << "\n";
         /* clang-format on */
-        }
       }
     }
+  }
 
-  if(!w.str().empty())
-    {
+  if (!w.str().empty()) {
     std::ostringstream m;
     /* clang-format off */
     m << cmPolicies::GetPolicyWarning(cmPolicies::CMP0019)
@@ -2317,7 +2045,7 @@ void cmMakefile::ExpandVariablesCMP0019()
       << w.str();
     /* clang-format on */
     this->IssueMessage(cmake::AUTHOR_WARNING, m.str());
-    }
+  }
 }
 
 bool cmMakefile::IsOn(const std::string& name) const
@@ -2329,30 +2057,26 @@ bool cmMakefile::IsOn(const std::string& name) const
 bool cmMakefile::IsSet(const std::string& name) const
 {
   const char* value = this->GetDefinition(name);
-  if ( !value )
-    {
+  if (!value) {
     return false;
-    }
+  }
 
-  if ( ! *value )
-    {
+  if (!*value) {
     return false;
-    }
+  }
 
-  if ( cmSystemTools::IsNOTFOUND(value) )
-    {
+  if (cmSystemTools::IsNOTFOUND(value)) {
     return false;
-    }
+  }
 
   return true;
 }
 
 bool cmMakefile::PlatformIs64Bit() const
 {
-  if(const char* sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P"))
-    {
+  if (const char* sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P")) {
     return atoi(sizeof_dptr) == 8;
-    }
+  }
   return false;
 }
 
@@ -2362,130 +2086,109 @@ bool cmMakefile::PlatformIsAppleIos() const
   sdkRoot = this->GetSafeDefinition("CMAKE_OSX_SYSROOT");
   sdkRoot = cmSystemTools::LowerCase(sdkRoot);
 
-  const std::string embedded[] =
-    {
-    "appletvos", "appletvsimulator",
-    "iphoneos", "iphonesimulator",
-    "watchos", "watchsimulator",
-    };
+  const std::string embedded[] = {
+    "appletvos",       "appletvsimulator", "iphoneos",
+    "iphonesimulator", "watchos",          "watchsimulator",
+  };
 
-  for(size_t i = 0; i < sizeof(embedded) / sizeof(embedded[0]); ++i)
-    {
-    if(sdkRoot.find(embedded[i]) == 0 ||
-       sdkRoot.find(std::string("/") + embedded[i]) != std::string::npos)
-      {
+  for (size_t i = 0; i < sizeof(embedded) / sizeof(embedded[0]); ++i) {
+    if (sdkRoot.find(embedded[i]) == 0 ||
+        sdkRoot.find(std::string("/") + embedded[i]) != std::string::npos) {
       return true;
-      }
     }
+  }
 
-   return false;
+  return false;
 }
 
 const char* cmMakefile::GetSONameFlag(const std::string& language) const
 {
   std::string name = "CMAKE_SHARED_LIBRARY_SONAME";
-  if(!language.empty())
-    {
+  if (!language.empty()) {
     name += "_";
     name += language;
-    }
+  }
   name += "_FLAG";
   return GetDefinition(name);
 }
 
 bool cmMakefile::CanIWriteThisFile(const char* fileName) const
 {
-  if ( !this->IsOn("CMAKE_DISABLE_SOURCE_CHANGES") )
-    {
+  if (!this->IsOn("CMAKE_DISABLE_SOURCE_CHANGES")) {
     return true;
-    }
+  }
   // If we are doing an in-source build, then the test will always fail
-  if ( cmSystemTools::SameFile(this->GetHomeDirectory(),
-                               this->GetHomeOutputDirectory()) )
-    {
-    if ( this->IsOn("CMAKE_DISABLE_IN_SOURCE_BUILD") )
-      {
+  if (cmSystemTools::SameFile(this->GetHomeDirectory(),
+                              this->GetHomeOutputDirectory())) {
+    if (this->IsOn("CMAKE_DISABLE_IN_SOURCE_BUILD")) {
       return false;
-      }
-    return true;
     }
+    return true;
+  }
 
   // Check if this is a subdirectory of the source tree but not a
   // subdirectory of the build tree
-  if ( cmSystemTools::IsSubDirectory(fileName,
-      this->GetHomeDirectory()) &&
-    !cmSystemTools::IsSubDirectory(fileName,
-      this->GetHomeOutputDirectory()) )
-    {
+  if (cmSystemTools::IsSubDirectory(fileName, this->GetHomeDirectory()) &&
+      !cmSystemTools::IsSubDirectory(fileName,
+                                     this->GetHomeOutputDirectory())) {
     return false;
-    }
+  }
   return true;
 }
 
 const char* cmMakefile::GetRequiredDefinition(const std::string& name) const
 {
   const char* ret = this->GetDefinition(name);
-  if(!ret)
-    {
+  if (!ret) {
     cmSystemTools::Error("Error required internal CMake variable not "
                          "set, cmake may be not be built correctly.\n",
-                         "Missing variable is:\n",
-                         name.c_str());
+                         "Missing variable is:\n", name.c_str());
     return "";
-    }
+  }
   return ret;
 }
 
 bool cmMakefile::IsDefinitionSet(const std::string& name) const
 {
   const char* def = this->StateSnapshot.GetDefinition(name);
-  if(!def)
-    {
+  if (!def) {
     def = this->GetState()->GetInitializedCacheValue(name);
-    }
+  }
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  if(cmVariableWatch* vv = this->GetVariableWatch())
-    {
-    if(!def)
-      {
-      vv->VariableAccessed
-        (name, cmVariableWatch::UNKNOWN_VARIABLE_DEFINED_ACCESS,
-         def, this);
-      }
+  if (cmVariableWatch* vv = this->GetVariableWatch()) {
+    if (!def) {
+      vv->VariableAccessed(
+        name, cmVariableWatch::UNKNOWN_VARIABLE_DEFINED_ACCESS, def, this);
     }
+  }
 #endif
-  return def?true:false;
+  return def ? true : false;
 }
 
 const char* cmMakefile::GetDefinition(const std::string& name) const
 {
   const char* def = this->StateSnapshot.GetDefinition(name);
-  if(!def)
-    {
+  if (!def) {
     def = this->GetState()->GetInitializedCacheValue(name);
-    }
+  }
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* vv = this->GetVariableWatch();
-  if ( vv && !this->SuppressWatches )
-    {
-    bool const watch_function_executed =
-      vv->VariableAccessed(name,
-                           def ? cmVariableWatch::VARIABLE_READ_ACCESS
-                           : cmVariableWatch::UNKNOWN_VARIABLE_READ_ACCESS,
-                           def, this);
+  if (vv && !this->SuppressWatches) {
+    bool const watch_function_executed = vv->VariableAccessed(
+      name, def ? cmVariableWatch::VARIABLE_READ_ACCESS
+                : cmVariableWatch::UNKNOWN_VARIABLE_READ_ACCESS,
+      def, this);
 
-    if (watch_function_executed)
-      {
+    if (watch_function_executed) {
       // A callback was executed and may have caused re-allocation of the
       // variable storage.  Look it up again for now.
       // FIXME: Refactor variable storage to avoid this problem.
       def = this->StateSnapshot.GetDefinition(name);
-      if(!def)
-        {
+      if (!def) {
         def = this->GetState()->GetInitializedCacheValue(name);
-        }
       }
     }
+  }
 #endif
   return def;
 }
@@ -2493,10 +2196,9 @@ const char* cmMakefile::GetDefinition(const std::string& name) const
 const char* cmMakefile::GetSafeDefinition(const std::string& def) const
 {
   const char* ret = this->GetDefinition(def);
-  if(!ret)
-    {
+  if (!ret) {
     return "";
-    }
+  }
   return ret;
 }
 
@@ -2509,20 +2211,14 @@ std::vector<std::string> cmMakefile::GetDefinitions() const
   return res;
 }
 
-
-const char *cmMakefile::ExpandVariablesInString(std::string& source) const
+const char* cmMakefile::ExpandVariablesInString(std::string& source) const
 {
   return this->ExpandVariablesInString(source, false, false);
 }
 
-const char *cmMakefile::ExpandVariablesInString(std::string& source,
-                                                bool escapeQuotes,
-                                                bool noEscapes,
-                                                bool atOnly,
-                                                const char* filename,
-                                                long line,
-                                                bool removeEmpty,
-                                                bool replaceAt) const
+const char* cmMakefile::ExpandVariablesInString(
+  std::string& source, bool escapeQuotes, bool noEscapes, bool atOnly,
+  const char* filename, long line, bool removeEmpty, bool replaceAt) const
 {
   bool compareResults = false;
   cmake::MessageType mtype = cmake::LOG;
@@ -2530,25 +2226,22 @@ const char *cmMakefile::ExpandVariablesInString(std::string& source,
   std::string original;
 
   // Sanity check the @ONLY mode.
-  if(atOnly && (!noEscapes || !removeEmpty))
-    {
+  if (atOnly && (!noEscapes || !removeEmpty)) {
     // This case should never be called.  At-only is for
     // configure-file/string which always does no escapes.
     this->IssueMessage(cmake::INTERNAL_ERROR,
                        "ExpandVariablesInString @ONLY called "
                        "on something with escapes.");
     return source.c_str();
-    }
+  }
 
   // Variables used in the WARN case.
   std::string newResult;
   std::string newErrorstr;
   cmake::MessageType newError = cmake::LOG;
 
-  switch(this->GetPolicyStatus(cmPolicies::CMP0053))
-    {
-    case cmPolicies::WARN:
-      {
+  switch (this->GetPolicyStatus(cmPolicies::CMP0053)) {
+    case cmPolicies::WARN: {
       // Save the original string for the warning.
       original = source;
       newResult = source;
@@ -2556,41 +2249,36 @@ const char *cmMakefile::ExpandVariablesInString(std::string& source,
       // Suppress variable watches to avoid calling hooks twice. Suppress new
       // dereferences since the OLD behavior is still what is actually used.
       this->SuppressWatches = true;
-      newError =
-        ExpandVariablesInStringNew(newErrorstr, newResult, escapeQuotes,
-                                   noEscapes, atOnly, filename, line,
-                                   removeEmpty, replaceAt);
+      newError = ExpandVariablesInStringNew(
+        newErrorstr, newResult, escapeQuotes, noEscapes, atOnly, filename,
+        line, removeEmpty, replaceAt);
       this->SuppressWatches = false;
-      }
+    }
     case cmPolicies::OLD:
-      mtype = ExpandVariablesInStringOld(errorstr, source, escapeQuotes,
-                                         noEscapes, atOnly, filename,
-                                         line, removeEmpty, true);
+      mtype =
+        ExpandVariablesInStringOld(errorstr, source, escapeQuotes, noEscapes,
+                                   atOnly, filename, line, removeEmpty, true);
       break;
     case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::REQUIRED_ALWAYS:
-      // Messaging here would be *very* verbose.
+    // Messaging here would be *very* verbose.
     case cmPolicies::NEW:
       mtype = ExpandVariablesInStringNew(errorstr, source, escapeQuotes,
-                                         noEscapes, atOnly, filename,
-                                         line, removeEmpty, replaceAt);
+                                         noEscapes, atOnly, filename, line,
+                                         removeEmpty, replaceAt);
       break;
-    }
+  }
 
   // If it's an error in either case, just report the error...
-  if(mtype != cmake::LOG)
-    {
-    if(mtype == cmake::FATAL_ERROR)
-      {
+  if (mtype != cmake::LOG) {
+    if (mtype == cmake::FATAL_ERROR) {
       cmSystemTools::SetFatalErrorOccured();
-      }
-    this->IssueMessage(mtype, errorstr);
     }
+    this->IssueMessage(mtype, errorstr);
+  }
   // ...otherwise, see if there's a difference that needs to be warned about.
-  else if(compareResults && (newResult != source || newError != mtype))
-    {
-    std::string msg =
-      cmPolicies::GetPolicyWarning(cmPolicies::CMP0053);
+  else if (compareResults && (newResult != source || newError != mtype)) {
+    std::string msg = cmPolicies::GetPolicyWarning(cmPolicies::CMP0053);
     msg += "\n";
 
     std::string msg_input = original;
@@ -2605,52 +2293,41 @@ const char *cmMakefile::ExpandVariablesInString(std::string& source,
     msg += msg_old;
     msg += "'\n";
 
-    if(newError == mtype)
-      {
+    if (newError == mtype) {
       std::string msg_new = newResult;
       cmSystemTools::ReplaceString(msg_new, "\n", "\n  ");
       msg += "but the new evaluation rules produce:\n  '";
       msg += msg_new;
       msg += "'\n";
-      }
-    else
-      {
+    } else {
       std::string msg_err = newErrorstr;
       cmSystemTools::ReplaceString(msg_err, "\n", "\n  ");
       msg += "but the new evaluation rules produce an error:\n  ";
       msg += msg_err;
       msg += "\n";
-      }
+    }
 
     msg +=
       "Using the old result for compatibility since the policy is not set.";
 
     this->IssueMessage(cmake::AUTHOR_WARNING, msg);
-    }
+  }
 
   return source.c_str();
 }
 
 cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
-                                                std::string& errorstr,
-                                                std::string& source,
-                                                bool escapeQuotes,
-                                                bool noEscapes,
-                                                bool atOnly,
-                                                const char* filename,
-                                                long line,
-                                                bool removeEmpty,
-                                                bool replaceAt) const
+  std::string& errorstr, std::string& source, bool escapeQuotes,
+  bool noEscapes, bool atOnly, const char* filename, long line,
+  bool removeEmpty, bool replaceAt) const
 {
   // Fast path strings without any special characters.
-  if ( source.find_first_of("$@\\") == source.npos)
-    {
+  if (source.find_first_of("$@\\") == source.npos) {
     return cmake::LOG;
-    }
+  }
 
   // Special-case the @ONLY mode.
-  if(atOnly)
-    {
+  if (atOnly) {
     // Store an original copy of the input.
     std::string input = source;
 
@@ -2659,39 +2336,34 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
 
     // Look for one @VAR@ at a time.
     const char* in = input.c_str();
-    while(this->cmAtVarRegex.find(in))
-      {
+    while (this->cmAtVarRegex.find(in)) {
       // Get the range of the string to replace.
       const char* first = in + this->cmAtVarRegex.start();
-      const char* last =  in + this->cmAtVarRegex.end();
+      const char* last = in + this->cmAtVarRegex.end();
 
       // Store the unchanged part of the string now.
-      source.append(in, first-in);
+      source.append(in, first - in);
 
       // Lookup the definition of VAR.
-      std::string var(first+1, last-first-2);
-      if(const char* val = this->GetDefinition(var))
-        {
+      std::string var(first + 1, last - first - 2);
+      if (const char* val = this->GetDefinition(var)) {
         // Store the value in the output escaping as requested.
-        if(escapeQuotes)
-          {
+        if (escapeQuotes) {
           source.append(cmSystemTools::EscapeQuotes(val));
-          }
-        else
-          {
+        } else {
           source.append(val);
-          }
         }
+      }
 
       // Continue looking for @VAR@ further along the string.
       in = last;
-      }
+    }
 
     // Append the rest of the unchanged part of the string.
     source.append(in);
 
     return cmake::LOG;
-    }
+  }
 
   // This method replaces ${VAR} and @VAR@ where VAR is looked up
   // with GetDefinition(), if not found in the map, nothing is expanded.
@@ -2708,23 +2380,19 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
   int res = parser.ParseString(source.c_str(), 0);
   const char* emsg = parser.GetError();
   cmake::MessageType mtype = cmake::LOG;
-  if ( res && !emsg[0] )
-    {
+  if (res && !emsg[0]) {
     source = parser.GetResult();
-    }
-  else
-    {
+  } else {
     // Construct the main error message.
     std::ostringstream error;
     error << "Syntax error in cmake code ";
-    if(filename && line > 0)
-      {
+    if (filename && line > 0) {
       // This filename and line number may be more specific than the
       // command context because one command invocation can have
       // arguments on multiple lines.
       error << "at\n"
             << "  " << filename << ":" << line << "\n";
-      }
+    }
     error << "when parsing string\n"
           << "  " << source << "\n";
     error << emsg;
@@ -2735,12 +2403,10 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
     // helper implementation is unhappy, which has always reported an
     // error.
     mtype = cmake::FATAL_ERROR;
-    if(!res)
-      {
+    if (!res) {
       // This is a real argument parsing error.  Use policy CMP0010 to
       // decide whether it is an error.
-      switch(this->GetPolicyStatus(cmPolicies::CMP0010))
-        {
+      switch (this->GetPolicyStatus(cmPolicies::CMP0010)) {
         case cmPolicies::WARN:
           error << "\n" << cmPolicies::GetPolicyWarning(cmPolicies::CMP0010);
         case cmPolicies::OLD:
@@ -2754,36 +2420,29 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
         case cmPolicies::NEW:
           // NEW behavior is to report the error.
           break;
-        }
       }
-    errorstr = error.str();
     }
+    errorstr = error.str();
+  }
   return mtype;
 }
 
-typedef enum
-  {
-  NORMAL,
-  ENVIRONMENT,
-  CACHE
-  } t_domain;
+typedef enum { NORMAL, ENVIRONMENT, CACHE } t_domain;
 struct t_lookup
+{
+  t_lookup()
+    : domain(NORMAL)
+    , loc(0)
   {
-  t_lookup(): domain(NORMAL), loc(0) {}
+  }
   t_domain domain;
   size_t loc;
-  };
+};
 
 cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
-                                            std::string& errorstr,
-                                            std::string& source,
-                                            bool escapeQuotes,
-                                            bool noEscapes,
-                                            bool atOnly,
-                                            const char* filename,
-                                            long line,
-                                            bool removeEmpty,
-                                            bool replaceAt) const
+  std::string& errorstr, std::string& source, bool escapeQuotes,
+  bool noEscapes, bool atOnly, const char* filename, long line,
+  bool removeEmpty, bool replaceAt) const
 {
   // This method replaces ${VAR} and @VAR@ where VAR is looked up
   // with GetDefinition(), if not found in the map, nothing is expanded.
@@ -2801,14 +2460,11 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
 
   cmState* state = this->GetCMakeInstance()->GetState();
 
-  do
-    {
+  do {
     char inc = *in;
-    switch(inc)
-      {
+    switch (inc) {
       case '}':
-        if(!openstack.empty())
-          {
+        if (!openstack.empty()) {
           t_lookup var = openstack.back();
           openstack.pop_back();
           result.append(last, in - last);
@@ -2816,19 +2472,15 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
           const char* value = NULL;
           std::string varresult;
           static const std::string lineVar = "CMAKE_CURRENT_LIST_LINE";
-          switch(var.domain)
-            {
+          switch (var.domain) {
             case NORMAL:
-              if(filename && lookup == lineVar)
-                {
+              if (filename && lookup == lineVar) {
                 std::ostringstream ostr;
                 ostr << line;
                 varresult = ostr.str();
-                }
-              else
-                {
+              } else {
                 value = this->GetDefinition(lookup);
-                }
+              }
               break;
             case ENVIRONMENT:
               value = cmSystemTools::GetEnv(lookup.c_str());
@@ -2836,154 +2488,116 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
             case CACHE:
               value = state->GetCacheEntryValue(lookup);
               break;
-            }
+          }
           // Get the string we're meant to append to.
-          if(value)
-            {
-            if(escapeQuotes)
-              {
+          if (value) {
+            if (escapeQuotes) {
               varresult = cmSystemTools::EscapeQuotes(value);
-              }
-            else
-              {
+            } else {
               varresult = value;
-              }
             }
-          else if(!removeEmpty)
-            {
+          } else if (!removeEmpty) {
             // check to see if we need to print a warning
             // if strict mode is on and the variable has
             // not been "cleared"/initialized with a set(foo ) call
-            if(this->GetCMakeInstance()->GetWarnUninitialized() &&
-               !this->VariableInitialized(lookup))
-              {
+            if (this->GetCMakeInstance()->GetWarnUninitialized() &&
+                !this->VariableInitialized(lookup)) {
               if (this->CheckSystemVars ||
                   cmSystemTools::IsSubDirectory(filename,
                                                 this->GetHomeDirectory()) ||
-                  cmSystemTools::IsSubDirectory(filename,
-                                             this->GetHomeOutputDirectory()))
-                {
+                  cmSystemTools::IsSubDirectory(
+                    filename, this->GetHomeOutputDirectory())) {
                 std::ostringstream msg;
                 msg << "uninitialized variable \'" << lookup << "\'";
                 this->IssueMessage(cmake::AUTHOR_WARNING, msg.str());
-                }
               }
             }
+          }
           result.replace(var.loc, result.size() - var.loc, varresult);
           // Start looking from here on out.
           last = in + 1;
-          }
+        }
         break;
       case '$':
-        if(!atOnly)
-          {
+        if (!atOnly) {
           t_lookup lookup;
           const char* next = in + 1;
           const char* start = NULL;
           char nextc = *next;
-          if(nextc == '{')
-            {
+          if (nextc == '{') {
             // Looking for a variable.
             start = in + 2;
             lookup.domain = NORMAL;
-            }
-          else if(nextc == '<')
-            {
-            }
-          else if(!nextc)
-            {
+          } else if (nextc == '<') {
+          } else if (!nextc) {
             result.append(last, next - last);
             last = next;
-            }
-          else if(cmHasLiteralPrefix(next, "ENV{"))
-            {
+          } else if (cmHasLiteralPrefix(next, "ENV{")) {
             // Looking for an environment variable.
             start = in + 5;
             lookup.domain = ENVIRONMENT;
-            }
-          else if(cmHasLiteralPrefix(next, "CACHE{"))
-            {
+          } else if (cmHasLiteralPrefix(next, "CACHE{")) {
             // Looking for a cache variable.
             start = in + 7;
             lookup.domain = CACHE;
-            }
-          else
-            {
-            if(this->cmNamedCurly.find(next))
-              {
-              errorstr = "Syntax $"
-                  + std::string(next, this->cmNamedCurly.end())
-                  + "{} is not supported.  Only ${}, $ENV{}, "
-                    "and $CACHE{} are allowed.";
+          } else {
+            if (this->cmNamedCurly.find(next)) {
+              errorstr = "Syntax $" +
+                std::string(next, this->cmNamedCurly.end()) +
+                "{} is not supported.  Only ${}, $ENV{}, "
+                "and $CACHE{} are allowed.";
               mtype = cmake::FATAL_ERROR;
               error = true;
-              }
             }
-          if(start)
-            {
+          }
+          if (start) {
             result.append(last, in - last);
             last = start;
             in = start - 1;
             lookup.loc = result.size();
             openstack.push_back(lookup);
-            }
-          break;
           }
+          break;
+        }
       case '\\':
-        if(!noEscapes)
-          {
+        if (!noEscapes) {
           const char* next = in + 1;
           char nextc = *next;
-          if(nextc == 't')
-            {
+          if (nextc == 't') {
             result.append(last, in - last);
             result.append("\t");
             last = next + 1;
-            }
-          else if(nextc == 'n')
-            {
+          } else if (nextc == 'n') {
             result.append(last, in - last);
             result.append("\n");
             last = next + 1;
-            }
-          else if(nextc == 'r')
-            {
+          } else if (nextc == 'r') {
             result.append(last, in - last);
             result.append("\r");
             last = next + 1;
-            }
-          else if(nextc == ';' && openstack.empty())
-            {
+          } else if (nextc == ';' && openstack.empty()) {
             // Handled in ExpandListArgument; pass the backslash literally.
-            }
-          else if (isalnum(nextc) || nextc == '\0')
-            {
+          } else if (isalnum(nextc) || nextc == '\0') {
             errorstr += "Invalid character escape '\\";
-            if (nextc)
-              {
+            if (nextc) {
               errorstr += nextc;
               errorstr += "'.";
-              }
-            else
-              {
+            } else {
               errorstr += "' (at end of input).";
-              }
-            error = true;
             }
-          else
-            {
+            error = true;
+          } else {
             // Take what we've found so far, skipping the escape character.
             result.append(last, in - last);
             // Start tracking from the next character.
             last = in + 1;
-            }
+          }
           // Skip the next character since it was escaped, but don't read past
           // the end of the string.
-          if(*last)
-            {
+          if (*last) {
             ++in;
-            }
           }
+        }
         break;
       case '\n':
         // Onto the next line.
@@ -2993,87 +2607,77 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
         done = true;
         break;
       case '@':
-        if(replaceAt)
-          {
+        if (replaceAt) {
           const char* nextAt = strchr(in + 1, '@');
-          if(nextAt && nextAt != in + 1 &&
-             nextAt == in + 1 + strspn(in + 1,
-                "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                "abcdefghijklmnopqrstuvwxyz"
-                "0123456789/_.+-"))
-            {
+          if (nextAt && nextAt != in + 1 &&
+              nextAt ==
+                in + 1 + strspn(in + 1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                        "abcdefghijklmnopqrstuvwxyz"
+                                        "0123456789/_.+-")) {
             std::string variable(in + 1, nextAt - in - 1);
             std::string varresult = this->GetSafeDefinition(variable);
-            if(escapeQuotes)
-              {
+            if (escapeQuotes) {
               varresult = cmSystemTools::EscapeQuotes(varresult);
-              }
+            }
             // Skip over the variable.
             result.append(last, in - last);
             result.append(varresult);
             in = nextAt;
             last = in + 1;
             break;
-            }
           }
-        // Failed to find a valid @ expansion; treat it as literal.
-        /* FALLTHROUGH */
-      default:
-        {
-        if(!openstack.empty() &&
-           !(isalnum(inc) || inc == '_' ||
-             inc == '/' || inc == '.' ||
-             inc == '+' || inc == '-'))
-          {
+        }
+      // Failed to find a valid @ expansion; treat it as literal.
+      /* FALLTHROUGH */
+      default: {
+        if (!openstack.empty() &&
+            !(isalnum(inc) || inc == '_' || inc == '/' || inc == '.' ||
+              inc == '+' || inc == '-')) {
           errorstr += "Invalid character (\'";
           errorstr += inc;
           result.append(last, in - last);
           errorstr += "\') in a variable name: "
-                      "'" + result.substr(openstack.back().loc) + "'";
+                      "'" +
+            result.substr(openstack.back().loc) + "'";
           mtype = cmake::FATAL_ERROR;
           error = true;
-          }
-        break;
         }
+        break;
       }
+    }
     // Look at the next character.
-    } while(!error && !done && *++in);
+  } while (!error && !done && *++in);
 
   // Check for open variable references yet.
-  if(!error && !openstack.empty())
-    {
+  if (!error && !openstack.empty()) {
     // There's an open variable reference waiting.  Policy CMP0010 flags
     // whether this is an error or not.  The new parser now enforces
     // CMP0010 as well.
     errorstr += "There is an unterminated variable reference.";
     error = true;
-    }
+  }
 
-  if(error)
-    {
+  if (error) {
     std::ostringstream emsg;
     emsg << "Syntax error in cmake code ";
-    if(filename)
-      {
+    if (filename) {
       // This filename and line number may be more specific than the
       // command context because one command invocation can have
       // arguments on multiple lines.
       emsg << "at\n"
-            << "  " << filename << ":" << line << "\n";
-      }
+           << "  " << filename << ":" << line << "\n";
+    }
     emsg << "when parsing string\n"
          << "  " << source << "\n";
     emsg << errorstr;
     mtype = cmake::FATAL_ERROR;
     errorstr = emsg.str();
-    }
-  else
-    {
+  } else {
     // Append the rest of the unchanged part of the string.
     result.append(last);
 
     source = result;
-    }
+  }
 
   return mtype;
 }
@@ -3081,52 +2685,41 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
 void cmMakefile::RemoveVariablesInString(std::string& source,
                                          bool atOnly) const
 {
-  if(!atOnly)
-    {
+  if (!atOnly) {
     cmsys::RegularExpression var("(\\${[A-Za-z_0-9]*})");
-    while (var.find(source))
-      {
-      source.erase(var.start(),var.end() - var.start());
-      }
+    while (var.find(source)) {
+      source.erase(var.start(), var.end() - var.start());
     }
+  }
 
-  if(!atOnly)
-    {
+  if (!atOnly) {
     cmsys::RegularExpression varb("(\\$ENV{[A-Za-z_0-9]*})");
-    while (varb.find(source))
-      {
-      source.erase(varb.start(),varb.end() - varb.start());
-      }
+    while (varb.find(source)) {
+      source.erase(varb.start(), varb.end() - varb.start());
     }
+  }
   cmsys::RegularExpression var2("(@[A-Za-z_0-9]*@)");
-  while (var2.find(source))
-    {
-    source.erase(var2.start(),var2.end() - var2.start());
-    }
+  while (var2.find(source)) {
+    source.erase(var2.start(), var2.end() - var2.start());
+  }
 }
 
-std::string
-cmMakefile::GetConfigurations(std::vector<std::string>& configs,
-                              bool singleConfig) const
+std::string cmMakefile::GetConfigurations(std::vector<std::string>& configs,
+                                          bool singleConfig) const
 {
-  if(this->GetGlobalGenerator()->IsMultiConfig())
-    {
-    if(const char* configTypes =
-       this->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
-      {
+  if (this->GetGlobalGenerator()->IsMultiConfig()) {
+    if (const char* configTypes =
+          this->GetDefinition("CMAKE_CONFIGURATION_TYPES")) {
       cmSystemTools::ExpandListArgument(configTypes, configs);
-      }
-    return "";
     }
-  else
-    {
+    return "";
+  } else {
     const std::string& buildType = this->GetSafeDefinition("CMAKE_BUILD_TYPE");
-    if(singleConfig && !buildType.empty())
-      {
+    if (singleConfig && !buildType.empty()) {
       configs.push_back(buildType);
-      }
-    return buildType;
     }
+    return buildType;
+  }
 }
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
@@ -3137,32 +2730,26 @@ cmMakefile::GetConfigurations(std::vector<std::string>& configs,
  * non-inherited SOURCE_GROUP commands will have precedence over
  * inherited ones.
  */
-cmSourceGroup*
-cmMakefile::FindSourceGroup(const char* source,
-                            std::vector<cmSourceGroup> &groups) const
+cmSourceGroup* cmMakefile::FindSourceGroup(
+  const char* source, std::vector<cmSourceGroup>& groups) const
 {
   // First search for a group that lists the file explicitly.
-  for(std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
-      sg != groups.rend(); ++sg)
-    {
-    cmSourceGroup *result = sg->MatchChildrenFiles(source);
-    if(result)
-      {
+  for (std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
+       sg != groups.rend(); ++sg) {
+    cmSourceGroup* result = sg->MatchChildrenFiles(source);
+    if (result) {
       return result;
-      }
     }
+  }
 
   // Now search for a group whose regex matches the file.
-  for(std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
-      sg != groups.rend(); ++sg)
-    {
-    cmSourceGroup *result = sg->MatchChildrenRegex(source);
-    if(result)
-      {
+  for (std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
+       sg != groups.rend(); ++sg) {
+    cmSourceGroup* result = sg->MatchChildrenRegex(source);
+    if (result) {
       return result;
-      }
     }
-
+  }
 
   // Shouldn't get here, but just in case, return the default group.
   return &groups.front();
@@ -3170,25 +2757,22 @@ cmMakefile::FindSourceGroup(const char* source,
 #endif
 
 bool cmMakefile::IsFunctionBlocked(const cmListFileFunction& lff,
-                                   cmExecutionStatus &status)
+                                   cmExecutionStatus& status)
 {
   // if there are no blockers get out of here
-  if (this->FunctionBlockers.begin() == this->FunctionBlockers.end())
-    {
+  if (this->FunctionBlockers.begin() == this->FunctionBlockers.end()) {
     return false;
-    }
+  }
 
   // loop over all function blockers to see if any block this command
   // evaluate in reverse, this is critical for balanced IF statements etc
   std::vector<cmFunctionBlocker*>::reverse_iterator pos;
   for (pos = this->FunctionBlockers.rbegin();
-       pos != this->FunctionBlockers.rend(); ++pos)
-    {
-    if((*pos)->IsFunctionBlocked(lff, *this, status))
-      {
+       pos != this->FunctionBlockers.rend(); ++pos) {
+    if ((*pos)->IsFunctionBlocked(lff, *this, status)) {
       return true;
-      }
     }
+  }
 
   return false;
 }
@@ -3203,12 +2787,10 @@ void cmMakefile::PopFunctionBlockerBarrier(bool reportError)
   // Remove any extra entries pushed on the barrier.
   FunctionBlockersType::size_type barrier =
     this->FunctionBlockerBarriers.back();
-  while(this->FunctionBlockers.size() > barrier)
-    {
+  while (this->FunctionBlockers.size() > barrier) {
     cmsys::auto_ptr<cmFunctionBlocker> fb(this->FunctionBlockers.back());
     this->FunctionBlockers.pop_back();
-    if(reportError)
-      {
+    if (reportError) {
       // Report the context in which the unclosed block was opened.
       cmListFileContext const& lfc = fb->GetStartingContext();
       std::ostringstream e;
@@ -3219,8 +2801,8 @@ void cmMakefile::PopFunctionBlockerBarrier(bool reportError)
       /* clang-format on */
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       reportError = false;
-      }
     }
+  }
 
   // Remove the barrier.
   this->FunctionBlockerBarriers.pop_back();
@@ -3263,42 +2845,36 @@ std::string cmMakefile::GetExecutionFilePath() const
   return this->StateSnapshot.GetExecutionListFile();
 }
 
-bool cmMakefile::ExpandArguments(
-  std::vector<cmListFileArgument> const& inArgs,
-  std::vector<std::string>& outArgs, const char* filename) const
+bool cmMakefile::ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
+                                 std::vector<std::string>& outArgs,
+                                 const char* filename) const
 {
   std::string efp = this->GetExecutionFilePath();
-  if (!filename)
-    {
+  if (!filename) {
     filename = efp.c_str();
-    }
+  }
   std::vector<cmListFileArgument>::const_iterator i;
   std::string value;
   outArgs.reserve(inArgs.size());
-  for(i = inArgs.begin(); i != inArgs.end(); ++i)
-    {
+  for (i = inArgs.begin(); i != inArgs.end(); ++i) {
     // No expansion in a bracket argument.
-    if(i->Delim == cmListFileArgument::Bracket)
-      {
+    if (i->Delim == cmListFileArgument::Bracket) {
       outArgs.push_back(i->Value);
       continue;
-      }
+    }
     // Expand the variables in the argument.
     value = i->Value;
-    this->ExpandVariablesInString(value, false, false, false,
-                                  filename, i->Line, false, false);
+    this->ExpandVariablesInString(value, false, false, false, filename,
+                                  i->Line, false, false);
 
     // If the argument is quoted, it should be one argument.
     // Otherwise, it may be a list of arguments.
-    if(i->Delim == cmListFileArgument::Quoted)
-      {
+    if (i->Delim == cmListFileArgument::Quoted) {
       outArgs.push_back(value);
-      }
-    else
-      {
+    } else {
       cmSystemTools::ExpandListArgument(value, outArgs);
-      }
     }
+  }
   return !cmSystemTools::GetFatalErrorOccured();
 }
 
@@ -3307,82 +2883,69 @@ bool cmMakefile::ExpandArguments(
   std::vector<cmExpandedCommandArgument>& outArgs, const char* filename) const
 {
   std::string efp = this->GetExecutionFilePath();
-  if (!filename)
-    {
+  if (!filename) {
     filename = efp.c_str();
-    }
+  }
   std::vector<cmListFileArgument>::const_iterator i;
   std::string value;
   outArgs.reserve(inArgs.size());
-  for(i = inArgs.begin(); i != inArgs.end(); ++i)
-    {
+  for (i = inArgs.begin(); i != inArgs.end(); ++i) {
     // No expansion in a bracket argument.
-    if(i->Delim == cmListFileArgument::Bracket)
-      {
+    if (i->Delim == cmListFileArgument::Bracket) {
       outArgs.push_back(cmExpandedCommandArgument(i->Value, true));
       continue;
-      }
+    }
     // Expand the variables in the argument.
     value = i->Value;
-    this->ExpandVariablesInString(value, false, false, false,
-                                  filename, i->Line, false, false);
+    this->ExpandVariablesInString(value, false, false, false, filename,
+                                  i->Line, false, false);
 
     // If the argument is quoted, it should be one argument.
     // Otherwise, it may be a list of arguments.
-    if(i->Delim == cmListFileArgument::Quoted)
-      {
+    if (i->Delim == cmListFileArgument::Quoted) {
       outArgs.push_back(cmExpandedCommandArgument(value, true));
-      }
-    else
-      {
+    } else {
       std::vector<std::string> stringArgs;
       cmSystemTools::ExpandListArgument(value, stringArgs);
-      for(size_t j = 0; j < stringArgs.size(); ++j)
-        {
+      for (size_t j = 0; j < stringArgs.size(); ++j) {
         outArgs.push_back(cmExpandedCommandArgument(stringArgs[j], false));
-        }
       }
     }
+  }
   return !cmSystemTools::GetFatalErrorOccured();
 }
 
 void cmMakefile::AddFunctionBlocker(cmFunctionBlocker* fb)
 {
-  if(!this->ExecutionStatusStack.empty())
-    {
+  if (!this->ExecutionStatusStack.empty()) {
     // Record the context in which the blocker is created.
     fb->SetStartingContext(this->GetExecutionContext());
-    }
+  }
 
   this->FunctionBlockers.push_back(fb);
 }
 
-cmsys::auto_ptr<cmFunctionBlocker>
-cmMakefile::RemoveFunctionBlocker(cmFunctionBlocker* fb,
-                                  const cmListFileFunction& lff)
+cmsys::auto_ptr<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker(
+  cmFunctionBlocker* fb, const cmListFileFunction& lff)
 {
   // Find the function blocker stack barrier for the current scope.
   // We only remove a blocker whose index is not less than the barrier.
   FunctionBlockersType::size_type barrier = 0;
-  if(!this->FunctionBlockerBarriers.empty())
-    {
+  if (!this->FunctionBlockerBarriers.empty()) {
     barrier = this->FunctionBlockerBarriers.back();
-    }
+  }
 
   // Search for the function blocker whose scope this command ends.
-  for(FunctionBlockersType::size_type
-        i = this->FunctionBlockers.size(); i > barrier; --i)
-    {
+  for (FunctionBlockersType::size_type i = this->FunctionBlockers.size();
+       i > barrier; --i) {
     std::vector<cmFunctionBlocker*>::iterator pos =
       this->FunctionBlockers.begin() + (i - 1);
-    if (*pos == fb)
-      {
+    if (*pos == fb) {
       // Warn if the arguments do not match, but always remove.
-      if(!(*pos)->ShouldRemove(lff, *this))
-        {
+      if (!(*pos)->ShouldRemove(lff, *this)) {
         cmListFileContext const& lfc = fb->GetStartingContext();
         cmListFileContext closingContext =
-            cmListFileContext::FromCommandContext(lff, lfc.FilePath);
+          cmListFileContext::FromCommandContext(lff, lfc.FilePath);
         std::ostringstream e;
         /* clang-format off */
         e << "A logical block opening on the line\n"
@@ -3392,12 +2955,12 @@ cmMakefile::RemoveFunctionBlocker(cmFunctionBlocker* fb,
           << "with mis-matching arguments.";
         /* clang-format on */
         this->IssueMessage(cmake::AUTHOR_WARNING, e.str());
-        }
+      }
       cmFunctionBlocker* b = *pos;
       this->FunctionBlockers.erase(pos);
       return cmsys::auto_ptr<cmFunctionBlocker>(b);
-      }
     }
+  }
 
   return cmsys::auto_ptr<cmFunctionBlocker>();
 }
@@ -3422,30 +2985,27 @@ void cmMakefile::SetArgcArgv(const std::vector<std::string>& args)
   std::ostringstream strStream;
   strStream << args.size();
   this->AddDefinition("CMAKE_ARGC", strStream.str().c_str());
-  //this->MarkVariableAsUsed("CMAKE_ARGC");
+  // this->MarkVariableAsUsed("CMAKE_ARGC");
 
-  for (unsigned int t = 0; t < args.size(); ++t)
-  {
+  for (unsigned int t = 0; t < args.size(); ++t) {
     std::ostringstream tmpStream;
     tmpStream << "CMAKE_ARGV" << t;
     this->AddDefinition(tmpStream.str(), args[t].c_str());
-    //this->MarkVariableAsUsed(tmpStream.str().c_str());
+    // this->MarkVariableAsUsed(tmpStream.str().c_str());
   }
 }
 
 cmSourceFile* cmMakefile::GetSource(const std::string& sourceName) const
 {
   cmSourceFileLocation sfl(this, sourceName);
-  for(std::vector<cmSourceFile*>::const_iterator
-        sfi = this->SourceFiles.begin();
-      sfi != this->SourceFiles.end(); ++sfi)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator sfi =
+         this->SourceFiles.begin();
+       sfi != this->SourceFiles.end(); ++sfi) {
     cmSourceFile* sf = *sfi;
-    if(sf->Matches(sfl))
-      {
+    if (sf->Matches(sfl)) {
       return sf;
-      }
     }
+  }
   return 0;
 }
 
@@ -3453,10 +3013,9 @@ cmSourceFile* cmMakefile::CreateSource(const std::string& sourceName,
                                        bool generated)
 {
   cmSourceFile* sf = new cmSourceFile(this, sourceName);
-  if(generated)
-    {
+  if (generated) {
     sf->SetProperty("GENERATED", "1");
-    }
+  }
   this->SourceFiles.push_back(sf);
   return sf;
 }
@@ -3464,18 +3023,15 @@ cmSourceFile* cmMakefile::CreateSource(const std::string& sourceName,
 cmSourceFile* cmMakefile::GetOrCreateSource(const std::string& sourceName,
                                             bool generated)
 {
-  if(cmSourceFile* esf = this->GetSource(sourceName))
-    {
+  if (cmSourceFile* esf = this->GetSource(sourceName)) {
     return esf;
-    }
-  else
-    {
+  } else {
     return this->CreateSource(sourceName, generated);
-    }
+  }
 }
 
-void cmMakefile::EnableLanguage(std::vector<std::string> const &  lang,
-                               bool optional)
+void cmMakefile::EnableLanguage(std::vector<std::string> const& lang,
+                                bool optional)
 {
   this->AddDefinition("CMAKE_CFG_INTDIR",
                       this->GetGlobalGenerator()->GetCMakeCFGIntDir());
@@ -3485,17 +3041,15 @@ void cmMakefile::EnableLanguage(std::vector<std::string> const &  lang,
 int cmMakefile::TryCompile(const std::string& srcdir,
                            const std::string& bindir,
                            const std::string& projectName,
-                           const std::string& targetName,
-                           bool fast,
-                           const std::vector<std::string> *cmakeArgs,
+                           const std::string& targetName, bool fast,
+                           const std::vector<std::string>* cmakeArgs,
                            std::string& output)
 {
   this->IsSourceFileTryCompile = fast;
   // does the binary directory exist ? If not create it...
-  if (!cmSystemTools::FileIsDirectory(bindir))
-    {
+  if (!cmSystemTools::FileIsDirectory(bindir)) {
     cmSystemTools::MakeDirectory(bindir.c_str());
-    }
+  }
 
   // change to the tests directory and run cmake
   // use the cmake object instead of calling cmake
@@ -3507,17 +3061,16 @@ int cmMakefile::TryCompile(const std::string& srcdir,
   // be run that way but the cmake object requires a vailid path
   cmake cm;
   cm.SetIsInTryCompile(true);
-  cmGlobalGenerator *gg = cm.CreateGlobalGenerator
-    (this->GetGlobalGenerator()->GetName());
-  if (!gg)
-    {
+  cmGlobalGenerator* gg =
+    cm.CreateGlobalGenerator(this->GetGlobalGenerator()->GetName());
+  if (!gg) {
     cmSystemTools::Error(
       "Internal CMake error, TryCompile bad GlobalGenerator");
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd);
     this->IsSourceFileTryCompile = false;
     return 1;
-    }
+  }
   cm.SetGlobalGenerator(gg);
 
   // do a configure
@@ -3526,21 +3079,18 @@ int cmMakefile::TryCompile(const std::string& srcdir,
   cm.SetGeneratorPlatform(this->GetCMakeInstance()->GetGeneratorPlatform());
   cm.SetGeneratorToolset(this->GetCMakeInstance()->GetGeneratorToolset());
   cm.LoadCache();
-  if(!gg->IsMultiConfig())
-    {
-    if(const char* config =
-       this->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION"))
-      {
+  if (!gg->IsMultiConfig()) {
+    if (const char* config =
+          this->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION")) {
       // Tell the single-configuration generator which one to use.
       // Add this before the user-provided CMake arguments in case
       // one of the arguments is -DCMAKE_BUILD_TYPE=...
-      cm.AddCacheEntry("CMAKE_BUILD_TYPE", config,
-                       "Build configuration", cmState::STRING);
-      }
+      cm.AddCacheEntry("CMAKE_BUILD_TYPE", config, "Build configuration",
+                       cmState::STRING);
     }
+  }
   // if cmake args were provided then pass them in
-  if (cmakeArgs)
-    {
+  if (cmakeArgs) {
     // FIXME: Workaround to ignore unused CLI variables in try-compile.
     //
     // Ideally we should use SetArgs to honor options like --warn-unused-vars.
@@ -3564,49 +3114,40 @@ int cmMakefile::TryCompile(const std::string& srcdir,
     // previously built.  Instead we work around the issue by never reporting
     // unused arguments and ignoring options such as --warn-unused-vars.
     cm.SetWarnUnusedCli(false);
-    //cm.SetArgs(*cmakeArgs, true);
+    // cm.SetArgs(*cmakeArgs, true);
 
     cm.SetCacheArgs(*cmakeArgs);
-    }
+  }
   // to save time we pass the EnableLanguage info directly
   gg->EnableLanguagesFromGenerator(this->GetGlobalGenerator(), this);
-  if(this->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS"))
-    {
-    cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
-                     "TRUE", "", cmState::INTERNAL);
-    }
-  else
-    {
-    cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
-                     "FALSE", "", cmState::INTERNAL);
-    }
-  if (cm.Configure() != 0)
-    {
+  if (this->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS")) {
+    cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE", "",
+                     cmState::INTERNAL);
+  } else {
+    cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE", "",
+                     cmState::INTERNAL);
+  }
+  if (cm.Configure() != 0) {
     cmSystemTools::Error(
       "Internal CMake error, TryCompile configure of cmake failed");
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd);
     this->IsSourceFileTryCompile = false;
     return 1;
-    }
+  }
 
-  if (cm.Generate() != 0)
-    {
+  if (cm.Generate() != 0) {
     cmSystemTools::Error(
       "Internal CMake error, TryCompile generation of cmake failed");
     // return to the original directory
     cmSystemTools::ChangeDirectory(cwd);
     this->IsSourceFileTryCompile = false;
     return 1;
-    }
+  }
 
   // finally call the generator to actually build the resulting project
-  int ret = this->GetGlobalGenerator()->TryCompile(srcdir,bindir,
-                                                   projectName,
-                                                   targetName,
-                                                   fast,
-                                                   output,
-                                                   this);
+  int ret = this->GetGlobalGenerator()->TryCompile(
+    srcdir, bindir, projectName, targetName, fast, output, this);
 
   cmSystemTools::ChangeDirectory(cwd);
   this->IsSourceFileTryCompile = false;
@@ -3618,7 +3159,7 @@ bool cmMakefile::GetIsSourceFileTryCompile() const
   return this->IsSourceFileTryCompile;
 }
 
-cmake *cmMakefile::GetCMakeInstance() const
+cmake* cmMakefile::GetCMakeInstance() const
 {
   return this->GlobalGenerator->GetCMakeInstance();
 }
@@ -3629,18 +3170,17 @@ cmGlobalGenerator* cmMakefile::GetGlobalGenerator() const
 }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-cmVariableWatch *cmMakefile::GetVariableWatch() const
+cmVariableWatch* cmMakefile::GetVariableWatch() const
 {
-  if ( this->GetCMakeInstance() &&
-       this->GetCMakeInstance()->GetVariableWatch() )
-    {
+  if (this->GetCMakeInstance() &&
+      this->GetCMakeInstance()->GetVariableWatch()) {
     return this->GetCMakeInstance()->GetVariableWatch();
-    }
+  }
   return 0;
 }
 #endif
 
-cmState *cmMakefile::GetState() const
+cmState* cmMakefile::GetState() const
 {
   return this->GetCMakeInstance()->GetState();
 }
@@ -3648,12 +3188,11 @@ cmState *cmMakefile::GetState() const
 void cmMakefile::DisplayStatus(const char* message, float s) const
 {
   cmake* cm = this->GetCMakeInstance();
-  if (cm->GetWorkingMode() == cmake::FIND_PACKAGE_MODE)
-    {
+  if (cm->GetWorkingMode() == cmake::FIND_PACKAGE_MODE) {
     // don't output any STATUS message in FIND_PACKAGE_MODE, since they will
     // directly be fed to the compiler, which will be confused.
     return;
-    }
+  }
   cm->UpdateProgress(message, s);
 }
 
@@ -3676,56 +3215,47 @@ std::string cmMakefile::GetModulesFile(const char* filename) const
 
   // Always search in CMAKE_MODULE_PATH:
   const char* cmakeModulePath = this->GetDefinition("CMAKE_MODULE_PATH");
-  if(cmakeModulePath)
-    {
+  if (cmakeModulePath) {
     std::vector<std::string> modulePath;
     cmSystemTools::ExpandListArgument(cmakeModulePath, modulePath);
 
-    //Look through the possible module directories.
-    for(std::vector<std::string>::iterator i = modulePath.begin();
-        i != modulePath.end(); ++i)
-      {
+    // Look through the possible module directories.
+    for (std::vector<std::string>::iterator i = modulePath.begin();
+         i != modulePath.end(); ++i) {
       std::string itempl = *i;
       cmSystemTools::ConvertToUnixSlashes(itempl);
       itempl += "/";
       itempl += filename;
-      if(cmSystemTools::FileExists(itempl.c_str()))
-        {
+      if (cmSystemTools::FileExists(itempl.c_str())) {
         moduleInCMakeModulePath = itempl;
         break;
-        }
       }
     }
+  }
 
   // Always search in the standard modules location.
   moduleInCMakeRoot = cmSystemTools::GetCMakeRoot();
   moduleInCMakeRoot += "/Modules/";
   moduleInCMakeRoot += filename;
   cmSystemTools::ConvertToUnixSlashes(moduleInCMakeRoot);
-  if(!cmSystemTools::FileExists(moduleInCMakeRoot.c_str()))
-    {
+  if (!cmSystemTools::FileExists(moduleInCMakeRoot.c_str())) {
     moduleInCMakeRoot = "";
-    }
+  }
 
   // Normally, prefer the files found in CMAKE_MODULE_PATH. Only when the file
   // from which we are being called is located itself in CMAKE_ROOT, then
   // prefer results from CMAKE_ROOT depending on the policy setting.
   result = moduleInCMakeModulePath;
-  if (result.empty())
-    {
+  if (result.empty()) {
     result = moduleInCMakeRoot;
-    }
+  }
 
-  if (!moduleInCMakeModulePath.empty() && !moduleInCMakeRoot.empty())
-    {
+  if (!moduleInCMakeModulePath.empty() && !moduleInCMakeRoot.empty()) {
     const char* currentFile = this->GetDefinition("CMAKE_CURRENT_LIST_FILE");
     std::string mods = cmSystemTools::GetCMakeRoot() + "/Modules/";
-    if (currentFile && strncmp(currentFile, mods.c_str(), mods.size()) == 0)
-      {
-      switch (this->GetPolicyStatus(cmPolicies::CMP0017))
-        {
-        case cmPolicies::WARN:
-        {
+    if (currentFile && strncmp(currentFile, mods.c_str(), mods.size()) == 0) {
+      switch (this->GetPolicyStatus(cmPolicies::CMP0017)) {
+        case cmPolicies::WARN: {
           std::ostringstream e;
           /* clang-format off */
           e << "File " << currentFile << " includes "
@@ -3736,7 +3266,7 @@ std::string cmMakefile::GetModulesFile(const char* filename) const
           /* clang-format on */
 
           this->IssueMessage(cmake::AUTHOR_WARNING, e.str());
-           // break;  // fall through to OLD behaviour
+          // break;  // fall through to OLD behaviour
         }
         case cmPolicies::OLD:
           result = moduleInCMakeModulePath;
@@ -3746,87 +3276,69 @@ std::string cmMakefile::GetModulesFile(const char* filename) const
         case cmPolicies::NEW:
           result = moduleInCMakeRoot;
           break;
-        }
       }
     }
+  }
 
   return result;
 }
 
-void cmMakefile::ConfigureString(const std::string& input,
-                                 std::string& output, bool atOnly,
-                                 bool escapeQuotes) const
+void cmMakefile::ConfigureString(const std::string& input, std::string& output,
+                                 bool atOnly, bool escapeQuotes) const
 {
   // Split input to handle one line at a time.
   std::string::const_iterator lineStart = input.begin();
-  while(lineStart != input.end())
-    {
+  while (lineStart != input.end()) {
     // Find the end of this line.
     std::string::const_iterator lineEnd = lineStart;
-    while(lineEnd != input.end() && *lineEnd != '\n')
-      {
+    while (lineEnd != input.end() && *lineEnd != '\n') {
       ++lineEnd;
-      }
+    }
 
     // Copy the line.
     std::string line(lineStart, lineEnd);
 
     // Skip the newline character.
     bool haveNewline = (lineEnd != input.end());
-    if(haveNewline)
-      {
+    if (haveNewline) {
       ++lineEnd;
-      }
+    }
 
     // Replace #cmakedefine instances.
-    if(this->cmDefineRegex.find(line))
-      {
-      const char* def =
-        this->GetDefinition(this->cmDefineRegex.match(1));
-      if(!cmSystemTools::IsOff(def))
-        {
+    if (this->cmDefineRegex.find(line)) {
+      const char* def = this->GetDefinition(this->cmDefineRegex.match(1));
+      if (!cmSystemTools::IsOff(def)) {
         cmSystemTools::ReplaceString(line, "#cmakedefine", "#define");
         output += line;
-        }
-      else
-        {
+      } else {
         output += "/* #undef ";
         output += this->cmDefineRegex.match(1);
         output += " */";
-        }
       }
-    else if(this->cmDefine01Regex.find(line))
-      {
-      const char* def =
-        this->GetDefinition(this->cmDefine01Regex.match(1));
+    } else if (this->cmDefine01Regex.find(line)) {
+      const char* def = this->GetDefinition(this->cmDefine01Regex.match(1));
       cmSystemTools::ReplaceString(line, "#cmakedefine01", "#define");
       output += line;
-      if(!cmSystemTools::IsOff(def))
-        {
+      if (!cmSystemTools::IsOff(def)) {
         output += " 1";
-        }
-      else
-        {
+      } else {
         output += " 0";
-        }
       }
-    else
-      {
+    } else {
       output += line;
-      }
+    }
 
-    if(haveNewline)
-      {
+    if (haveNewline) {
       output += "\n";
-      }
+    }
 
     // Move to the next line.
     lineStart = lineEnd;
-    }
+  }
 
   // Perform variable replacements.
-  this->ExpandVariablesInString(output, escapeQuotes, true,
-                                atOnly, 0, -1, true, true);
+  this->ExpandVariablesInString(output, escapeQuotes, true, atOnly, 0, -1,
+                                true, true);
 }
 
 int cmMakefile::ConfigureFile(const char* infile, const char* outfile,
@@ -3834,114 +3346,94 @@ int cmMakefile::ConfigureFile(const char* infile, const char* outfile,
                               const cmNewLineStyle& newLine)
 {
   int res = 1;
-  if ( !this->CanIWriteThisFile(outfile) )
-    {
-    cmSystemTools::Error("Attempt to write file: ",
-                         outfile, " into a source directory.");
+  if (!this->CanIWriteThisFile(outfile)) {
+    cmSystemTools::Error("Attempt to write file: ", outfile,
+                         " into a source directory.");
     return 0;
-    }
-  if ( !cmSystemTools::FileExists(infile) )
-    {
+  }
+  if (!cmSystemTools::FileExists(infile)) {
     cmSystemTools::Error("File ", infile, " does not exist.");
     return 0;
-    }
+  }
   std::string soutfile = outfile;
   std::string sinfile = infile;
   this->AddCMakeDependFile(sinfile);
   cmSystemTools::ConvertToUnixSlashes(soutfile);
 
   // Re-generate if non-temporary outputs are missing.
-  //when we finalize the configuration we will remove all
-  //output files that now don't exist.
+  // when we finalize the configuration we will remove all
+  // output files that now don't exist.
   this->AddCMakeOutputFile(soutfile);
 
   mode_t perm = 0;
   cmSystemTools::GetPermissions(sinfile.c_str(), perm);
   std::string::size_type pos = soutfile.rfind('/');
-  if(pos != std::string::npos)
-    {
+  if (pos != std::string::npos) {
     std::string path = soutfile.substr(0, pos);
     cmSystemTools::MakeDirectory(path.c_str());
-    }
+  }
 
-  if(copyonly)
-    {
-    if ( !cmSystemTools::CopyFileIfDifferent(sinfile.c_str(),
-                                             soutfile.c_str()))
-      {
+  if (copyonly) {
+    if (!cmSystemTools::CopyFileIfDifferent(sinfile.c_str(),
+                                            soutfile.c_str())) {
       return 0;
-      }
     }
-  else
-    {
+  } else {
     std::string newLineCharacters;
     std::ios_base::openmode omode = std::ios_base::out | std::ios_base::trunc;
-    if (newLine.IsValid())
-      {
+    if (newLine.IsValid()) {
       newLineCharacters = newLine.GetCharacters();
       omode |= std::ios::binary;
-      }
-    else
-      {
+    } else {
       newLineCharacters = "\n";
-      }
+    }
     std::string tempOutputFile = soutfile;
     tempOutputFile += ".tmp";
     cmsys::ofstream fout(tempOutputFile.c_str(), omode);
-    if(!fout)
-      {
-      cmSystemTools::Error(
-        "Could not open file for write in copy operation ",
-        tempOutputFile.c_str());
+    if (!fout) {
+      cmSystemTools::Error("Could not open file for write in copy operation ",
+                           tempOutputFile.c_str());
       cmSystemTools::ReportLastSystemError("");
       return 0;
-      }
+    }
     cmsys::ifstream fin(sinfile.c_str());
-    if(!fin)
-      {
+    if (!fin) {
       cmSystemTools::Error("Could not open file for read in copy operation ",
                            sinfile.c_str());
       return 0;
-      }
+    }
 
     cmsys::FStream::BOM bom = cmsys::FStream::ReadBOM(fin);
-    if(bom != cmsys::FStream::BOM_None &&
-       bom != cmsys::FStream::BOM_UTF8)
-      {
+    if (bom != cmsys::FStream::BOM_None && bom != cmsys::FStream::BOM_UTF8) {
       std::ostringstream e;
       e << "File starts with a Byte-Order-Mark that is not UTF-8:\n  "
         << sinfile;
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return 0;
-      }
+    }
     // rewind to copy BOM to output file
     fin.seekg(0);
 
-
     // now copy input to output and expand variables in the
     // input file at the same time
     std::string inLine;
     std::string outLine;
-    while( cmSystemTools::GetLineFromStream(fin, inLine) )
-      {
+    while (cmSystemTools::GetLineFromStream(fin, inLine)) {
       outLine = "";
       this->ConfigureString(inLine, outLine, atOnly, escapeQuotes);
       fout << outLine.c_str() << newLineCharacters;
-      }
+    }
     // close the files before attempting to copy
     fin.close();
     fout.close();
-    if ( !cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(),
-                                             soutfile.c_str()) )
-      {
+    if (!cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(),
+                                            soutfile.c_str())) {
       res = 0;
-      }
-    else
-      {
+    } else {
       cmSystemTools::SetPermissions(soutfile.c_str(), perm);
-      }
-    cmSystemTools::RemoveFile(tempOutputFile);
     }
+    cmSystemTools::RemoveFile(tempOutputFile);
+  }
   return res;
 }
 
@@ -3951,22 +3443,20 @@ void cmMakefile::SetProperty(const std::string& prop, const char* value)
   this->StateSnapshot.GetDirectory().SetProperty(prop, value, lfbt);
 }
 
-void cmMakefile::AppendProperty(const std::string& prop,
-                                const char* value,
+void cmMakefile::AppendProperty(const std::string& prop, const char* value,
                                 bool asString)
 {
   cmListFileBacktrace lfbt = this->GetBacktrace();
-  this->StateSnapshot.GetDirectory().AppendProperty(prop, value,
-                                                    asString, lfbt);
+  this->StateSnapshot.GetDirectory().AppendProperty(prop, value, asString,
+                                                    lfbt);
 }
 
-const char *cmMakefile::GetProperty(const std::string& prop) const
+const char* cmMakefile::GetProperty(const std::string& prop) const
 {
   return this->StateSnapshot.GetDirectory().GetProperty(prop);
 }
 
-const char *cmMakefile::GetProperty(const std::string& prop,
-                                    bool chain) const
+const char* cmMakefile::GetProperty(const std::string& prop, bool chain) const
 {
   return this->StateSnapshot.GetDirectory().GetProperty(prop, chain);
 }
@@ -3983,21 +3473,19 @@ std::vector<std::string> cmMakefile::GetPropertyKeys() const
 
 cmTarget* cmMakefile::FindLocalNonAliasTarget(const std::string& name) const
 {
-  cmTargets::iterator i = this->Targets.find( name );
-  if ( i != this->Targets.end() )
-    {
+  cmTargets::iterator i = this->Targets.find(name);
+  if (i != this->Targets.end()) {
     return &i->second;
-    }
+  }
   return 0;
 }
 
 cmTest* cmMakefile::CreateTest(const std::string& testName)
 {
   cmTest* test = this->GetTest(testName);
-  if ( test )
-    {
+  if (test) {
     return test;
-    }
+  }
   test = new cmTest(this);
   test->SetName(testName);
   this->Tests[testName] = test;
@@ -4006,77 +3494,65 @@ cmTest* cmMakefile::CreateTest(const std::string& testName)
 
 cmTest* cmMakefile::GetTest(const std::string& testName) const
 {
-  std::map<std::string, cmTest*>::const_iterator
-    mi = this->Tests.find(testName);
-  if(mi != this->Tests.end())
-    {
+  std::map<std::string, cmTest*>::const_iterator mi =
+    this->Tests.find(testName);
+  if (mi != this->Tests.end()) {
     return mi->second;
-    }
+  }
   return 0;
 }
 
 void cmMakefile::AddCMakeDependFilesFromUser()
 {
   std::vector<std::string> deps;
-  if(const char* deps_str = this->GetProperty("CMAKE_CONFIGURE_DEPENDS"))
-    {
+  if (const char* deps_str = this->GetProperty("CMAKE_CONFIGURE_DEPENDS")) {
     cmSystemTools::ExpandListArgument(deps_str, deps);
-    }
-  for(std::vector<std::string>::iterator i = deps.begin();
-      i != deps.end(); ++i)
-    {
-    if(cmSystemTools::FileIsFullPath(i->c_str()))
-      {
+  }
+  for (std::vector<std::string>::iterator i = deps.begin(); i != deps.end();
+       ++i) {
+    if (cmSystemTools::FileIsFullPath(i->c_str())) {
       this->AddCMakeDependFile(*i);
-      }
-    else
-      {
+    } else {
       std::string f = this->GetCurrentSourceDirectory();
       f += "/";
       f += *i;
       this->AddCMakeDependFile(f);
-      }
     }
+  }
 }
 
 std::string cmMakefile::FormatListFileStack() const
 {
   std::vector<std::string> listFiles;
   cmState::Snapshot snp = this->StateSnapshot;
-  while (snp.IsValid())
-    {
+  while (snp.IsValid()) {
     listFiles.push_back(snp.GetExecutionListFile());
     snp = snp.GetCallStackParent();
-    }
+  }
   std::reverse(listFiles.begin(), listFiles.end());
   std::ostringstream tmp;
   size_t depth = listFiles.size();
-  if (depth > 0)
-    {
+  if (depth > 0) {
     std::vector<std::string>::const_iterator it = listFiles.end();
-    do
-      {
-      if (depth != listFiles.size())
-        {
+    do {
+      if (depth != listFiles.size()) {
         tmp << "\n                ";
-        }
+      }
       --it;
       tmp << "[";
       tmp << depth;
       tmp << "]\t";
       tmp << *it;
       depth--;
-      }
-    while (it != listFiles.begin());
-    }
+    } while (it != listFiles.begin());
+  }
   return tmp.str();
 }
 
-
 void cmMakefile::PushScope()
 {
-  this->StateSnapshot = this->GetState()->CreateVariableScopeSnapshot(
-        this->StateSnapshot);
+  this->StateSnapshot =
+    this->GetState()->CreateVariableScopeSnapshot(this->StateSnapshot);
   this->PushLoopBlockBarrier();
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
@@ -4097,25 +3573,21 @@ void cmMakefile::PopScope()
   this->PopSnapshot();
 }
 
-void cmMakefile::RaiseScope(const std::string& var, const char *varDef)
+void cmMakefile::RaiseScope(const std::string& var, const char* varDef)
 {
-  if (var.empty())
-    {
+  if (var.empty()) {
     return;
-    }
+  }
 
-  if (!this->StateSnapshot.RaiseScope(var, varDef))
-    {
+  if (!this->StateSnapshot.RaiseScope(var, varDef)) {
     std::ostringstream m;
     m << "Cannot set \"" << var << "\": current scope has no parent.";
     this->IssueMessage(cmake::AUTHOR_WARNING, m.str());
-    }
+  }
 }
 
-cmTarget*
-cmMakefile::AddImportedTarget(const std::string& name,
-                              cmState::TargetType type,
-                              bool global)
+cmTarget* cmMakefile::AddImportedTarget(const std::string& name,
+                                        cmState::TargetType type, bool global)
 {
   // Create the target.
   cmsys::auto_ptr<cmTarget> target(new cmTarget);
@@ -4137,18 +3609,15 @@ cmTarget* cmMakefile::FindTargetToUse(const std::string& name,
 {
   // Look for an imported target.  These take priority because they
   // are more local in scope and do not have to be globally unique.
-  TargetMap::const_iterator
-    imported = this->ImportedTargets.find(name);
-  if(imported != this->ImportedTargets.end())
-    {
+  TargetMap::const_iterator imported = this->ImportedTargets.find(name);
+  if (imported != this->ImportedTargets.end()) {
     return imported->second;
-    }
+  }
 
   // Look for a target built in this directory.
-  if(cmTarget* t = this->FindLocalNonAliasTarget(name))
-    {
+  if (cmTarget* t = this->FindLocalNonAliasTarget(name)) {
     return t;
-    }
+  }
 
   // Look for a target built in this project.
   return this->GetGlobalGenerator()->FindTarget(name, excludeAliases);
@@ -4164,20 +3633,17 @@ bool cmMakefile::IsAlias(const std::string& name) const
 bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
                                    bool isCustom) const
 {
-  if(this->IsAlias(name))
-    {
+  if (this->IsAlias(name)) {
     std::ostringstream e;
     e << "cannot create target \"" << name
       << "\" because an alias with the same name already exists.";
     msg = e.str();
     return false;
-    }
-  if(cmTarget* existing = this->FindTargetToUse(name))
-    {
+  }
+  if (cmTarget* existing = this->FindTargetToUse(name)) {
     // The name given conflicts with an existing target.  Produce an
     // error in a compatible way.
-    if(existing->IsImported())
-      {
+    if (existing->IsImported()) {
       // Imported targets were not supported in previous versions.
       // This is new code, so we can make it an error.
       std::ostringstream e;
@@ -4185,37 +3651,34 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
         << "\" because an imported target with the same name already exists.";
       msg = e.str();
       return false;
-      }
-    else
-      {
+    } else {
       // target names must be globally unique
-      switch (this->GetPolicyStatus(cmPolicies::CMP0002))
-        {
+      switch (this->GetPolicyStatus(cmPolicies::CMP0002)) {
         case cmPolicies::WARN:
-          this->IssueMessage(cmake::AUTHOR_WARNING, cmPolicies::
-                             GetPolicyWarning(cmPolicies::CMP0002));
+          this->IssueMessage(
+            cmake::AUTHOR_WARNING,
+            cmPolicies::GetPolicyWarning(cmPolicies::CMP0002));
         case cmPolicies::OLD:
           return true;
         case cmPolicies::REQUIRED_IF_USED:
         case cmPolicies::REQUIRED_ALWAYS:
-          this->IssueMessage(cmake::FATAL_ERROR,
-            cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0002)
-            );
+          this->IssueMessage(
+            cmake::FATAL_ERROR,
+            cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0002));
           return true;
         case cmPolicies::NEW:
           break;
-        }
+      }
 
       // The conflict is with a non-imported target.
       // Allow this if the user has requested support.
       cmake* cm = this->GetCMakeInstance();
-      if(isCustom && existing->GetType() == cmState::UTILITY &&
-         this != existing->GetMakefile() &&
-         cm->GetState()
-           ->GetGlobalPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS"))
-        {
+      if (isCustom && existing->GetType() == cmState::UTILITY &&
+          this != existing->GetMakefile() &&
+          cm->GetState()->GetGlobalPropertyAsBool(
+            "ALLOW_DUPLICATE_CUSTOM_TARGETS")) {
         return true;
-        }
+      }
 
       // Produce an error that tells the user how to work around the
       // problem.
@@ -4223,8 +3686,7 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
       e << "cannot create target \"" << name
         << "\" because another target with the same name already exists.  "
         << "The existing target is ";
-      switch(existing->GetType())
-        {
+      switch (existing->GetType()) {
         case cmState::EXECUTABLE:
           e << "an executable ";
           break;
@@ -4243,15 +3705,16 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
         case cmState::INTERFACE_LIBRARY:
           e << "an interface library ";
           break;
-        default: break;
-        }
+        default:
+          break;
+      }
       e << "created in source directory \""
         << existing->GetMakefile()->GetCurrentSourceDirectory() << "\".  "
         << "See documentation for policy CMP0002 for more details.";
       msg = e.str();
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -4260,13 +3723,11 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
 {
   // Make sure the binary directory is unique.
   cmGlobalGenerator* gg = this->GetGlobalGenerator();
-  if(gg->BinaryDirectoryIsNew(binPath))
-    {
+  if (gg->BinaryDirectoryIsNew(binPath)) {
     return true;
-    }
+  }
   std::ostringstream e;
-  switch (this->GetPolicyStatus(cmPolicies::CMP0013))
-    {
+  switch (this->GetPolicyStatus(cmPolicies::CMP0013)) {
     case cmPolicies::WARN:
       // Print the warning.
       /* clang-format off */
@@ -4288,8 +3749,7 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
       return true;
     case cmPolicies::REQUIRED_IF_USED:
     case cmPolicies::REQUIRED_ALWAYS:
-      e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0013)
-        << "\n";
+      e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0013) << "\n";
     case cmPolicies::NEW:
       // NEW behavior prints the error.
       /* clang-format off */
@@ -4302,12 +3762,12 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
       /* clang-format on */
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       break;
-    }
+  }
 
   return false;
 }
 
-void cmMakefile::AddQtUiFileWithOptions(cmSourceFile *sf)
+void cmMakefile::AddQtUiFileWithOptions(cmSourceFile* sf)
 {
   this->QtUiFilesWithOptions.push_back(sf);
 }
@@ -4318,16 +3778,9 @@ std::vector<cmSourceFile*> cmMakefile::GetQtUiFilesWithOptions() const
 }
 
 static std::string const matchVariables[] = {
-  "CMAKE_MATCH_0",
-  "CMAKE_MATCH_1",
-  "CMAKE_MATCH_2",
-  "CMAKE_MATCH_3",
-  "CMAKE_MATCH_4",
-  "CMAKE_MATCH_5",
-  "CMAKE_MATCH_6",
-  "CMAKE_MATCH_7",
-  "CMAKE_MATCH_8",
-  "CMAKE_MATCH_9"
+  "CMAKE_MATCH_0", "CMAKE_MATCH_1", "CMAKE_MATCH_2", "CMAKE_MATCH_3",
+  "CMAKE_MATCH_4", "CMAKE_MATCH_5", "CMAKE_MATCH_6", "CMAKE_MATCH_7",
+  "CMAKE_MATCH_8", "CMAKE_MATCH_9"
 };
 
 static std::string const nMatchesVariable = "CMAKE_MATCH_COUNT";
@@ -4335,21 +3788,18 @@ static std::string const nMatchesVariable = "CMAKE_MATCH_COUNT";
 void cmMakefile::ClearMatches()
 {
   const char* nMatchesStr = this->GetDefinition(nMatchesVariable);
-  if (!nMatchesStr)
-    {
+  if (!nMatchesStr) {
     return;
-    }
+  }
   int nMatches = atoi(nMatchesStr);
-  for (int i=0; i<=nMatches; i++)
-    {
+  for (int i = 0; i <= nMatches; i++) {
     std::string const& var = matchVariables[i];
     std::string const& s = this->GetSafeDefinition(var);
-    if(!s.empty())
-      {
+    if (!s.empty()) {
       this->AddDefinition(var, "");
       this->MarkVariableAsUsed(var);
-      }
     }
+  }
   this->AddDefinition(nMatchesVariable, "0");
   this->MarkVariableAsUsed(nMatchesVariable);
 }
@@ -4357,18 +3807,16 @@ void cmMakefile::ClearMatches()
 void cmMakefile::StoreMatches(cmsys::RegularExpression& re)
 {
   char highest = 0;
-  for (int i=0; i<10; i++)
-    {
+  for (int i = 0; i < 10; i++) {
     std::string const& m = re.match(i);
-    if(!m.empty())
-      {
+    if (!m.empty()) {
       std::string const& var = matchVariables[i];
       this->AddDefinition(var, m.c_str());
       this->MarkVariableAsUsed(var);
       highest = static_cast<char>('0' + i);
-      }
     }
-  char nMatches[] = {highest, '\0'};
+  }
+  char nMatches[] = { highest, '\0' };
   this->AddDefinition(nMatchesVariable, nMatches);
   this->MarkVariableAsUsed(nMatchesVariable);
 }
@@ -4383,8 +3831,8 @@ const char* cmMakefile::GetDefineFlagsCMP0059() const
   return this->DefineFlagsOrig.c_str();
 }
 
-cmPolicies::PolicyStatus
-cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id) const
+cmPolicies::PolicyStatus cmMakefile::GetPolicyStatus(
+  cmPolicies::PolicyID id) const
 {
   return this->StateSnapshot.GetPolicy(id);
 }
@@ -4392,52 +3840,46 @@ cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id) const
 bool cmMakefile::PolicyOptionalWarningEnabled(std::string const& var)
 {
   // Check for an explicit CMAKE_POLICY_WARNING_CMP<NNNN> setting.
-  if(!var.empty())
-    {
-    if(const char* val = this->GetDefinition(var))
-      {
+  if (!var.empty()) {
+    if (const char* val = this->GetDefinition(var)) {
       return cmSystemTools::IsOn(val);
-      }
     }
+  }
   // Enable optional policy warnings with --debug-output, --trace,
   // or --trace-expand.
   cmake* cm = this->GetCMakeInstance();
   return cm->GetDebugOutput() || cm->GetTrace();
 }
 
-bool cmMakefile::SetPolicy(const char *id,
-                           cmPolicies::PolicyStatus status)
+bool cmMakefile::SetPolicy(const char* id, cmPolicies::PolicyStatus status)
 {
   cmPolicies::PolicyID pid;
-  if (!cmPolicies::GetPolicyID(id, /* out */ pid))
-    {
+  if (!cmPolicies::GetPolicyID(id, /* out */ pid)) {
     std::ostringstream e;
     e << "Policy \"" << id << "\" is not known to this version of CMake.";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
-  return this->SetPolicy(pid,status);
+  }
+  return this->SetPolicy(pid, status);
 }
 
 bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
                            cmPolicies::PolicyStatus status)
 {
   // A REQUIRED_ALWAYS policy may be set only to NEW.
-  if(status != cmPolicies::NEW &&
-     cmPolicies::GetPolicyStatus(id) ==
-     cmPolicies::REQUIRED_ALWAYS)
-    {
-    std::string msg =
-      cmPolicies::GetRequiredAlwaysPolicyError(id);
+  if (status != cmPolicies::NEW &&
+      cmPolicies::GetPolicyStatus(id) == cmPolicies::REQUIRED_ALWAYS) {
+    std::string msg = cmPolicies::GetRequiredAlwaysPolicyError(id);
     this->IssueMessage(cmake::FATAL_ERROR, msg);
     return false;
-    }
+  }
 
   this->StateSnapshot.SetPolicy(id, status);
   return true;
 }
 
-cmMakefile::PolicyPushPop::PolicyPushPop(cmMakefile* m): Makefile(m)
+cmMakefile::PolicyPushPop::PolicyPushPop(cmMakefile* m)
+  : Makefile(m)
 {
   this->Makefile->PushPolicy();
 }
@@ -4454,11 +3896,10 @@ void cmMakefile::PushPolicy(bool weak, cmPolicies::PolicyMap const& pm)
 
 void cmMakefile::PopPolicy()
 {
-  if (!this->StateSnapshot.PopPolicy())
-    {
+  if (!this->StateSnapshot.PopPolicy()) {
     this->IssueMessage(cmake::FATAL_ERROR,
                        "cmake_policy POP without matching PUSH");
-    }
+  }
 }
 
 void cmMakefile::PopSnapshot(bool reportError)
@@ -4466,28 +3907,26 @@ void cmMakefile::PopSnapshot(bool reportError)
   // cmState::Snapshot manages nested policy scopes within it.
   // Since the scope corresponding to the snapshot is closing,
   // reject any still-open nested policy scopes with an error.
-  while (!this->StateSnapshot.CanPopPolicyScope())
-    {
-    if(reportError)
-      {
+  while (!this->StateSnapshot.CanPopPolicyScope()) {
+    if (reportError) {
       this->IssueMessage(cmake::FATAL_ERROR,
                          "cmake_policy PUSH without matching POP");
       reportError = false;
-      }
-    this->PopPolicy();
     }
+    this->PopPolicy();
+  }
 
   this->StateSnapshot = this->GetState()->Pop(this->StateSnapshot);
   assert(this->StateSnapshot.IsValid());
 }
 
-bool cmMakefile::SetPolicyVersion(const char *version)
+bool cmMakefile::SetPolicyVersion(const char* version)
 {
-  return cmPolicies::ApplyPolicyVersion(this,version);
+  return cmPolicies::ApplyPolicyVersion(this, version);
 }
 
 bool cmMakefile::HasCMP0054AlreadyBeenReported(
-    cmListFileContext const& context) const
+  cmListFileContext const& context) const
 {
   return !this->CMP0054ReportedIds.insert(context).second;
 }
@@ -4496,20 +3935,18 @@ void cmMakefile::RecordPolicies(cmPolicies::PolicyMap& pm)
 {
   /* Record the setting of every policy.  */
   typedef cmPolicies::PolicyID PolicyID;
-  for(PolicyID pid = cmPolicies::CMP0000;
-      pid != cmPolicies::CMPCOUNT; pid = PolicyID(pid+1))
-    {
+  for (PolicyID pid = cmPolicies::CMP0000; pid != cmPolicies::CMPCOUNT;
+       pid = PolicyID(pid + 1)) {
     pm.Set(pid, this->GetPolicyStatus(pid));
-    }
+  }
 }
 
 bool cmMakefile::IgnoreErrorsCMP0061() const
 {
   bool ignoreErrors = true;
-  switch (this->GetPolicyStatus(cmPolicies::CMP0061))
-    {
+  switch (this->GetPolicyStatus(cmPolicies::CMP0061)) {
     case cmPolicies::WARN:
-      // No warning for this policy!
+    // No warning for this policy!
     case cmPolicies::OLD:
       break;
     case cmPolicies::REQUIRED_IF_USED:
@@ -4517,189 +3954,155 @@ bool cmMakefile::IgnoreErrorsCMP0061() const
     case cmPolicies::NEW:
       ignoreErrors = false;
       break;
-    }
+  }
   return ignoreErrors;
 }
 
 #define FEATURE_STRING(F) , #F
-static const char * const C_FEATURES[] = {
-  0
-  FOR_EACH_C_FEATURE(FEATURE_STRING)
-};
+static const char* const C_FEATURES[] = { 0 FOR_EACH_C_FEATURE(
+  FEATURE_STRING) };
 
-static const char * const CXX_FEATURES[] = {
-  0
-  FOR_EACH_CXX_FEATURE(FEATURE_STRING)
-};
+static const char* const CXX_FEATURES[] = { 0 FOR_EACH_CXX_FEATURE(
+  FEATURE_STRING) };
 #undef FEATURE_STRING
 
-static const char * const C_STANDARDS[] = {
-    "90"
-  , "99"
-  , "11"
-};
-static const char * const CXX_STANDARDS[] = {
-    "98"
-  , "11"
-  , "14"
-};
+static const char* const C_STANDARDS[] = { "90", "99", "11" };
+static const char* const CXX_STANDARDS[] = { "98", "11", "14" };
 
-bool cmMakefile::
-AddRequiredTargetFeature(cmTarget *target, const std::string& feature,
-                         std::string *error) const
+bool cmMakefile::AddRequiredTargetFeature(cmTarget* target,
+                                          const std::string& feature,
+                                          std::string* error) const
 {
-  if (cmGeneratorExpression::Find(feature) != std::string::npos)
-    {
+  if (cmGeneratorExpression::Find(feature) != std::string::npos) {
     target->AppendProperty("COMPILE_FEATURES", feature.c_str());
     return true;
-    }
+  }
 
   std::string lang;
-  if (!this->CompileFeatureKnown(target, feature, lang, error))
-    {
+  if (!this->CompileFeatureKnown(target, feature, lang, error)) {
     return false;
-    }
+  }
 
   const char* features = this->CompileFeaturesAvailable(lang, error);
-  if (!features)
-    {
+  if (!features) {
     return false;
-    }
+  }
 
   std::vector<std::string> availableFeatures;
   cmSystemTools::ExpandListArgument(features, availableFeatures);
-  if (std::find(availableFeatures.begin(),
-                availableFeatures.end(),
-                feature) == availableFeatures.end())
-    {
+  if (std::find(availableFeatures.begin(), availableFeatures.end(), feature) ==
+      availableFeatures.end()) {
     std::ostringstream e;
-    e << "The compiler feature \"" << feature
-      << "\" is not known to " << lang << " compiler\n\""
+    e << "The compiler feature \"" << feature << "\" is not known to " << lang
+      << " compiler\n\""
       << this->GetDefinition("CMAKE_" + lang + "_COMPILER_ID")
       << "\"\nversion "
       << this->GetDefinition("CMAKE_" + lang + "_COMPILER_VERSION") << ".";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   target->AppendProperty("COMPILE_FEATURES", feature.c_str());
 
-  return lang == "C"
-      ? this->AddRequiredTargetCFeature(target, feature)
-      : this->AddRequiredTargetCxxFeature(target, feature);
+  return lang == "C" ? this->AddRequiredTargetCFeature(target, feature)
+                     : this->AddRequiredTargetCxxFeature(target, feature);
 }
 
-bool cmMakefile::
-CompileFeatureKnown(cmTarget const* target, const std::string& feature,
-                    std::string& lang, std::string *error) const
+bool cmMakefile::CompileFeatureKnown(cmTarget const* target,
+                                     const std::string& feature,
+                                     std::string& lang,
+                                     std::string* error) const
 {
   assert(cmGeneratorExpression::Find(feature) == std::string::npos);
 
-  bool isCFeature = std::find_if(cmArrayBegin(C_FEATURES) + 1,
-              cmArrayEnd(C_FEATURES), cmStrCmp(feature))
-              != cmArrayEnd(C_FEATURES);
-  if (isCFeature)
-    {
+  bool isCFeature =
+    std::find_if(cmArrayBegin(C_FEATURES) + 1, cmArrayEnd(C_FEATURES),
+                 cmStrCmp(feature)) != cmArrayEnd(C_FEATURES);
+  if (isCFeature) {
     lang = "C";
     return true;
-    }
-  bool isCxxFeature = std::find_if(cmArrayBegin(CXX_FEATURES) + 1,
-              cmArrayEnd(CXX_FEATURES), cmStrCmp(feature))
-              != cmArrayEnd(CXX_FEATURES);
-  if (isCxxFeature)
-    {
+  }
+  bool isCxxFeature =
+    std::find_if(cmArrayBegin(CXX_FEATURES) + 1, cmArrayEnd(CXX_FEATURES),
+                 cmStrCmp(feature)) != cmArrayEnd(CXX_FEATURES);
+  if (isCxxFeature) {
     lang = "CXX";
     return true;
-    }
+  }
   std::ostringstream e;
-  if (error)
-    {
+  if (error) {
     e << "specified";
-    }
-  else
-    {
+  } else {
     e << "Specified";
-    }
+  }
   e << " unknown feature \"" << feature << "\" for "
-    "target \"" << target->GetName() << "\".";
-  if (error)
-    {
+                                           "target \""
+    << target->GetName() << "\".";
+  if (error) {
     *error = e.str();
-    }
-  else
-    {
+  } else {
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
+  }
   return false;
 }
 
-const char* cmMakefile::
-CompileFeaturesAvailable(const std::string& lang, std::string *error) const
+const char* cmMakefile::CompileFeaturesAvailable(const std::string& lang,
+                                                 std::string* error) const
 {
   const char* featuresKnown =
     this->GetDefinition("CMAKE_" + lang + "_COMPILE_FEATURES");
 
-  if (!featuresKnown || !*featuresKnown)
-    {
+  if (!featuresKnown || !*featuresKnown) {
     std::ostringstream e;
-    if (error)
-      {
+    if (error) {
       e << "no";
-      }
-    else
-      {
+    } else {
       e << "No";
-      }
+    }
     e << " known features for " << lang << " compiler\n\""
       << this->GetDefinition("CMAKE_" + lang + "_COMPILER_ID")
       << "\"\nversion "
       << this->GetDefinition("CMAKE_" + lang + "_COMPILER_VERSION") << ".";
-    if (error)
-      {
+    if (error) {
       *error = e.str();
-      }
-    else
-      {
+    } else {
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
-      }
-    return 0;
     }
+    return 0;
+  }
   return featuresKnown;
 }
 
 bool cmMakefile::HaveStandardAvailable(cmTarget const* target,
-                                      std::string const& lang,
-                                      const std::string& feature) const
+                                       std::string const& lang,
+                                       const std::string& feature) const
 {
-  return lang == "C"
-      ? this->HaveCStandardAvailable(target, feature)
-      : this->HaveCxxStandardAvailable(target, feature);
+  return lang == "C" ? this->HaveCStandardAvailable(target, feature)
+                     : this->HaveCxxStandardAvailable(target, feature);
 }
 
-bool cmMakefile::
-HaveCStandardAvailable(cmTarget const* target,
-                       const std::string& feature) const
+bool cmMakefile::HaveCStandardAvailable(cmTarget const* target,
+                                        const std::string& feature) const
 {
   const char* defaultCStandard =
     this->GetDefinition("CMAKE_C_STANDARD_DEFAULT");
-  if (!defaultCStandard)
-    {
+  if (!defaultCStandard) {
     std::ostringstream e;
     e << "CMAKE_C_STANDARD_DEFAULT is not set.  COMPILE_FEATURES support "
-      "not fully configured for this compiler.";
+         "not fully configured for this compiler.";
     this->IssueMessage(cmake::INTERNAL_ERROR, e.str());
     // Return true so the caller does not try to lookup the default standard.
     return true;
-    }
+  }
   if (std::find_if(cmArrayBegin(C_STANDARDS), cmArrayEnd(C_STANDARDS),
-                cmStrCmp(defaultCStandard)) == cmArrayEnd(C_STANDARDS))
-    {
+                   cmStrCmp(defaultCStandard)) == cmArrayEnd(C_STANDARDS)) {
     std::ostringstream e;
     e << "The CMAKE_C_STANDARD_DEFAULT variable contains an "
-         "invalid value: \"" << defaultCStandard << "\".";
+         "invalid value: \""
+      << defaultCStandard << "\".";
     this->IssueMessage(cmake::INTERNAL_ERROR, e.str());
     return false;
-    }
+  }
 
   bool needC90 = false;
   bool needC99 = false;
@@ -4707,49 +4110,40 @@ HaveCStandardAvailable(cmTarget const* target,
 
   this->CheckNeededCLanguage(feature, needC90, needC99, needC11);
 
-  const char *existingCStandard = target->GetProperty("C_STANDARD");
-  if (!existingCStandard)
-    {
+  const char* existingCStandard = target->GetProperty("C_STANDARD");
+  if (!existingCStandard) {
     existingCStandard = defaultCStandard;
-    }
+  }
 
   if (std::find_if(cmArrayBegin(C_STANDARDS), cmArrayEnd(C_STANDARDS),
-                cmStrCmp(existingCStandard)) == cmArrayEnd(C_STANDARDS))
-    {
+                   cmStrCmp(existingCStandard)) == cmArrayEnd(C_STANDARDS)) {
     std::ostringstream e;
     e << "The C_STANDARD property on target \"" << target->GetName()
       << "\" contained an invalid value: \"" << existingCStandard << "\".";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
-  const char * const *existingCIt = existingCStandard
-                                    ? std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp(existingCStandard))
-                                    : cmArrayEnd(C_STANDARDS);
+  const char* const* existingCIt = existingCStandard
+    ? std::find_if(cmArrayBegin(C_STANDARDS), cmArrayEnd(C_STANDARDS),
+                   cmStrCmp(existingCStandard))
+    : cmArrayEnd(C_STANDARDS);
 
-  if (needC11 && existingCStandard && existingCIt <
-                                    std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp("11")))
-    {
+  if (needC11 && existingCStandard &&
+      existingCIt < std::find_if(cmArrayBegin(C_STANDARDS),
+                                 cmArrayEnd(C_STANDARDS), cmStrCmp("11"))) {
     return false;
-    }
-  else if(needC99 && existingCStandard && existingCIt <
-                                    std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp("99")))
-    {
+  } else if (needC99 && existingCStandard &&
+             existingCIt < std::find_if(cmArrayBegin(C_STANDARDS),
+                                        cmArrayEnd(C_STANDARDS),
+                                        cmStrCmp("99"))) {
     return false;
-    }
-  else if(needC90 && existingCStandard && existingCIt <
-                                    std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp("90")))
-    {
+  } else if (needC90 && existingCStandard &&
+             existingCIt < std::find_if(cmArrayBegin(C_STANDARDS),
+                                        cmArrayEnd(C_STANDARDS),
+                                        cmStrCmp("90"))) {
     return false;
-    }
+  }
   return true;
 }
 
@@ -4757,121 +4151,109 @@ bool cmMakefile::IsLaterStandard(std::string const& lang,
                                  std::string const& lhs,
                                  std::string const& rhs)
 {
-  if (lang == "C")
-    {
-    const char * const *rhsIt = std::find_if(cmArrayBegin(C_STANDARDS),
-                                            cmArrayEnd(C_STANDARDS),
-                                            cmStrCmp(rhs));
+  if (lang == "C") {
+    const char* const* rhsIt = std::find_if(
+      cmArrayBegin(C_STANDARDS), cmArrayEnd(C_STANDARDS), cmStrCmp(rhs));
 
-    return std::find_if(rhsIt, cmArrayEnd(C_STANDARDS),
-                        cmStrCmp(lhs)) != cmArrayEnd(C_STANDARDS);
-    }
-  const char * const *rhsIt = std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                           cmArrayEnd(CXX_STANDARDS),
-                                           cmStrCmp(rhs));
+    return std::find_if(rhsIt, cmArrayEnd(C_STANDARDS), cmStrCmp(lhs)) !=
+      cmArrayEnd(C_STANDARDS);
+  }
+  const char* const* rhsIt = std::find_if(
+    cmArrayBegin(CXX_STANDARDS), cmArrayEnd(CXX_STANDARDS), cmStrCmp(rhs));
 
-  return std::find_if(rhsIt, cmArrayEnd(CXX_STANDARDS),
-                      cmStrCmp(lhs)) != cmArrayEnd(CXX_STANDARDS);
+  return std::find_if(rhsIt, cmArrayEnd(CXX_STANDARDS), cmStrCmp(lhs)) !=
+    cmArrayEnd(CXX_STANDARDS);
 }
 
 bool cmMakefile::HaveCxxStandardAvailable(cmTarget const* target,
-                                         const std::string& feature) const
+                                          const std::string& feature) const
 {
   const char* defaultCxxStandard =
     this->GetDefinition("CMAKE_CXX_STANDARD_DEFAULT");
-  if (!defaultCxxStandard)
-    {
+  if (!defaultCxxStandard) {
     std::ostringstream e;
     e << "CMAKE_CXX_STANDARD_DEFAULT is not set.  COMPILE_FEATURES support "
-      "not fully configured for this compiler.";
+         "not fully configured for this compiler.";
     this->IssueMessage(cmake::INTERNAL_ERROR, e.str());
     // Return true so the caller does not try to lookup the default standard.
     return true;
-    }
+  }
   if (std::find_if(cmArrayBegin(CXX_STANDARDS), cmArrayEnd(CXX_STANDARDS),
-                cmStrCmp(defaultCxxStandard)) == cmArrayEnd(CXX_STANDARDS))
-    {
+                   cmStrCmp(defaultCxxStandard)) ==
+      cmArrayEnd(CXX_STANDARDS)) {
     std::ostringstream e;
     e << "The CMAKE_CXX_STANDARD_DEFAULT variable contains an "
-         "invalid value: \"" << defaultCxxStandard << "\".";
+         "invalid value: \""
+      << defaultCxxStandard << "\".";
     this->IssueMessage(cmake::INTERNAL_ERROR, e.str());
     return false;
-    }
+  }
 
   bool needCxx98 = false;
   bool needCxx11 = false;
   bool needCxx14 = false;
   this->CheckNeededCxxLanguage(feature, needCxx98, needCxx11, needCxx14);
 
-  const char *existingCxxStandard = target->GetProperty("CXX_STANDARD");
-  if (!existingCxxStandard)
-    {
+  const char* existingCxxStandard = target->GetProperty("CXX_STANDARD");
+  if (!existingCxxStandard) {
     existingCxxStandard = defaultCxxStandard;
-    }
+  }
 
   if (std::find_if(cmArrayBegin(CXX_STANDARDS), cmArrayEnd(CXX_STANDARDS),
-                cmStrCmp(existingCxxStandard)) == cmArrayEnd(CXX_STANDARDS))
-    {
+                   cmStrCmp(existingCxxStandard)) ==
+      cmArrayEnd(CXX_STANDARDS)) {
     std::ostringstream e;
     e << "The CXX_STANDARD property on target \"" << target->GetName()
       << "\" contained an invalid value: \"" << existingCxxStandard << "\".";
     this->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
-  const char * const *existingCxxIt = existingCxxStandard
-                                    ? std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp(existingCxxStandard))
-                                    : cmArrayEnd(CXX_STANDARDS);
+  const char* const* existingCxxIt = existingCxxStandard
+    ? std::find_if(cmArrayBegin(CXX_STANDARDS), cmArrayEnd(CXX_STANDARDS),
+                   cmStrCmp(existingCxxStandard))
+    : cmArrayEnd(CXX_STANDARDS);
 
-  if (needCxx11 && existingCxxIt < std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp("11")))
-    {
+  if (needCxx11 &&
+      existingCxxIt < std::find_if(cmArrayBegin(CXX_STANDARDS),
+                                   cmArrayEnd(CXX_STANDARDS),
+                                   cmStrCmp("11"))) {
     return false;
-    }
-  else if(needCxx98 && existingCxxIt <
-                                    std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp("98")))
-    {
+  } else if (needCxx98 &&
+             existingCxxIt < std::find_if(cmArrayBegin(CXX_STANDARDS),
+                                          cmArrayEnd(CXX_STANDARDS),
+                                          cmStrCmp("98"))) {
     return false;
-    }
+  }
   return true;
 }
 
 void cmMakefile::CheckNeededCxxLanguage(const std::string& feature,
-                                        bool& needCxx98,
-                                        bool& needCxx11,
+                                        bool& needCxx98, bool& needCxx11,
                                         bool& needCxx14) const
 {
-  if (const char *propCxx98 =
-          this->GetDefinition("CMAKE_CXX98_COMPILE_FEATURES"))
-    {
+  if (const char* propCxx98 =
+        this->GetDefinition("CMAKE_CXX98_COMPILE_FEATURES")) {
     std::vector<std::string> props;
     cmSystemTools::ExpandListArgument(propCxx98, props);
     needCxx98 = std::find(props.begin(), props.end(), feature) != props.end();
-    }
-  if (const char *propCxx11 =
-          this->GetDefinition("CMAKE_CXX11_COMPILE_FEATURES"))
-    {
+  }
+  if (const char* propCxx11 =
+        this->GetDefinition("CMAKE_CXX11_COMPILE_FEATURES")) {
     std::vector<std::string> props;
     cmSystemTools::ExpandListArgument(propCxx11, props);
     needCxx11 = std::find(props.begin(), props.end(), feature) != props.end();
-    }
-  if (const char *propCxx14 =
-          this->GetDefinition("CMAKE_CXX14_COMPILE_FEATURES"))
-    {
+  }
+  if (const char* propCxx14 =
+        this->GetDefinition("CMAKE_CXX14_COMPILE_FEATURES")) {
     std::vector<std::string> props;
     cmSystemTools::ExpandListArgument(propCxx14, props);
     needCxx14 = std::find(props.begin(), props.end(), feature) != props.end();
-    }
+  }
 }
 
-bool cmMakefile::
-AddRequiredTargetCxxFeature(cmTarget *target,
-                            const std::string& feature) const
+bool cmMakefile::AddRequiredTargetCxxFeature(cmTarget* target,
+                                             const std::string& feature) const
 {
   bool needCxx98 = false;
   bool needCxx11 = false;
@@ -4879,96 +4261,80 @@ AddRequiredTargetCxxFeature(cmTarget *target,
 
   this->CheckNeededCxxLanguage(feature, needCxx98, needCxx11, needCxx14);
 
-  const char *existingCxxStandard = target->GetProperty("CXX_STANDARD");
-  if (existingCxxStandard)
-    {
+  const char* existingCxxStandard = target->GetProperty("CXX_STANDARD");
+  if (existingCxxStandard) {
     if (std::find_if(cmArrayBegin(CXX_STANDARDS), cmArrayEnd(CXX_STANDARDS),
-                  cmStrCmp(existingCxxStandard)) == cmArrayEnd(CXX_STANDARDS))
-      {
+                     cmStrCmp(existingCxxStandard)) ==
+        cmArrayEnd(CXX_STANDARDS)) {
       std::ostringstream e;
       e << "The CXX_STANDARD property on target \"" << target->GetName()
         << "\" contained an invalid value: \"" << existingCxxStandard << "\".";
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
     }
-  const char * const *existingCxxIt = existingCxxStandard
-                                    ? std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp(existingCxxStandard))
-                                    : cmArrayEnd(CXX_STANDARDS);
+  }
+  const char* const* existingCxxIt = existingCxxStandard
+    ? std::find_if(cmArrayBegin(CXX_STANDARDS), cmArrayEnd(CXX_STANDARDS),
+                   cmStrCmp(existingCxxStandard))
+    : cmArrayEnd(CXX_STANDARDS);
 
   bool setCxx98 = needCxx98 && !existingCxxStandard;
   bool setCxx11 = needCxx11 && !existingCxxStandard;
   bool setCxx14 = needCxx14 && !existingCxxStandard;
 
-  if (needCxx14 && existingCxxStandard && existingCxxIt <
-                                    std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp("14")))
-    {
+  if (needCxx14 && existingCxxStandard &&
+      existingCxxIt < std::find_if(cmArrayBegin(CXX_STANDARDS),
+                                   cmArrayEnd(CXX_STANDARDS),
+                                   cmStrCmp("14"))) {
     setCxx14 = true;
-    }
-  else if (needCxx11 && existingCxxStandard && existingCxxIt <
-                                    std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp("11")))
-    {
+  } else if (needCxx11 && existingCxxStandard &&
+             existingCxxIt < std::find_if(cmArrayBegin(CXX_STANDARDS),
+                                          cmArrayEnd(CXX_STANDARDS),
+                                          cmStrCmp("11"))) {
     setCxx11 = true;
-    }
-  else if(needCxx98 && existingCxxStandard && existingCxxIt <
-                                    std::find_if(cmArrayBegin(CXX_STANDARDS),
-                                      cmArrayEnd(CXX_STANDARDS),
-                                      cmStrCmp("98")))
-    {
+  } else if (needCxx98 && existingCxxStandard &&
+             existingCxxIt < std::find_if(cmArrayBegin(CXX_STANDARDS),
+                                          cmArrayEnd(CXX_STANDARDS),
+                                          cmStrCmp("98"))) {
     setCxx98 = true;
-    }
+  }
 
-  if (setCxx14)
-    {
+  if (setCxx14) {
     target->SetProperty("CXX_STANDARD", "14");
-    }
-  else if (setCxx11)
-    {
+  } else if (setCxx11) {
     target->SetProperty("CXX_STANDARD", "11");
-    }
-  else if (setCxx98)
-    {
+  } else if (setCxx98) {
     target->SetProperty("CXX_STANDARD", "98");
-    }
+  }
   return true;
 }
 
 void cmMakefile::CheckNeededCLanguage(const std::string& feature,
-                                        bool& needC90,
-                                        bool& needC99,
-                                        bool& needC11) const
+                                      bool& needC90, bool& needC99,
+                                      bool& needC11) const
 {
-  if (const char *propC90 =
-          this->GetDefinition("CMAKE_C90_COMPILE_FEATURES"))
-    {
+  if (const char* propC90 =
+        this->GetDefinition("CMAKE_C90_COMPILE_FEATURES")) {
     std::vector<std::string> props;
     cmSystemTools::ExpandListArgument(propC90, props);
     needC90 = std::find(props.begin(), props.end(), feature) != props.end();
-    }
-  if (const char *propC99 =
-          this->GetDefinition("CMAKE_C99_COMPILE_FEATURES"))
-    {
+  }
+  if (const char* propC99 =
+        this->GetDefinition("CMAKE_C99_COMPILE_FEATURES")) {
     std::vector<std::string> props;
     cmSystemTools::ExpandListArgument(propC99, props);
     needC99 = std::find(props.begin(), props.end(), feature) != props.end();
-    }
-  if (const char *propC11 =
-          this->GetDefinition("CMAKE_C11_COMPILE_FEATURES"))
-    {
+  }
+  if (const char* propC11 =
+        this->GetDefinition("CMAKE_C11_COMPILE_FEATURES")) {
     std::vector<std::string> props;
     cmSystemTools::ExpandListArgument(propC11, props);
     needC11 = std::find(props.begin(), props.end(), feature) != props.end();
-    }
+  }
 }
 
-bool cmMakefile::
-AddRequiredTargetCFeature(cmTarget *target, const std::string& feature) const
+bool cmMakefile::AddRequiredTargetCFeature(cmTarget* target,
+                                           const std::string& feature) const
 {
   bool needC90 = false;
   bool needC99 = false;
@@ -4976,71 +4342,57 @@ AddRequiredTargetCFeature(cmTarget *target, const std::string& feature) const
 
   this->CheckNeededCLanguage(feature, needC90, needC99, needC11);
 
-  const char *existingCStandard = target->GetProperty("C_STANDARD");
-  if (existingCStandard)
-    {
+  const char* existingCStandard = target->GetProperty("C_STANDARD");
+  if (existingCStandard) {
     if (std::find_if(cmArrayBegin(C_STANDARDS), cmArrayEnd(C_STANDARDS),
-                  cmStrCmp(existingCStandard)) == cmArrayEnd(C_STANDARDS))
-      {
+                     cmStrCmp(existingCStandard)) == cmArrayEnd(C_STANDARDS)) {
       std::ostringstream e;
       e << "The C_STANDARD property on target \"" << target->GetName()
         << "\" contained an invalid value: \"" << existingCStandard << "\".";
       this->IssueMessage(cmake::FATAL_ERROR, e.str());
       return false;
-      }
     }
-  const char * const *existingCIt = existingCStandard
-                                    ? std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp(existingCStandard))
-                                    : cmArrayEnd(C_STANDARDS);
+  }
+  const char* const* existingCIt = existingCStandard
+    ? std::find_if(cmArrayBegin(C_STANDARDS), cmArrayEnd(C_STANDARDS),
+                   cmStrCmp(existingCStandard))
+    : cmArrayEnd(C_STANDARDS);
 
   bool setC90 = needC90 && !existingCStandard;
   bool setC99 = needC99 && !existingCStandard;
   bool setC11 = needC11 && !existingCStandard;
 
-  if (needC11 && existingCStandard && existingCIt <
-                                    std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp("11")))
-    {
+  if (needC11 && existingCStandard &&
+      existingCIt < std::find_if(cmArrayBegin(C_STANDARDS),
+                                 cmArrayEnd(C_STANDARDS), cmStrCmp("11"))) {
     setC11 = true;
-    }
-  else if(needC99 && existingCStandard && existingCIt <
-                                    std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp("99")))
-    {
+  } else if (needC99 && existingCStandard &&
+             existingCIt < std::find_if(cmArrayBegin(C_STANDARDS),
+                                        cmArrayEnd(C_STANDARDS),
+                                        cmStrCmp("99"))) {
     setC99 = true;
-    }
-  else if(needC90 && existingCStandard && existingCIt <
-                                    std::find_if(cmArrayBegin(C_STANDARDS),
-                                      cmArrayEnd(C_STANDARDS),
-                                      cmStrCmp("90")))
-    {
+  } else if (needC90 && existingCStandard &&
+             existingCIt < std::find_if(cmArrayBegin(C_STANDARDS),
+                                        cmArrayEnd(C_STANDARDS),
+                                        cmStrCmp("90"))) {
     setC90 = true;
-    }
+  }
 
-  if (setC11)
-    {
+  if (setC11) {
     target->SetProperty("C_STANDARD", "11");
-    }
-  else if (setC99)
-    {
+  } else if (setC99) {
     target->SetProperty("C_STANDARD", "99");
-    }
-  else if (setC90)
-    {
+  } else if (setC90) {
     target->SetProperty("C_STANDARD", "90");
-    }
+  }
   return true;
 }
 
-
 cmMakefile::FunctionPushPop::FunctionPushPop(cmMakefile* mf,
                                              const std::string& fileName,
                                              cmPolicies::PolicyMap const& pm)
-  : Makefile(mf), ReportError(true)
+  : Makefile(mf)
+  , ReportError(true)
 {
   this->Makefile->PushFunctionScope(fileName, pm);
 }
@@ -5050,11 +4402,11 @@ cmMakefile::FunctionPushPop::~FunctionPushPop()
   this->Makefile->PopFunctionScope(this->ReportError);
 }
 
-
 cmMakefile::MacroPushPop::MacroPushPop(cmMakefile* mf,
                                        const std::string& fileName,
                                        const cmPolicies::PolicyMap& pm)
-  : Makefile(mf), ReportError(true)
+  : Makefile(mf)
+  , ReportError(true)
 {
   this->Makefile->PushMacroScope(fileName, pm);
 }
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index fa5e9b4..c665b1f 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -31,11 +31,11 @@
 #include <cmsys/RegularExpression.hxx>
 #include <cmsys/auto_ptr.hxx>
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# ifdef CMake_HAVE_CXX11_UNORDERED_MAP
-#  include <unordered_map>
-# else
-#  include <cmsys/hash_map.hxx>
-# endif
+#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
+#include <unordered_map>
+#else
+#include <cmsys/hash_map.hxx>
+#endif
 #endif
 
 #include <stack>
@@ -66,7 +66,7 @@ public:
   /* Mark a variable as used */
   void MarkVariableAsUsed(const std::string& var);
   /* return true if a variable has been initialized */
-  bool VariableInitialized(const std::string& ) const;
+  bool VariableInitialized(const std::string&) const;
 
   /**
    * Construct an empty makefile.
@@ -97,8 +97,8 @@ public:
    * Remove the function blocker whose scope ends with the given command.
    * This returns ownership of the function blocker object.
    */
-  cmsys::auto_ptr<cmFunctionBlocker>
-  RemoveFunctionBlocker(cmFunctionBlocker* fb, const cmListFileFunction& lff);
+  cmsys::auto_ptr<cmFunctionBlocker> RemoveFunctionBlocker(
+    cmFunctionBlocker* fb, const cmListFileFunction& lff);
 
   /**
    * Try running cmake and building a file. This is used for dynalically
@@ -106,8 +106,7 @@ public:
    */
   int TryCompile(const std::string& srcdir, const std::string& bindir,
                  const std::string& projectName, const std::string& targetName,
-                 bool fast,
-                 const std::vector<std::string> *cmakeArgs,
+                 bool fast, const std::vector<std::string>* cmakeArgs,
                  std::string& output);
 
   bool GetIsSourceFileTryCompile() const;
@@ -143,19 +142,14 @@ public:
     const std::vector<std::string>& byproducts,
     const std::vector<std::string>& depends,
     const std::string& main_dependency,
-    const cmCustomCommandLines& commandLines,
-    const char* comment, const char* workingDir,
-    bool replace = false,
-    bool escapeOldStyle = true,
+    const cmCustomCommandLines& commandLines, const char* comment,
+    const char* workingDir, bool replace = false, bool escapeOldStyle = true,
     bool uses_terminal = false);
   cmSourceFile* AddCustomCommandToOutput(
-    const std::string& output,
-    const std::vector<std::string>& depends,
+    const std::string& output, const std::vector<std::string>& depends,
     const std::string& main_dependency,
-    const cmCustomCommandLines& commandLines,
-    const char* comment, const char* workingDir,
-    bool replace = false,
-    bool escapeOldStyle = true,
+    const cmCustomCommandLines& commandLines, const char* comment,
+    const char* workingDir, bool replace = false, bool escapeOldStyle = true,
     bool uses_terminal = false);
   void AddCustomCommandOldStyle(const std::string& target,
                                 const std::vector<std::string>& outputs,
@@ -173,16 +167,15 @@ public:
 
   /** Create a new imported target with the name and type given.  */
   cmTarget* AddImportedTarget(const std::string& name,
-                              cmState::TargetType type,
-                              bool global);
+                              cmState::TargetType type, bool global);
 
   cmTarget* AddNewTarget(cmState::TargetType type, const std::string& name);
 
   /**
    * Add an executable to the build.
    */
-  cmTarget* AddExecutable(const char *exename,
-                          const std::vector<std::string> &srcs,
+  cmTarget* AddExecutable(const char* exename,
+                          const std::vector<std::string>& srcs,
                           bool excludeFromAll = false);
 
   /**
@@ -193,28 +186,20 @@ public:
                               bool excludeFromAll,
                               const std::vector<std::string>& depends,
                               const char* workingDirectory,
-                              const char* command,
-                              const char* arg1=0,
-                              const char* arg2=0,
-                              const char* arg3=0,
-                              const char* arg4=0);
-  cmTarget* AddUtilityCommand(const std::string& utilityName,
-                              bool excludeFromAll,
-                              const char* workingDirectory,
-                              const std::vector<std::string>& depends,
-                              const cmCustomCommandLines& commandLines,
-                              bool escapeOldStyle = true,
-                              const char* comment = 0,
-                              bool uses_terminal = false);
-  cmTarget* AddUtilityCommand(const std::string& utilityName,
-                              bool excludeFromAll,
-                              const char* workingDirectory,
-                              const std::vector<std::string>& byproducts,
-                              const std::vector<std::string>& depends,
-                              const cmCustomCommandLines& commandLines,
-                              bool escapeOldStyle = true,
-                              const char* comment = 0,
-                              bool uses_terminal = false);
+                              const char* command, const char* arg1 = 0,
+                              const char* arg2 = 0, const char* arg3 = 0,
+                              const char* arg4 = 0);
+  cmTarget* AddUtilityCommand(
+    const std::string& utilityName, bool excludeFromAll,
+    const char* workingDirectory, const std::vector<std::string>& depends,
+    const cmCustomCommandLines& commandLines, bool escapeOldStyle = true,
+    const char* comment = 0, bool uses_terminal = false);
+  cmTarget* AddUtilityCommand(
+    const std::string& utilityName, bool excludeFromAll,
+    const char* workingDirectory, const std::vector<std::string>& byproducts,
+    const std::vector<std::string>& depends,
+    const cmCustomCommandLines& commandLines, bool escapeOldStyle = true,
+    const char* comment = 0, bool uses_terminal = false);
 
   /**
    * Add a link library to the build.
@@ -229,8 +214,7 @@ public:
    * Add a subdirectory to the build.
    */
   void AddSubDirectory(const std::string& fullSrcDir,
-                       const std::string& fullBinDir,
-                       bool excludeFromAll,
+                       const std::string& fullBinDir, bool excludeFromAll,
                        bool immediate);
 
   void Configure();
@@ -243,7 +227,7 @@ public:
   /**
    * Add an include directory to the build.
    */
-  void AddIncludeDirectories(const std::vector<std::string> &incs,
+  void AddIncludeDirectories(const std::vector<std::string>& incs,
                              bool before = false);
 
   /**
@@ -253,8 +237,7 @@ public:
   void AddDefinition(const std::string& name, const char* value);
   ///! Add a definition to this makefile and the global cmake cache.
   void AddCacheDefinition(const std::string& name, const char* value,
-                          const char* doc,
-                          cmState::CacheEntryType type,
+                          const char* doc, cmState::CacheEntryType type,
                           bool force = false);
 
   /**
@@ -283,22 +266,22 @@ public:
    * Set the name of the library.
    */
   cmTarget* AddLibrary(const std::string& libname, cmState::TargetType type,
-                  const std::vector<std::string> &srcs,
-                  bool excludeFromAll = false);
+                       const std::vector<std::string>& srcs,
+                       bool excludeFromAll = false);
   void AddAlias(const std::string& libname, const std::string& tgt);
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   /**
    * Add a root source group for consideration when adding a new source.
    */
-  void AddSourceGroup(const std::string& name, const char* regex=0);
+  void AddSourceGroup(const std::string& name, const char* regex = 0);
 
   /**
    * Add a source group for consideration when adding a new source.
    * name is tokenized.
    */
   void AddSourceGroup(const std::vector<std::string>& name,
-                      const char* regex=0);
+                      const char* regex = 0);
 
 #endif
 
@@ -307,9 +290,9 @@ public:
      * Set, Push, Pop policy values for CMake.
      */
   bool SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
-  bool SetPolicy(const char *id, cmPolicies::PolicyStatus status);
+  bool SetPolicy(const char* id, cmPolicies::PolicyStatus status);
   cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id) const;
-  bool SetPolicyVersion(const char *version);
+  bool SetPolicyVersion(const char* version);
   void RecordPolicies(cmPolicies::PolicyMap& pm);
   //@}
 
@@ -319,6 +302,7 @@ public:
   public:
     PolicyPushPop(cmMakefile* m);
     ~PolicyPushPop();
+
   private:
     cmMakefile* Makefile;
   };
@@ -328,7 +312,7 @@ public:
    * Determine if the given context, name pair has already been reported
    * in context of CMP0054.
    */
-  bool HasCMP0054AlreadyBeenReported(const cmListFileContext &context) const;
+  bool HasCMP0054AlreadyBeenReported(const cmListFileContext& context) const;
 
   bool IgnoreErrorsCMP0061() const;
 
@@ -355,39 +339,39 @@ public:
    * in order to be considered as part of the depend information.
    */
   void SetIncludeRegularExpression(const char* regex)
-    {
-      this->SetProperty("INCLUDE_REGULAR_EXPRESSION", regex);
-    }
+  {
+    this->SetProperty("INCLUDE_REGULAR_EXPRESSION", regex);
+  }
   const char* GetIncludeRegularExpression() const
-    {
-      return this->GetProperty("INCLUDE_REGULAR_EXPRESSION");
-    }
+  {
+    return this->GetProperty("INCLUDE_REGULAR_EXPRESSION");
+  }
 
   /**
    * Set a regular expression that include files that are not found
    * must match in order to be considered a problem.
    */
   void SetComplainRegularExpression(const std::string& regex)
-    {
-      this->ComplainFileRegularExpression = regex;
-    }
+  {
+    this->ComplainFileRegularExpression = regex;
+  }
   const char* GetComplainRegularExpression() const
-    {
-      return this->ComplainFileRegularExpression.c_str();
-    }
+  {
+    return this->ComplainFileRegularExpression.c_str();
+  }
 
   /**
    * Get the list of targets
    */
-  cmTargets &GetTargets() { return this->Targets; }
+  cmTargets& GetTargets() { return this->Targets; }
   /**
    * Get the list of targets, const version
    */
-  const cmTargets &GetTargets() const { return this->Targets; }
-  const std::vector<cmTarget*> &GetOwnedImportedTargets() const
-    {
-      return this->ImportedTargetsOwned;
-    }
+  const cmTargets& GetTargets() const { return this->Targets; }
+  const std::vector<cmTarget*>& GetOwnedImportedTargets() const
+  {
+    return this->ImportedTargetsOwned;
+  }
   std::vector<cmTarget*> GetImportedTargets() const;
 
   cmTarget* FindLocalNonAliasTarget(const std::string& name) const;
@@ -406,7 +390,7 @@ public:
   /**
    * Mark include directories as system directories.
    */
-  void AddSystemIncludeDirectories(const std::set<std::string> &incs);
+  void AddSystemIncludeDirectories(const std::set<std::string>& incs);
 
   /** Get a cmSourceFile pointer for a given source name, if the name is
    *  not found, then a null pointer is returned.
@@ -465,8 +449,7 @@ public:
   /**
    * Get a list of preprocessor define flags.
    */
-  const char* GetDefineFlags() const
-    {return this->DefineFlags.c_str();}
+  const char* GetDefineFlags() const { return this->DefineFlags.c_str(); }
 
   /**
    * Make sure CMake can write this file
@@ -478,22 +461,28 @@ public:
    * Get the vector source groups.
    */
   const std::vector<cmSourceGroup>& GetSourceGroups() const
-    { return this->SourceGroups; }
+  {
+    return this->SourceGroups;
+  }
 
   /**
    * Get the source group
    */
-  cmSourceGroup* GetSourceGroup(const std::vector<std::string>&name) const;
+  cmSourceGroup* GetSourceGroup(const std::vector<std::string>& name) const;
 #endif
 
   /**
    * Get the vector of list files on which this makefile depends
    */
   const std::vector<std::string>& GetListFiles() const
-    { return this->ListFiles; }
+  {
+    return this->ListFiles;
+  }
   ///! When the file changes cmake will be re-run from the build system.
   void AddCMakeDependFile(const std::string& file)
-    { this->ListFiles.push_back(file);}
+  {
+    this->ListFiles.push_back(file);
+  }
   void AddCMakeDependFilesFromUser();
 
   std::string FormatListFileStack() const;
@@ -509,9 +498,13 @@ public:
    * Get the vector of  files created by this makefile
    */
   const std::vector<std::string>& GetOutputFiles() const
-    { return this->OutputFiles; }
+  {
+    return this->OutputFiles;
+  }
   void AddCMakeOutputFile(const std::string& file)
-    { this->OutputFiles.push_back(file);}
+  {
+    this->OutputFiles.push_back(file);
+  }
 
   /**
    * Expand all defined variables in the string.
@@ -520,12 +513,10 @@ public:
    * entry in the this->Definitions map.  Also \@var\@ is
    * expanded to match autoconf style expansions.
    */
-  const char *ExpandVariablesInString(std::string& source) const;
-  const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
-                                      bool noEscapes,
-                                      bool atOnly = false,
-                                      const char* filename = 0,
-                                      long line = -1,
+  const char* ExpandVariablesInString(std::string& source) const;
+  const char* ExpandVariablesInString(std::string& source, bool escapeQuotes,
+                                      bool noEscapes, bool atOnly = false,
+                                      const char* filename = 0, long line = -1,
                                       bool removeEmpty = false,
                                       bool replaceAt = false) const;
 
@@ -533,8 +524,7 @@ public:
    * Remove any remaining variables in the string. Anything with ${var} or
    * \@var\@ will be removed.
    */
-  void RemoveVariablesInString(std::string& source,
-                               bool atOnly = false) const;
+  void RemoveVariablesInString(std::string& source, bool atOnly = false) const;
 
   /**
    * Expand variables in the makefiles ivars such as link directories etc
@@ -551,17 +541,16 @@ public:
   /**
    * Copy file but change lines acording to ConfigureString
    */
-  int ConfigureFile(const char* infile, const char* outfile,
-                    bool copyonly, bool atOnly, bool escapeQuotes,
+  int ConfigureFile(const char* infile, const char* outfile, bool copyonly,
+                    bool atOnly, bool escapeQuotes,
                     const cmNewLineStyle& = cmNewLineStyle());
 
-
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   /**
    * find what source group this source is in
    */
   cmSourceGroup* FindSourceGroup(const char* source,
-                                 std::vector<cmSourceGroup> &groups) const;
+                                 std::vector<cmSourceGroup>& groups) const;
 #endif
 
   /**
@@ -574,18 +563,19 @@ public:
    * succeeded or false if it failed.
    */
   bool ExecuteCommand(const cmListFileFunction& lff,
-                      cmExecutionStatus &status);
+                      cmExecutionStatus& status);
 
   ///! Enable support for named language, if nil then all languages are
-  ///enabled.
-  void EnableLanguage(std::vector<std::string>const& languages, bool optional);
+  /// enabled.
+  void EnableLanguage(std::vector<std::string> const& languages,
+                      bool optional);
 
-  cmState *GetState() const;
+  cmState* GetState() const;
 
-  /**
-   * Get the variable watch. This is used to determine when certain variables
-   * are accessed.
-   */
+/**
+ * Get the variable watch. This is used to determine when certain variables
+ * are accessed.
+ */
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmVariableWatch* GetVariableWatch() const;
 #endif
@@ -608,21 +598,23 @@ public:
   /**
    * Get the instance
    */
-  cmake *GetCMakeInstance() const;
+  cmake* GetCMakeInstance() const;
   cmGlobalGenerator* GetGlobalGenerator() const;
 
   /**
    * Get all the source files this makefile knows about
    */
-  const std::vector<cmSourceFile*> &GetSourceFiles() const
-    {return this->SourceFiles;}
-  std::vector<cmSourceFile*> &GetSourceFiles() {return this->SourceFiles;}
+  const std::vector<cmSourceFile*>& GetSourceFiles() const
+  {
+    return this->SourceFiles;
+  }
+  std::vector<cmSourceFile*>& GetSourceFiles() { return this->SourceFiles; }
 
   /**
    * Is there a source file that has the provided source file as an output?
    * if so then return it
    */
-  cmSourceFile *GetSourceFileWithOutput(const std::string& outName) const;
+  cmSourceFile* GetSourceFileWithOutput(const std::string& outName) const;
 
   ///! Add a new cmTest to the list of tests for this makefile.
   cmTest* CreateTest(const std::string& testName);
@@ -638,11 +630,11 @@ public:
   std::string GetModulesFile(const char* name) const;
 
   ///! Set/Get a property of this directory
-  void SetProperty(const std::string& prop, const char *value);
-  void AppendProperty(const std::string& prop, const char *value,
-                      bool asString=false);
-  const char *GetProperty(const std::string& prop) const;
-  const char *GetProperty(const std::string& prop, bool chain) const;
+  void SetProperty(const std::string& prop, const char* value);
+  void AppendProperty(const std::string& prop, const char* value,
+                      bool asString = false);
+  const char* GetProperty(const std::string& prop) const;
+  const char* GetProperty(const std::string& prop, bool chain) const;
   bool GetPropertyAsBool(const std::string& prop) const;
   std::vector<std::string> GetPropertyKeys() const;
 
@@ -650,14 +642,24 @@ public:
   void InitializeFromParent(cmMakefile* parent);
 
   void AddInstallGenerator(cmInstallGenerator* g)
-    { if(g) this->InstallGenerators.push_back(g); }
+  {
+    if (g)
+      this->InstallGenerators.push_back(g);
+  }
   std::vector<cmInstallGenerator*>& GetInstallGenerators()
-    { return this->InstallGenerators; }
+  {
+    return this->InstallGenerators;
+  }
 
   void AddTestGenerator(cmTestGenerator* g)
-    { if(g) this->TestGenerators.push_back(g); }
+  {
+    if (g)
+      this->TestGenerators.push_back(g);
+  }
   const std::vector<cmTestGenerator*>& GetTestGenerators() const
-    { return this->TestGenerators; }
+  {
+    return this->TestGenerators;
+  }
 
   class FunctionPushPop
   {
@@ -693,7 +695,7 @@ public:
   void PopMacroScope(bool reportError);
   void PushScope();
   void PopScope();
-  void RaiseScope(const std::string& var, const char *value);
+  void RaiseScope(const std::string& var, const char* value);
 
   // push and pop loop scopes
   void PushLoopBlockBarrier();
@@ -703,14 +705,17 @@ public:
   class ScopePushPop
   {
   public:
-    ScopePushPop(cmMakefile* m): Makefile(m) { this->Makefile->PushScope(); }
+    ScopePushPop(cmMakefile* m)
+      : Makefile(m)
+    {
+      this->Makefile->PushScope();
+    }
     ~ScopePushPop() { this->Makefile->PopScope(); }
   private:
     cmMakefile* Makefile;
   };
 
-  void IssueMessage(cmake::MessageType t,
-                    std::string const& text,
+  void IssueMessage(cmake::MessageType t, std::string const& text,
                     bool force = false) const;
 
   /** Set whether or not to report a CMP0000 violation.  */
@@ -723,29 +728,29 @@ public:
   cmStringRange GetCompileDefinitionsEntries() const;
   cmBacktraceRange GetCompileDefinitionsBacktraces() const;
 
-  void AddQtUiFileWithOptions(cmSourceFile *sf);
+  void AddQtUiFileWithOptions(cmSourceFile* sf);
   std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const;
 
-  std::set<std::string> const & GetSystemIncludeDirectories() const
-    { return this->SystemIncludeDirectories; }
+  std::set<std::string> const& GetSystemIncludeDirectories() const
+  {
+    return this->SystemIncludeDirectories;
+  }
 
   bool PolicyOptionalWarningEnabled(std::string const& var);
 
-  bool AddRequiredTargetFeature(cmTarget *target,
-                                const std::string& feature,
-                                std::string *error = 0) const;
+  bool AddRequiredTargetFeature(cmTarget* target, const std::string& feature,
+                                std::string* error = 0) const;
 
   bool CompileFeatureKnown(cmTarget const* target, const std::string& feature,
-                           std::string& lang, std::string *error) const;
+                           std::string& lang, std::string* error) const;
 
   const char* CompileFeaturesAvailable(const std::string& lang,
-                                       std::string *error) const;
+                                       std::string* error) const;
 
   bool HaveStandardAvailable(cmTarget const* target, std::string const& lang,
-                            const std::string& feature) const;
+                             const std::string& feature) const;
 
-  bool IsLaterStandard(std::string const& lang,
-                       std::string const& lhs,
+  bool IsLaterStandard(std::string const& lang, std::string const& lhs,
                        std::string const& rhs);
 
   void PushLoopBlock();
@@ -763,14 +768,15 @@ public:
 
   void EnforceDirectoryLevelRules() const;
 
-  void AddEvaluationFile(const std::string &inputFile,
-                  cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
-                  cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
-                  bool inputIsContent);
+  void AddEvaluationFile(
+    const std::string& inputFile,
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
+    bool inputIsContent);
   std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const;
 
-  std::vector<cmExportBuildFileGenerator*>
-  GetExportBuildFileGenerators() const;
+  std::vector<cmExportBuildFileGenerator*> GetExportBuildFileGenerators()
+    const;
   void RemoveExportBuildFileGeneratorCMP0024(cmExportBuildFileGenerator* gen);
   void AddExportBuildFileGenerator(cmExportBuildFileGenerator* gen);
 
@@ -830,7 +836,7 @@ protected:
   std::vector<cmCommand*> FinalPassCommands;
   cmGlobalGenerator* GlobalGenerator;
   bool IsFunctionBlocked(const cmListFileFunction& lff,
-                         cmExecutionStatus &status);
+                         cmExecutionStatus& status);
 
 private:
   cmMakefile(const cmMakefile& mf);
@@ -885,38 +891,25 @@ private:
   class BuildsystemFileScope;
   friend class BuildsystemFileScope;
 
-
   // CMP0053 == old
   cmake::MessageType ExpandVariablesInStringOld(
-                                  std::string& errorstr,
-                                  std::string& source,
-                                  bool escapeQuotes,
-                                  bool noEscapes,
-                                  bool atOnly,
-                                  const char* filename,
-                                  long line,
-                                  bool removeEmpty,
-                                  bool replaceAt) const;
+    std::string& errorstr, std::string& source, bool escapeQuotes,
+    bool noEscapes, bool atOnly, const char* filename, long line,
+    bool removeEmpty, bool replaceAt) const;
   // CMP0053 == new
   cmake::MessageType ExpandVariablesInStringNew(
-                                  std::string& errorstr,
-                                  std::string& source,
-                                  bool escapeQuotes,
-                                  bool noEscapes,
-                                  bool atOnly,
-                                  const char* filename,
-                                  long line,
-                                  bool removeEmpty,
-                                  bool replaceAt) const;
+    std::string& errorstr, std::string& source, bool escapeQuotes,
+    bool noEscapes, bool atOnly, const char* filename, long line,
+    bool removeEmpty, bool replaceAt) const;
   /**
    * Old version of GetSourceFileWithOutput(const std::string&) kept for
    * backward-compatibility. It implements a linear search and support
    * relative file paths. It is used as a fall back by
    * GetSourceFileWithOutput(const std::string&).
    */
-  cmSourceFile *LinearGetSourceFileWithOutput(const std::string& cname) const;
+  cmSourceFile* LinearGetSourceFileWithOutput(const std::string& cname) const;
 
-  // A map for fast output to input look up.
+// A map for fast output to input look up.
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 #ifdef CMake_HAVE_CXX11_UNORDERED_MAP
   typedef std::unordered_map<std::string, cmSourceFile*> OutputToSourceMap;
@@ -935,10 +928,10 @@ private:
 
   std::vector<cmSourceFile*> QtUiFilesWithOptions;
 
-  bool AddRequiredTargetCFeature(cmTarget *target,
+  bool AddRequiredTargetCFeature(cmTarget* target,
                                  const std::string& feature) const;
 
-  bool AddRequiredTargetCxxFeature(cmTarget *target,
+  bool AddRequiredTargetCxxFeature(cmTarget* target,
                                    const std::string& feature) const;
 
   void CheckNeededCLanguage(const std::string& feature, bool& needC90,
@@ -947,9 +940,9 @@ private:
                               bool& needCxx11, bool& needCxx14) const;
 
   bool HaveCStandardAvailable(cmTarget const* target,
-                             const std::string& feature) const;
+                              const std::string& feature) const;
   bool HaveCxxStandardAvailable(cmTarget const* target,
-                               const std::string& feature) const;
+                                const std::string& feature) const;
 
   void CheckForUnusedVariables() const;
 
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 7e54680..674bc2f 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -18,22 +18,21 @@
 #include "cmSourceFile.h"
 #include "cmake.h"
 
-cmMakefileExecutableTargetGenerator
-::cmMakefileExecutableTargetGenerator(cmGeneratorTarget* target):
-  cmMakefileTargetGenerator(target)
+cmMakefileExecutableTargetGenerator::cmMakefileExecutableTargetGenerator(
+  cmGeneratorTarget* target)
+  : cmMakefileTargetGenerator(target)
 {
   this->CustomCommandDriver = OnDepends;
   this->GeneratorTarget->GetExecutableNames(
     this->TargetNameOut, this->TargetNameReal, this->TargetNameImport,
     this->TargetNamePDB, this->ConfigName);
 
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
-                                                      this->ConfigName);
+  this->OSXBundleGenerator =
+    new cmOSXBundleGenerator(target, this->ConfigName);
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
 
-cmMakefileExecutableTargetGenerator
-::~cmMakefileExecutableTargetGenerator()
+cmMakefileExecutableTargetGenerator::~cmMakefileExecutableTargetGenerator()
 {
   delete this->OSXBundleGenerator;
 }
@@ -54,11 +53,10 @@ void cmMakefileExecutableTargetGenerator::WriteRuleFiles()
 
   // write the link rules
   this->WriteExecutableRule(false);
-  if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName))
-    {
+  if (this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) {
     // Write rules to link an installable version of the target.
     this->WriteExecutableRule(true);
-    }
+  }
 
   // Write the requires target.
   this->WriteTargetRequiresRules();
@@ -74,8 +72,6 @@ void cmMakefileExecutableTargetGenerator::WriteRuleFiles()
   this->CloseFileStreams();
 }
 
-
-
 void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
 {
   std::vector<std::string> commands;
@@ -89,70 +85,58 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
   std::string targetNameReal;
   std::string targetNameImport;
   std::string targetNamePDB;
-  this->GeneratorTarget->GetExecutableNames
-    (targetName, targetNameReal, targetNameImport, targetNamePDB,
-     this->ConfigName);
+  this->GeneratorTarget->GetExecutableNames(targetName, targetNameReal,
+                                            targetNameImport, targetNamePDB,
+                                            this->ConfigName);
 
   // Construct the full path version of the names.
   std::string outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
-  if(this->GeneratorTarget->IsAppBundleOnApple())
-    {
+  if (this->GeneratorTarget->IsAppBundleOnApple()) {
     this->OSXBundleGenerator->CreateAppBundle(targetName, outpath);
-    }
+  }
   outpath += "/";
   std::string outpathImp;
-  if(relink)
-    {
+  if (relink) {
     outpath = this->Makefile->GetCurrentBinaryDirectory();
     outpath += cmake::GetCMakeFilesDirectory();
     outpath += "/CMakeRelink.dir";
     cmSystemTools::MakeDirectory(outpath.c_str());
     outpath += "/";
-    if(!targetNameImport.empty())
-      {
+    if (!targetNameImport.empty()) {
       outpathImp = outpath;
-      }
     }
-  else
-    {
+  } else {
     cmSystemTools::MakeDirectory(outpath.c_str());
-    if(!targetNameImport.empty())
-      {
+    if (!targetNameImport.empty()) {
       outpathImp = this->GeneratorTarget->GetDirectory(this->ConfigName, true);
       cmSystemTools::MakeDirectory(outpathImp.c_str());
       outpathImp += "/";
-      }
     }
+  }
 
   std::string compilePdbOutputPath =
     this->GeneratorTarget->GetCompilePDBDirectory(this->ConfigName);
   cmSystemTools::MakeDirectory(compilePdbOutputPath.c_str());
 
   std::string pdbOutputPath =
-      this->GeneratorTarget->GetPDBDirectory(this->ConfigName);
+    this->GeneratorTarget->GetPDBDirectory(this->ConfigName);
   cmSystemTools::MakeDirectory(pdbOutputPath.c_str());
   pdbOutputPath += "/";
 
   std::string targetFullPath = outpath + targetName;
   std::string targetFullPathReal = outpath + targetNameReal;
-  std::string targetFullPathPDB =  pdbOutputPath + targetNamePDB;
+  std::string targetFullPathPDB = pdbOutputPath + targetNamePDB;
   std::string targetFullPathImport = outpathImp + targetNameImport;
-  std::string targetOutPathPDB =
-    this->Convert(targetFullPathPDB,
-                  cmLocalGenerator::NONE,
-                  cmLocalGenerator::SHELL);
+  std::string targetOutPathPDB = this->Convert(
+    targetFullPathPDB, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
   // Convert to the output path to use in constructing commands.
-  std::string targetOutPath =
-    this->Convert(targetFullPath,
-                  cmLocalGenerator::START_OUTPUT,
-                  cmLocalGenerator::SHELL);
+  std::string targetOutPath = this->Convert(
+    targetFullPath, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL);
   std::string targetOutPathReal =
-    this->Convert(targetFullPathReal,
-                  cmLocalGenerator::START_OUTPUT,
+    this->Convert(targetFullPathReal, cmLocalGenerator::START_OUTPUT,
                   cmLocalGenerator::SHELL);
   std::string targetOutPathImport =
-    this->Convert(targetFullPathImport,
-                  cmLocalGenerator::START_OUTPUT,
+    this->Convert(targetFullPathImport, cmLocalGenerator::START_OUTPUT,
                   cmLocalGenerator::SHELL);
 
   // Get the language to use for linking this executable.
@@ -160,16 +144,14 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
     this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
 
   // Make sure we have a link language.
-  if(linkLanguage.empty())
-    {
+  if (linkLanguage.empty()) {
     cmSystemTools::Error("Cannot determine link language for target \"",
                          this->GeneratorTarget->GetName().c_str(), "\".");
     return;
-    }
+  }
 
   this->NumberOfProgressActions++;
-  if(!this->NoRuleMessages)
-    {
+  if (!this->NoRuleMessages) {
     cmLocalUnixMakefileGenerator3::EchoProgress progress;
     this->MakeEchoProgress(progress);
     // Add the link message.
@@ -180,38 +162,32 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
     this->LocalGenerator->AppendEcho(commands, buildEcho.c_str(),
                                      cmLocalUnixMakefileGenerator3::EchoLink,
                                      &progress);
-    }
+  }
 
   // Build a list of compiler flags and linker flags.
   std::string flags;
   std::string linkFlags;
 
   // Add flags to create an executable.
-  this->LocalGenerator->
-    AddConfigVariableFlags(linkFlags, "CMAKE_EXE_LINKER_FLAGS",
-                           this->ConfigName);
-
-
-  if(this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE"))
-    {
-    this->LocalGenerator->AppendFlags
-      (linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_WIN32_EXE"));
-    }
-  else
-    {
-    this->LocalGenerator->AppendFlags
-      (linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_CONSOLE_EXE"));
-    }
+  this->LocalGenerator->AddConfigVariableFlags(
+    linkFlags, "CMAKE_EXE_LINKER_FLAGS", this->ConfigName);
+
+  if (this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE")) {
+    this->LocalGenerator->AppendFlags(
+      linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_WIN32_EXE"));
+  } else {
+    this->LocalGenerator->AppendFlags(
+      linkFlags, this->Makefile->GetDefinition("CMAKE_CREATE_CONSOLE_EXE"));
+  }
 
   // Add symbol export flags if necessary.
-  if(this->GeneratorTarget->IsExecutableWithExports())
-    {
+  if (this->GeneratorTarget->IsExecutableWithExports()) {
     std::string export_flag_var = "CMAKE_EXE_EXPORTS_";
     export_flag_var += linkLanguage;
     export_flag_var += "_FLAG";
-    this->LocalGenerator->AppendFlags
-      (linkFlags, this->Makefile->GetDefinition(export_flag_var));
-    }
+    this->LocalGenerator->AppendFlags(
+      linkFlags, this->Makefile->GetDefinition(export_flag_var));
+  }
 
   // Add language feature flags.
   this->AddFeatureFlags(flags, linkLanguage);
@@ -220,12 +196,12 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
                                              linkLanguage, this->ConfigName);
 
   // Add target-specific linker flags.
-  this->LocalGenerator->AppendFlags
-    (linkFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
+  this->LocalGenerator->AppendFlags(
+    linkFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
   std::string linkFlagsConfig = "LINK_FLAGS_";
   linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
-  this->LocalGenerator->AppendFlags
-    (linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
+  this->LocalGenerator->AppendFlags(
+    linkFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
 
   this->AddModuleDefinitionFlag(linkFlags);
 
@@ -238,50 +214,43 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
 #ifdef _WIN32
   // There may be a manifest file for this target.  Add it to the
   // clean set just in case.
-  exeCleanFiles.push_back(this->Convert((targetFullPath+".manifest").c_str(),
+  exeCleanFiles.push_back(this->Convert((targetFullPath + ".manifest").c_str(),
                                         cmLocalGenerator::START_OUTPUT,
                                         cmLocalGenerator::UNCHANGED));
 #endif
-  if(targetNameReal != targetName)
-    {
+  if (targetNameReal != targetName) {
     exeCleanFiles.push_back(this->Convert(targetFullPathReal,
                                           cmLocalGenerator::START_OUTPUT,
                                           cmLocalGenerator::UNCHANGED));
-    }
-  if(!targetNameImport.empty())
-    {
+  }
+  if (!targetNameImport.empty()) {
     exeCleanFiles.push_back(this->Convert(targetFullPathImport,
                                           cmLocalGenerator::START_OUTPUT,
                                           cmLocalGenerator::UNCHANGED));
     std::string implib;
-    if(this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport, implib))
-      {
-      exeCleanFiles.push_back(this->Convert(implib,
-                                            cmLocalGenerator::START_OUTPUT,
-                                            cmLocalGenerator::UNCHANGED));
-      }
+    if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
+                                                implib)) {
+      exeCleanFiles.push_back(this->Convert(
+        implib, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED));
     }
+  }
 
   // List the PDB for cleaning only when the whole target is
   // cleaned.  We do not want to delete the .pdb file just before
   // linking the target.
-  this->CleanFiles.push_back
-    (this->Convert(targetFullPathPDB,
-                   cmLocalGenerator::START_OUTPUT,
-                   cmLocalGenerator::UNCHANGED));
+  this->CleanFiles.push_back(this->Convert(targetFullPathPDB,
+                                           cmLocalGenerator::START_OUTPUT,
+                                           cmLocalGenerator::UNCHANGED));
 
   // Add the pre-build and pre-link rules building but not when relinking.
-  if(!relink)
-    {
-    this->LocalGenerator
-      ->AppendCustomCommands(commands,
-                        this->GeneratorTarget->GetPreBuildCommands(),
-                        this->GeneratorTarget);
-    this->LocalGenerator
-      ->AppendCustomCommands(commands,
-                        this->GeneratorTarget->GetPreLinkCommands(),
-                        this->GeneratorTarget);
-    }
+  if (!relink) {
+    this->LocalGenerator->AppendCustomCommands(
+      commands, this->GeneratorTarget->GetPreBuildCommands(),
+      this->GeneratorTarget);
+    this->LocalGenerator->AppendCustomCommands(
+      commands, this->GeneratorTarget->GetPreLinkCommands(),
+      this->GeneratorTarget);
+  }
 
   // Determine whether a link script will be used.
   bool useLinkScript = this->GlobalGenerator->GetUseLinkScript();
@@ -294,186 +263,167 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
   std::string linkRule = this->GetLinkRule(linkRuleVar);
   std::vector<std::string> commands1;
   cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
-  if(this->GeneratorTarget->IsExecutableWithExports())
-    {
+  if (this->GeneratorTarget->IsExecutableWithExports()) {
     // If a separate rule for creating an import library is specified
     // add it now.
     std::string implibRuleVar = "CMAKE_";
     implibRuleVar += linkLanguage;
     implibRuleVar += "_CREATE_IMPORT_LIBRARY";
-    if(const char* rule =
-       this->Makefile->GetDefinition(implibRuleVar))
-      {
+    if (const char* rule = this->Makefile->GetDefinition(implibRuleVar)) {
       cmSystemTools::ExpandListArgument(rule, real_link_commands);
-      }
     }
+  }
 
   // Select whether to use a response file for objects.
   bool useResponseFileForObjects = false;
   {
-  std::string responseVar = "CMAKE_";
-  responseVar += linkLanguage;
-  responseVar += "_USE_RESPONSE_FILE_FOR_OBJECTS";
-  if(this->Makefile->IsOn(responseVar))
-    {
-    useResponseFileForObjects = true;
+    std::string responseVar = "CMAKE_";
+    responseVar += linkLanguage;
+    responseVar += "_USE_RESPONSE_FILE_FOR_OBJECTS";
+    if (this->Makefile->IsOn(responseVar)) {
+      useResponseFileForObjects = true;
     }
   }
 
   // Select whether to use a response file for libraries.
   bool useResponseFileForLibs = false;
   {
-  std::string responseVar = "CMAKE_";
-  responseVar += linkLanguage;
-  responseVar += "_USE_RESPONSE_FILE_FOR_LIBRARIES";
-  if(this->Makefile->IsOn(responseVar))
-    {
-    useResponseFileForLibs = true;
+    std::string responseVar = "CMAKE_";
+    responseVar += linkLanguage;
+    responseVar += "_USE_RESPONSE_FILE_FOR_LIBRARIES";
+    if (this->Makefile->IsOn(responseVar)) {
+      useResponseFileForLibs = true;
     }
   }
 
   // Expand the rule variables.
   {
-  bool useWatcomQuote = this->Makefile->IsOn(linkRuleVar+"_USE_WATCOM_QUOTE");
-
-  // Set path conversion for link script shells.
-  this->LocalGenerator->SetLinkScriptShell(useLinkScript);
-
-  // Collect up flags to link in needed libraries.
-  std::string linkLibs;
-  this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends,
-                       useWatcomQuote);
-
-  // Construct object file lists that may be needed to expand the
-  // rule.
-  std::string buildObjs;
-  this->CreateObjectLists(useLinkScript, false,
-                          useResponseFileForObjects, buildObjs, depends,
-                          useWatcomQuote);
-
-  std::string manifests = this->GetManifests();
-
-  cmLocalGenerator::RuleVariables vars;
-  vars.RuleLauncher = "RULE_LAUNCH_LINK";
-  vars.CMTarget = this->GeneratorTarget;
-  vars.Language = linkLanguage.c_str();
-  vars.Objects = buildObjs.c_str();
-  std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
-  objectDir = this->Convert(objectDir,
-                            cmLocalGenerator::START_OUTPUT,
-                            cmLocalGenerator::SHELL);
-  vars.ObjectDir = objectDir.c_str();
-  cmLocalGenerator::OutputFormat output = (useWatcomQuote) ?
-    cmLocalGenerator::WATCOMQUOTE : cmLocalGenerator::SHELL;
-  std::string target = this->Convert(targetFullPathReal,
-                                     cmLocalGenerator::START_OUTPUT,
-                                     output);
-  vars.Target = target.c_str();
-  vars.TargetPDB = targetOutPathPDB.c_str();
-
-  // Setup the target version.
-  std::string targetVersionMajor;
-  std::string targetVersionMinor;
-  {
-  std::ostringstream majorStream;
-  std::ostringstream minorStream;
-  int major;
-  int minor;
-  this->GeneratorTarget->GetTargetVersion(major, minor);
-  majorStream << major;
-  minorStream << minor;
-  targetVersionMajor = majorStream.str();
-  targetVersionMinor = minorStream.str();
-  }
-  vars.TargetVersionMajor = targetVersionMajor.c_str();
-  vars.TargetVersionMinor = targetVersionMinor.c_str();
-
-  vars.LinkLibraries = linkLibs.c_str();
-  vars.Flags = flags.c_str();
-  vars.LinkFlags = linkFlags.c_str();
-  vars.Manifests = manifests.c_str();
-
-  // Expand placeholders in the commands.
-  this->LocalGenerator->TargetImplib = targetOutPathImport;
-  for(std::vector<std::string>::iterator i = real_link_commands.begin();
-      i != real_link_commands.end(); ++i)
+    bool useWatcomQuote =
+      this->Makefile->IsOn(linkRuleVar + "_USE_WATCOM_QUOTE");
+
+    // Set path conversion for link script shells.
+    this->LocalGenerator->SetLinkScriptShell(useLinkScript);
+
+    // Collect up flags to link in needed libraries.
+    std::string linkLibs;
+    this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends,
+                         useWatcomQuote);
+
+    // Construct object file lists that may be needed to expand the
+    // rule.
+    std::string buildObjs;
+    this->CreateObjectLists(useLinkScript, false, useResponseFileForObjects,
+                            buildObjs, depends, useWatcomQuote);
+
+    std::string manifests = this->GetManifests();
+
+    cmLocalGenerator::RuleVariables vars;
+    vars.RuleLauncher = "RULE_LAUNCH_LINK";
+    vars.CMTarget = this->GeneratorTarget;
+    vars.Language = linkLanguage.c_str();
+    vars.Objects = buildObjs.c_str();
+    std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
+    objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT,
+                              cmLocalGenerator::SHELL);
+    vars.ObjectDir = objectDir.c_str();
+    cmLocalGenerator::OutputFormat output = (useWatcomQuote)
+      ? cmLocalGenerator::WATCOMQUOTE
+      : cmLocalGenerator::SHELL;
+    std::string target = this->Convert(targetFullPathReal,
+                                       cmLocalGenerator::START_OUTPUT, output);
+    vars.Target = target.c_str();
+    vars.TargetPDB = targetOutPathPDB.c_str();
+
+    // Setup the target version.
+    std::string targetVersionMajor;
+    std::string targetVersionMinor;
     {
-    this->LocalGenerator->ExpandRuleVariables(*i, vars);
+      std::ostringstream majorStream;
+      std::ostringstream minorStream;
+      int major;
+      int minor;
+      this->GeneratorTarget->GetTargetVersion(major, minor);
+      majorStream << major;
+      minorStream << minor;
+      targetVersionMajor = majorStream.str();
+      targetVersionMinor = minorStream.str();
+    }
+    vars.TargetVersionMajor = targetVersionMajor.c_str();
+    vars.TargetVersionMinor = targetVersionMinor.c_str();
+
+    vars.LinkLibraries = linkLibs.c_str();
+    vars.Flags = flags.c_str();
+    vars.LinkFlags = linkFlags.c_str();
+    vars.Manifests = manifests.c_str();
+
+    // Expand placeholders in the commands.
+    this->LocalGenerator->TargetImplib = targetOutPathImport;
+    for (std::vector<std::string>::iterator i = real_link_commands.begin();
+         i != real_link_commands.end(); ++i) {
+      this->LocalGenerator->ExpandRuleVariables(*i, vars);
     }
-  this->LocalGenerator->TargetImplib = "";
+    this->LocalGenerator->TargetImplib = "";
 
-  // Restore path conversion to normal shells.
-  this->LocalGenerator->SetLinkScriptShell(false);
+    // Restore path conversion to normal shells.
+    this->LocalGenerator->SetLinkScriptShell(false);
   }
 
   // Optionally convert the build rule to use a script to avoid long
   // command lines in the make shell.
-  if(useLinkScript)
-    {
+  if (useLinkScript) {
     // Use a link script.
-    const char* name = (relink? "relink.txt" : "link.txt");
+    const char* name = (relink ? "relink.txt" : "link.txt");
     this->CreateLinkScript(name, real_link_commands, commands1, depends);
-    }
-  else
-    {
+  } else {
     // No link script.  Just use the link rule directly.
     commands1 = real_link_commands;
-    }
-  this->LocalGenerator->CreateCDCommand
-    (commands1,
-     this->Makefile->GetCurrentBinaryDirectory(),
-     cmLocalGenerator::HOME_OUTPUT);
+  }
+  this->LocalGenerator->CreateCDCommand(
+    commands1, this->Makefile->GetCurrentBinaryDirectory(),
+    cmLocalGenerator::HOME_OUTPUT);
   commands.insert(commands.end(), commands1.begin(), commands1.end());
   commands1.clear();
 
   // Add a rule to create necessary symlinks for the library.
-  if(targetOutPath != targetOutPathReal)
-    {
+  if (targetOutPath != targetOutPathReal) {
     std::string symlink = "$(CMAKE_COMMAND) -E cmake_symlink_executable ";
     symlink += targetOutPathReal;
     symlink += " ";
     symlink += targetOutPath;
     commands1.push_back(symlink);
-    this->LocalGenerator->CreateCDCommand(commands1,
-                                  this->Makefile->GetCurrentBinaryDirectory(),
-                                  cmLocalGenerator::HOME_OUTPUT);
+    this->LocalGenerator->CreateCDCommand(
+      commands1, this->Makefile->GetCurrentBinaryDirectory(),
+      cmLocalGenerator::HOME_OUTPUT);
     commands.insert(commands.end(), commands1.begin(), commands1.end());
     commands1.clear();
-    }
+  }
 
   // Add the post-build rules when building but not when relinking.
-  if(!relink)
-    {
-    this->LocalGenerator->
-      AppendCustomCommands(commands,
-                       this->GeneratorTarget->GetPostBuildCommands(),
-                       this->GeneratorTarget);
-    }
+  if (!relink) {
+    this->LocalGenerator->AppendCustomCommands(
+      commands, this->GeneratorTarget->GetPostBuildCommands(),
+      this->GeneratorTarget);
+  }
 
   // Write the build rule.
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream,
-                                      0,
-                                      targetFullPathReal,
-                                      depends, commands, false);
+  this->LocalGenerator->WriteMakeRule(
+    *this->BuildFileStream, 0, targetFullPathReal, depends, commands, false);
 
   // The symlink name for the target should depend on the real target
   // so if the target version changes it rebuilds and recreates the
   // symlink.
-  if(targetFullPath != targetFullPathReal)
-    {
+  if (targetFullPath != targetFullPathReal) {
     depends.clear();
     commands.clear();
     depends.push_back(targetFullPathReal);
-    this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                        targetFullPath,
-                                        depends, commands, false);
-    }
+    this->LocalGenerator->WriteMakeRule(
+      *this->BuildFileStream, 0, targetFullPath, depends, commands, false);
+  }
 
   // Write the main driver rule to build everything in this target.
   this->WriteTargetDriverRule(targetFullPath, relink);
 
   // Clean all the possible executable names and symlinks.
-  this->CleanFiles.insert(this->CleanFiles.end(),
-                          exeCleanFiles.begin(),
+  this->CleanFiles.insert(this->CleanFiles.end(), exeCleanFiles.begin(),
                           exeCleanFiles.end());
 }
diff --git a/Source/cmMakefileExecutableTargetGenerator.h b/Source/cmMakefileExecutableTargetGenerator.h
index 940226b..64cb17f 100644
--- a/Source/cmMakefileExecutableTargetGenerator.h
+++ b/Source/cmMakefileExecutableTargetGenerator.h
@@ -14,7 +14,7 @@
 
 #include "cmMakefileTargetGenerator.h"
 
-class cmMakefileExecutableTargetGenerator: public cmMakefileTargetGenerator
+class cmMakefileExecutableTargetGenerator : public cmMakefileTargetGenerator
 {
 public:
   cmMakefileExecutableTargetGenerator(cmGeneratorTarget* target);
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 195dd98..25235ea 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -19,25 +19,23 @@
 #include "cmSourceFile.h"
 #include "cmake.h"
 
-cmMakefileLibraryTargetGenerator
-::cmMakefileLibraryTargetGenerator(cmGeneratorTarget* target):
-  cmMakefileTargetGenerator(target)
+cmMakefileLibraryTargetGenerator::cmMakefileLibraryTargetGenerator(
+  cmGeneratorTarget* target)
+  : cmMakefileTargetGenerator(target)
 {
   this->CustomCommandDriver = OnDepends;
-  if (this->GeneratorTarget->GetType() != cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() != cmState::INTERFACE_LIBRARY) {
     this->GeneratorTarget->GetLibraryNames(
       this->TargetNameOut, this->TargetNameSO, this->TargetNameReal,
       this->TargetNameImport, this->TargetNamePDB, this->ConfigName);
-    }
+  }
 
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
-                                                      this->ConfigName);
+  this->OSXBundleGenerator =
+    new cmOSXBundleGenerator(target, this->ConfigName);
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
 
-cmMakefileLibraryTargetGenerator
-::~cmMakefileLibraryTargetGenerator()
+cmMakefileLibraryTargetGenerator::~cmMakefileLibraryTargetGenerator()
 {
   delete this->OSXBundleGenerator;
 }
@@ -58,26 +56,23 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles()
 
   // write the link rules
   // Write the rule for this target type.
-  switch(this->GeneratorTarget->GetType())
-    {
+  switch (this->GeneratorTarget->GetType()) {
     case cmState::STATIC_LIBRARY:
       this->WriteStaticLibraryRules();
       break;
     case cmState::SHARED_LIBRARY:
       this->WriteSharedLibraryRules(false);
-      if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName))
-        {
+      if (this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) {
         // Write rules to link an installable version of the target.
         this->WriteSharedLibraryRules(true);
-        }
+      }
       break;
     case cmState::MODULE_LIBRARY:
       this->WriteModuleLibraryRules(false);
-      if(this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName))
-        {
+      if (this->GeneratorTarget->NeedRelinkBeforeInstall(this->ConfigName)) {
         // Write rules to link an installable version of the target.
         this->WriteModuleLibraryRules(true);
-        }
+      }
       break;
     case cmState::OBJECT_LIBRARY:
       this->WriteObjectLibraryRules();
@@ -86,7 +81,7 @@ void cmMakefileLibraryTargetGenerator::WriteRuleFiles()
       // If language is not known, this is an error.
       cmSystemTools::Error("Unknown Library Type");
       break;
-    }
+  }
 
   // Write the requires target.
   this->WriteTargetRequiresRules();
@@ -108,10 +103,9 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules()
   std::vector<std::string> depends;
 
   // Add post-build rules.
-  this->LocalGenerator->
-    AppendCustomCommands(commands,
-                         this->GeneratorTarget->GetPostBuildCommands(),
-                         this->GeneratorTarget);
+  this->LocalGenerator->AppendCustomCommands(
+    commands, this->GeneratorTarget->GetPostBuildCommands(),
+    this->GeneratorTarget);
 
   // Depend on the object files.
   this->AppendObjectDepends(depends);
@@ -133,25 +127,24 @@ void cmMakefileLibraryTargetGenerator::WriteStaticLibraryRules()
   linkRuleVar += linkLanguage;
   linkRuleVar += "_CREATE_STATIC_LIBRARY";
 
-  if(this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION") &&
-     this->Makefile->GetDefinition(linkRuleVar+"_IPO"))
-    {
+  if (this->GetFeatureAsBool("INTERPROCEDURAL_OPTIMIZATION") &&
+      this->Makefile->GetDefinition(linkRuleVar + "_IPO")) {
     linkRuleVar += "_IPO";
-    }
+  }
 
   std::string extraFlags;
-  this->LocalGenerator->GetStaticLibraryFlags(extraFlags,
-    cmSystemTools::UpperCase(this->ConfigName), this->GeneratorTarget);
+  this->LocalGenerator->GetStaticLibraryFlags(
+    extraFlags, cmSystemTools::UpperCase(this->ConfigName),
+    this->GeneratorTarget);
   this->WriteLibraryRules(linkRuleVar, extraFlags, false);
 }
 
 void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
 {
-  if(this->GeneratorTarget->IsFrameworkOnApple())
-    {
+  if (this->GeneratorTarget->IsFrameworkOnApple()) {
     this->WriteFrameworkRules(relink);
     return;
-    }
+  }
   std::string linkLanguage =
     this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
   std::string linkRuleVar = "CMAKE_";
@@ -159,15 +152,15 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
   linkRuleVar += "_CREATE_SHARED_LIBRARY";
 
   std::string extraFlags;
-  this->LocalGenerator->AppendFlags
-    (extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
+  this->LocalGenerator->AppendFlags(
+    extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
   std::string linkFlagsConfig = "LINK_FLAGS_";
   linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
-  this->LocalGenerator->AppendFlags
-    (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
+  this->LocalGenerator->AppendFlags(
+    extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
 
-  this->LocalGenerator->AddConfigVariableFlags
-    (extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName);
+  this->LocalGenerator->AddConfigVariableFlags(
+    extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->ConfigName);
   this->AddModuleDefinitionFlag(extraFlags);
 
   this->WriteLibraryRules(linkRuleVar, extraFlags, relink);
@@ -182,14 +175,14 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink)
   linkRuleVar += "_CREATE_SHARED_MODULE";
 
   std::string extraFlags;
-  this->LocalGenerator->AppendFlags(extraFlags,
-                           this->GeneratorTarget->GetProperty("LINK_FLAGS"));
+  this->LocalGenerator->AppendFlags(
+    extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
   std::string linkFlagsConfig = "LINK_FLAGS_";
   linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
-  this->LocalGenerator->AppendFlags
-    (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
-  this->LocalGenerator->AddConfigVariableFlags
-    (extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->ConfigName);
+  this->LocalGenerator->AppendFlags(
+    extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
+  this->LocalGenerator->AddConfigVariableFlags(
+    extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->ConfigName);
   this->AddModuleDefinitionFlag(extraFlags);
 
   this->WriteLibraryRules(linkRuleVar, extraFlags, relink);
@@ -204,20 +197,20 @@ void cmMakefileLibraryTargetGenerator::WriteFrameworkRules(bool relink)
   linkRuleVar += "_CREATE_MACOSX_FRAMEWORK";
 
   std::string extraFlags;
-  this->LocalGenerator->AppendFlags(extraFlags,
-                             this->GeneratorTarget->GetProperty("LINK_FLAGS"));
+  this->LocalGenerator->AppendFlags(
+    extraFlags, this->GeneratorTarget->GetProperty("LINK_FLAGS"));
   std::string linkFlagsConfig = "LINK_FLAGS_";
   linkFlagsConfig += cmSystemTools::UpperCase(this->ConfigName);
-  this->LocalGenerator->AppendFlags
-    (extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
-  this->LocalGenerator->AddConfigVariableFlags
-    (extraFlags, "CMAKE_MACOSX_FRAMEWORK_LINKER_FLAGS", this->ConfigName);
+  this->LocalGenerator->AppendFlags(
+    extraFlags, this->GeneratorTarget->GetProperty(linkFlagsConfig));
+  this->LocalGenerator->AddConfigVariableFlags(
+    extraFlags, "CMAKE_MACOSX_FRAMEWORK_LINKER_FLAGS", this->ConfigName);
 
   this->WriteLibraryRules(linkRuleVar, extraFlags, relink);
 }
 
-void cmMakefileLibraryTargetGenerator::WriteLibraryRules
-(const std::string& linkRuleVar, const std::string& extraFlags, bool relink)
+void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
+  const std::string& linkRuleVar, const std::string& extraFlags, bool relink)
 {
   // TODO: Merge the methods that call this method to avoid
   // code duplication.
@@ -232,24 +225,22 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
 
   // Make sure we have a link language.
-  if(linkLanguage.empty())
-    {
+  if (linkLanguage.empty()) {
     cmSystemTools::Error("Cannot determine link language for target \"",
                          this->GeneratorTarget->GetName().c_str(), "\".");
     return;
-    }
+  }
 
   // Create set of linking flags.
   std::string linkFlags;
   this->LocalGenerator->AppendFlags(linkFlags, extraFlags);
 
   // Add OSX version flags, if any.
-  if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
-     this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
+      this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
     this->AppendOSXVerFlag(linkFlags, linkLanguage, "COMPATIBILITY", true);
     this->AppendOSXVerFlag(linkFlags, linkLanguage, "CURRENT", false);
-    }
+  }
 
   // Construct the name of the library.
   std::string targetName;
@@ -257,56 +248,47 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
   std::string targetNameReal;
   std::string targetNameImport;
   std::string targetNamePDB;
-  this->GeneratorTarget->GetLibraryNames(
-    targetName, targetNameSO, targetNameReal, targetNameImport, targetNamePDB,
-    this->ConfigName);
+  this->GeneratorTarget->GetLibraryNames(targetName, targetNameSO,
+                                         targetNameReal, targetNameImport,
+                                         targetNamePDB, this->ConfigName);
 
   // Construct the full path version of the names.
   std::string outpath;
   std::string outpathImp;
-  if(this->GeneratorTarget->IsFrameworkOnApple())
-    {
+  if (this->GeneratorTarget->IsFrameworkOnApple()) {
     outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
     this->OSXBundleGenerator->CreateFramework(targetName, outpath);
     outpath += "/";
-    }
-  else if(this->GeneratorTarget->IsCFBundleOnApple())
-    {
+  } else if (this->GeneratorTarget->IsCFBundleOnApple()) {
     outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
     this->OSXBundleGenerator->CreateCFBundle(targetName, outpath);
     outpath += "/";
-    }
-  else if(relink)
-    {
+  } else if (relink) {
     outpath = this->Makefile->GetCurrentBinaryDirectory();
     outpath += cmake::GetCMakeFilesDirectory();
     outpath += "/CMakeRelink.dir";
     cmSystemTools::MakeDirectory(outpath.c_str());
     outpath += "/";
-    if(!targetNameImport.empty())
-      {
+    if (!targetNameImport.empty()) {
       outpathImp = outpath;
-      }
     }
-  else
-    {
+  } else {
     outpath = this->GeneratorTarget->GetDirectory(this->ConfigName);
     cmSystemTools::MakeDirectory(outpath.c_str());
     outpath += "/";
-    if(!targetNameImport.empty())
-      {
+    if (!targetNameImport.empty()) {
       outpathImp = this->GeneratorTarget->GetDirectory(this->ConfigName, true);
       cmSystemTools::MakeDirectory(outpathImp.c_str());
       outpathImp += "/";
-      }
     }
+  }
 
   std::string compilePdbOutputPath =
     this->GeneratorTarget->GetCompilePDBDirectory(this->ConfigName);
   cmSystemTools::MakeDirectory(compilePdbOutputPath.c_str());
 
   std::string pdbOutputPath =
-      this->GeneratorTarget->GetPDBDirectory(this->ConfigName);
+    this->GeneratorTarget->GetPDBDirectory(this->ConfigName);
   cmSystemTools::MakeDirectory(pdbOutputPath.c_str());
   pdbOutputPath += "/";
 
@@ -318,32 +300,27 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
 
   // Construct the output path version of the names for use in command
   // arguments.
-  std::string targetOutPathPDB =
-    this->Convert(targetFullPathPDB,cmLocalGenerator::NONE,
-                  cmLocalGenerator::SHELL);
-  std::string targetOutPath =
-    this->Convert(targetFullPath,cmLocalGenerator::START_OUTPUT,
-                  cmLocalGenerator::SHELL);
-  std::string targetOutPathSO =
-    this->Convert(targetFullPathSO,cmLocalGenerator::START_OUTPUT,
-                  cmLocalGenerator::SHELL);
+  std::string targetOutPathPDB = this->Convert(
+    targetFullPathPDB, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+  std::string targetOutPath = this->Convert(
+    targetFullPath, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL);
+  std::string targetOutPathSO = this->Convert(
+    targetFullPathSO, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::SHELL);
   std::string targetOutPathReal =
-    this->Convert(targetFullPathReal,cmLocalGenerator::START_OUTPUT,
+    this->Convert(targetFullPathReal, cmLocalGenerator::START_OUTPUT,
                   cmLocalGenerator::SHELL);
   std::string targetOutPathImport =
-    this->Convert(targetFullPathImport,cmLocalGenerator::START_OUTPUT,
+    this->Convert(targetFullPathImport, cmLocalGenerator::START_OUTPUT,
                   cmLocalGenerator::SHELL);
 
   this->NumberOfProgressActions++;
-  if(!this->NoRuleMessages)
-    {
+  if (!this->NoRuleMessages) {
     cmLocalUnixMakefileGenerator3::EchoProgress progress;
     this->MakeEchoProgress(progress);
     // Add the link message.
     std::string buildEcho = "Linking ";
     buildEcho += linkLanguage;
-    switch(this->GeneratorTarget->GetType())
-      {
+    switch (this->GeneratorTarget->GetType()) {
       case cmState::STATIC_LIBRARY:
         buildEcho += " static library ";
         break;
@@ -352,110 +329,97 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
         break;
       case cmState::MODULE_LIBRARY:
         if (this->GeneratorTarget->IsCFBundleOnApple())
-            buildEcho += " CFBundle";
+          buildEcho += " CFBundle";
         buildEcho += " shared module ";
         break;
       default:
         buildEcho += " library ";
         break;
-      }
+    }
     buildEcho += targetOutPath.c_str();
     this->LocalGenerator->AppendEcho(commands, buildEcho.c_str(),
                                      cmLocalUnixMakefileGenerator3::EchoLink,
                                      &progress);
-    }
+  }
 
   const char* forbiddenFlagVar = 0;
-  switch(this->GeneratorTarget->GetType())
-    {
+  switch (this->GeneratorTarget->GetType()) {
     case cmState::SHARED_LIBRARY:
       forbiddenFlagVar = "_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS";
       break;
     case cmState::MODULE_LIBRARY:
       forbiddenFlagVar = "_CREATE_SHARED_MODULE_FORBIDDEN_FLAGS";
       break;
-    default: break;
-    }
+    default:
+      break;
+  }
 
   // Clean files associated with this library.
   std::vector<std::string> libCleanFiles;
   libCleanFiles.push_back(this->Convert(targetFullPath,
-        cmLocalGenerator::START_OUTPUT,
-        cmLocalGenerator::UNCHANGED));
-  if(targetNameReal != targetName)
-    {
+                                        cmLocalGenerator::START_OUTPUT,
+                                        cmLocalGenerator::UNCHANGED));
+  if (targetNameReal != targetName) {
     libCleanFiles.push_back(this->Convert(targetFullPathReal,
-        cmLocalGenerator::START_OUTPUT,
-        cmLocalGenerator::UNCHANGED));
-    }
-  if(targetNameSO != targetName &&
-     targetNameSO != targetNameReal)
-    {
+                                          cmLocalGenerator::START_OUTPUT,
+                                          cmLocalGenerator::UNCHANGED));
+  }
+  if (targetNameSO != targetName && targetNameSO != targetNameReal) {
     libCleanFiles.push_back(this->Convert(targetFullPathSO,
-        cmLocalGenerator::START_OUTPUT,
-        cmLocalGenerator::UNCHANGED));
-    }
-  if(!targetNameImport.empty())
-    {
+                                          cmLocalGenerator::START_OUTPUT,
+                                          cmLocalGenerator::UNCHANGED));
+  }
+  if (!targetNameImport.empty()) {
     libCleanFiles.push_back(this->Convert(targetFullPathImport,
-        cmLocalGenerator::START_OUTPUT,
-        cmLocalGenerator::UNCHANGED));
+                                          cmLocalGenerator::START_OUTPUT,
+                                          cmLocalGenerator::UNCHANGED));
     std::string implib;
-    if(this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport, implib))
-      {
-      libCleanFiles.push_back(this->Convert(implib,
-                                            cmLocalGenerator::START_OUTPUT,
-                                            cmLocalGenerator::UNCHANGED));
-      }
+    if (this->GeneratorTarget->GetImplibGNUtoMS(targetFullPathImport,
+                                                implib)) {
+      libCleanFiles.push_back(this->Convert(
+        implib, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED));
     }
+  }
 
   // List the PDB for cleaning only when the whole target is
   // cleaned.  We do not want to delete the .pdb file just before
   // linking the target.
-  this->CleanFiles.push_back
-    (this->Convert(targetFullPathPDB,
-                   cmLocalGenerator::START_OUTPUT,
-                   cmLocalGenerator::UNCHANGED));
+  this->CleanFiles.push_back(this->Convert(targetFullPathPDB,
+                                           cmLocalGenerator::START_OUTPUT,
+                                           cmLocalGenerator::UNCHANGED));
 
 #ifdef _WIN32
   // There may be a manifest file for this target.  Add it to the
   // clean set just in case.
-  if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY)
-    {
-    libCleanFiles.push_back(
-      this->Convert((targetFullPath+".manifest").c_str(),
-                    cmLocalGenerator::START_OUTPUT,
-                    cmLocalGenerator::UNCHANGED));
-    }
+  if (this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) {
+    libCleanFiles.push_back(this->Convert(
+      (targetFullPath + ".manifest").c_str(), cmLocalGenerator::START_OUTPUT,
+      cmLocalGenerator::UNCHANGED));
+  }
 #endif
 
   std::vector<std::string> commands1;
   // Add a command to remove any existing files for this library.
   // for static libs only
-  if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) {
     this->LocalGenerator->AppendCleanCommand(commands1, libCleanFiles,
                                              this->GeneratorTarget, "target");
-    this->LocalGenerator->CreateCDCommand
-      (commands1,
-       this->Makefile->GetCurrentBinaryDirectory(),
-       cmLocalGenerator::HOME_OUTPUT);
+    this->LocalGenerator->CreateCDCommand(
+      commands1, this->Makefile->GetCurrentBinaryDirectory(),
+      cmLocalGenerator::HOME_OUTPUT);
     commands.insert(commands.end(), commands1.begin(), commands1.end());
     commands1.clear();
-    }
+  }
 
   // Add the pre-build and pre-link rules building but not when relinking.
-  if(!relink)
-    {
-    this->LocalGenerator
-      ->AppendCustomCommands(commands,
-                        this->GeneratorTarget->GetPreBuildCommands(),
-                        this->GeneratorTarget);
-    this->LocalGenerator
-      ->AppendCustomCommands(commands,
-                        this->GeneratorTarget->GetPreLinkCommands(),
-                        this->GeneratorTarget);
-    }
+  if (!relink) {
+    this->LocalGenerator->AppendCustomCommands(
+      commands, this->GeneratorTarget->GetPreBuildCommands(),
+      this->GeneratorTarget);
+    this->LocalGenerator->AppendCustomCommands(
+      commands, this->GeneratorTarget->GetPreLinkCommands(),
+      this->GeneratorTarget);
+  }
 
   // Determine whether a link script will be used.
   bool useLinkScript = this->GlobalGenerator->GetUseLinkScript();
@@ -463,24 +427,22 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
   // Select whether to use a response file for objects.
   bool useResponseFileForObjects = false;
   {
-  std::string responseVar = "CMAKE_";
-  responseVar += linkLanguage;
-  responseVar += "_USE_RESPONSE_FILE_FOR_OBJECTS";
-  if(this->Makefile->IsOn(responseVar))
-    {
-    useResponseFileForObjects = true;
+    std::string responseVar = "CMAKE_";
+    responseVar += linkLanguage;
+    responseVar += "_USE_RESPONSE_FILE_FOR_OBJECTS";
+    if (this->Makefile->IsOn(responseVar)) {
+      useResponseFileForObjects = true;
     }
   }
 
   // Select whether to use a response file for libraries.
   bool useResponseFileForLibs = false;
   {
-  std::string responseVar = "CMAKE_";
-  responseVar += linkLanguage;
-  responseVar += "_USE_RESPONSE_FILE_FOR_LIBRARIES";
-  if(this->Makefile->IsOn(responseVar))
-    {
-    useResponseFileForLibs = true;
+    std::string responseVar = "CMAKE_";
+    responseVar += linkLanguage;
+    responseVar += "_USE_RESPONSE_FILE_FOR_LIBRARIES";
+    if (this->Makefile->IsOn(responseVar)) {
+      useResponseFileForLibs = true;
     }
   }
 
@@ -490,39 +452,33 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
   std::vector<std::string> archiveAppendCommands;
   std::vector<std::string> archiveFinishCommands;
   std::string::size_type archiveCommandLimit = std::string::npos;
-  if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) {
     haveStaticLibraryRule =
-      this->Makefile->GetDefinition(linkRuleVar)? true:false;
+      this->Makefile->GetDefinition(linkRuleVar) ? true : false;
     std::string arCreateVar = "CMAKE_";
     arCreateVar += linkLanguage;
     arCreateVar += "_ARCHIVE_CREATE";
-    if(const char* rule = this->Makefile->GetDefinition(arCreateVar))
-      {
+    if (const char* rule = this->Makefile->GetDefinition(arCreateVar)) {
       cmSystemTools::ExpandListArgument(rule, archiveCreateCommands);
-      }
+    }
     std::string arAppendVar = "CMAKE_";
     arAppendVar += linkLanguage;
     arAppendVar += "_ARCHIVE_APPEND";
-    if(const char* rule = this->Makefile->GetDefinition(arAppendVar))
-      {
+    if (const char* rule = this->Makefile->GetDefinition(arAppendVar)) {
       cmSystemTools::ExpandListArgument(rule, archiveAppendCommands);
-      }
+    }
     std::string arFinishVar = "CMAKE_";
     arFinishVar += linkLanguage;
     arFinishVar += "_ARCHIVE_FINISH";
-    if(const char* rule = this->Makefile->GetDefinition(arFinishVar))
-      {
+    if (const char* rule = this->Makefile->GetDefinition(arFinishVar)) {
       cmSystemTools::ExpandListArgument(rule, archiveFinishCommands);
-      }
     }
+  }
 
   // Decide whether to use archiving rules.
-  bool useArchiveRules =
-    !haveStaticLibraryRule &&
+  bool useArchiveRules = !haveStaticLibraryRule &&
     !archiveCreateCommands.empty() && !archiveAppendCommands.empty();
-  if(useArchiveRules)
-    {
+  if (useArchiveRules) {
     // Archiving rules are always run with a link script.
     useLinkScript = true;
 
@@ -533,260 +489,232 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     // 32K command line length limit on Windows.  We could make this a
     // platform file variable but this should work everywhere.
     archiveCommandLimit = 30000;
-    }
+  }
 
   // Expand the rule variables.
   std::vector<std::string> real_link_commands;
   {
-  bool useWatcomQuote = this->Makefile->IsOn(linkRuleVar+"_USE_WATCOM_QUOTE");
-
-  // Set path conversion for link script shells.
-  this->LocalGenerator->SetLinkScriptShell(useLinkScript);
-
-  // Collect up flags to link in needed libraries.
-  std::string linkLibs;
-  if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY)
-    {
-    this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends,
-                         useWatcomQuote);
-    }
-
-  // Construct object file lists that may be needed to expand the
-  // rule.
-  std::string buildObjs;
-  this->CreateObjectLists(useLinkScript, useArchiveRules,
-                          useResponseFileForObjects, buildObjs, depends,
-                          useWatcomQuote);
-
-  // maybe create .def file from list of objects
-  if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
-      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
-    {
-    if(this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
-      std::string name_of_def_file =
-        this->GeneratorTarget->GetSupportDirectory();
-      name_of_def_file += std::string("/") +
-        this->GeneratorTarget->GetName();
-      name_of_def_file += ".def";
-      std::string cmd = cmSystemTools::GetCMakeCommand();
-      cmd = this->Convert(cmd, cmLocalGenerator::NONE,
-                          cmLocalGenerator::SHELL);
-      cmd += " -E __create_def ";
-      cmd += this->Convert(name_of_def_file,
-                           cmLocalGenerator::START_OUTPUT,
-                           cmLocalGenerator::SHELL);
-      cmd += " ";
-      std::string objlist_file = name_of_def_file;
-      objlist_file += ".objs";
-      cmd += this->Convert(objlist_file,
-                           cmLocalGenerator::START_OUTPUT,
-                           cmLocalGenerator::SHELL);
-      real_link_commands.push_back(cmd);
-      // create a list of obj files for the -E __create_def to read
-      cmGeneratedFileStream fout(objlist_file.c_str());
-      for(std::vector<std::string>::const_iterator i = this->Objects.begin();
-          i != this->Objects.end(); ++i)
-        {
-        if(cmHasLiteralSuffix(*i, ".obj"))
-          {
-          fout << *i << "\n";
+    bool useWatcomQuote =
+      this->Makefile->IsOn(linkRuleVar + "_USE_WATCOM_QUOTE");
+
+    // Set path conversion for link script shells.
+    this->LocalGenerator->SetLinkScriptShell(useLinkScript);
+
+    // Collect up flags to link in needed libraries.
+    std::string linkLibs;
+    if (this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY) {
+      this->CreateLinkLibs(linkLibs, relink, useResponseFileForLibs, depends,
+                           useWatcomQuote);
+    }
+
+    // Construct object file lists that may be needed to expand the
+    // rule.
+    std::string buildObjs;
+    this->CreateObjectLists(useLinkScript, useArchiveRules,
+                            useResponseFileForObjects, buildObjs, depends,
+                            useWatcomQuote);
+
+    // maybe create .def file from list of objects
+    if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
+        this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) {
+      if (this->GeneratorTarget->GetPropertyAsBool(
+            "WINDOWS_EXPORT_ALL_SYMBOLS")) {
+        std::string name_of_def_file =
+          this->GeneratorTarget->GetSupportDirectory();
+        name_of_def_file +=
+          std::string("/") + this->GeneratorTarget->GetName();
+        name_of_def_file += ".def";
+        std::string cmd = cmSystemTools::GetCMakeCommand();
+        cmd =
+          this->Convert(cmd, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+        cmd += " -E __create_def ";
+        cmd += this->Convert(name_of_def_file, cmLocalGenerator::START_OUTPUT,
+                             cmLocalGenerator::SHELL);
+        cmd += " ";
+        std::string objlist_file = name_of_def_file;
+        objlist_file += ".objs";
+        cmd += this->Convert(objlist_file, cmLocalGenerator::START_OUTPUT,
+                             cmLocalGenerator::SHELL);
+        real_link_commands.push_back(cmd);
+        // create a list of obj files for the -E __create_def to read
+        cmGeneratedFileStream fout(objlist_file.c_str());
+        for (std::vector<std::string>::const_iterator i =
+               this->Objects.begin();
+             i != this->Objects.end(); ++i) {
+          if (cmHasLiteralSuffix(*i, ".obj")) {
+            fout << *i << "\n";
           }
         }
-      for(std::vector<std::string>::const_iterator i =
-        this->ExternalObjects.begin();
-          i != this->ExternalObjects.end(); ++i)
-        {
-        fout << *i << "\n";
+        for (std::vector<std::string>::const_iterator i =
+               this->ExternalObjects.begin();
+             i != this->ExternalObjects.end(); ++i) {
+          fout << *i << "\n";
         }
-      // now add the def file link flag
-      linkFlags += " ";
-      linkFlags +=
-        this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
-      linkFlags += this->Convert(name_of_def_file,
-                                 cmLocalGenerator::START_OUTPUT,
-                                 cmLocalGenerator::SHELL);
-      linkFlags += " ";
+        // now add the def file link flag
+        linkFlags += " ";
+        linkFlags +=
+          this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
+        linkFlags +=
+          this->Convert(name_of_def_file, cmLocalGenerator::START_OUTPUT,
+                        cmLocalGenerator::SHELL);
+        linkFlags += " ";
       }
     }
 
-  std::string manifests = this->GetManifests();
-
-  cmLocalGenerator::RuleVariables vars;
-  vars.TargetPDB = targetOutPathPDB.c_str();
-
-  // Setup the target version.
-  std::string targetVersionMajor;
-  std::string targetVersionMinor;
-  {
-  std::ostringstream majorStream;
-  std::ostringstream minorStream;
-  int major;
-  int minor;
-  this->GeneratorTarget->GetTargetVersion(major, minor);
-  majorStream << major;
-  minorStream << minor;
-  targetVersionMajor = majorStream.str();
-  targetVersionMinor = minorStream.str();
-  }
-  vars.TargetVersionMajor = targetVersionMajor.c_str();
-  vars.TargetVersionMinor = targetVersionMinor.c_str();
-
-  vars.RuleLauncher = "RULE_LAUNCH_LINK";
-  vars.CMTarget = this->GeneratorTarget;
-  vars.Language = linkLanguage.c_str();
-  vars.Objects = buildObjs.c_str();
-  std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
-  objectDir = this->Convert(objectDir,
-                            cmLocalGenerator::START_OUTPUT,
-                            cmLocalGenerator::SHELL);
-  vars.ObjectDir = objectDir.c_str();
-  cmLocalGenerator::OutputFormat output = (useWatcomQuote) ?
-    cmLocalGenerator::WATCOMQUOTE : cmLocalGenerator::SHELL;
-  std::string target = this->Convert(targetFullPathReal,
-                                     cmLocalGenerator::START_OUTPUT,
-                                     output);
-  vars.Target = target.c_str();
-  vars.LinkLibraries = linkLibs.c_str();
-  vars.ObjectsQuoted = buildObjs.c_str();
-  if (this->GeneratorTarget->HasSOName(this->ConfigName))
-    {
-    vars.SONameFlag = this->Makefile->GetSONameFlag(linkLanguage);
-    vars.TargetSOName= targetNameSO.c_str();
-    }
-  vars.LinkFlags = linkFlags.c_str();
-
-  vars.Manifests = manifests.c_str();
-
-  // Compute the directory portion of the install_name setting.
-  std::string install_name_dir;
-  if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY)
-    {
-    // Get the install_name directory for the build tree.
-    install_name_dir =
-      this->GeneratorTarget->GetInstallNameDirForBuildTree(this->ConfigName);
-
-    // Set the rule variable replacement value.
-    if(install_name_dir.empty())
-      {
-      vars.TargetInstallNameDir = "";
-      }
-    else
-      {
-      // Convert to a path for the native build tool.
+    std::string manifests = this->GetManifests();
+
+    cmLocalGenerator::RuleVariables vars;
+    vars.TargetPDB = targetOutPathPDB.c_str();
+
+    // Setup the target version.
+    std::string targetVersionMajor;
+    std::string targetVersionMinor;
+    {
+      std::ostringstream majorStream;
+      std::ostringstream minorStream;
+      int major;
+      int minor;
+      this->GeneratorTarget->GetTargetVersion(major, minor);
+      majorStream << major;
+      minorStream << minor;
+      targetVersionMajor = majorStream.str();
+      targetVersionMinor = minorStream.str();
+    }
+    vars.TargetVersionMajor = targetVersionMajor.c_str();
+    vars.TargetVersionMinor = targetVersionMinor.c_str();
+
+    vars.RuleLauncher = "RULE_LAUNCH_LINK";
+    vars.CMTarget = this->GeneratorTarget;
+    vars.Language = linkLanguage.c_str();
+    vars.Objects = buildObjs.c_str();
+    std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
+    objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT,
+                              cmLocalGenerator::SHELL);
+    vars.ObjectDir = objectDir.c_str();
+    cmLocalGenerator::OutputFormat output = (useWatcomQuote)
+      ? cmLocalGenerator::WATCOMQUOTE
+      : cmLocalGenerator::SHELL;
+    std::string target = this->Convert(targetFullPathReal,
+                                       cmLocalGenerator::START_OUTPUT, output);
+    vars.Target = target.c_str();
+    vars.LinkLibraries = linkLibs.c_str();
+    vars.ObjectsQuoted = buildObjs.c_str();
+    if (this->GeneratorTarget->HasSOName(this->ConfigName)) {
+      vars.SONameFlag = this->Makefile->GetSONameFlag(linkLanguage);
+      vars.TargetSOName = targetNameSO.c_str();
+    }
+    vars.LinkFlags = linkFlags.c_str();
+
+    vars.Manifests = manifests.c_str();
+
+    // Compute the directory portion of the install_name setting.
+    std::string install_name_dir;
+    if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY) {
+      // Get the install_name directory for the build tree.
       install_name_dir =
-        this->LocalGenerator->Convert(install_name_dir,
-                                      cmLocalGenerator::NONE,
-                                      cmLocalGenerator::SHELL);
-      vars.TargetInstallNameDir = install_name_dir.c_str();
+        this->GeneratorTarget->GetInstallNameDirForBuildTree(this->ConfigName);
+
+      // Set the rule variable replacement value.
+      if (install_name_dir.empty()) {
+        vars.TargetInstallNameDir = "";
+      } else {
+        // Convert to a path for the native build tool.
+        install_name_dir = this->LocalGenerator->Convert(
+          install_name_dir, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+        vars.TargetInstallNameDir = install_name_dir.c_str();
       }
     }
 
-  // Add language feature flags.
-  std::string langFlags;
-  this->AddFeatureFlags(langFlags, linkLanguage);
+    // Add language feature flags.
+    std::string langFlags;
+    this->AddFeatureFlags(langFlags, linkLanguage);
 
-  this->LocalGenerator->AddArchitectureFlags(langFlags, this->GeneratorTarget,
-                                             linkLanguage, this->ConfigName);
+    this->LocalGenerator->AddArchitectureFlags(
+      langFlags, this->GeneratorTarget, linkLanguage, this->ConfigName);
 
-  // remove any language flags that might not work with the
-  // particular os
-  if(forbiddenFlagVar)
-    {
-    this->RemoveForbiddenFlags(forbiddenFlagVar,
-                               linkLanguage, langFlags);
+    // remove any language flags that might not work with the
+    // particular os
+    if (forbiddenFlagVar) {
+      this->RemoveForbiddenFlags(forbiddenFlagVar, linkLanguage, langFlags);
     }
-  vars.LanguageCompileFlags = langFlags.c_str();
+    vars.LanguageCompileFlags = langFlags.c_str();
 
-  // Construct the main link rule and expand placeholders.
-  this->LocalGenerator->TargetImplib = targetOutPathImport;
-  if(useArchiveRules)
-    {
-    // Construct the individual object list strings.
-    std::vector<std::string> object_strings;
-    this->WriteObjectsStrings(object_strings, archiveCommandLimit);
+    // Construct the main link rule and expand placeholders.
+    this->LocalGenerator->TargetImplib = targetOutPathImport;
+    if (useArchiveRules) {
+      // Construct the individual object list strings.
+      std::vector<std::string> object_strings;
+      this->WriteObjectsStrings(object_strings, archiveCommandLimit);
 
-    // Create the archive with the first set of objects.
-    std::vector<std::string>::iterator osi = object_strings.begin();
-    {
-    vars.Objects = osi->c_str();
-    for(std::vector<std::string>::const_iterator
-          i = archiveCreateCommands.begin();
-        i != archiveCreateCommands.end(); ++i)
+      // Create the archive with the first set of objects.
+      std::vector<std::string>::iterator osi = object_strings.begin();
       {
-      std::string cmd = *i;
-      this->LocalGenerator->ExpandRuleVariables(cmd, vars);
-      real_link_commands.push_back(cmd);
+        vars.Objects = osi->c_str();
+        for (std::vector<std::string>::const_iterator i =
+               archiveCreateCommands.begin();
+             i != archiveCreateCommands.end(); ++i) {
+          std::string cmd = *i;
+          this->LocalGenerator->ExpandRuleVariables(cmd, vars);
+          real_link_commands.push_back(cmd);
+        }
       }
-    }
-    // Append to the archive with the other object sets.
-    for(++osi; osi != object_strings.end(); ++osi)
-      {
-      vars.Objects = osi->c_str();
-      for(std::vector<std::string>::const_iterator
-            i = archiveAppendCommands.begin();
-          i != archiveAppendCommands.end(); ++i)
-        {
+      // Append to the archive with the other object sets.
+      for (++osi; osi != object_strings.end(); ++osi) {
+        vars.Objects = osi->c_str();
+        for (std::vector<std::string>::const_iterator i =
+               archiveAppendCommands.begin();
+             i != archiveAppendCommands.end(); ++i) {
+          std::string cmd = *i;
+          this->LocalGenerator->ExpandRuleVariables(cmd, vars);
+          real_link_commands.push_back(cmd);
+        }
+      }
+      // Finish the archive.
+      vars.Objects = "";
+      for (std::vector<std::string>::const_iterator i =
+             archiveFinishCommands.begin();
+           i != archiveFinishCommands.end(); ++i) {
         std::string cmd = *i;
         this->LocalGenerator->ExpandRuleVariables(cmd, vars);
         real_link_commands.push_back(cmd);
-        }
-      }
-    // Finish the archive.
-    vars.Objects = "";
-    for(std::vector<std::string>::const_iterator
-          i = archiveFinishCommands.begin();
-        i != archiveFinishCommands.end(); ++i)
-      {
-      std::string cmd = *i;
-      this->LocalGenerator->ExpandRuleVariables(cmd, vars);
-      real_link_commands.push_back(cmd);
       }
-    }
-  else
-    {
-    // Get the set of commands.
-    std::string linkRule = this->GetLinkRule(linkRuleVar);
-    cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
-
-    // Expand placeholders.
-    for(std::vector<std::string>::iterator i = real_link_commands.begin();
-        i != real_link_commands.end(); ++i)
-      {
-      this->LocalGenerator->ExpandRuleVariables(*i, vars);
+    } else {
+      // Get the set of commands.
+      std::string linkRule = this->GetLinkRule(linkRuleVar);
+      cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
+
+      // Expand placeholders.
+      for (std::vector<std::string>::iterator i = real_link_commands.begin();
+           i != real_link_commands.end(); ++i) {
+        this->LocalGenerator->ExpandRuleVariables(*i, vars);
       }
     }
-  this->LocalGenerator->TargetImplib = "";
+    this->LocalGenerator->TargetImplib = "";
 
-  // Restore path conversion to normal shells.
-  this->LocalGenerator->SetLinkScriptShell(false);
+    // Restore path conversion to normal shells.
+    this->LocalGenerator->SetLinkScriptShell(false);
   }
 
   // Optionally convert the build rule to use a script to avoid long
   // command lines in the make shell.
-  if(useLinkScript)
-    {
+  if (useLinkScript) {
     // Use a link script.
-    const char* name = (relink? "relink.txt" : "link.txt");
+    const char* name = (relink ? "relink.txt" : "link.txt");
     this->CreateLinkScript(name, real_link_commands, commands1, depends);
-    }
-  else
-    {
+  } else {
     // No link script.  Just use the link rule directly.
     commands1 = real_link_commands;
-    }
-  this->LocalGenerator->CreateCDCommand
-    (commands1,
-     this->Makefile->GetCurrentBinaryDirectory(),
-     cmLocalGenerator::HOME_OUTPUT);
+  }
+  this->LocalGenerator->CreateCDCommand(
+    commands1, this->Makefile->GetCurrentBinaryDirectory(),
+    cmLocalGenerator::HOME_OUTPUT);
   commands.insert(commands.end(), commands1.begin(), commands1.end());
   commands1.clear();
 
   // Add a rule to create necessary symlinks for the library.
   // Frameworks are handled by cmOSXBundleGenerator.
-  if(targetOutPath != targetOutPathReal
-     && !this->GeneratorTarget->IsFrameworkOnApple())
-    {
+  if (targetOutPath != targetOutPathReal &&
+      !this->GeneratorTarget->IsFrameworkOnApple()) {
     std::string symlink = "$(CMAKE_COMMAND) -E cmake_symlink_library ";
     symlink += targetOutPathReal;
     symlink += " ";
@@ -794,41 +722,36 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     symlink += " ";
     symlink += targetOutPath;
     commands1.push_back(symlink);
-    this->LocalGenerator->CreateCDCommand(commands1,
-                                  this->Makefile->GetCurrentBinaryDirectory(),
-                                  cmLocalGenerator::HOME_OUTPUT);
+    this->LocalGenerator->CreateCDCommand(
+      commands1, this->Makefile->GetCurrentBinaryDirectory(),
+      cmLocalGenerator::HOME_OUTPUT);
     commands.insert(commands.end(), commands1.begin(), commands1.end());
     commands1.clear();
-    }
+  }
   // Add the post-build rules when building but not when relinking.
-  if(!relink)
-    {
-    this->LocalGenerator->
-      AppendCustomCommands(commands,
-                       this->GeneratorTarget->GetPostBuildCommands(),
-                       this->GeneratorTarget);
-    }
+  if (!relink) {
+    this->LocalGenerator->AppendCustomCommands(
+      commands, this->GeneratorTarget->GetPostBuildCommands(),
+      this->GeneratorTarget);
+  }
 
   // Compute the list of outputs.
   std::vector<std::string> outputs(1, targetFullPathReal);
-  if(targetNameSO != targetNameReal)
-    {
+  if (targetNameSO != targetNameReal) {
     outputs.push_back(targetFullPathSO);
-    }
-  if(targetName != targetNameSO &&
-     targetName != targetNameReal)
-    {
+  }
+  if (targetName != targetNameSO && targetName != targetNameReal) {
     outputs.push_back(targetFullPath);
-    }
+  }
 
   // Write the build rule.
-  this->WriteMakeRule(*this->BuildFileStream, 0, outputs,
-                      depends, commands, false);
+  this->WriteMakeRule(*this->BuildFileStream, 0, outputs, depends, commands,
+                      false);
 
   // Write the main driver rule to build everything in this target.
   this->WriteTargetDriverRule(targetFullPath, relink);
 
   // Clean all the possible library names and symlinks.
-  this->CleanFiles.insert(this->CleanFiles.end(),
-                          libCleanFiles.begin(),libCleanFiles.end());
+  this->CleanFiles.insert(this->CleanFiles.end(), libCleanFiles.begin(),
+                          libCleanFiles.end());
 }
diff --git a/Source/cmMakefileLibraryTargetGenerator.h b/Source/cmMakefileLibraryTargetGenerator.h
index 009f15d..f72dbd7 100644
--- a/Source/cmMakefileLibraryTargetGenerator.h
+++ b/Source/cmMakefileLibraryTargetGenerator.h
@@ -14,8 +14,7 @@
 
 #include "cmMakefileTargetGenerator.h"
 
-class cmMakefileLibraryTargetGenerator:
-  public cmMakefileTargetGenerator
+class cmMakefileLibraryTargetGenerator : public cmMakefileTargetGenerator
 {
 public:
   cmMakefileLibraryTargetGenerator(cmGeneratorTarget* target);
@@ -31,8 +30,7 @@ protected:
   void WriteSharedLibraryRules(bool relink);
   void WriteModuleLibraryRules(bool relink);
   void WriteLibraryRules(const std::string& linkRule,
-                         const std::string& extraFlags,
-                         bool relink);
+                         const std::string& extraFlags, bool relink);
   // MacOSX Framework support methods
   void WriteFrameworkRules(bool relink);
 
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index bd06298..e480140 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -42,16 +42,14 @@ cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target)
   this->CustomCommandDriver = OnBuild;
   this->LocalGenerator =
     static_cast<cmLocalUnixMakefileGenerator3*>(target->GetLocalGenerator());
-  this->GlobalGenerator =
-    static_cast<cmGlobalUnixMakefileGenerator3*>(
-      this->LocalGenerator->GetGlobalGenerator());
+  this->GlobalGenerator = static_cast<cmGlobalUnixMakefileGenerator3*>(
+    this->LocalGenerator->GetGlobalGenerator());
   cmake* cm = this->GlobalGenerator->GetCMakeInstance();
   this->NoRuleMessages = false;
-  if(const char* ruleStatus = cm->GetState()
-                                ->GetGlobalProperty("RULE_MESSAGES"))
-    {
+  if (const char* ruleStatus =
+        cm->GetState()->GetGlobalProperty("RULE_MESSAGES")) {
     this->NoRuleMessages = cmSystemTools::IsOff(ruleStatus);
-    }
+  }
   MacOSXContentGenerator = new MacOSXContentGeneratorType(this);
 }
 
@@ -60,13 +58,12 @@ cmMakefileTargetGenerator::~cmMakefileTargetGenerator()
   delete MacOSXContentGenerator;
 }
 
-cmMakefileTargetGenerator *
-cmMakefileTargetGenerator::New(cmGeneratorTarget *tgt)
+cmMakefileTargetGenerator* cmMakefileTargetGenerator::New(
+  cmGeneratorTarget* tgt)
 {
-  cmMakefileTargetGenerator *result = 0;
+  cmMakefileTargetGenerator* result = 0;
 
-  switch (tgt->GetType())
-    {
+  switch (tgt->GetType()) {
     case cmState::EXECUTABLE:
       result = new cmMakefileExecutableTargetGenerator(tgt);
       break;
@@ -82,7 +79,7 @@ cmMakefileTargetGenerator::New(cmGeneratorTarget *tgt)
     default:
       return result;
       // break; /* unreachable */
-    }
+  }
   return result;
 }
 
@@ -113,19 +110,17 @@ void cmMakefileTargetGenerator::CreateRuleFile()
   this->BuildFileStream =
     new cmGeneratedFileStream(this->BuildFileNameFull.c_str());
   this->BuildFileStream->SetCopyIfDifferent(true);
-  if(!this->BuildFileStream)
-    {
+  if (!this->BuildFileStream) {
     return;
-    }
+  }
   this->LocalGenerator->WriteDisclaimer(*this->BuildFileStream);
-  if (this->GlobalGenerator->AllowDeleteOnError())
-    {
+  if (this->GlobalGenerator->AllowDeleteOnError()) {
     std::vector<std::string> no_depends;
     std::vector<std::string> no_commands;
     this->LocalGenerator->WriteMakeRule(
       *this->BuildFileStream, "Delete rule output on recipe failure.",
       ".DELETE_ON_ERROR", no_depends, no_commands, false);
-    }
+  }
   this->LocalGenerator->WriteSpecialTargetsTop(*this->BuildFileStream);
 }
 
@@ -136,84 +131,71 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
 
   // write the custom commands for this target
   // Look for files registered for cleaning in this directory.
-  if(const char* additional_clean_files =
-     this->Makefile->GetProperty
-     ("ADDITIONAL_MAKE_CLEAN_FILES"))
-    {
+  if (const char* additional_clean_files =
+        this->Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES")) {
     cmGeneratorExpression ge;
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
-                                            ge.Parse(additional_clean_files);
-
-    cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator,
-                                                    config,
-                                                    false,
-                                                    this->GeneratorTarget,
-                                                    0, 0),
-                                      this->CleanFiles);
-    }
+      ge.Parse(additional_clean_files);
+
+    cmSystemTools::ExpandListArgument(
+      cge->Evaluate(this->LocalGenerator, config, false, this->GeneratorTarget,
+                    0, 0),
+      this->CleanFiles);
+  }
 
   // add custom commands to the clean rules?
-  const char* clean_no_custom =
-    this->Makefile->GetProperty("CLEAN_NO_CUSTOM");
+  const char* clean_no_custom = this->Makefile->GetProperty("CLEAN_NO_CUSTOM");
   bool clean = cmSystemTools::IsOff(clean_no_custom);
 
   // First generate the object rule files.  Save a list of all object
   // files for this target.
   std::vector<cmSourceFile const*> customCommands;
   this->GeneratorTarget->GetCustomCommands(customCommands, config);
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = customCommands.begin();
-      si != customCommands.end(); ++si)
-    {
-    cmCustomCommandGenerator ccg(*(*si)->GetCustomCommand(),
-                                 this->ConfigName,
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         customCommands.begin();
+       si != customCommands.end(); ++si) {
+    cmCustomCommandGenerator ccg(*(*si)->GetCustomCommand(), this->ConfigName,
                                  this->LocalGenerator);
     this->GenerateCustomRuleFile(ccg);
-    if (clean)
-      {
+    if (clean) {
       const std::vector<std::string>& outputs = ccg.GetOutputs();
-      for(std::vector<std::string>::const_iterator o = outputs.begin();
-          o != outputs.end(); ++o)
-        {
-        this->CleanFiles.push_back
-          (this->Convert(*o,
-                         cmLocalGenerator::START_OUTPUT,
-                         cmLocalGenerator::UNCHANGED));
-        }
+      for (std::vector<std::string>::const_iterator o = outputs.begin();
+           o != outputs.end(); ++o) {
+        this->CleanFiles.push_back(this->Convert(
+          *o, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::UNCHANGED));
       }
     }
+  }
   std::vector<cmSourceFile const*> headerSources;
   this->GeneratorTarget->GetHeaderSources(headerSources, config);
   this->OSXBundleGenerator->GenerateMacOSXContentStatements(
-    headerSources,
-    this->MacOSXContentGenerator);
+    headerSources, this->MacOSXContentGenerator);
   std::vector<cmSourceFile const*> extraSources;
   this->GeneratorTarget->GetExtraSources(extraSources, config);
   this->OSXBundleGenerator->GenerateMacOSXContentStatements(
-    extraSources,
-    this->MacOSXContentGenerator);
+    extraSources, this->MacOSXContentGenerator);
   std::vector<cmSourceFile const*> externalObjects;
   this->GeneratorTarget->GetExternalObjects(externalObjects, config);
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = externalObjects.begin();
-      si != externalObjects.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         externalObjects.begin();
+       si != externalObjects.end(); ++si) {
     this->ExternalObjects.push_back((*si)->GetFullPath());
-    }
+  }
   std::vector<cmSourceFile const*> objectSources;
   this->GeneratorTarget->GetObjectSources(objectSources, config);
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = objectSources.begin(); si != objectSources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         objectSources.begin();
+       si != objectSources.end(); ++si) {
     // Generate this object file's rule file.
     this->WriteObjectRuleFiles(**si);
-    }
+  }
 }
 
 void cmMakefileTargetGenerator::WriteCommonCodeRules()
 {
-  const char* root = (this->Makefile->IsOn("CMAKE_MAKE_INCLUDE_FROM_ROOT")?
-                      "$(CMAKE_BINARY_DIR)/" : "");
+  const char* root = (this->Makefile->IsOn("CMAKE_MAKE_INCLUDE_FROM_ROOT")
+                        ? "$(CMAKE_BINARY_DIR)/"
+                        : "");
 
   // Include the dependencies for the target.
   std::string dependFileNameFull = this->TargetBuildDirectoryFull;
@@ -221,13 +203,11 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
   *this->BuildFileStream
     << "# Include any dependencies generated for this target.\n"
     << this->GlobalGenerator->IncludeDirective << " " << root
-    << this->Convert(dependFileNameFull,
-                     cmLocalGenerator::HOME_OUTPUT,
+    << this->Convert(dependFileNameFull, cmLocalGenerator::HOME_OUTPUT,
                      cmLocalGenerator::MAKERULE)
     << "\n\n";
 
-  if(!this->NoRuleMessages)
-    {
+  if (!this->NoRuleMessages) {
     // Include the progress variables for the target.
     *this->BuildFileStream
       << "# Include the progress variables for this target.\n"
@@ -236,18 +216,17 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
                        cmLocalGenerator::HOME_OUTPUT,
                        cmLocalGenerator::MAKERULE)
       << "\n\n";
-    }
+  }
 
   // make sure the depend file exists
-  if (!cmSystemTools::FileExists(dependFileNameFull.c_str()))
-    {
+  if (!cmSystemTools::FileExists(dependFileNameFull.c_str())) {
     // Write an empty dependency file.
     cmGeneratedFileStream depFileStream(dependFileNameFull.c_str());
-    depFileStream
-      << "# Empty dependencies file for "
-      << this->GeneratorTarget->GetName() << ".\n"
-      << "# This may be replaced when dependencies are built." << std::endl;
-    }
+    depFileStream << "# Empty dependencies file for "
+                  << this->GeneratorTarget->GetName() << ".\n"
+                  << "# This may be replaced when dependencies are built."
+                  << std::endl;
+  }
 
   // Open the flags file.  This should be copy-if-different because the
   // rules may depend on this file itself.
@@ -256,19 +235,17 @@ void cmMakefileTargetGenerator::WriteCommonCodeRules()
   this->FlagFileStream =
     new cmGeneratedFileStream(this->FlagFileNameFull.c_str());
   this->FlagFileStream->SetCopyIfDifferent(true);
-  if(!this->FlagFileStream)
-    {
+  if (!this->FlagFileStream) {
     return;
-    }
+  }
   this->LocalGenerator->WriteDisclaimer(*this->FlagFileStream);
 
   // Include the flags for the target.
   *this->BuildFileStream
     << "# Include the compile flags for this target's objects.\n"
     << this->GlobalGenerator->IncludeDirective << " " << root
-    << this->Convert(this->FlagFileNameFull,
-                                     cmLocalGenerator::HOME_OUTPUT,
-                                     cmLocalGenerator::MAKERULE)
+    << this->Convert(this->FlagFileNameFull, cmLocalGenerator::HOME_OUTPUT,
+                     cmLocalGenerator::MAKERULE)
     << "\n\n";
 }
 
@@ -276,23 +253,22 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
 {
   // write language flags for target
   std::set<std::string> languages;
-  this->GeneratorTarget->GetLanguages(languages,
-                      this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+  this->GeneratorTarget->GetLanguages(
+    languages, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
   // put the compiler in the rules.make file so that if it changes
   // things rebuild
-  for(std::set<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
-    {
+  for (std::set<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
     std::string compiler = "CMAKE_";
     compiler += *l;
     compiler += "_COMPILER";
-    *this->FlagFileStream << "# compile " << *l << " with " <<
-      this->Makefile->GetSafeDefinition(compiler) << "\n";
-    }
+    *this->FlagFileStream << "# compile " << *l << " with "
+                          << this->Makefile->GetSafeDefinition(compiler)
+                          << "\n";
+  }
 
-  for(std::set<std::string>::const_iterator l = languages.begin();
-      l != languages.end(); ++l)
-    {
+  for (std::set<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
     std::string flags = this->GetFlags(*l);
     std::string defines = this->GetDefines(*l);
     std::string includes = this->GetIncludes(*l);
@@ -303,19 +279,16 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
     *this->FlagFileStream << *l << "_FLAGS = " << flags << "\n\n";
     *this->FlagFileStream << *l << "_DEFINES = " << defines << "\n\n";
     *this->FlagFileStream << *l << "_INCLUDES = " << includes << "\n\n";
-    }
+  }
 }
 
-
-void
-cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()
-  (cmSourceFile const& source, const char* pkgloc)
+void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()(
+  cmSourceFile const& source, const char* pkgloc)
 {
   // Skip OS X content when not building a Framework or Bundle.
-  if(!this->Generator->GetGeneratorTarget()->IsBundleOnApple())
-    {
+  if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {
     return;
-    }
+  }
 
   std::string macdir =
     this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc);
@@ -328,10 +301,8 @@ cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()
   output += "/";
   output += cmSystemTools::GetFilenameName(input);
   this->Generator->CleanFiles.push_back(
-    this->Generator->Convert(output,
-                             cmLocalGenerator::START_OUTPUT));
-  output = this->Generator->Convert(output,
-                                    cmLocalGenerator::HOME_OUTPUT);
+    this->Generator->Convert(output, cmLocalGenerator::START_OUTPUT));
+  output = this->Generator->Convert(output, cmLocalGenerator::HOME_OUTPUT);
 
   // Create a rule to copy the content into the bundle.
   std::vector<std::string> depends;
@@ -340,75 +311,64 @@ cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()
   std::string copyEcho = "Copying OS X content ";
   copyEcho += output;
   this->Generator->LocalGenerator->AppendEcho(
-    commands, copyEcho.c_str(),
-    cmLocalUnixMakefileGenerator3::EchoBuild);
+    commands, copyEcho.c_str(), cmLocalUnixMakefileGenerator3::EchoBuild);
   std::string copyCommand = "$(CMAKE_COMMAND) -E copy ";
-  copyCommand += this->Generator->Convert(input,
-                                          cmLocalGenerator::NONE,
+  copyCommand += this->Generator->Convert(input, cmLocalGenerator::NONE,
                                           cmLocalGenerator::SHELL);
   copyCommand += " ";
-  copyCommand += this->Generator->Convert(output,
-                                          cmLocalGenerator::NONE,
+  copyCommand += this->Generator->Convert(output, cmLocalGenerator::NONE,
                                           cmLocalGenerator::SHELL);
   commands.push_back(copyCommand);
   this->Generator->LocalGenerator->WriteMakeRule(
-    *this->Generator->BuildFileStream, 0,
-    output,
-    depends, commands, false);
+    *this->Generator->BuildFileStream, 0, output, depends, commands, false);
   this->Generator->ExtraFiles.insert(output);
 }
 
-void cmMakefileTargetGenerator
-::WriteObjectRuleFiles(cmSourceFile const& source)
+void cmMakefileTargetGenerator::WriteObjectRuleFiles(
+  cmSourceFile const& source)
 {
   // Identify the language of the source file.
   const std::string& lang =
     this->LocalGenerator->GetSourceFileLanguage(source);
-  if(lang.empty())
-    {
+  if (lang.empty()) {
     // don't know anything about this file so skip it
     return;
-    }
+  }
 
   // Get the full path name of the object file.
-  std::string const& objectName = this->GeneratorTarget
-                                      ->GetObjectName(&source);
+  std::string const& objectName =
+    this->GeneratorTarget->GetObjectName(&source);
   std::string obj =
-      this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
+    this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
   obj += "/";
   obj += objectName;
 
   // Avoid generating duplicate rules.
-  if(this->ObjectFiles.find(obj) == this->ObjectFiles.end())
-    {
+  if (this->ObjectFiles.find(obj) == this->ObjectFiles.end()) {
     this->ObjectFiles.insert(obj);
-    }
-  else
-    {
+  } else {
     std::ostringstream err;
-    err << "Warning: Source file \""
-        << source.GetFullPath()
+    err << "Warning: Source file \"" << source.GetFullPath()
         << "\" is listed multiple times for target \""
-        << this->GeneratorTarget->GetName()
-        << "\".";
+        << this->GeneratorTarget->GetName() << "\".";
     cmSystemTools::Message(err.str().c_str(), "Warning");
     return;
-    }
+  }
 
   // Create the directory containing the object file.  This may be a
   // subdirectory under the target's directory.
   std::string dir = cmSystemTools::GetFilenamePath(obj);
-  cmSystemTools::MakeDirectory
-    (this->LocalGenerator->ConvertToFullPath(dir).c_str());
+  cmSystemTools::MakeDirectory(
+    this->LocalGenerator->ConvertToFullPath(dir).c_str());
 
   // Save this in the target's list of object files.
   this->Objects.push_back(obj);
   this->CleanFiles.push_back(obj);
 
   // TODO: Remove
-  //std::string relativeObj
+  // std::string relativeObj
   //= this->LocalGenerator->GetHomeRelativeOutputPath();
-  //relativeObj += obj;
+  // relativeObj += obj;
 
   // we compute some depends when writing the depend.make that we will also
   // use in the build.make, same with depMakeFile
@@ -421,22 +381,16 @@ void cmMakefileTargetGenerator
   std::string objFullPath = this->LocalGenerator->GetCurrentBinaryDirectory();
   objFullPath += "/";
   objFullPath += obj;
-  objFullPath =
-    this->Convert(objFullPath, cmLocalGenerator::FULL);
+  objFullPath = this->Convert(objFullPath, cmLocalGenerator::FULL);
   std::string srcFullPath =
     this->Convert(source.GetFullPath(), cmLocalGenerator::FULL);
-  this->LocalGenerator->
-    AddImplicitDepends(this->GeneratorTarget, lang,
-                       objFullPath.c_str(),
-                       srcFullPath.c_str());
+  this->LocalGenerator->AddImplicitDepends(
+    this->GeneratorTarget, lang, objFullPath.c_str(), srcFullPath.c_str());
 }
 
-void
-cmMakefileTargetGenerator
-::WriteObjectBuildFile(std::string &obj,
-                       const std::string& lang,
-                       cmSourceFile const& source,
-                       std::vector<std::string>& depends)
+void cmMakefileTargetGenerator::WriteObjectBuildFile(
+  std::string& obj, const std::string& lang, cmSourceFile const& source,
+  std::vector<std::string>& depends)
 {
   this->LocalGenerator->AppendRuleDepend(depends,
                                          this->FlagFileNameFull.c_str());
@@ -463,52 +417,43 @@ cmMakefileTargetGenerator
     cmSystemTools::UpperCase(this->LocalGenerator->GetConfigName());
 
   // Add Fortran format flags.
-  if(lang == "Fortran")
-    {
+  if (lang == "Fortran") {
     this->AppendFortranFormatFlags(flags, source);
-    }
+  }
 
   // Add flags from source file properties.
-  if (source.GetProperty("COMPILE_FLAGS"))
-    {
-    this->LocalGenerator->AppendFlags
-      (flags, source.GetProperty("COMPILE_FLAGS"));
-    *this->FlagFileStream << "# Custom flags: "
-                          << relativeObj << "_FLAGS = "
-                          << source.GetProperty("COMPILE_FLAGS")
+  if (source.GetProperty("COMPILE_FLAGS")) {
+    this->LocalGenerator->AppendFlags(flags,
+                                      source.GetProperty("COMPILE_FLAGS"));
+    *this->FlagFileStream << "# Custom flags: " << relativeObj
+                          << "_FLAGS = " << source.GetProperty("COMPILE_FLAGS")
                           << "\n"
                           << "\n";
-    }
+  }
 
   // Add language-specific defines.
   std::set<std::string> defines;
 
   // Add source-sepcific preprocessor definitions.
-  if(const char* compile_defs = source.GetProperty("COMPILE_DEFINITIONS"))
-    {
+  if (const char* compile_defs = source.GetProperty("COMPILE_DEFINITIONS")) {
     this->LocalGenerator->AppendDefines(defines, compile_defs);
-    *this->FlagFileStream << "# Custom defines: "
-                          << relativeObj << "_DEFINES = "
-                          << compile_defs << "\n"
+    *this->FlagFileStream << "# Custom defines: " << relativeObj
+                          << "_DEFINES = " << compile_defs << "\n"
                           << "\n";
-    }
+  }
   std::string defPropName = "COMPILE_DEFINITIONS_";
   defPropName += configUpper;
-  if(const char* config_compile_defs =
-     source.GetProperty(defPropName))
-    {
+  if (const char* config_compile_defs = source.GetProperty(defPropName)) {
     this->LocalGenerator->AppendDefines(defines, config_compile_defs);
-    *this->FlagFileStream
-      << "# Custom defines: "
-      << relativeObj << "_DEFINES_" << configUpper
-      << " = " << config_compile_defs << "\n"
-      << "\n";
-    }
+    *this->FlagFileStream << "# Custom defines: " << relativeObj << "_DEFINES_"
+                          << configUpper << " = " << config_compile_defs
+                          << "\n"
+                          << "\n";
+  }
 
   // Get the output paths for source and object files.
-  std::string sourceFile = this->Convert(source.GetFullPath(),
-                             cmLocalGenerator::NONE,
-                             cmLocalGenerator::SHELL);
+  std::string sourceFile = this->Convert(
+    source.GetFullPath(), cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
 
   // Construct the build message.
   std::vector<std::string> no_commands;
@@ -517,67 +462,60 @@ cmMakefileTargetGenerator
   // add in a progress call if needed
   this->NumberOfProgressActions++;
 
-  if(!this->NoRuleMessages)
-    {
+  if (!this->NoRuleMessages) {
     cmLocalUnixMakefileGenerator3::EchoProgress progress;
     this->MakeEchoProgress(progress);
     std::string buildEcho = "Building ";
     buildEcho += lang;
     buildEcho += " object ";
     buildEcho += relativeObj;
-    this->LocalGenerator->AppendEcho
-      (commands, buildEcho.c_str(), cmLocalUnixMakefileGenerator3::EchoBuild,
-       &progress);
-    }
+    this->LocalGenerator->AppendEcho(commands, buildEcho.c_str(),
+                                     cmLocalUnixMakefileGenerator3::EchoBuild,
+                                     &progress);
+  }
 
   std::string targetOutPathReal;
   std::string targetOutPathPDB;
   std::string targetOutPathCompilePDB;
   {
-  std::string targetFullPathReal;
-  std::string targetFullPathPDB;
-  std::string targetFullPathCompilePDB;
-  if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
-     this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
-     this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
-     this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
-    {
-    targetFullPathReal =
-      this->GeneratorTarget->GetFullPath(this->ConfigName, false, true);
-    targetFullPathPDB =
+    std::string targetFullPathReal;
+    std::string targetFullPathPDB;
+    std::string targetFullPathCompilePDB;
+    if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
+        this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
+        this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
+        this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
+      targetFullPathReal =
+        this->GeneratorTarget->GetFullPath(this->ConfigName, false, true);
+      targetFullPathPDB =
         this->GeneratorTarget->GetPDBDirectory(this->ConfigName);
-    targetFullPathPDB += "/";
-    targetFullPathPDB += this->GeneratorTarget->GetPDBName(this->ConfigName);
+      targetFullPathPDB += "/";
+      targetFullPathPDB += this->GeneratorTarget->GetPDBName(this->ConfigName);
     }
-  if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
-    {
-    targetFullPathCompilePDB =
-      this->GeneratorTarget->GetCompilePDBPath(this->ConfigName);
-    if(targetFullPathCompilePDB.empty())
-      {
+    if (this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) {
       targetFullPathCompilePDB =
+        this->GeneratorTarget->GetCompilePDBPath(this->ConfigName);
+      if (targetFullPathCompilePDB.empty()) {
+        targetFullPathCompilePDB =
           this->GeneratorTarget->GetSupportDirectory() + "/";
       }
     }
 
-  targetOutPathReal = this->Convert(targetFullPathReal,
-                                    cmLocalGenerator::START_OUTPUT,
-                                    cmLocalGenerator::SHELL);
-  targetOutPathPDB =
-    this->Convert(targetFullPathPDB,cmLocalGenerator::NONE,
-                  cmLocalGenerator::SHELL);
-  targetOutPathCompilePDB =
-    this->Convert(targetFullPathCompilePDB,
-                  cmLocalGenerator::START_OUTPUT,
-                  cmLocalGenerator::SHELL);
-
-  if (this->LocalGenerator->IsMinGWMake() &&
-      cmHasLiteralSuffix(targetOutPathCompilePDB, "\\"))
-    {
-    // mingw32-make incorrectly interprets 'a\ b c' as 'a b' and 'c'
-    // (but 'a\ b "c"' as 'a\', 'b', and 'c'!).  Workaround this by
-    // avoiding a trailing backslash in the argument.
-    targetOutPathCompilePDB[targetOutPathCompilePDB.size()-1] = '/';
+    targetOutPathReal =
+      this->Convert(targetFullPathReal, cmLocalGenerator::START_OUTPUT,
+                    cmLocalGenerator::SHELL);
+    targetOutPathPDB = this->Convert(targetFullPathPDB, cmLocalGenerator::NONE,
+                                     cmLocalGenerator::SHELL);
+    targetOutPathCompilePDB =
+      this->Convert(targetFullPathCompilePDB, cmLocalGenerator::START_OUTPUT,
+                    cmLocalGenerator::SHELL);
+
+    if (this->LocalGenerator->IsMinGWMake() &&
+        cmHasLiteralSuffix(targetOutPathCompilePDB, "\\")) {
+      // mingw32-make incorrectly interprets 'a\ b c' as 'a b' and 'c'
+      // (but 'a\ b "c"' as 'a\', 'b', and 'c'!).  Workaround this by
+      // avoiding a trailing backslash in the argument.
+      targetOutPathCompilePDB[targetOutPathCompilePDB.size() - 1] = '/';
     }
   }
   cmLocalGenerator::RuleVariables vars;
@@ -589,18 +527,14 @@ cmMakefileTargetGenerator
   vars.TargetCompilePDB = targetOutPathCompilePDB.c_str();
   vars.Source = sourceFile.c_str();
   std::string shellObj =
-    this->Convert(obj,
-                  cmLocalGenerator::NONE,
-                  cmLocalGenerator::SHELL);
+    this->Convert(obj, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
   vars.Object = shellObj.c_str();
   std::string objectDir = this->GeneratorTarget->GetSupportDirectory();
-  objectDir = this->Convert(objectDir,
-                            cmLocalGenerator::START_OUTPUT,
+  objectDir = this->Convert(objectDir, cmLocalGenerator::START_OUTPUT,
                             cmLocalGenerator::SHELL);
   vars.ObjectDir = objectDir.c_str();
   std::string objectFileDir = cmSystemTools::GetFilenamePath(obj);
-  objectFileDir = this->Convert(objectFileDir,
-                                cmLocalGenerator::START_OUTPUT,
+  objectFileDir = this->Convert(objectFileDir, cmLocalGenerator::START_OUTPUT,
                                 cmLocalGenerator::SHELL);
   vars.ObjectFileDir = objectFileDir.c_str();
   vars.Flags = flags.c_str();
@@ -619,126 +553,112 @@ cmMakefileTargetGenerator
   // At the moment, it is assumed that C, C++, and Fortran have both
   // assembly and preprocessor capabilities. The same is true for the
   // ability to export compile commands
-  bool lang_has_preprocessor = ((lang == "C") ||
-                                (lang == "CXX") ||
-                                (lang == "Fortran"));
+  bool lang_has_preprocessor =
+    ((lang == "C") || (lang == "CXX") || (lang == "Fortran"));
   bool const lang_has_assembly = lang_has_preprocessor;
   bool const lang_can_export_cmds = lang_has_preprocessor;
 
   // Construct the compile rules.
   {
-  std::string compileRuleVar = "CMAKE_";
-  compileRuleVar += lang;
-  compileRuleVar += "_COMPILE_OBJECT";
-  std::string compileRule =
-    this->Makefile->GetRequiredDefinition(compileRuleVar);
-  std::vector<std::string> compileCommands;
-  cmSystemTools::ExpandListArgument(compileRule, compileCommands);
-
-  if (this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS") &&
-      lang_can_export_cmds && compileCommands.size() == 1)
-    {
-    std::string compileCommand = compileCommands[0];
-    this->LocalGenerator->ExpandRuleVariables(compileCommand, vars);
-    std::string workingDirectory =
-      this->LocalGenerator->Convert(
+    std::string compileRuleVar = "CMAKE_";
+    compileRuleVar += lang;
+    compileRuleVar += "_COMPILE_OBJECT";
+    std::string compileRule =
+      this->Makefile->GetRequiredDefinition(compileRuleVar);
+    std::vector<std::string> compileCommands;
+    cmSystemTools::ExpandListArgument(compileRule, compileCommands);
+
+    if (this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS") &&
+        lang_can_export_cmds && compileCommands.size() == 1) {
+      std::string compileCommand = compileCommands[0];
+      this->LocalGenerator->ExpandRuleVariables(compileCommand, vars);
+      std::string workingDirectory = this->LocalGenerator->Convert(
         this->LocalGenerator->GetCurrentBinaryDirectory(),
-                                    cmLocalGenerator::FULL);
-    compileCommand.replace(compileCommand.find(langFlags),
-                           langFlags.size(), this->GetFlags(lang));
-    std::string langDefines = std::string("$(") + lang + "_DEFINES)";
-    compileCommand.replace(compileCommand.find(langDefines),
-                           langDefines.size(), this->GetDefines(lang));
-    std::string langIncludes = std::string("$(") + lang + "_INCLUDES)";
-    compileCommand.replace(compileCommand.find(langIncludes),
-                           langIncludes.size(), this->GetIncludes(lang));
-    this->GlobalGenerator->AddCXXCompileCommand(
-      source.GetFullPath(), workingDirectory, compileCommand);
-    }
-
-  // Maybe insert an include-what-you-use runner.
-  if (!compileCommands.empty() && (lang == "C" || lang == "CXX"))
-    {
-    std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
-    const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
-    std::string const tidy_prop = lang + "_CLANG_TIDY";
-    const char *tidy = this->GeneratorTarget->GetProperty(tidy_prop);
-    if ((iwyu && *iwyu) || (tidy && *tidy))
-      {
-      std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_iwyu";
-      if (iwyu && *iwyu)
-        {
-        run_iwyu += " --iwyu=";
-        run_iwyu += this->LocalGenerator->EscapeForShell(iwyu);
+        cmLocalGenerator::FULL);
+      compileCommand.replace(compileCommand.find(langFlags), langFlags.size(),
+                             this->GetFlags(lang));
+      std::string langDefines = std::string("$(") + lang + "_DEFINES)";
+      compileCommand.replace(compileCommand.find(langDefines),
+                             langDefines.size(), this->GetDefines(lang));
+      std::string langIncludes = std::string("$(") + lang + "_INCLUDES)";
+      compileCommand.replace(compileCommand.find(langIncludes),
+                             langIncludes.size(), this->GetIncludes(lang));
+      this->GlobalGenerator->AddCXXCompileCommand(
+        source.GetFullPath(), workingDirectory, compileCommand);
+    }
+
+    // Maybe insert an include-what-you-use runner.
+    if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) {
+      std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
+      const char* iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
+      std::string const tidy_prop = lang + "_CLANG_TIDY";
+      const char* tidy = this->GeneratorTarget->GetProperty(tidy_prop);
+      if ((iwyu && *iwyu) || (tidy && *tidy)) {
+        std::string run_iwyu = "$(CMAKE_COMMAND) -E __run_iwyu";
+        if (iwyu && *iwyu) {
+          run_iwyu += " --iwyu=";
+          run_iwyu += this->LocalGenerator->EscapeForShell(iwyu);
         }
-      if (tidy && *tidy)
-        {
-        run_iwyu += " --tidy=";
-        run_iwyu += this->LocalGenerator->EscapeForShell(tidy);
-        run_iwyu += " --source=";
-        run_iwyu += sourceFile;
+        if (tidy && *tidy) {
+          run_iwyu += " --tidy=";
+          run_iwyu += this->LocalGenerator->EscapeForShell(tidy);
+          run_iwyu += " --source=";
+          run_iwyu += sourceFile;
         }
-      run_iwyu += " -- ";
-      compileCommands.front().insert(0, run_iwyu);
+        run_iwyu += " -- ";
+        compileCommands.front().insert(0, run_iwyu);
       }
     }
 
-  // Maybe insert a compiler launcher like ccache or distcc
-  if (!compileCommands.empty() && (lang == "C" || lang == "CXX"))
-    {
-    std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
-    const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
-    if (clauncher && *clauncher)
-      {
-      std::vector<std::string> launcher_cmd;
-      cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
-      for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
-             e = launcher_cmd.end(); i != e; ++i)
-        {
-        *i = this->LocalGenerator->EscapeForShell(*i);
+    // Maybe insert a compiler launcher like ccache or distcc
+    if (!compileCommands.empty() && (lang == "C" || lang == "CXX")) {
+      std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
+      const char* clauncher =
+        this->GeneratorTarget->GetProperty(clauncher_prop);
+      if (clauncher && *clauncher) {
+        std::vector<std::string> launcher_cmd;
+        cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
+        for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
+                                                e = launcher_cmd.end();
+             i != e; ++i) {
+          *i = this->LocalGenerator->EscapeForShell(*i);
         }
-      std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
-      compileCommands.front().insert(0, run_launcher);
+        std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
+        compileCommands.front().insert(0, run_launcher);
       }
     }
 
-  // Expand placeholders in the commands.
-  for(std::vector<std::string>::iterator i = compileCommands.begin();
-      i != compileCommands.end(); ++i)
-    {
-    this->LocalGenerator->ExpandRuleVariables(*i, vars);
+    // Expand placeholders in the commands.
+    for (std::vector<std::string>::iterator i = compileCommands.begin();
+         i != compileCommands.end(); ++i) {
+      this->LocalGenerator->ExpandRuleVariables(*i, vars);
     }
 
-  // Change the command working directory to the local build tree.
-  this->LocalGenerator->CreateCDCommand
-    (compileCommands,
-     this->LocalGenerator->GetCurrentBinaryDirectory(),
-     cmLocalGenerator::HOME_OUTPUT);
-  commands.insert(commands.end(),
-                  compileCommands.begin(), compileCommands.end());
+    // Change the command working directory to the local build tree.
+    this->LocalGenerator->CreateCDCommand(
+      compileCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
+      cmLocalGenerator::HOME_OUTPUT);
+    commands.insert(commands.end(), compileCommands.begin(),
+                    compileCommands.end());
   }
 
   // Check for extra outputs created by the compilation.
   std::vector<std::string> outputs(1, relativeObj);
-  if(const char* extra_outputs_str =
-     source.GetProperty("OBJECT_OUTPUTS"))
-    {
+  if (const char* extra_outputs_str = source.GetProperty("OBJECT_OUTPUTS")) {
     // Register these as extra files to clean.
     cmSystemTools::ExpandListArgument(extra_outputs_str, outputs);
-    this->CleanFiles.insert(this->CleanFiles.end(),
-                            outputs.begin() + 1, outputs.end());
-    }
+    this->CleanFiles.insert(this->CleanFiles.end(), outputs.begin() + 1,
+                            outputs.end());
+  }
 
   // Write the rule.
-  this->WriteMakeRule(*this->BuildFileStream, 0, outputs,
-                      depends, commands);
+  this->WriteMakeRule(*this->BuildFileStream, 0, outputs, depends, commands);
 
   bool do_preprocess_rules = lang_has_preprocessor &&
     this->LocalGenerator->GetCreatePreprocessedSourceRules();
-  bool do_assembly_rules = lang_has_assembly &&
-    this->LocalGenerator->GetCreateAssemblySourceRules();
-  if(do_preprocess_rules || do_assembly_rules)
-    {
+  bool do_assembly_rules =
+    lang_has_assembly && this->LocalGenerator->GetCreateAssemblySourceRules();
+  if (do_preprocess_rules || do_assembly_rules) {
     std::vector<std::string> force_depends;
     force_depends.push_back("cmake_force");
     std::string::size_type dot_pos = relativeObj.rfind(".");
@@ -746,8 +666,7 @@ cmMakefileTargetGenerator
     dot_pos = obj.rfind(".");
     std::string objBase = obj.substr(0, dot_pos);
 
-    if(do_preprocess_rules)
-      {
+    if (do_preprocess_rules) {
       commands.clear();
       std::string relativeObjI = relativeObjBase + ".i";
       std::string objI = objBase + ".i";
@@ -758,53 +677,44 @@ cmMakefileTargetGenerator
       preprocessEcho += objI;
       this->LocalGenerator->AppendEcho(
         commands, preprocessEcho.c_str(),
-        cmLocalUnixMakefileGenerator3::EchoBuild
-        );
+        cmLocalUnixMakefileGenerator3::EchoBuild);
 
       std::string preprocessRuleVar = "CMAKE_";
       preprocessRuleVar += lang;
       preprocessRuleVar += "_CREATE_PREPROCESSED_SOURCE";
-      if(const char* preprocessRule =
-         this->Makefile->GetDefinition(preprocessRuleVar))
-        {
+      if (const char* preprocessRule =
+            this->Makefile->GetDefinition(preprocessRuleVar)) {
         std::vector<std::string> preprocessCommands;
         cmSystemTools::ExpandListArgument(preprocessRule, preprocessCommands);
 
         std::string shellObjI =
-          this->Convert(objI,
-                        cmLocalGenerator::NONE,
-                        cmLocalGenerator::SHELL);
+          this->Convert(objI, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
         vars.PreprocessedSource = shellObjI.c_str();
 
         // Expand placeholders in the commands.
-        for(std::vector<std::string>::iterator i = preprocessCommands.begin();
-            i != preprocessCommands.end(); ++i)
-          {
+        for (std::vector<std::string>::iterator i = preprocessCommands.begin();
+             i != preprocessCommands.end(); ++i) {
           this->LocalGenerator->ExpandRuleVariables(*i, vars);
-          }
-
-        this->LocalGenerator->CreateCDCommand
-          (preprocessCommands,
-           this->LocalGenerator->GetCurrentBinaryDirectory(),
-           cmLocalGenerator::HOME_OUTPUT);
-        commands.insert(commands.end(),
-                        preprocessCommands.begin(),
-                        preprocessCommands.end());
         }
-      else
-        {
+
+        this->LocalGenerator->CreateCDCommand(
+          preprocessCommands,
+          this->LocalGenerator->GetCurrentBinaryDirectory(),
+          cmLocalGenerator::HOME_OUTPUT);
+        commands.insert(commands.end(), preprocessCommands.begin(),
+                        preprocessCommands.end());
+      } else {
         std::string cmd = "$(CMAKE_COMMAND) -E cmake_unimplemented_variable ";
         cmd += preprocessRuleVar;
         commands.push_back(cmd);
-        }
+      }
 
       this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                          relativeObjI,
-                                          force_depends, commands, false);
-      }
+                                          relativeObjI, force_depends,
+                                          commands, false);
+    }
 
-    if(do_assembly_rules)
-      {
+    if (do_assembly_rules) {
       commands.clear();
       std::string relativeObjS = relativeObjBase + ".s";
       std::string objS = objBase + ".s";
@@ -815,51 +725,42 @@ cmMakefileTargetGenerator
       assemblyEcho += objS;
       this->LocalGenerator->AppendEcho(
         commands, assemblyEcho.c_str(),
-        cmLocalUnixMakefileGenerator3::EchoBuild
-        );
+        cmLocalUnixMakefileGenerator3::EchoBuild);
 
       std::string assemblyRuleVar = "CMAKE_";
       assemblyRuleVar += lang;
       assemblyRuleVar += "_CREATE_ASSEMBLY_SOURCE";
-      if(const char* assemblyRule =
-         this->Makefile->GetDefinition(assemblyRuleVar))
-        {
+      if (const char* assemblyRule =
+            this->Makefile->GetDefinition(assemblyRuleVar)) {
         std::vector<std::string> assemblyCommands;
         cmSystemTools::ExpandListArgument(assemblyRule, assemblyCommands);
 
         std::string shellObjS =
-          this->Convert(objS,
-                        cmLocalGenerator::NONE,
-                        cmLocalGenerator::SHELL);
+          this->Convert(objS, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
         vars.AssemblySource = shellObjS.c_str();
 
         // Expand placeholders in the commands.
-        for(std::vector<std::string>::iterator i = assemblyCommands.begin();
-            i != assemblyCommands.end(); ++i)
-          {
+        for (std::vector<std::string>::iterator i = assemblyCommands.begin();
+             i != assemblyCommands.end(); ++i) {
           this->LocalGenerator->ExpandRuleVariables(*i, vars);
-          }
-
-        this->LocalGenerator->CreateCDCommand
-          (assemblyCommands,
-           this->LocalGenerator->GetCurrentBinaryDirectory(),
-           cmLocalGenerator::HOME_OUTPUT);
-        commands.insert(commands.end(),
-                        assemblyCommands.begin(),
-                        assemblyCommands.end());
         }
-      else
-        {
+
+        this->LocalGenerator->CreateCDCommand(
+          assemblyCommands, this->LocalGenerator->GetCurrentBinaryDirectory(),
+          cmLocalGenerator::HOME_OUTPUT);
+        commands.insert(commands.end(), assemblyCommands.begin(),
+                        assemblyCommands.end());
+      } else {
         std::string cmd = "$(CMAKE_COMMAND) -E cmake_unimplemented_variable ";
         cmd += assemblyRuleVar;
         commands.push_back(cmd);
-        }
+      }
 
       this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                          relativeObjS,
-                                          force_depends, commands, false);
-      }
+                                          relativeObjS, force_depends,
+                                          commands, false);
     }
+  }
 
   // If the language needs provides-requires mode, create the
   // corresponding targets.
@@ -867,9 +768,8 @@ cmMakefileTargetGenerator
   objectRequires += ".requires";
   std::vector<std::string> p_depends;
   // always provide an empty requires target
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                      objectRequires, p_depends,
-                                      no_commands, true);
+  this->LocalGenerator->WriteMakeRule(
+    *this->BuildFileStream, 0, objectRequires, p_depends, no_commands, true);
 
   // write a build rule to recursively build what this obj provides
   std::string objectProvides = relativeObj;
@@ -880,22 +780,19 @@ cmMakefileTargetGenerator
   std::string tgtMakefileName =
     this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
   tgtMakefileName += "/build.make";
-  r_commands.push_back
-    (this->LocalGenerator->GetRecursiveMakeCall(tgtMakefileName.c_str(),
-                                                temp));
+  r_commands.push_back(
+    this->LocalGenerator->GetRecursiveMakeCall(tgtMakefileName.c_str(), temp));
 
   p_depends.clear();
   p_depends.push_back(objectRequires);
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                      objectProvides, p_depends,
-                                      r_commands, true);
+  this->LocalGenerator->WriteMakeRule(
+    *this->BuildFileStream, 0, objectProvides, p_depends, r_commands, true);
 
   // write the provides.build rule dependency on the obj file
   p_depends.clear();
   p_depends.push_back(relativeObj);
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                      temp, p_depends, no_commands,
-                                      false);
+  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, temp,
+                                      p_depends, no_commands, false);
 }
 
 void cmMakefileTargetGenerator::WriteTargetRequiresRules()
@@ -911,18 +808,16 @@ void cmMakefileTargetGenerator::WriteTargetRequiresRules()
   // This target drives dependency generation for all object files.
   std::string relPath = this->LocalGenerator->GetHomeRelativeOutputPath();
   std::string objTarget;
-  for(std::vector<std::string>::const_iterator obj = this->Objects.begin();
-      obj != this->Objects.end(); ++obj)
-    {
+  for (std::vector<std::string>::const_iterator obj = this->Objects.begin();
+       obj != this->Objects.end(); ++obj) {
     objTarget = relPath;
     objTarget += *obj;
     objTarget += ".requires";
     depends.push_back(objTarget);
-    }
+  }
 
   // Write the rule.
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                      depTarget,
+  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, depTarget,
                                       depends, no_commands, true);
 }
 
@@ -939,58 +834,49 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules()
   // Construct the clean command.
   this->LocalGenerator->AppendCleanCommand(commands, this->CleanFiles,
                                            this->GeneratorTarget);
-  this->LocalGenerator->CreateCDCommand
-    (commands,
-     this->LocalGenerator->GetCurrentBinaryDirectory(),
-     cmLocalGenerator::HOME_OUTPUT);
+  this->LocalGenerator->CreateCDCommand(
+    commands, this->LocalGenerator->GetCurrentBinaryDirectory(),
+    cmLocalGenerator::HOME_OUTPUT);
 
   // Write the rule.
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                      cleanTarget,
+  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, cleanTarget,
                                       depends, commands, true);
 }
 
 bool cmMakefileTargetGenerator::WriteMakeRule(
-  std::ostream& os,
-  const char* comment,
+  std::ostream& os, const char* comment,
   const std::vector<std::string>& outputs,
   const std::vector<std::string>& depends,
-  const std::vector<std::string>& commands,
-  bool in_help)
+  const std::vector<std::string>& commands, bool in_help)
 {
   bool symbolic = false;
-  if (outputs.size() == 0)
-    {
+  if (outputs.size() == 0) {
     return symbolic;
-    }
+  }
 
   // Check whether we need to bother checking for a symbolic output.
   bool need_symbolic = this->GlobalGenerator->GetNeedSymbolicMark();
 
   // Check whether the first output is marked as symbolic.
-  if(need_symbolic)
-    {
-    if(cmSourceFile* sf = this->Makefile->GetSource(outputs[0]))
-      {
+  if (need_symbolic) {
+    if (cmSourceFile* sf = this->Makefile->GetSource(outputs[0])) {
       symbolic = sf->GetPropertyAsBool("SYMBOLIC");
-      }
     }
+  }
 
   // We always attach the actual commands to the first output.
   this->LocalGenerator->WriteMakeRule(os, comment, outputs[0], depends,
                                       commands, symbolic, in_help);
 
   // For single outputs, we are done.
-  if (outputs.size() == 1)
-    {
+  if (outputs.size() == 1) {
     return symbolic;
-    }
+  }
 
   // For multiple outputs, make the extra ones depend on the first one.
   std::vector<std::string> const output_depends(1, outputs[0]);
-  for (std::vector<std::string>::const_iterator o = outputs.begin()+1;
-       o != outputs.end(); ++o)
-    {
+  for (std::vector<std::string>::const_iterator o = outputs.begin() + 1;
+       o != outputs.end(); ++o) {
     // Touch the extra output so "make" knows that it was updated,
     // but only if the output was acually created.
     std::string const out = this->Convert(*o, cmLocalGenerator::HOME_OUTPUT,
@@ -998,30 +884,26 @@ bool cmMakefileTargetGenerator::WriteMakeRule(
     std::vector<std::string> output_commands;
 
     bool o_symbolic = false;
-    if(need_symbolic)
-      {
-      if(cmSourceFile* sf = this->Makefile->GetSource(*o))
-        {
+    if (need_symbolic) {
+      if (cmSourceFile* sf = this->Makefile->GetSource(*o)) {
         o_symbolic = sf->GetPropertyAsBool("SYMBOLIC");
-        }
       }
+    }
     symbolic = symbolic && o_symbolic;
 
-    if (!o_symbolic)
-      {
+    if (!o_symbolic) {
       output_commands.push_back("@$(CMAKE_COMMAND) -E touch_nocreate " + out);
-      }
+    }
     this->LocalGenerator->WriteMakeRule(os, 0, *o, output_depends,
                                         output_commands, o_symbolic, in_help);
 
-    if (!o_symbolic)
-      {
+    if (!o_symbolic) {
       // At build time, remove the first output if this one does not exist
       // so that "make" will rerun the real commands that create this one.
       MultipleOutputPairsType::value_type p(*o, outputs[0]);
       this->MultipleOutputPairs.insert(p);
-      }
     }
+  }
   return symbolic;
 }
 
@@ -1029,7 +911,7 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
 {
   // must write the targets depend info file
   std::string dir =
-      this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
+    this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
   this->InfoFileNameFull = dir;
   this->InfoFileNameFull += "/DependInfo.cmake";
   this->InfoFileNameFull =
@@ -1037,50 +919,44 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
   this->InfoFileStream =
     new cmGeneratedFileStream(this->InfoFileNameFull.c_str());
   this->InfoFileStream->SetCopyIfDifferent(true);
-  if(!*this->InfoFileStream)
-    {
+  if (!*this->InfoFileStream) {
     return;
-    }
-  this->LocalGenerator->
-    WriteDependLanguageInfo(*this->InfoFileStream, this->GeneratorTarget);
+  }
+  this->LocalGenerator->WriteDependLanguageInfo(*this->InfoFileStream,
+                                                this->GeneratorTarget);
 
   // Store multiple output pairs in the depend info file.
-  if(!this->MultipleOutputPairs.empty())
-    {
+  if (!this->MultipleOutputPairs.empty()) {
     /* clang-format off */
     *this->InfoFileStream
       << "\n"
       << "# Pairs of files generated by the same build rule.\n"
       << "set(CMAKE_MULTIPLE_OUTPUT_PAIRS\n";
     /* clang-format on */
-    for(MultipleOutputPairsType::const_iterator pi =
-          this->MultipleOutputPairs.begin();
-        pi != this->MultipleOutputPairs.end(); ++pi)
-      {
+    for (MultipleOutputPairsType::const_iterator pi =
+           this->MultipleOutputPairs.begin();
+         pi != this->MultipleOutputPairs.end(); ++pi) {
       *this->InfoFileStream
-        << "  " << cmOutputConverter::EscapeForCMake(pi->first)
-        << " "  << cmOutputConverter::EscapeForCMake(pi->second)
-        << "\n";
-      }
-    *this->InfoFileStream << "  )\n\n";
+        << "  " << cmOutputConverter::EscapeForCMake(pi->first) << " "
+        << cmOutputConverter::EscapeForCMake(pi->second) << "\n";
     }
+    *this->InfoFileStream << "  )\n\n";
+  }
 
   // Store list of targets linked directly or transitively.
   {
-  /* clang-format off */
+    /* clang-format off */
   *this->InfoFileStream
     << "\n"
     << "# Targets to which this target links.\n"
     << "set(CMAKE_TARGET_LINKED_INFO_FILES\n";
-  /* clang-format on */
-  std::vector<std::string> dirs = this->GetLinkedTargetDirectories();
-  for (std::vector<std::string>::iterator i = dirs.begin();
-       i != dirs.end(); ++i)
-    {
-    *this->InfoFileStream << "  \"" << *i << "/DependInfo.cmake\"\n";
+    /* clang-format on */
+    std::vector<std::string> dirs = this->GetLinkedTargetDirectories();
+    for (std::vector<std::string>::iterator i = dirs.begin(); i != dirs.end();
+         ++i) {
+      *this->InfoFileStream << "  \"" << *i << "/DependInfo.cmake\"\n";
     }
-  *this->InfoFileStream
-    << "  )\n";
+    *this->InfoFileStream << "  )\n";
   }
 
   /* clang-format off */
@@ -1103,17 +979,16 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
   // Add a command to call CMake to scan dependencies.  CMake will
   // touch the corresponding depends file after scanning dependencies.
   std::ostringstream depCmd;
-  // TODO: Account for source file properties and directory-level
-  // definitions when scanning for dependencies.
+// TODO: Account for source file properties and directory-level
+// definitions when scanning for dependencies.
 #if !defined(_WIN32) || defined(__CYGWIN__)
   // This platform supports symlinks, so cmSystemTools will translate
   // paths.  Make sure PWD is set to the original name of the home
   // output directory to help cmSystemTools to create the same
   // translation table for the dependency scanning process.
-  depCmd << "cd "
-         << (this->LocalGenerator->Convert(
-               this->LocalGenerator->GetBinaryDirectory(),
-               cmLocalGenerator::FULL, cmLocalGenerator::SHELL))
+  depCmd << "cd " << (this->LocalGenerator->Convert(
+                       this->LocalGenerator->GetBinaryDirectory(),
+                       cmLocalGenerator::FULL, cmLocalGenerator::SHELL))
          << " && ";
 #endif
   // Generate a call this signature:
@@ -1139,87 +1014,75 @@ void cmMakefileTargetGenerator::WriteTargetDependRules()
          << this->Convert(this->LocalGenerator->GetCurrentBinaryDirectory(),
                           cmLocalGenerator::FULL, cmLocalGenerator::SHELL)
          << " "
-         << this->Convert(this->InfoFileNameFull,
-                          cmLocalGenerator::FULL, cmLocalGenerator::SHELL);
-  if(this->LocalGenerator->GetColorMakefile())
-    {
+         << this->Convert(this->InfoFileNameFull, cmLocalGenerator::FULL,
+                          cmLocalGenerator::SHELL);
+  if (this->LocalGenerator->GetColorMakefile()) {
     depCmd << " --color=$(COLOR)";
-    }
+  }
   commands.push_back(depCmd.str());
 
   // Make sure all custom command outputs in this target are built.
-  if(this->CustomCommandDriver == OnDepends)
-    {
+  if (this->CustomCommandDriver == OnDepends) {
     this->DriveCustomCommands(depends);
-    }
+  }
 
   // Write the rule.
-  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
-                                      depTarget,
+  this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, depTarget,
                                       depends, commands, true);
 }
 
-void
-cmMakefileTargetGenerator
-::DriveCustomCommands(std::vector<std::string>& depends)
+void cmMakefileTargetGenerator::DriveCustomCommands(
+  std::vector<std::string>& depends)
 {
   // Depend on all custom command outputs.
   std::vector<cmSourceFile*> sources;
-  this->GeneratorTarget->GetSourceFiles(sources,
-                      this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-  for(std::vector<cmSourceFile*>::const_iterator source = sources.begin();
-      source != sources.end(); ++source)
-    {
-    if(cmCustomCommand* cc = (*source)->GetCustomCommand())
-      {
+  this->GeneratorTarget->GetSourceFiles(
+    sources, this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+  for (std::vector<cmSourceFile*>::const_iterator source = sources.begin();
+       source != sources.end(); ++source) {
+    if (cmCustomCommand* cc = (*source)->GetCustomCommand()) {
       cmCustomCommandGenerator ccg(*cc, this->ConfigName,
                                    this->LocalGenerator);
       const std::vector<std::string>& outputs = ccg.GetOutputs();
       depends.insert(depends.end(), outputs.begin(), outputs.end());
-      }
     }
+  }
 }
 
-void cmMakefileTargetGenerator
-::WriteObjectDependRules(cmSourceFile const& source,
-                         std::vector<std::string>& depends)
+void cmMakefileTargetGenerator::WriteObjectDependRules(
+  cmSourceFile const& source, std::vector<std::string>& depends)
 {
   // Create the list of dependencies known at cmake time.  These are
   // shared between the object file and dependency scanning rule.
   depends.push_back(source.GetFullPath());
-  if(const char* objectDeps = source.GetProperty("OBJECT_DEPENDS"))
-    {
+  if (const char* objectDeps = source.GetProperty("OBJECT_DEPENDS")) {
     cmSystemTools::ExpandListArgument(objectDeps, depends);
-    }
+  }
 }
 
-void cmMakefileTargetGenerator
-::GenerateCustomRuleFile(cmCustomCommandGenerator const& ccg)
+void cmMakefileTargetGenerator::GenerateCustomRuleFile(
+  cmCustomCommandGenerator const& ccg)
 {
   // Collect the commands.
   std::vector<std::string> commands;
   std::string comment = this->LocalGenerator->ConstructComment(ccg);
-  if(!comment.empty())
-    {
+  if (!comment.empty()) {
     // add in a progress call if needed
     this->NumberOfProgressActions++;
-    if(!this->NoRuleMessages)
-      {
+    if (!this->NoRuleMessages) {
       cmLocalUnixMakefileGenerator3::EchoProgress progress;
       this->MakeEchoProgress(progress);
-      this->LocalGenerator
-        ->AppendEcho(commands, comment.c_str(),
-                     cmLocalUnixMakefileGenerator3::EchoGenerate,
-                     &progress);
-      }
+      this->LocalGenerator->AppendEcho(
+        commands, comment.c_str(), cmLocalUnixMakefileGenerator3::EchoGenerate,
+        &progress);
     }
+  }
 
   // Now append the actual user-specified commands.
   std::ostringstream content;
-  this->LocalGenerator->AppendCustomCommand(commands, ccg,
-                                            this->GeneratorTarget, false,
-                                            cmLocalGenerator::HOME_OUTPUT,
-                                            &content);
+  this->LocalGenerator->AppendCustomCommand(
+    commands, ccg, this->GeneratorTarget, false, cmLocalGenerator::HOME_OUTPUT,
+    &content);
 
   // Collect the dependencies.
   std::vector<std::string> depends;
@@ -1227,34 +1090,30 @@ void cmMakefileTargetGenerator
 
   // Write the rule.
   const std::vector<std::string>& outputs = ccg.GetOutputs();
-  bool symbolic = this->WriteMakeRule(*this->BuildFileStream, 0,
-                                      outputs, depends, commands);
+  bool symbolic =
+    this->WriteMakeRule(*this->BuildFileStream, 0, outputs, depends, commands);
 
   // If the rule has changed make sure the output is rebuilt.
-  if(!symbolic)
-    {
+  if (!symbolic) {
     this->GlobalGenerator->AddRuleHash(ccg.GetOutputs(), content.str());
-    }
+  }
 
   // Setup implicit dependency scanning.
-  for(cmCustomCommand::ImplicitDependsList::const_iterator
-        idi = ccg.GetCC().GetImplicitDepends().begin();
-      idi != ccg.GetCC().GetImplicitDepends().end(); ++idi)
-    {
+  for (cmCustomCommand::ImplicitDependsList::const_iterator idi =
+         ccg.GetCC().GetImplicitDepends().begin();
+       idi != ccg.GetCC().GetImplicitDepends().end(); ++idi) {
     std::string objFullPath =
       this->Convert(outputs[0], cmLocalGenerator::FULL);
     std::string srcFullPath =
       this->Convert(idi->second, cmLocalGenerator::FULL);
-    this->LocalGenerator->
-      AddImplicitDepends(this->GeneratorTarget, idi->first,
-                         objFullPath.c_str(),
-                         srcFullPath.c_str());
-    }
+    this->LocalGenerator->AddImplicitDepends(this->GeneratorTarget, idi->first,
+                                             objFullPath.c_str(),
+                                             srcFullPath.c_str());
+  }
 }
 
-void
-cmMakefileTargetGenerator
-::MakeEchoProgress(cmLocalUnixMakefileGenerator3::EchoProgress& progress) const
+void cmMakefileTargetGenerator::MakeEchoProgress(
+  cmLocalUnixMakefileGenerator3::EchoProgress& progress) const
 {
   progress.Dir = this->LocalGenerator->GetBinaryDirectory();
   progress.Dir += cmake::GetCMakeFilesDirectory();
@@ -1263,42 +1122,35 @@ cmMakefileTargetGenerator
   progress.Arg = progressArg.str();
 }
 
-void
-cmMakefileTargetGenerator
-::WriteObjectsVariable(std::string& variableName,
-                       std::string& variableNameExternal,
-                       bool useWatcomQuote)
+void cmMakefileTargetGenerator::WriteObjectsVariable(
+  std::string& variableName, std::string& variableNameExternal,
+  bool useWatcomQuote)
 {
   // Write a make variable assignment that lists all objects for the
   // target.
-  variableName =
-    this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(),
-                                             "_OBJECTS");
-  *this->BuildFileStream
-    << "# Object files for target " << this->GeneratorTarget->GetName() << "\n"
-    << variableName << " =";
+  variableName = this->LocalGenerator->CreateMakeVariable(
+    this->GeneratorTarget->GetName(), "_OBJECTS");
+  *this->BuildFileStream << "# Object files for target "
+                         << this->GeneratorTarget->GetName() << "\n"
+                         << variableName << " =";
   std::string object;
   const char* lineContinue =
     this->Makefile->GetDefinition("CMAKE_MAKE_LINE_CONTINUE");
-  if(!lineContinue)
-    {
+  if (!lineContinue) {
     lineContinue = "\\";
-    }
-  for(std::vector<std::string>::const_iterator i = this->Objects.begin();
-      i != this->Objects.end(); ++i)
-    {
+  }
+  for (std::vector<std::string>::const_iterator i = this->Objects.begin();
+       i != this->Objects.end(); ++i) {
     *this->BuildFileStream << " " << lineContinue << "\n";
-    *this->BuildFileStream  <<
-      this->LocalGenerator->ConvertToQuotedOutputPath(i->c_str(),
-                                                      useWatcomQuote);
-    }
+    *this->BuildFileStream << this->LocalGenerator->ConvertToQuotedOutputPath(
+      i->c_str(), useWatcomQuote);
+  }
   *this->BuildFileStream << "\n";
 
   // Write a make variable assignment that lists all external objects
   // for the target.
-  variableNameExternal =
-    this->LocalGenerator->CreateMakeVariable(this->GeneratorTarget->GetName(),
-                                             "_EXTERNAL_OBJECTS");
+  variableNameExternal = this->LocalGenerator->CreateMakeVariable(
+    this->GeneratorTarget->GetName(), "_EXTERNAL_OBJECTS");
   /* clang-format off */
   *this->BuildFileStream
     << "\n"
@@ -1306,24 +1158,21 @@ cmMakefileTargetGenerator
     << this->GeneratorTarget->GetName() << "\n"
     << variableNameExternal << " =";
   /* clang-format on */
-  for(std::vector<std::string>::const_iterator i =
-        this->ExternalObjects.begin();
-      i != this->ExternalObjects.end(); ++i)
-    {
-    object = this->Convert(*i,cmLocalGenerator::START_OUTPUT);
-    *this->BuildFileStream
-      << " " << lineContinue << "\n"
-      << this->Makefile->GetSafeDefinition("CMAKE_OBJECT_NAME");
-    *this->BuildFileStream  <<
-      this->LocalGenerator->ConvertToQuotedOutputPath(i->c_str(),
-                                                      useWatcomQuote);
-    }
-  *this->BuildFileStream << "\n" << "\n";
+  for (std::vector<std::string>::const_iterator i =
+         this->ExternalObjects.begin();
+       i != this->ExternalObjects.end(); ++i) {
+    object = this->Convert(*i, cmLocalGenerator::START_OUTPUT);
+    *this->BuildFileStream << " " << lineContinue << "\n"
+                           << this->Makefile->GetSafeDefinition(
+                                "CMAKE_OBJECT_NAME");
+    *this->BuildFileStream << this->LocalGenerator->ConvertToQuotedOutputPath(
+      i->c_str(), useWatcomQuote);
+  }
+  *this->BuildFileStream << "\n"
+                         << "\n";
 }
 
-void
-cmMakefileTargetGenerator
-::WriteObjectsString(std::string& buildObjs)
+void cmMakefileTargetGenerator::WriteObjectsString(std::string& buildObjs)
 {
   std::vector<std::string> objStrings;
   this->WriteObjectsStrings(objStrings);
@@ -1335,28 +1184,27 @@ class cmMakefileTargetGeneratorObjectStrings
 public:
   cmMakefileTargetGeneratorObjectStrings(std::vector<std::string>& strings,
                                          cmLocalUnixMakefileGenerator3* lg,
-                                         std::string::size_type limit):
-    Strings(strings), LocalGenerator(lg), LengthLimit(limit)
-    {
+                                         std::string::size_type limit)
+    : Strings(strings)
+    , LocalGenerator(lg)
+    , LengthLimit(limit)
+  {
     this->Space = "";
-    }
+  }
   void Feed(std::string const& obj)
-    {
+  {
     // Construct the name of the next object.
-    this->NextObject =
-      this->LocalGenerator->Convert(obj,
-                                    cmLocalGenerator::START_OUTPUT,
-                                    cmLocalGenerator::RESPONSE);
+    this->NextObject = this->LocalGenerator->Convert(
+      obj, cmLocalGenerator::START_OUTPUT, cmLocalGenerator::RESPONSE);
 
     // Roll over to next string if the limit will be exceeded.
-    if(this->LengthLimit != std::string::npos &&
-       (this->CurrentString.length() + 1 + this->NextObject.length()
-        > this->LengthLimit))
-      {
+    if (this->LengthLimit != std::string::npos &&
+        (this->CurrentString.length() + 1 + this->NextObject.length() >
+         this->LengthLimit)) {
       this->Strings.push_back(this->CurrentString);
       this->CurrentString = "";
       this->Space = "";
-      }
+    }
 
     // Separate from previous object.
     this->CurrentString += this->Space;
@@ -1364,11 +1212,8 @@ public:
 
     // Append this object.
     this->CurrentString += this->NextObject;
-    }
-  void Done()
-    {
-    this->Strings.push_back(this->CurrentString);
-    }
+  }
+  void Done() { this->Strings.push_back(this->CurrentString); }
 private:
   std::vector<std::string>& Strings;
   cmLocalUnixMakefileGenerator3* LocalGenerator;
@@ -1378,117 +1223,105 @@ private:
   const char* Space;
 };
 
-void
-cmMakefileTargetGenerator
-::WriteObjectsStrings(std::vector<std::string>& objStrings,
-                      std::string::size_type limit)
+void cmMakefileTargetGenerator::WriteObjectsStrings(
+  std::vector<std::string>& objStrings, std::string::size_type limit)
 {
-  cmMakefileTargetGeneratorObjectStrings
-    helper(objStrings, this->LocalGenerator, limit);
-  for(std::vector<std::string>::const_iterator i = this->Objects.begin();
-      i != this->Objects.end(); ++i)
-    {
+  cmMakefileTargetGeneratorObjectStrings helper(objStrings,
+                                                this->LocalGenerator, limit);
+  for (std::vector<std::string>::const_iterator i = this->Objects.begin();
+       i != this->Objects.end(); ++i) {
     helper.Feed(*i);
-    }
-  for(std::vector<std::string>::const_iterator i =
-        this->ExternalObjects.begin();
-      i != this->ExternalObjects.end(); ++i)
-    {
+  }
+  for (std::vector<std::string>::const_iterator i =
+         this->ExternalObjects.begin();
+       i != this->ExternalObjects.end(); ++i) {
     helper.Feed(*i);
-    }
+  }
   helper.Done();
 }
 
 void cmMakefileTargetGenerator::WriteTargetDriverRule(
-                                                const std::string& main_output,
-                                                bool relink)
+  const std::string& main_output, bool relink)
 {
   // Compute the name of the driver target.
   std::string dir =
     this->LocalGenerator->GetRelativeTargetDirectory(this->GeneratorTarget);
   std::string buildTargetRuleName = dir;
-  buildTargetRuleName += relink?"/preinstall":"/build";
-  buildTargetRuleName = this->Convert(buildTargetRuleName,
-                                      cmLocalGenerator::HOME_OUTPUT,
-                                      cmLocalGenerator::UNCHANGED);
+  buildTargetRuleName += relink ? "/preinstall" : "/build";
+  buildTargetRuleName =
+    this->Convert(buildTargetRuleName, cmLocalGenerator::HOME_OUTPUT,
+                  cmLocalGenerator::UNCHANGED);
 
   // Build the list of target outputs to drive.
   std::vector<std::string> depends;
   depends.push_back(main_output);
 
   const char* comment = 0;
-  if(relink)
-    {
+  if (relink) {
     // Setup the comment for the preinstall driver.
     comment = "Rule to relink during preinstall.";
-    }
-  else
-    {
+  } else {
     // Setup the comment for the main build driver.
     comment = "Rule to build all files generated by this target.";
 
     // Make sure all custom command outputs in this target are built.
-    if(this->CustomCommandDriver == OnBuild)
-      {
+    if (this->CustomCommandDriver == OnBuild) {
       this->DriveCustomCommands(depends);
-      }
+    }
 
     // Make sure the extra files are built.
-    depends.insert(depends.end(),
-                   this->ExtraFiles.begin(), this->ExtraFiles.end());
-    }
+    depends.insert(depends.end(), this->ExtraFiles.begin(),
+                   this->ExtraFiles.end());
+  }
 
   // Write the driver rule.
   std::vector<std::string> no_commands;
   this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, comment,
-                                      buildTargetRuleName,
-                                      depends, no_commands, true);
+                                      buildTargetRuleName, depends,
+                                      no_commands, true);
 }
 
-void cmMakefileTargetGenerator
-::AppendTargetDepends(std::vector<std::string>& depends)
+void cmMakefileTargetGenerator::AppendTargetDepends(
+  std::vector<std::string>& depends)
 {
   // Static libraries never depend on anything for linking.
-  if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY) {
     return;
-    }
+  }
 
   // Loop over all library dependencies.
   const char* cfg = this->LocalGenerator->GetConfigName().c_str();
-  if(cmComputeLinkInformation* cli =
-                              this->GeneratorTarget->GetLinkInformation(cfg))
-    {
+  if (cmComputeLinkInformation* cli =
+        this->GeneratorTarget->GetLinkInformation(cfg)) {
     std::vector<std::string> const& libDeps = cli->GetDepends();
     depends.insert(depends.end(), libDeps.begin(), libDeps.end());
-    }
+  }
 }
 
-void cmMakefileTargetGenerator
-::AppendObjectDepends(std::vector<std::string>& depends)
+void cmMakefileTargetGenerator::AppendObjectDepends(
+  std::vector<std::string>& depends)
 {
   // Add dependencies on the compiled object files.
   std::string relPath = this->LocalGenerator->GetHomeRelativeOutputPath();
   std::string objTarget;
-  for(std::vector<std::string>::const_iterator obj = this->Objects.begin();
-      obj != this->Objects.end(); ++obj)
-    {
+  for (std::vector<std::string>::const_iterator obj = this->Objects.begin();
+       obj != this->Objects.end(); ++obj) {
     objTarget = relPath;
     objTarget += *obj;
     depends.push_back(objTarget);
-    }
+  }
 
   // Add dependencies on the external object files.
-  depends.insert(depends.end(),
-                 this->ExternalObjects.begin(), this->ExternalObjects.end());
+  depends.insert(depends.end(), this->ExternalObjects.begin(),
+                 this->ExternalObjects.end());
 
   // Add a dependency on the rule file itself.
   this->LocalGenerator->AppendRuleDepend(depends,
                                          this->BuildFileNameFull.c_str());
 }
 
-void cmMakefileTargetGenerator
-::AppendLinkDepends(std::vector<std::string>& depends)
+void cmMakefileTargetGenerator::AppendLinkDepends(
+  std::vector<std::string>& depends)
 {
   this->AppendObjectDepends(depends);
 
@@ -1496,56 +1329,49 @@ void cmMakefileTargetGenerator
   this->AppendTargetDepends(depends);
 
   // Add a dependency on the link definitions file, if any.
-  if(this->ModuleDefinitionFile)
-    {
+  if (this->ModuleDefinitionFile) {
     depends.push_back(this->ModuleDefinitionFile->GetFullPath());
-    }
+  }
 
   // Add a dependency on user-specified manifest files, if any.
   std::vector<cmSourceFile const*> manifest_srcs;
   this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
   for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
-       mi != manifest_srcs.end(); ++mi)
-    {
+       mi != manifest_srcs.end(); ++mi) {
     depends.push_back((*mi)->GetFullPath());
-    }
+  }
 
   // Add user-specified dependencies.
-  if(const char* linkDepends =
-     this->GeneratorTarget->GetProperty("LINK_DEPENDS"))
-    {
+  if (const char* linkDepends =
+        this->GeneratorTarget->GetProperty("LINK_DEPENDS")) {
     cmSystemTools::ExpandListArgument(linkDepends, depends);
-    }
+  }
 }
 
 std::string cmMakefileTargetGenerator::GetLinkRule(
-                                              const std::string& linkRuleVar)
+  const std::string& linkRuleVar)
 {
   std::string linkRule = this->Makefile->GetRequiredDefinition(linkRuleVar);
-  if(this->GeneratorTarget->HasImplibGNUtoMS())
-    {
+  if (this->GeneratorTarget->HasImplibGNUtoMS()) {
     std::string ruleVar = "CMAKE_";
     ruleVar += this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
     ruleVar += "_GNUtoMS_RULE";
-    if(const char* rule = this->Makefile->GetDefinition(ruleVar))
-      {
+    if (const char* rule = this->Makefile->GetDefinition(ruleVar)) {
       linkRule += rule;
-      }
     }
+  }
   return linkRule;
 }
 
-void cmMakefileTargetGenerator
-::CloseFileStreams()
+void cmMakefileTargetGenerator::CloseFileStreams()
 {
   delete this->BuildFileStream;
   delete this->InfoFileStream;
   delete this->FlagFileStream;
 }
 
-void cmMakefileTargetGenerator::RemoveForbiddenFlags(const char* flagVar,
-                                                const std::string& linkLang,
-                                                std::string& linkFlags)
+void cmMakefileTargetGenerator::RemoveForbiddenFlags(
+  const char* flagVar, const std::string& linkLang, std::string& linkFlags)
 {
   // check for language flags that are not allowed at link time, and
   // remove them, -w on darwin for gcc -w -dynamiclib sends -w to libtool
@@ -1554,55 +1380,46 @@ void cmMakefileTargetGenerator::RemoveForbiddenFlags(const char* flagVar,
   std::string removeFlags = "CMAKE_";
   removeFlags += linkLang;
   removeFlags += flagVar;
-  std::string removeflags =
-    this->Makefile->GetSafeDefinition(removeFlags);
+  std::string removeflags = this->Makefile->GetSafeDefinition(removeFlags);
   std::vector<std::string> removeList;
   cmSystemTools::ExpandListArgument(removeflags, removeList);
 
-  for(std::vector<std::string>::iterator i = removeList.begin();
-      i != removeList.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = removeList.begin();
+       i != removeList.end(); ++i) {
     std::string tmp;
     std::string::size_type lastPosition = 0;
 
-    for(;;)
-      {
+    for (;;) {
       std::string::size_type position = linkFlags.find(*i, lastPosition);
 
-      if(position == std::string::npos)
-        {
+      if (position == std::string::npos) {
         tmp += linkFlags.substr(lastPosition);
         break;
-        }
-      else
-        {
+      } else {
         std::string::size_type prefixLength = position - lastPosition;
         tmp += linkFlags.substr(lastPosition, prefixLength);
         lastPosition = position + i->length();
 
-        bool validFlagStart = position == 0 ||
-          isspace(linkFlags[position - 1]);
+        bool validFlagStart =
+          position == 0 || isspace(linkFlags[position - 1]);
 
-        bool validFlagEnd = lastPosition == linkFlags.size() ||
-          isspace(linkFlags[lastPosition]);
+        bool validFlagEnd =
+          lastPosition == linkFlags.size() || isspace(linkFlags[lastPosition]);
 
-        if(!validFlagStart || !validFlagEnd)
-          {
+        if (!validFlagStart || !validFlagEnd) {
           tmp += *i;
-          }
         }
       }
+    }
 
     linkFlags = tmp;
-    }
+  }
 }
 
-void
-cmMakefileTargetGenerator
-::CreateLinkScript(const char* name,
-                   std::vector<std::string> const& link_commands,
-                   std::vector<std::string>& makefile_commands,
-                   std::vector<std::string>& makefile_depends)
+void cmMakefileTargetGenerator::CreateLinkScript(
+  const char* name, std::vector<std::string> const& link_commands,
+  std::vector<std::string>& makefile_commands,
+  std::vector<std::string>& makefile_depends)
 {
   // Create the link script file.
   std::string linkScriptName = this->TargetBuildDirectoryFull;
@@ -1610,31 +1427,27 @@ cmMakefileTargetGenerator
   linkScriptName += name;
   cmGeneratedFileStream linkScriptStream(linkScriptName.c_str());
   linkScriptStream.SetCopyIfDifferent(true);
-  for(std::vector<std::string>::const_iterator cmd = link_commands.begin();
-      cmd != link_commands.end(); ++cmd)
-    {
+  for (std::vector<std::string>::const_iterator cmd = link_commands.begin();
+       cmd != link_commands.end(); ++cmd) {
     // Do not write out empty commands or commands beginning in the
     // shell no-op ":".
-    if(!cmd->empty() && (*cmd)[0] != ':')
-      {
+    if (!cmd->empty() && (*cmd)[0] != ':') {
       linkScriptStream << *cmd << "\n";
-      }
     }
+  }
 
   // Create the makefile command to invoke the link script.
   std::string link_command = "$(CMAKE_COMMAND) -E cmake_link_script ";
-  link_command += this->Convert(linkScriptName,
-                                cmLocalGenerator::START_OUTPUT,
+  link_command += this->Convert(linkScriptName, cmLocalGenerator::START_OUTPUT,
                                 cmLocalGenerator::SHELL);
   link_command += " --verbose=$(VERBOSE)";
   makefile_commands.push_back(link_command);
   makefile_depends.push_back(linkScriptName);
 }
 
-std::string
-cmMakefileTargetGenerator
-::CreateResponseFile(const char* name, std::string const& options,
-                     std::vector<std::string>& makefile_depends)
+std::string cmMakefileTargetGenerator::CreateResponseFile(
+  const char* name, std::string const& options,
+  std::vector<std::string>& makefile_depends)
 {
   // Create the response file.
   std::string responseFileNameFull = this->TargetBuildDirectoryFull;
@@ -1655,35 +1468,27 @@ cmMakefileTargetGenerator
   return responseFileName;
 }
 
-void
-cmMakefileTargetGenerator
-::CreateLinkLibs(std::string& linkLibs, bool relink,
-                 bool useResponseFile,
-                 std::vector<std::string>& makefile_depends,
-                 bool useWatcomQuote)
+void cmMakefileTargetGenerator::CreateLinkLibs(
+  std::string& linkLibs, bool relink, bool useResponseFile,
+  std::vector<std::string>& makefile_depends, bool useWatcomQuote)
 {
   std::string frameworkPath;
   std::string linkPath;
-  this->LocalGenerator
-    ->OutputLinkLibraries(linkLibs, frameworkPath, linkPath,
-                          *this->GeneratorTarget, relink,
-                          useResponseFile,
-                          useWatcomQuote);
+  this->LocalGenerator->OutputLinkLibraries(linkLibs, frameworkPath, linkPath,
+                                            *this->GeneratorTarget, relink,
+                                            useResponseFile, useWatcomQuote);
   linkLibs = frameworkPath + linkPath + linkLibs;
 
-  if(useResponseFile && linkLibs.find_first_not_of(" ") != linkLibs.npos)
-    {
+  if (useResponseFile && linkLibs.find_first_not_of(" ") != linkLibs.npos) {
     // Lookup the response file reference flag.
     std::string responseFlagVar = "CMAKE_";
-    responseFlagVar += this->GeneratorTarget
-                           ->GetLinkerLanguage(this->ConfigName);
+    responseFlagVar +=
+      this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
     responseFlagVar += "_RESPONSE_FILE_LINK_FLAG";
-    const char* responseFlag =
-      this->Makefile->GetDefinition(responseFlagVar);
-    if(!responseFlag)
-      {
+    const char* responseFlag = this->Makefile->GetDefinition(responseFlagVar);
+    if (!responseFlag) {
       responseFlag = "@";
-      }
+    }
 
     // Create this response file.
     std::string link_rsp =
@@ -1691,25 +1496,21 @@ cmMakefileTargetGenerator
 
     // Reference the response file.
     linkLibs = responseFlag;
-    linkLibs += this->Convert(link_rsp,
-                              cmLocalGenerator::NONE,
-                              cmLocalGenerator::SHELL);
-    }
+    linkLibs +=
+      this->Convert(link_rsp, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
+  }
 }
 
-void
-cmMakefileTargetGenerator
-::CreateObjectLists(bool useLinkScript, bool useArchiveRules,
-                    bool useResponseFile, std::string& buildObjs,
-                    std::vector<std::string>& makefile_depends,
-                    bool useWatcomQuote)
+void cmMakefileTargetGenerator::CreateObjectLists(
+  bool useLinkScript, bool useArchiveRules, bool useResponseFile,
+  std::string& buildObjs, std::vector<std::string>& makefile_depends,
+  bool useWatcomQuote)
 {
   std::string variableName;
   std::string variableNameExternal;
   this->WriteObjectsVariable(variableName, variableNameExternal,
                              useWatcomQuote);
-  if(useResponseFile)
-    {
+  if (useResponseFile) {
     // MSVC response files cannot exceed 128K.
     std::string::size_type const responseFileLimit = 131000;
 
@@ -1719,23 +1520,20 @@ cmMakefileTargetGenerator
 
     // Lookup the response file reference flag.
     std::string responseFlagVar = "CMAKE_";
-    responseFlagVar += this->GeneratorTarget
-                           ->GetLinkerLanguage(this->ConfigName);
+    responseFlagVar +=
+      this->GeneratorTarget->GetLinkerLanguage(this->ConfigName);
     responseFlagVar += "_RESPONSE_FILE_LINK_FLAG";
-    const char* responseFlag =
-      this->Makefile->GetDefinition(responseFlagVar);
-    if(!responseFlag)
-      {
+    const char* responseFlag = this->Makefile->GetDefinition(responseFlagVar);
+    if (!responseFlag) {
       responseFlag = "@";
-      }
+    }
 
     // Write a response file for each string.
     const char* sep = "";
-    for(unsigned int i = 0; i < object_strings.size(); ++i)
-      {
+    for (unsigned int i = 0; i < object_strings.size(); ++i) {
       // Number the response files.
       char rsp[32];
-      sprintf(rsp, "objects%u.rsp", i+1);
+      sprintf(rsp, "objects%u.rsp", i + 1);
 
       // Create this response file.
       std::string objects_rsp =
@@ -1747,26 +1545,20 @@ cmMakefileTargetGenerator
 
       // Reference the response file.
       buildObjs += responseFlag;
-      buildObjs += this->Convert(objects_rsp,
-                                 cmLocalGenerator::NONE,
+      buildObjs += this->Convert(objects_rsp, cmLocalGenerator::NONE,
                                  cmLocalGenerator::SHELL);
-      }
     }
-  else if(useLinkScript)
-    {
-    if(!useArchiveRules)
-      {
+  } else if (useLinkScript) {
+    if (!useArchiveRules) {
       this->WriteObjectsString(buildObjs);
-      }
     }
-  else
-    {
+  } else {
     buildObjs = "$(";
     buildObjs += variableName;
     buildObjs += ") $(";
     buildObjs += variableNameExternal;
     buildObjs += ")";
-    }
+  }
 }
 
 void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
@@ -1777,25 +1569,19 @@ void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
   responseVar += "_USE_RESPONSE_FILE_FOR_INCLUDES";
   bool useResponseFile = this->Makefile->IsOn(responseVar);
 
-
   std::vector<std::string> includes;
   const std::string& config =
     this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
-  this->LocalGenerator->GetIncludeDirectories(includes,
-                                              this->GeneratorTarget,
+  this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
                                               lang, config);
 
-  std::string includeFlags =
-    this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
-                                          lang, false, useResponseFile,
-                                          config);
-  if(includeFlags.empty())
-    {
+  std::string includeFlags = this->LocalGenerator->GetIncludeFlags(
+    includes, this->GeneratorTarget, lang, false, useResponseFile, config);
+  if (includeFlags.empty()) {
     return;
-    }
+  }
 
-  if(useResponseFile)
-    {
+  if (useResponseFile) {
     std::string name = "includes_";
     name += lang;
     name += ".rsp";
@@ -1803,9 +1589,7 @@ void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
       this->CreateResponseFile(name.c_str(), includeFlags,
                                this->FlagFileDepends[lang]);
     this->LocalGenerator->AppendFlags(flags, arg);
-    }
-  else
-    {
+  } else {
     this->LocalGenerator->AppendFlags(flags, includeFlags);
-    }
+  }
 }
diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h
index 38f40c0..c513026 100644
--- a/Source/cmMakefileTargetGenerator.h
+++ b/Source/cmMakefileTargetGenerator.h
@@ -30,7 +30,7 @@ class cmSourceFile;
  * \brief Support Routines for writing makefiles
  *
  */
-class cmMakefileTargetGenerator: public cmCommonTargetGenerator
+class cmMakefileTargetGenerator : public cmCommonTargetGenerator
 {
 public:
   // constructor to set the ivars
@@ -38,22 +38,22 @@ public:
   virtual ~cmMakefileTargetGenerator();
 
   // construct using this factory call
-  static cmMakefileTargetGenerator *New(cmGeneratorTarget *tgt);
+  static cmMakefileTargetGenerator* New(cmGeneratorTarget* tgt);
 
   /* the main entry point for this class. Writes the Makefiles associated
      with this target */
   virtual void WriteRuleFiles() = 0;
 
   /* return the number of actions that have progress reporting on them */
-  virtual unsigned long GetNumberOfProgressActions() {
-    return this->NumberOfProgressActions;}
-  std::string GetProgressFileNameFull()
-    { return this->ProgressFileNameFull; }
+  virtual unsigned long GetNumberOfProgressActions()
+  {
+    return this->NumberOfProgressActions;
+  }
+  std::string GetProgressFileNameFull() { return this->ProgressFileNameFull; }
 
-  cmGeneratorTarget* GetGeneratorTarget() { return this->GeneratorTarget;}
+  cmGeneratorTarget* GetGeneratorTarget() { return this->GeneratorTarget; }
 
 protected:
-
   // create the file and directory etc
   void CreateRuleFile();
 
@@ -75,11 +75,13 @@ protected:
   void WriteTargetDependRules();
 
   // write rules for Mac OS X Application Bundle content.
-  struct MacOSXContentGeneratorType :
-    cmOSXBundleGenerator::MacOSXContentGeneratorType
+  struct MacOSXContentGeneratorType
+    : cmOSXBundleGenerator::MacOSXContentGeneratorType
   {
-    MacOSXContentGeneratorType(cmMakefileTargetGenerator* gen) :
-      Generator(gen) {}
+    MacOSXContentGeneratorType(cmMakefileTargetGenerator* gen)
+      : Generator(gen)
+    {
+    }
 
     void operator()(cmSourceFile const& source, const char* pkgloc);
 
@@ -92,8 +94,7 @@ protected:
   void WriteObjectRuleFiles(cmSourceFile const& source);
 
   // write the build rule for an object
-  void WriteObjectBuildFile(std::string &obj,
-                            const std::string& lang,
+  void WriteObjectBuildFile(std::string& obj, const std::string& lang,
                             cmSourceFile const& source,
                             std::vector<std::string>& depends);
 
@@ -146,13 +147,11 @@ protected:
   /** Create a response file with the given set of options.  Returns
       the relative path from the target build working directory to the
       response file name.  */
-  std::string CreateResponseFile(const char* name,
-                                 std::string const& options,
+  std::string CreateResponseFile(const char* name, std::string const& options,
                                  std::vector<std::string>& makefile_depends);
 
   /** Create list of flags for link libraries. */
-  void CreateLinkLibs(std::string& linkLibs, bool relink,
-                      bool useResponseFile,
+  void CreateLinkLibs(std::string& linkLibs, bool relink, bool useResponseFile,
                       std::vector<std::string>& makefile_depends,
                       bool useWatcomQuote);
 
@@ -167,10 +166,15 @@ protected:
   virtual void CloseFileStreams();
   void RemoveForbiddenFlags(const char* flagVar, const std::string& linkLang,
                             std::string& linkFlags);
-  cmLocalUnixMakefileGenerator3 *LocalGenerator;
-  cmGlobalUnixMakefileGenerator3 *GlobalGenerator;
+  cmLocalUnixMakefileGenerator3* LocalGenerator;
+  cmGlobalUnixMakefileGenerator3* GlobalGenerator;
 
-  enum CustomCommandDriveType { OnBuild, OnDepends, OnUtility };
+  enum CustomCommandDriveType
+  {
+    OnBuild,
+    OnDepends,
+    OnUtility
+  };
   CustomCommandDriveType CustomCommandDriver;
 
   // the full path to the build file
@@ -187,17 +191,19 @@ protected:
   std::string TargetBuildDirectoryFull;
 
   // the stream for the build file
-  cmGeneratedFileStream *BuildFileStream;
+  cmGeneratedFileStream* BuildFileStream;
 
   // the stream for the flag file
   std::string FlagFileNameFull;
-  cmGeneratedFileStream *FlagFileStream;
-  class StringList: public std::vector<std::string> {};
+  cmGeneratedFileStream* FlagFileStream;
+  class StringList : public std::vector<std::string>
+  {
+  };
   std::map<std::string, StringList> FlagFileDepends;
 
   // the stream for the info file
   std::string InfoFileNameFull;
-  cmGeneratedFileStream *InfoFileStream;
+  cmGeneratedFileStream* InfoFileStream;
 
   // files to clean
   std::vector<std::string> CleanFiles;
@@ -214,8 +220,7 @@ protected:
 
   typedef std::map<std::string, std::string> MultipleOutputPairsType;
   MultipleOutputPairsType MultipleOutputPairs;
-  bool WriteMakeRule(std::ostream& os,
-                     const char* comment,
+  bool WriteMakeRule(std::ostream& os, const char* comment,
                      const std::vector<std::string>& outputs,
                      const std::vector<std::string>& depends,
                      const std::vector<std::string>& commands,
diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx
index 1c601c6..697f123 100644
--- a/Source/cmMakefileUtilityTargetGenerator.cxx
+++ b/Source/cmMakefileUtilityTargetGenerator.cxx
@@ -17,18 +17,17 @@
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
 
-cmMakefileUtilityTargetGenerator
-::cmMakefileUtilityTargetGenerator(cmGeneratorTarget* target):
-  cmMakefileTargetGenerator(target)
+cmMakefileUtilityTargetGenerator::cmMakefileUtilityTargetGenerator(
+  cmGeneratorTarget* target)
+  : cmMakefileTargetGenerator(target)
 {
   this->CustomCommandDriver = OnUtility;
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
-                                                      this->ConfigName);
+  this->OSXBundleGenerator =
+    new cmOSXBundleGenerator(target, this->ConfigName);
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
 
-cmMakefileUtilityTargetGenerator
-::~cmMakefileUtilityTargetGenerator()
+cmMakefileUtilityTargetGenerator::~cmMakefileUtilityTargetGenerator()
 {
   delete this->OSXBundleGenerator;
 }
@@ -37,14 +36,13 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
 {
   this->CreateRuleFile();
 
-  *this->BuildFileStream
-    << "# Utility rule file for "
-    << this->GeneratorTarget->GetName() << ".\n\n";
+  *this->BuildFileStream << "# Utility rule file for "
+                         << this->GeneratorTarget->GetName() << ".\n\n";
 
-  if(!this->NoRuleMessages)
-    {
-    const char* root = (this->Makefile->IsOn("CMAKE_MAKE_INCLUDE_FROM_ROOT")?
-                      "$(CMAKE_BINARY_DIR)/" : "");
+  if (!this->NoRuleMessages) {
+    const char* root = (this->Makefile->IsOn("CMAKE_MAKE_INCLUDE_FROM_ROOT")
+                          ? "$(CMAKE_BINARY_DIR)/"
+                          : "");
     // Include the progress variables for the target.
     *this->BuildFileStream
       << "# Include the progress variables for this target.\n"
@@ -53,7 +51,7 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
                        cmLocalGenerator::HOME_OUTPUT,
                        cmLocalGenerator::MAKERULE)
       << "\n\n";
-    }
+  }
 
   // write the custom commands for this target
   this->WriteTargetBuildRules();
@@ -63,22 +61,22 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
   std::vector<std::string> depends;
 
   // Utility targets store their rules in pre- and post-build commands.
-  this->LocalGenerator->AppendCustomDepends
-    (depends, this->GeneratorTarget->GetPreBuildCommands());
+  this->LocalGenerator->AppendCustomDepends(
+    depends, this->GeneratorTarget->GetPreBuildCommands());
 
-  this->LocalGenerator->AppendCustomDepends
-    (depends, this->GeneratorTarget->GetPostBuildCommands());
+  this->LocalGenerator->AppendCustomDepends(
+    depends, this->GeneratorTarget->GetPostBuildCommands());
 
-  this->LocalGenerator->AppendCustomCommands
-    (commands, this->GeneratorTarget->GetPreBuildCommands(),
-     this->GeneratorTarget);
+  this->LocalGenerator->AppendCustomCommands(
+    commands, this->GeneratorTarget->GetPreBuildCommands(),
+    this->GeneratorTarget);
 
   // Depend on all custom command outputs for sources
   this->DriveCustomCommands(depends);
 
-  this->LocalGenerator->AppendCustomCommands
-    (commands, this->GeneratorTarget->GetPostBuildCommands(),
-     this->GeneratorTarget);
+  this->LocalGenerator->AppendCustomCommands(
+    commands, this->GeneratorTarget->GetPostBuildCommands(),
+    this->GeneratorTarget);
 
   // Add dependencies on targets that must be built first.
   this->AppendTargetDepends(depends);
@@ -89,14 +87,12 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
 
   // If the rule is empty add the special empty rule dependency needed
   // by some make tools.
-  if(depends.empty() && commands.empty())
-    {
+  if (depends.empty() && commands.empty()) {
     std::string hack = this->GlobalGenerator->GetEmptyRuleHackDepends();
-    if(!hack.empty())
-      {
+    if (!hack.empty()) {
       depends.push_back(hack);
-      }
     }
+  }
 
   // Write the rule.
   this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0,
@@ -116,4 +112,3 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles()
   // close the streams
   this->CloseFileStreams();
 }
-
diff --git a/Source/cmMakefileUtilityTargetGenerator.h b/Source/cmMakefileUtilityTargetGenerator.h
index 8f99300..dbb312c 100644
--- a/Source/cmMakefileUtilityTargetGenerator.h
+++ b/Source/cmMakefileUtilityTargetGenerator.h
@@ -14,8 +14,7 @@
 
 #include "cmMakefileTargetGenerator.h"
 
-class cmMakefileUtilityTargetGenerator:
-  public cmMakefileTargetGenerator
+class cmMakefileUtilityTargetGenerator : public cmMakefileTargetGenerator
 {
 public:
   cmMakefileUtilityTargetGenerator(cmGeneratorTarget* target);
@@ -26,7 +25,6 @@ public:
   virtual void WriteRuleFiles();
 
 protected:
-
 };
 
 #endif
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index 8d0e2b3..07f1fa8 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -12,47 +12,39 @@
 #include "cmMarkAsAdvancedCommand.h"
 
 // cmMarkAsAdvancedCommand
-bool cmMarkAsAdvancedCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmMarkAsAdvancedCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
-  unsigned int i =0;
+  unsigned int i = 0;
   const char* value = "1";
   bool overwrite = false;
-  if(args[0] == "CLEAR" || args[0] == "FORCE")
-    {
+  if (args[0] == "CLEAR" || args[0] == "FORCE") {
     overwrite = true;
-    if(args[0] == "CLEAR")
-      {
+    if (args[0] == "CLEAR") {
       value = "0";
-      }
-    i = 1;
     }
-  for(; i < args.size(); ++i)
-    {
+    i = 1;
+  }
+  for (; i < args.size(); ++i) {
     std::string variable = args[i];
     cmState* state = this->Makefile->GetState();
-    if (!state->GetCacheEntryValue(variable))
-      {
+    if (!state->GetCacheEntryValue(variable)) {
       this->Makefile->GetCMakeInstance()->AddCacheEntry(
-              variable, 0, 0, cmState::UNINITIALIZED);
+        variable, 0, 0, cmState::UNINITIALIZED);
       overwrite = true;
-      }
-    if (!state->GetCacheEntryValue(variable))
-      {
+    }
+    if (!state->GetCacheEntryValue(variable)) {
       cmSystemTools::Error("This should never happen...");
       return false;
-      }
-    if (!state->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
-      {
+    }
+    if (!state->GetCacheEntryProperty(variable, "ADVANCED") || overwrite) {
       state->SetCacheEntryProperty(variable, "ADVANCED", value);
-      }
     }
+  }
   return true;
 }
-
diff --git a/Source/cmMarkAsAdvancedCommand.h b/Source/cmMarkAsAdvancedCommand.h
index 38064a3..add43c9 100644
--- a/Source/cmMarkAsAdvancedCommand.h
+++ b/Source/cmMarkAsAdvancedCommand.h
@@ -25,22 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmMarkAsAdvancedCommand;
-    }
+  virtual cmCommand* Clone() { return new cmMarkAsAdvancedCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "mark_as_advanced";}
+  virtual std::string GetName() const { return "mark_as_advanced"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -53,6 +50,4 @@ public:
   cmTypeMacro(cmMarkAsAdvancedCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmMathCommand.cxx b/Source/cmMathCommand.cxx
index d6e1d17..ca8b926 100644
--- a/Source/cmMathCommand.cxx
+++ b/Source/cmMathCommand.cxx
@@ -13,43 +13,39 @@
 
 #include "cmExprParserHelper.h"
 
-bool cmMathCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmMathCommand::InitialPass(std::vector<std::string> const& args,
+                                cmExecutionStatus&)
 {
-  if ( args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("must be called with at least one argument.");
     return false;
-    }
-  const std::string &subCommand = args[0];
-  if(subCommand == "EXPR")
-    {
+  }
+  const std::string& subCommand = args[0];
+  if (subCommand == "EXPR") {
     return this->HandleExprCommand(args);
-    }
-  std::string e = "does not recognize sub-command "+subCommand;
+  }
+  std::string e = "does not recognize sub-command " + subCommand;
   this->SetError(e);
   return false;
 }
 
 bool cmMathCommand::HandleExprCommand(std::vector<std::string> const& args)
 {
-  if ( args.size() != 3 )
-    {
+  if (args.size() != 3) {
     this->SetError("EXPR called with incorrect arguments.");
     return false;
-    }
+  }
 
   const std::string& outputVariable = args[1];
   const std::string& expression = args[2];
 
   cmExprParserHelper helper;
-  if ( !helper.ParseString(expression.c_str(), 0) )
-    {
-    std::string e = "cannot parse the expression: \""+expression+"\": ";
+  if (!helper.ParseString(expression.c_str(), 0)) {
+    std::string e = "cannot parse the expression: \"" + expression + "\": ";
     e += helper.GetError();
     this->SetError(e);
     return false;
-    }
+  }
 
   char buffer[1024];
   sprintf(buffer, "%d", helper.GetResult());
diff --git a/Source/cmMathCommand.h b/Source/cmMathCommand.h
index 76dc102..3ac6f41 100644
--- a/Source/cmMathCommand.h
+++ b/Source/cmMathCommand.h
@@ -21,17 +21,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmMathCommand;
-    }
+  virtual cmCommand* Clone() { return new cmMathCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -41,14 +38,12 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "math";}
+  virtual std::string GetName() const { return "math"; }
 
   cmTypeMacro(cmMathCommand, cmCommand);
-protected:
 
+protected:
   bool HandleExprCommand(std::vector<std::string> const& args);
 };
 
-
 #endif
-
diff --git a/Source/cmMessageCommand.cxx b/Source/cmMessageCommand.cxx
index 1c67cea..f4458a7 100644
--- a/Source/cmMessageCommand.cxx
+++ b/Source/cmMessageCommand.cxx
@@ -12,98 +12,68 @@
 #include "cmMessageCommand.h"
 
 // cmLibraryCommand
-bool cmMessageCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmMessageCommand::InitialPass(std::vector<std::string> const& args,
+                                   cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::vector<std::string>::const_iterator i = args.begin();
 
   cmake::MessageType type = cmake::MESSAGE;
   bool status = false;
   bool fatal = false;
   cmake* cm = this->Makefile->GetCMakeInstance();
-  if (*i == "SEND_ERROR")
-    {
+  if (*i == "SEND_ERROR") {
     type = cmake::FATAL_ERROR;
     ++i;
-    }
-  else if (*i == "FATAL_ERROR")
-    {
+  } else if (*i == "FATAL_ERROR") {
     fatal = true;
     type = cmake::FATAL_ERROR;
     ++i;
-    }
-  else if (*i == "WARNING")
-    {
+  } else if (*i == "WARNING") {
     type = cmake::WARNING;
     ++i;
-    }
-  else if (*i == "AUTHOR_WARNING")
-    {
-    if (cm->GetDevWarningsAsErrors(this->Makefile))
-      {
+  } else if (*i == "AUTHOR_WARNING") {
+    if (cm->GetDevWarningsAsErrors(this->Makefile)) {
       fatal = true;
       type = cmake::AUTHOR_ERROR;
-      }
-    else if (!cm->GetSuppressDevWarnings(this->Makefile))
-      {
+    } else if (!cm->GetSuppressDevWarnings(this->Makefile)) {
       type = cmake::AUTHOR_WARNING;
-      }
-    else
-      {
+    } else {
       return true;
-      }
-    ++i;
     }
-  else if (*i == "STATUS")
-    {
+    ++i;
+  } else if (*i == "STATUS") {
     status = true;
     ++i;
-    }
-  else if (*i == "DEPRECATION")
-    {
-    if (cm->GetDeprecatedWarningsAsErrors(this->Makefile))
-      {
+  } else if (*i == "DEPRECATION") {
+    if (cm->GetDeprecatedWarningsAsErrors(this->Makefile)) {
       fatal = true;
       type = cmake::DEPRECATION_ERROR;
-      }
-    else if (!cm->GetSuppressDeprecatedWarnings(this->Makefile))
-      {
+    } else if (!cm->GetSuppressDeprecatedWarnings(this->Makefile)) {
       type = cmake::DEPRECATION_WARNING;
-      }
-    else
-      {
+    } else {
       return true;
-      }
-    ++i;
     }
+    ++i;
+  }
 
   std::string message = cmJoin(cmMakeRange(i, args.end()), std::string());
 
-  if (type != cmake::MESSAGE)
-    {
+  if (type != cmake::MESSAGE) {
     // we've overriden the message type, above, so force IssueMessage to use it
     this->Makefile->IssueMessage(type, message, true);
-    }
-  else
-    {
-    if (status)
-      {
+  } else {
+    if (status) {
       this->Makefile->DisplayStatus(message.c_str(), -1);
-      }
-    else
-      {
+    } else {
       cmSystemTools::Message(message.c_str());
-      }
     }
-  if(fatal)
-    {
+  }
+  if (fatal) {
     cmSystemTools::SetFatalErrorOccured();
-    }
+  }
   return true;
 }
-
diff --git a/Source/cmMessageCommand.h b/Source/cmMessageCommand.h
index c0ae2a3..afc5509 100644
--- a/Source/cmMessageCommand.h
+++ b/Source/cmMessageCommand.h
@@ -24,22 +24,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmMessageCommand;
-    }
+  virtual cmCommand* Clone() { return new cmMessageCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "message";}
+  virtual std::string GetName() const { return "message"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -49,5 +46,4 @@ public:
   cmTypeMacro(cmMessageCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmNewLineStyle.cxx b/Source/cmNewLineStyle.cxx
index 08f0b5b..c03f60d 100644
--- a/Source/cmNewLineStyle.cxx
+++ b/Source/cmNewLineStyle.cxx
@@ -11,82 +11,65 @@
 ============================================================================*/
 #include "cmNewLineStyle.h"
 
-
-
-cmNewLineStyle::cmNewLineStyle() : NewLineStyle(Invalid)
+cmNewLineStyle::cmNewLineStyle()
+  : NewLineStyle(Invalid)
 {
 }
 
-
 bool cmNewLineStyle::IsValid() const
 {
   return NewLineStyle != Invalid;
 }
 
-
 bool cmNewLineStyle::ReadFromArguments(const std::vector<std::string>& args,
                                        std::string& errorString)
 {
   NewLineStyle = Invalid;
 
-  for (size_t i = 0; i< args.size(); i++)
-    {
-    if (args[i] == "NEWLINE_STYLE")
-      {
+  for (size_t i = 0; i < args.size(); i++) {
+    if (args[i] == "NEWLINE_STYLE") {
       size_t const styleIndex = i + 1;
-      if (args.size() > styleIndex)
-        {
+      if (args.size() > styleIndex) {
         const std::string eol = args[styleIndex];
-        if (eol == "LF" || eol == "UNIX")
-          {
+        if (eol == "LF" || eol == "UNIX") {
           NewLineStyle = LF;
           return true;
-          }
-        else if (eol == "CRLF" || eol == "WIN32" || eol == "DOS")
-          {
+        } else if (eol == "CRLF" || eol == "WIN32" || eol == "DOS") {
           NewLineStyle = CRLF;
           return true;
-          }
-        else
-          {
+        } else {
           errorString = "NEWLINE_STYLE sets an unknown style, only LF, "
                         "CRLF, UNIX, DOS, and WIN32 are supported";
           return false;
-          }
         }
-      else
-        {
+      } else {
         errorString = "NEWLINE_STYLE must set a style: "
                       "LF, CRLF, UNIX, DOS, or WIN32";
         return false;
-        }
       }
     }
+  }
   return true;
 }
 
-
 const std::string cmNewLineStyle::GetCharacters() const
 {
-  switch (NewLineStyle)
-    {
+  switch (NewLineStyle) {
     case Invalid:
       return "";
     case LF:
       return "\n";
     case CRLF:
       return "\r\n";
-    }
+  }
   return "";
 }
 
-
 void cmNewLineStyle::SetStyle(Style style)
 {
   NewLineStyle = style;
 }
 
-
 cmNewLineStyle::Style cmNewLineStyle::GetStyle() const
 {
   return NewLineStyle;
diff --git a/Source/cmNewLineStyle.h b/Source/cmNewLineStyle.h
index cae1106..800f131 100644
--- a/Source/cmNewLineStyle.h
+++ b/Source/cmNewLineStyle.h
@@ -17,16 +17,15 @@
 class cmNewLineStyle
 {
 public:
-
   cmNewLineStyle();
 
   enum Style
   {
     Invalid,
-               // LF = '\n', 0x0A, 10
-               // CR = '\r', 0x0D, 13
-    LF,        // Unix
-    CRLF       // Dos
+    // LF = '\n', 0x0A, 10
+    // CR = '\r', 0x0D, 13
+    LF,  // Unix
+    CRLF // Dos
   };
 
   void SetStyle(Style);
@@ -35,7 +34,7 @@ public:
   bool IsValid() const;
 
   bool ReadFromArguments(const std::vector<std::string>& args,
-                         std::string &errorString);
+                         std::string& errorString);
 
   const std::string GetCharacters() const;
 
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index 04e84fe..831d44b 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -30,9 +30,8 @@
 #include <unistd.h>
 #endif
 
-
-cmNinjaNormalTargetGenerator::
-cmNinjaNormalTargetGenerator(cmGeneratorTarget* target)
+cmNinjaNormalTargetGenerator::cmNinjaNormalTargetGenerator(
+  cmGeneratorTarget* target)
   : cmNinjaTargetGenerator(target)
   , TargetNameOut()
   , TargetNameSO()
@@ -43,28 +42,23 @@ cmNinjaNormalTargetGenerator(cmGeneratorTarget* target)
 {
   this->TargetLinkLanguage = target->GetLinkerLanguage(this->GetConfigName());
   if (target->GetType() == cmState::EXECUTABLE)
-    this->GetGeneratorTarget()->GetExecutableNames(this->TargetNameOut,
-                               this->TargetNameReal,
-                               this->TargetNameImport,
-                               this->TargetNamePDB,
-                               GetLocalGenerator()->GetConfigName());
+    this->GetGeneratorTarget()->GetExecutableNames(
+      this->TargetNameOut, this->TargetNameReal, this->TargetNameImport,
+      this->TargetNamePDB, GetLocalGenerator()->GetConfigName());
   else
-    this->GetGeneratorTarget()->GetLibraryNames(this->TargetNameOut,
-                            this->TargetNameSO,
-                            this->TargetNameReal,
-                            this->TargetNameImport,
-                            this->TargetNamePDB,
-                            GetLocalGenerator()->GetConfigName());
-
-  if(target->GetType() != cmState::OBJECT_LIBRARY)
-    {
+    this->GetGeneratorTarget()->GetLibraryNames(
+      this->TargetNameOut, this->TargetNameSO, this->TargetNameReal,
+      this->TargetNameImport, this->TargetNamePDB,
+      GetLocalGenerator()->GetConfigName());
+
+  if (target->GetType() != cmState::OBJECT_LIBRARY) {
     // on Windows the output dir is already needed at compile time
     // ensure the directory exists (OutDir test)
     EnsureDirectoryExists(target->GetDirectory(this->GetConfigName()));
-    }
+  }
 
-  this->OSXBundleGenerator = new cmOSXBundleGenerator(target,
-                                                      this->GetConfigName());
+  this->OSXBundleGenerator =
+    new cmOSXBundleGenerator(target, this->GetConfigName());
   this->OSXBundleGenerator->SetMacContentFolders(&this->MacContentFolders);
 }
 
@@ -88,14 +82,11 @@ void cmNinjaNormalTargetGenerator::Generate()
   // Write the build statements
   this->WriteObjectBuildStatements();
 
-  if(this->GetGeneratorTarget()->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  if (this->GetGeneratorTarget()->GetType() == cmState::OBJECT_LIBRARY) {
     this->WriteObjectLibStatement();
-    }
-  else
-    {
+  } else {
     this->WriteLinkStatement();
-    }
+  }
 }
 
 void cmNinjaNormalTargetGenerator::WriteLanguagesRules()
@@ -105,34 +96,28 @@ void cmNinjaNormalTargetGenerator::WriteLanguagesRules()
   this->GetRulesFileStream()
     << "# Rules for each languages for "
     << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
-    << " target "
-    << this->GetTargetName()
-    << "\n\n";
+    << " target " << this->GetTargetName() << "\n\n";
 #endif
 
   // Write rules for languages compiled in this target.
   std::set<std::string> languages;
   std::vector<cmSourceFile*> sourceFiles;
-  this->GetGeneratorTarget()->GetSourceFiles(sourceFiles,
-    this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
-  for(std::vector<cmSourceFile*>::const_iterator
-        i = sourceFiles.begin(); i != sourceFiles.end(); ++i)
-    {
+  this->GetGeneratorTarget()->GetSourceFiles(
+    sourceFiles, this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE"));
+  for (std::vector<cmSourceFile*>::const_iterator i = sourceFiles.begin();
+       i != sourceFiles.end(); ++i) {
     const std::string& lang = (*i)->GetLanguage();
-    if(!lang.empty())
-      {
+    if (!lang.empty()) {
       languages.insert(lang);
-      }
     }
-  for(std::set<std::string>::const_iterator l = languages.begin();
-      l != languages.end();
-      ++l)
-    {
+  }
+  for (std::set<std::string>::const_iterator l = languages.begin();
+       l != languages.end(); ++l) {
     this->WriteLanguageRules(*l);
-    }
+  }
 }
 
-const char *cmNinjaNormalTargetGenerator::GetVisibleTypeName() const
+const char* cmNinjaNormalTargetGenerator::GetVisibleTypeName() const
 {
   switch (this->GetGeneratorTarget()->GetType()) {
     case cmState::STATIC_LIBRARY:
@@ -151,25 +136,17 @@ const char *cmNinjaNormalTargetGenerator::GetVisibleTypeName() const
   }
 }
 
-std::string
-cmNinjaNormalTargetGenerator
-::LanguageLinkerRule() const
+std::string cmNinjaNormalTargetGenerator::LanguageLinkerRule() const
 {
-  return this->TargetLinkLanguage
-    + "_"
-    + cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
-    + "_LINKER__"
-    + cmGlobalNinjaGenerator::EncodeRuleName(
-        this->GetGeneratorTarget()->GetName())
-    ;
+  return this->TargetLinkLanguage + "_" +
+    cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType()) +
+    "_LINKER__" + cmGlobalNinjaGenerator::EncodeRuleName(
+                    this->GetGeneratorTarget()->GetName());
 }
 
-void
-cmNinjaNormalTargetGenerator
-::WriteLinkRule(bool useResponseFile)
+void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile)
 {
-  cmState::TargetType targetType =
-      this->GetGeneratorTarget()->GetType();
+  cmState::TargetType targetType = this->GetGeneratorTarget()->GetType();
   std::string ruleName = this->LanguageLinkerRule();
 
   // Select whether to use a response file for objects.
@@ -187,29 +164,29 @@ cmNinjaNormalTargetGenerator
       vars.Objects = "$in";
       vars.LinkLibraries = "$LINK_PATH $LINK_LIBRARIES";
     } else {
-        std::string cmakeVarLang = "CMAKE_";
-        cmakeVarLang += this->TargetLinkLanguage;
-
-        // build response file name
-        std::string cmakeLinkVar =  cmakeVarLang + "_RESPONSE_FILE_LINK_FLAG";
-        const char * flag = GetMakefile()->GetDefinition(cmakeLinkVar);
-        if(flag) {
-          responseFlag = flag;
-        } else {
-          responseFlag = "@";
-        }
-        rspfile = "$RSP_FILE";
-        responseFlag += rspfile;
-
-        // build response file content
-        if (this->GetGlobalGenerator()->IsGCCOnWindows()) {
-          rspcontent = "$in";
-        } else {
-          rspcontent = "$in_newline";
-        }
-        rspcontent += " $LINK_PATH $LINK_LIBRARIES";
-        vars.Objects = responseFlag.c_str();
-        vars.LinkLibraries = "";
+      std::string cmakeVarLang = "CMAKE_";
+      cmakeVarLang += this->TargetLinkLanguage;
+
+      // build response file name
+      std::string cmakeLinkVar = cmakeVarLang + "_RESPONSE_FILE_LINK_FLAG";
+      const char* flag = GetMakefile()->GetDefinition(cmakeLinkVar);
+      if (flag) {
+        responseFlag = flag;
+      } else {
+        responseFlag = "@";
+      }
+      rspfile = "$RSP_FILE";
+      responseFlag += rspfile;
+
+      // build response file content
+      if (this->GetGlobalGenerator()->IsGCCOnWindows()) {
+        rspcontent = "$in";
+      } else {
+        rspcontent = "$in_newline";
+      }
+      rspcontent += " $LINK_PATH $LINK_LIBRARIES";
+      vars.Objects = responseFlag.c_str();
+      vars.LinkLibraries = "";
     }
 
     vars.ObjectDir = "$OBJECT_DIR";
@@ -225,15 +202,15 @@ cmNinjaNormalTargetGenerator
     std::string targetVersionMajor;
     std::string targetVersionMinor;
     {
-    std::ostringstream majorStream;
-    std::ostringstream minorStream;
-    int major;
-    int minor;
-    this->GetGeneratorTarget()->GetTargetVersion(major, minor);
-    majorStream << major;
-    minorStream << minor;
-    targetVersionMajor = majorStream.str();
-    targetVersionMinor = minorStream.str();
+      std::ostringstream majorStream;
+      std::ostringstream minorStream;
+      int major;
+      int minor;
+      this->GetGeneratorTarget()->GetTargetVersion(major, minor);
+      majorStream << major;
+      minorStream << minor;
+      targetVersionMajor = majorStream.str();
+      targetVersionMinor = minorStream.str();
     }
     vars.TargetVersionMajor = targetVersionMajor.c_str();
     vars.TargetVersionMinor = targetVersionMinor.c_str();
@@ -243,20 +220,17 @@ cmNinjaNormalTargetGenerator
     vars.Manifests = "$MANIFESTS";
 
     std::string langFlags;
-    if (targetType != cmState::EXECUTABLE)
-      {
+    if (targetType != cmState::EXECUTABLE) {
       langFlags += "$LANGUAGE_COMPILE_FLAGS $ARCH_FLAGS";
       vars.LanguageCompileFlags = langFlags.c_str();
-      }
+    }
 
     // Rule for linking library/executable.
     std::vector<std::string> linkCmds = this->ComputeLinkCmd();
-    for(std::vector<std::string>::iterator i = linkCmds.begin();
-        i != linkCmds.end();
-        ++i)
-      {
+    for (std::vector<std::string>::iterator i = linkCmds.begin();
+         i != linkCmds.end(); ++i) {
       this->GetLocalGenerator()->ExpandRuleVariables(*i, vars);
-      }
+    }
     linkCmds.insert(linkCmds.begin(), "$PRE_LINK");
     linkCmds.push_back("$POST_BUILD");
     std::string linkCmd =
@@ -269,93 +243,84 @@ cmNinjaNormalTargetGenerator
     std::ostringstream description;
     description << "Linking " << this->TargetLinkLanguage << " "
                 << this->GetVisibleTypeName() << " $TARGET_FILE";
-    this->GetGlobalGenerator()->AddRule(ruleName,
-                                        linkCmd,
-                                        description.str(),
+    this->GetGlobalGenerator()->AddRule(ruleName, linkCmd, description.str(),
                                         comment.str(),
                                         /*depfile*/ "",
-                                        /*deptype*/ "",
-                                        rspfile,
-                                        rspcontent,
+                                        /*deptype*/ "", rspfile, rspcontent,
                                         /*restat*/ "$RESTAT",
                                         /*generator*/ false);
   }
 
   if (this->TargetNameOut != this->TargetNameReal &&
-    !this->GetGeneratorTarget()->IsFrameworkOnApple()) {
+      !this->GetGeneratorTarget()->IsFrameworkOnApple()) {
     std::string cmakeCommand =
       this->GetLocalGenerator()->ConvertToOutputFormat(
         cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
     if (targetType == cmState::EXECUTABLE)
-      this->GetGlobalGenerator()->AddRule("CMAKE_SYMLINK_EXECUTABLE",
-                                          cmakeCommand +
-                                          " -E cmake_symlink_executable"
-                                          " $in $out && $POST_BUILD",
-                                          "Creating executable symlink $out",
-                                          "Rule for creating "
-                                          "executable symlink.",
-                                          /*depfile*/ "",
-                                          /*deptype*/ "",
-                                          /*rspfile*/ "",
-                                          /*rspcontent*/ "",
-                                          /*restat*/ "",
-                                          /*generator*/ false);
+      this->GetGlobalGenerator()->AddRule(
+        "CMAKE_SYMLINK_EXECUTABLE",
+        cmakeCommand + " -E cmake_symlink_executable"
+                       " $in $out && $POST_BUILD",
+        "Creating executable symlink $out", "Rule for creating "
+                                            "executable symlink.",
+        /*depfile*/ "",
+        /*deptype*/ "",
+        /*rspfile*/ "",
+        /*rspcontent*/ "",
+        /*restat*/ "",
+        /*generator*/ false);
     else
-      this->GetGlobalGenerator()->AddRule("CMAKE_SYMLINK_LIBRARY",
-                                          cmakeCommand +
-                                          " -E cmake_symlink_library"
-                                          " $in $SONAME $out && $POST_BUILD",
-                                          "Creating library symlink $out",
-                                          "Rule for creating "
-                                          "library symlink.",
-                                          /*depfile*/ "",
-                                          /*deptype*/ "",
-                                          /*rspfile*/ "",
-                                          /*rspcontent*/ "",
-                                          /*restat*/ "",
-                                          /*generator*/ false);
+      this->GetGlobalGenerator()->AddRule(
+        "CMAKE_SYMLINK_LIBRARY",
+        cmakeCommand + " -E cmake_symlink_library"
+                       " $in $SONAME $out && $POST_BUILD",
+        "Creating library symlink $out", "Rule for creating "
+                                         "library symlink.",
+        /*depfile*/ "",
+        /*deptype*/ "",
+        /*rspfile*/ "",
+        /*rspcontent*/ "",
+        /*restat*/ "",
+        /*generator*/ false);
   }
 }
 
-std::vector<std::string>
-cmNinjaNormalTargetGenerator
-::ComputeLinkCmd()
+std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeLinkCmd()
 {
   std::vector<std::string> linkCmds;
   cmMakefile* mf = this->GetMakefile();
   {
-  std::string linkCmdVar = this->GetGeneratorTarget()
-    ->GetCreateRuleVariable(this->TargetLinkLanguage, this->GetConfigName());
-  const char *linkCmd = mf->GetDefinition(linkCmdVar);
-  if (linkCmd)
-    {
-    cmSystemTools::ExpandListArgument(linkCmd, linkCmds);
-    return linkCmds;
+    std::string linkCmdVar = this->GetGeneratorTarget()->GetCreateRuleVariable(
+      this->TargetLinkLanguage, this->GetConfigName());
+    const char* linkCmd = mf->GetDefinition(linkCmdVar);
+    if (linkCmd) {
+      cmSystemTools::ExpandListArgument(linkCmd, linkCmds);
+      return linkCmds;
     }
   }
   switch (this->GetGeneratorTarget()->GetType()) {
     case cmState::STATIC_LIBRARY: {
       // We have archive link commands set. First, delete the existing archive.
       {
-      std::string cmakeCommand =
-        this->GetLocalGenerator()->ConvertToOutputFormat(
-          cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
-      linkCmds.push_back(cmakeCommand + " -E remove $TARGET_FILE");
+        std::string cmakeCommand =
+          this->GetLocalGenerator()->ConvertToOutputFormat(
+            cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+        linkCmds.push_back(cmakeCommand + " -E remove $TARGET_FILE");
       }
       // TODO: Use ARCHIVE_APPEND for archives over a certain size.
       {
-      std::string linkCmdVar = "CMAKE_";
-      linkCmdVar += this->TargetLinkLanguage;
-      linkCmdVar += "_ARCHIVE_CREATE";
-      const char *linkCmd = mf->GetRequiredDefinition(linkCmdVar);
-      cmSystemTools::ExpandListArgument(linkCmd, linkCmds);
+        std::string linkCmdVar = "CMAKE_";
+        linkCmdVar += this->TargetLinkLanguage;
+        linkCmdVar += "_ARCHIVE_CREATE";
+        const char* linkCmd = mf->GetRequiredDefinition(linkCmdVar);
+        cmSystemTools::ExpandListArgument(linkCmd, linkCmds);
       }
       {
-      std::string linkCmdVar = "CMAKE_";
-      linkCmdVar += this->TargetLinkLanguage;
-      linkCmdVar += "_ARCHIVE_FINISH";
-      const char *linkCmd = mf->GetRequiredDefinition(linkCmdVar);
-      cmSystemTools::ExpandListArgument(linkCmd, linkCmds);
+        std::string linkCmdVar = "CMAKE_";
+        linkCmdVar += this->TargetLinkLanguage;
+        linkCmdVar += "_ARCHIVE_FINISH";
+        const char* linkCmd = mf->GetRequiredDefinition(linkCmdVar);
+        cmSystemTools::ExpandListArgument(linkCmd, linkCmds);
       }
       return linkCmds;
     }
@@ -369,7 +334,6 @@ cmNinjaNormalTargetGenerator
   return std::vector<std::string>();
 }
 
-
 static int calculateCommandLineLengthLimit(int linkRuleLength)
 {
   static int const limits[] = {
@@ -389,31 +353,27 @@ static int calculateCommandLineLengthLimit(int linkRuleLength)
 
   size_t const arrSz = cmArraySize(limits);
   int const sz = *std::min_element(limits, limits + arrSz);
-  if (sz == std::numeric_limits<int>::max())
-    {
+  if (sz == std::numeric_limits<int>::max()) {
     return -1;
-    }
+  }
 
   return sz - linkRuleLength;
 }
 
-
 void cmNinjaNormalTargetGenerator::WriteLinkStatement()
 {
   cmGeneratorTarget& gt = *this->GetGeneratorTarget();
   const std::string cfgName = this->GetConfigName();
-  std::string targetOutput = ConvertToNinjaPath(
-                               gt.GetFullPath(cfgName));
-  std::string targetOutputReal = ConvertToNinjaPath(
-                                   gt.GetFullPath(cfgName,
+  std::string targetOutput = ConvertToNinjaPath(gt.GetFullPath(cfgName));
+  std::string targetOutputReal =
+    ConvertToNinjaPath(gt.GetFullPath(cfgName,
                                       /*implib=*/false,
                                       /*realpath=*/true));
-  std::string targetOutputImplib = ConvertToNinjaPath(
-                                     gt.GetFullPath(cfgName,
-                                       /*implib=*/true));
+  std::string targetOutputImplib =
+    ConvertToNinjaPath(gt.GetFullPath(cfgName,
+                                      /*implib=*/true));
 
-  if (gt.IsAppBundleOnApple())
-    {
+  if (gt.IsAppBundleOnApple()) {
     // Create the app bundle
     std::string outpath = gt.GetDirectory(cfgName);
     this->OSXBundleGenerator->CreateAppBundle(this->TargetNameOut, outpath);
@@ -427,37 +387,30 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
     targetOutputReal += "/";
     targetOutputReal += this->TargetNameReal;
     targetOutputReal = this->ConvertToNinjaPath(targetOutputReal);
-    }
-  else if (gt.IsFrameworkOnApple())
-    {
+  } else if (gt.IsFrameworkOnApple()) {
     // Create the library framework.
     this->OSXBundleGenerator->CreateFramework(this->TargetNameOut,
                                               gt.GetDirectory(cfgName));
-    }
-  else if(gt.IsCFBundleOnApple())
-    {
+  } else if (gt.IsCFBundleOnApple()) {
     // Create the core foundation bundle.
     this->OSXBundleGenerator->CreateCFBundle(this->TargetNameOut,
                                              gt.GetDirectory(cfgName));
-    }
+  }
 
   // Write comments.
   cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream());
   const cmState::TargetType targetType = gt.GetType();
-  this->GetBuildFileStream()
-    << "# Link build statements for "
-    << cmState::GetTargetTypeName(targetType)
-    << " target "
-    << this->GetTargetName()
-    << "\n\n";
+  this->GetBuildFileStream() << "# Link build statements for "
+                             << cmState::GetTargetTypeName(targetType)
+                             << " target " << this->GetTargetName() << "\n\n";
 
   cmNinjaDeps emptyDeps;
   cmNinjaVars vars;
 
   // Compute the comment.
   std::ostringstream comment;
-  comment <<
-    "Link the " << this->GetVisibleTypeName() << " " << targetOutputReal;
+  comment << "Link the " << this->GetVisibleTypeName() << " "
+          << targetOutputReal;
 
   // Compute outputs.
   cmNinjaDeps outputs;
@@ -473,53 +426,43 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
   std::string linkPath;
   cmGeneratorTarget& genTarget = *this->GetGeneratorTarget();
 
-  std::string createRule =
-    genTarget.GetCreateRuleVariable(this->TargetLinkLanguage,
-                                    this->GetConfigName());
-  bool useWatcomQuote = mf->IsOn(createRule+"_USE_WATCOM_QUOTE");
+  std::string createRule = genTarget.GetCreateRuleVariable(
+    this->TargetLinkLanguage, this->GetConfigName());
+  bool useWatcomQuote = mf->IsOn(createRule + "_USE_WATCOM_QUOTE");
   cmLocalNinjaGenerator& localGen = *this->GetLocalGenerator();
 
   vars["TARGET_FILE"] =
     localGen.ConvertToOutputFormat(targetOutputReal, cmLocalGenerator::SHELL);
 
-  localGen.GetTargetFlags(vars["LINK_LIBRARIES"],
-                          vars["FLAGS"],
-                          vars["LINK_FLAGS"],
-                          frameworkPath,
-                          linkPath,
-                          &genTarget,
-                          useWatcomQuote);
-  if(this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")
-     && gt.GetType() == cmState::SHARED_LIBRARY)
-    {
-    if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
-      std::string name_of_def_file
-        = gt.GetSupportDirectory();
+  localGen.GetTargetFlags(vars["LINK_LIBRARIES"], vars["FLAGS"],
+                          vars["LINK_FLAGS"], frameworkPath, linkPath,
+                          &genTarget, useWatcomQuote);
+  if (this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS") &&
+      gt.GetType() == cmState::SHARED_LIBRARY) {
+    if (gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) {
+      std::string name_of_def_file = gt.GetSupportDirectory();
       name_of_def_file += "/" + gt.GetName();
       name_of_def_file += ".def ";
       vars["LINK_FLAGS"] += " /DEF:";
-      vars["LINK_FLAGS"] += this->GetLocalGenerator()
-        ->ConvertToOutputFormat(name_of_def_file.c_str(),
-                                cmLocalGenerator::SHELL);
-      }
+      vars["LINK_FLAGS"] += this->GetLocalGenerator()->ConvertToOutputFormat(
+        name_of_def_file.c_str(), cmLocalGenerator::SHELL);
     }
+  }
 
   // Add OS X version flags, if any.
-  if(this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
-     this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
+      this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
     this->AppendOSXVerFlag(vars["LINK_FLAGS"], this->TargetLinkLanguage,
                            "COMPATIBILITY", true);
     this->AppendOSXVerFlag(vars["LINK_FLAGS"], this->TargetLinkLanguage,
                            "CURRENT", false);
-    }
+  }
 
   this->addPoolNinjaVariable("JOB_POOL_LINK", &gt, vars);
 
   this->AddModuleDefinitionFlag(vars["LINK_FLAGS"]);
-  vars["LINK_FLAGS"] = cmGlobalNinjaGenerator
-                        ::EncodeLiteral(vars["LINK_FLAGS"]);
+  vars["LINK_FLAGS"] =
+    cmGlobalNinjaGenerator::EncodeLiteral(vars["LINK_FLAGS"]);
 
   vars["MANIFESTS"] = this->GetManifests();
 
@@ -528,56 +471,45 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
   // Compute architecture specific link flags.  Yes, these go into a different
   // variable for executables, probably due to a mistake made when duplicating
   // code between the Makefile executable and library generators.
-  if (targetType == cmState::EXECUTABLE)
-    {
+  if (targetType == cmState::EXECUTABLE) {
     std::string t = vars["FLAGS"];
     localGen.AddArchitectureFlags(t, &genTarget, TargetLinkLanguage, cfgName);
     vars["FLAGS"] = t;
-    }
-  else
-    {
+  } else {
     std::string t = vars["ARCH_FLAGS"];
     localGen.AddArchitectureFlags(t, &genTarget, TargetLinkLanguage, cfgName);
     vars["ARCH_FLAGS"] = t;
     t = "";
     localGen.AddLanguageFlags(t, TargetLinkLanguage, cfgName);
     vars["LANGUAGE_COMPILE_FLAGS"] = t;
-    }
+  }
 
-  if (this->GetGeneratorTarget()->HasSOName(cfgName))
-    {
+  if (this->GetGeneratorTarget()->HasSOName(cfgName)) {
     vars["SONAME_FLAG"] = mf->GetSONameFlag(this->TargetLinkLanguage);
     vars["SONAME"] = this->TargetNameSO;
-    if (targetType == cmState::SHARED_LIBRARY)
-      {
+    if (targetType == cmState::SHARED_LIBRARY) {
       std::string install_dir =
-          this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName);
-      if (!install_dir.empty())
-        {
-        vars["INSTALLNAME_DIR"] = localGen.Convert(install_dir,
-                                                   cmLocalGenerator::NONE,
-                                                   cmLocalGenerator::SHELL);
-        }
+        this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(cfgName);
+      if (!install_dir.empty()) {
+        vars["INSTALLNAME_DIR"] = localGen.Convert(
+          install_dir, cmLocalGenerator::NONE, cmLocalGenerator::SHELL);
       }
     }
+  }
 
   cmNinjaDeps byproducts;
 
-  if (!this->TargetNameImport.empty())
-    {
+  if (!this->TargetNameImport.empty()) {
     const std::string impLibPath = localGen.ConvertToOutputFormat(
-                                              targetOutputImplib,
-                                              cmLocalGenerator::SHELL);
+      targetOutputImplib, cmLocalGenerator::SHELL);
     vars["TARGET_IMPLIB"] = impLibPath;
     EnsureParentDirectoryExists(impLibPath);
-    if(genTarget.HasImportLibrary())
-      {
+    if (genTarget.HasImportLibrary()) {
       byproducts.push_back(targetOutputImplib);
-      }
     }
+  }
 
-  if (!this->SetMsvcTargetPdbVariable(vars))
-    {
+  if (!this->SetMsvcTargetPdbVariable(vars)) {
     // It is common to place debug symbols at a specific place,
     // so we need a plain target name in the rule available.
     std::string prefix;
@@ -586,198 +518,155 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
     this->GetGeneratorTarget()->GetFullNameComponents(prefix, base, suffix);
     std::string dbg_suffix = ".dbg";
     // TODO: Where to document?
-    if (mf->GetDefinition("CMAKE_DEBUG_SYMBOL_SUFFIX"))
-      {
+    if (mf->GetDefinition("CMAKE_DEBUG_SYMBOL_SUFFIX")) {
       dbg_suffix = mf->GetDefinition("CMAKE_DEBUG_SYMBOL_SUFFIX");
-      }
-    vars["TARGET_PDB"] = base + suffix + dbg_suffix;
     }
+    vars["TARGET_PDB"] = base + suffix + dbg_suffix;
+  }
 
   const std::string objPath = GetGeneratorTarget()->GetSupportDirectory();
-  vars["OBJECT_DIR"] =
-    this->GetLocalGenerator()->ConvertToOutputFormat(
-      this->ConvertToNinjaPath(objPath), cmLocalGenerator::SHELL);
+  vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
+    this->ConvertToNinjaPath(objPath), cmLocalGenerator::SHELL);
   EnsureDirectoryExists(objPath);
 
-  if (this->GetGlobalGenerator()->IsGCCOnWindows())
-    {
+  if (this->GetGlobalGenerator()->IsGCCOnWindows()) {
     // ar.exe can't handle backslashes in rsp files (implicitly used by gcc)
     std::string& linkLibraries = vars["LINK_LIBRARIES"];
     std::replace(linkLibraries.begin(), linkLibraries.end(), '\\', '/');
     std::string& link_path = vars["LINK_PATH"];
     std::replace(link_path.begin(), link_path.end(), '\\', '/');
-    }
+  }
 
-  const std::vector<cmCustomCommand> *cmdLists[3] = {
-    &gt.GetPreBuildCommands(),
-    &gt.GetPreLinkCommands(),
+  const std::vector<cmCustomCommand>* cmdLists[3] = {
+    &gt.GetPreBuildCommands(), &gt.GetPreLinkCommands(),
     &gt.GetPostBuildCommands()
   };
 
   std::vector<std::string> preLinkCmdLines, postBuildCmdLines;
-  std::vector<std::string> *cmdLineLists[3] = {
-    &preLinkCmdLines,
-    &preLinkCmdLines,
-    &postBuildCmdLines
-  };
-
-  for (unsigned i = 0; i != 3; ++i)
-    {
-    for (std::vector<cmCustomCommand>::const_iterator
-         ci = cmdLists[i]->begin();
-         ci != cmdLists[i]->end(); ++ci)
-      {
+  std::vector<std::string>* cmdLineLists[3] = { &preLinkCmdLines,
+                                                &preLinkCmdLines,
+                                                &postBuildCmdLines };
+
+  for (unsigned i = 0; i != 3; ++i) {
+    for (std::vector<cmCustomCommand>::const_iterator ci =
+           cmdLists[i]->begin();
+         ci != cmdLists[i]->end(); ++ci) {
       cmCustomCommandGenerator ccg(*ci, cfgName, this->GetLocalGenerator());
       localGen.AppendCustomCommandLines(ccg, *cmdLineLists[i]);
       std::vector<std::string> const& ccByproducts = ccg.GetByproducts();
       std::transform(ccByproducts.begin(), ccByproducts.end(),
                      std::back_inserter(byproducts), MapToNinjaPath());
-      }
     }
+  }
 
   // maybe create .def file from list of objects
   if (gt.GetType() == cmState::SHARED_LIBRARY &&
-      this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
-    {
-    if(gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
+      this->GetMakefile()->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) {
+    if (gt.GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS")) {
       std::string cmakeCommand =
-      this->GetLocalGenerator()->ConvertToOutputFormat(
-        cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
-      std::string name_of_def_file
-        = gt.GetSupportDirectory();
+        this->GetLocalGenerator()->ConvertToOutputFormat(
+          cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+      std::string name_of_def_file = gt.GetSupportDirectory();
       name_of_def_file += "/" + gt.GetName();
       name_of_def_file += ".def";
       std::string cmd = cmakeCommand;
       cmd += " -E __create_def ";
-      cmd += this->GetLocalGenerator()
-        ->ConvertToOutputFormat(name_of_def_file.c_str(),
-                                cmLocalGenerator::SHELL);
+      cmd += this->GetLocalGenerator()->ConvertToOutputFormat(
+        name_of_def_file.c_str(), cmLocalGenerator::SHELL);
       cmd += " ";
       cmNinjaDeps objs = this->GetObjects();
       std::string obj_list_file = name_of_def_file;
       obj_list_file += ".objs";
-      cmd += this->GetLocalGenerator()
-        ->ConvertToOutputFormat(obj_list_file.c_str(),
-                                cmLocalGenerator::SHELL);
+      cmd += this->GetLocalGenerator()->ConvertToOutputFormat(
+        obj_list_file.c_str(), cmLocalGenerator::SHELL);
       preLinkCmdLines.push_back(cmd);
       // create a list of obj files for the -E __create_def to read
       cmGeneratedFileStream fout(obj_list_file.c_str());
-      for(cmNinjaDeps::iterator i=objs.begin(); i != objs.end(); ++i)
-        {
-        if(cmHasLiteralSuffix(*i, ".obj"))
-          {
+      for (cmNinjaDeps::iterator i = objs.begin(); i != objs.end(); ++i) {
+        if (cmHasLiteralSuffix(*i, ".obj")) {
           fout << *i << "\n";
-          }
         }
       }
     }
+  }
   // If we have any PRE_LINK commands, we need to go back to HOME_OUTPUT for
   // the link commands.
-  if (!preLinkCmdLines.empty())
-    {
+  if (!preLinkCmdLines.empty()) {
     const std::string homeOutDir = localGen.ConvertToOutputFormat(
-                                            localGen.GetBinaryDirectory(),
-                                            cmLocalGenerator::SHELL);
+      localGen.GetBinaryDirectory(), cmLocalGenerator::SHELL);
     preLinkCmdLines.push_back("cd " + homeOutDir);
-    }
+  }
 
   vars["PRE_LINK"] = localGen.BuildCommandLine(preLinkCmdLines);
   std::string postBuildCmdLine = localGen.BuildCommandLine(postBuildCmdLines);
 
   cmNinjaVars symlinkVars;
-  if (targetOutput == targetOutputReal)
-    {
+  if (targetOutput == targetOutputReal) {
     vars["POST_BUILD"] = postBuildCmdLine;
-    }
-  else
-    {
+  } else {
     vars["POST_BUILD"] = ":";
     symlinkVars["POST_BUILD"] = postBuildCmdLine;
-    }
+  }
 
   cmGlobalNinjaGenerator& globalGen = *this->GetGlobalGenerator();
 
   int commandLineLengthLimit = -1;
-  if (!this->ForceResponseFile())
-    {
+  if (!this->ForceResponseFile()) {
     commandLineLengthLimit = calculateCommandLineLengthLimit(
-                globalGen.GetRuleCmdLength(this->LanguageLinkerRule()));
-    }
+      globalGen.GetRuleCmdLength(this->LanguageLinkerRule()));
+  }
 
   const std::string rspfile =
-      std::string(cmake::GetCMakeFilesDirectoryPostSlash())
-      + gt.GetName() + ".rsp";
+    std::string(cmake::GetCMakeFilesDirectoryPostSlash()) + gt.GetName() +
+    ".rsp";
 
   // Gather order-only dependencies.
   cmNinjaDeps orderOnlyDeps;
   this->GetLocalGenerator()->AppendTargetDepends(this->GetGeneratorTarget(),
-    orderOnlyDeps);
+                                                 orderOnlyDeps);
 
   // Ninja should restat after linking if and only if there are byproducts.
-  vars["RESTAT"] = byproducts.empty()? "" : "1";
+  vars["RESTAT"] = byproducts.empty() ? "" : "1";
 
   for (cmNinjaDeps::const_iterator oi = byproducts.begin(),
-         oe = byproducts.end();
-       oi != oe; ++oi)
-    {
+                                   oe = byproducts.end();
+       oi != oe; ++oi) {
     this->GetGlobalGenerator()->SeenCustomCommandOutput(*oi);
     outputs.push_back(*oi);
-    }
+  }
 
   // Write the build statement for this target.
   bool usedResponseFile = false;
-  globalGen.WriteBuild(this->GetBuildFileStream(),
-                        comment.str(),
-                        this->LanguageLinkerRule(),
-                        outputs,
-                        explicitDeps,
-                        implicitDeps,
-                        orderOnlyDeps,
-                        vars,
-                        rspfile,
-                        commandLineLengthLimit,
-                        &usedResponseFile);
+  globalGen.WriteBuild(this->GetBuildFileStream(), comment.str(),
+                       this->LanguageLinkerRule(), outputs, explicitDeps,
+                       implicitDeps, orderOnlyDeps, vars, rspfile,
+                       commandLineLengthLimit, &usedResponseFile);
   this->WriteLinkRule(usedResponseFile);
 
-  if (targetOutput != targetOutputReal && !gt.IsFrameworkOnApple())
-    {
-    if (targetType == cmState::EXECUTABLE)
-      {
-      globalGen.WriteBuild(this->GetBuildFileStream(),
-                            "Create executable symlink " + targetOutput,
-                            "CMAKE_SYMLINK_EXECUTABLE",
-                            cmNinjaDeps(1, targetOutput),
-                            cmNinjaDeps(1, targetOutputReal),
-                            emptyDeps,
-                            emptyDeps,
-                            symlinkVars);
-      }
-   else
-     {
+  if (targetOutput != targetOutputReal && !gt.IsFrameworkOnApple()) {
+    if (targetType == cmState::EXECUTABLE) {
+      globalGen.WriteBuild(
+        this->GetBuildFileStream(),
+        "Create executable symlink " + targetOutput,
+        "CMAKE_SYMLINK_EXECUTABLE", cmNinjaDeps(1, targetOutput),
+        cmNinjaDeps(1, targetOutputReal), emptyDeps, emptyDeps, symlinkVars);
+    } else {
       cmNinjaDeps symlinks;
       const std::string soName = this->GetTargetFilePath(this->TargetNameSO);
       // If one link has to be created.
-      if (targetOutputReal == soName || targetOutput == soName)
-        {
+      if (targetOutputReal == soName || targetOutput == soName) {
         symlinkVars["SONAME"] = soName;
-        }
-      else
-        {
+      } else {
         symlinkVars["SONAME"] = "";
         symlinks.push_back(soName);
-        }
-      symlinks.push_back(targetOutput);
-      globalGen.WriteBuild(this->GetBuildFileStream(),
-                                  "Create library symlink " + targetOutput,
-                                     "CMAKE_SYMLINK_LIBRARY",
-                                  symlinks,
-                                  cmNinjaDeps(1, targetOutputReal),
-                                  emptyDeps,
-                                  emptyDeps,
-                                  symlinkVars);
       }
+      symlinks.push_back(targetOutput);
+      globalGen.WriteBuild(
+        this->GetBuildFileStream(), "Create library symlink " + targetOutput,
+        "CMAKE_SYMLINK_LIBRARY", symlinks, cmNinjaDeps(1, targetOutputReal),
+        emptyDeps, emptyDeps, symlinkVars);
     }
+  }
 
   // Add aliases for the file name and the target name.
   globalGen.AddTargetAlias(this->TargetNameOut, &gt);
@@ -791,11 +680,9 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement()
   this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(),
                                                  outputs);
   cmNinjaDeps depends = this->GetObjects();
-  this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
-                                              "Object library "
-                                                + this->GetTargetName(),
-                                              outputs,
-                                              depends);
+  this->GetGlobalGenerator()->WritePhonyBuild(
+    this->GetBuildFileStream(), "Object library " + this->GetTargetName(),
+    outputs, depends);
 
   // Add aliases for the target name.
   this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index f077c64..c214c8a 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -27,44 +27,43 @@
 
 #include <algorithm>
 
-cmNinjaTargetGenerator *
-cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
+cmNinjaTargetGenerator* cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
 {
-  switch (target->GetType())
-    {
-      case cmState::EXECUTABLE:
-      case cmState::SHARED_LIBRARY:
-      case cmState::STATIC_LIBRARY:
-      case cmState::MODULE_LIBRARY:
-      case cmState::OBJECT_LIBRARY:
-        return new cmNinjaNormalTargetGenerator(target);
-
-      case cmState::UTILITY:
-        return new cmNinjaUtilityTargetGenerator(target);;
-
-      case cmState::GLOBAL_TARGET: {
-        // We only want to process global targets that live in the home
-        // (i.e. top-level) directory.  CMake creates copies of these targets
-        // in every directory, which we don't need.
-        if (strcmp(target->GetLocalGenerator()->GetCurrentSourceDirectory(),
-                   target->GetLocalGenerator()->GetSourceDirectory()) == 0)
-          return new cmNinjaUtilityTargetGenerator(target);
-        // else fallthrough
-      }
-
-      default:
-        return 0;
+  switch (target->GetType()) {
+    case cmState::EXECUTABLE:
+    case cmState::SHARED_LIBRARY:
+    case cmState::STATIC_LIBRARY:
+    case cmState::MODULE_LIBRARY:
+    case cmState::OBJECT_LIBRARY:
+      return new cmNinjaNormalTargetGenerator(target);
+
+    case cmState::UTILITY:
+      return new cmNinjaUtilityTargetGenerator(target);
+      ;
+
+    case cmState::GLOBAL_TARGET: {
+      // We only want to process global targets that live in the home
+      // (i.e. top-level) directory.  CMake creates copies of these targets
+      // in every directory, which we don't need.
+      if (strcmp(target->GetLocalGenerator()->GetCurrentSourceDirectory(),
+                 target->GetLocalGenerator()->GetSourceDirectory()) == 0)
+        return new cmNinjaUtilityTargetGenerator(target);
+      // else fallthrough
     }
+
+    default:
+      return 0;
+  }
 }
 
 cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
-  : cmCommonTargetGenerator(cmOutputConverter::HOME_OUTPUT, target),
-    MacOSXContentGenerator(0),
-    OSXBundleGenerator(0),
-    MacContentFolders(),
-    LocalGenerator(
-      static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator())),
-    Objects()
+  : cmCommonTargetGenerator(cmOutputConverter::HOME_OUTPUT, target)
+  , MacOSXContentGenerator(0)
+  , OSXBundleGenerator(0)
+  , MacContentFolders()
+  , LocalGenerator(
+      static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator()))
+  , Objects()
 {
   MacOSXContentGenerator = new MacOSXContentGeneratorType(this);
 }
@@ -96,8 +95,7 @@ std::string cmNinjaTargetGenerator::LanguageCompilerRule(
     cmGlobalNinjaGenerator::EncodeRuleName(this->GeneratorTarget->GetName());
 }
 
-std::string
-cmNinjaTargetGenerator::OrderDependsTargetForTarget()
+std::string cmNinjaTargetGenerator::OrderDependsTargetForTarget()
 {
   return "cmake_order_depends_target_" + this->GetTargetName();
 }
@@ -106,21 +104,19 @@ cmNinjaTargetGenerator::OrderDependsTargetForTarget()
 // void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink),
 // void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
 // Refactor it.
-std::string
-cmNinjaTargetGenerator::ComputeFlagsForObject(cmSourceFile const* source,
-                                              const std::string& language)
+std::string cmNinjaTargetGenerator::ComputeFlagsForObject(
+  cmSourceFile const* source, const std::string& language)
 {
   std::string flags = this->GetFlags(language);
 
   // Add Fortran format flags.
-  if(language == "Fortran")
-    {
+  if (language == "Fortran") {
     this->AppendFortranFormatFlags(flags, *source);
-    }
+  }
 
   // Add source file specific flags.
   this->LocalGenerator->AppendFlags(flags,
-    source->GetProperty("COMPILE_FLAGS"));
+                                    source->GetProperty("COMPILE_FLAGS"));
 
   return flags;
 }
@@ -129,18 +125,14 @@ void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
                                              std::string const& language)
 {
   std::vector<std::string> includes;
-  this->LocalGenerator->GetIncludeDirectories(includes,
-                                              this->GeneratorTarget,
-                                              language,
-                                              this->GetConfigName());
+  this->LocalGenerator->GetIncludeDirectories(includes, this->GeneratorTarget,
+                                              language, this->GetConfigName());
   // Add include directory flags.
-  std::string includeFlags =
-    this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
-                                          language,
-        language == "RC" ? true : false,  // full include paths for RC
-                                          // needed by cmcldeps
-                                          false,
-                                          this->GetConfigName());
+  std::string includeFlags = this->LocalGenerator->GetIncludeFlags(
+    includes, this->GeneratorTarget, language,
+    language == "RC" ? true : false, // full include paths for RC
+    // needed by cmcldeps
+    false, this->GetConfigName());
   if (this->GetGlobalGenerator()->IsGCCOnWindows())
     cmSystemTools::ReplaceString(includeFlags, "\\", "/");
 
@@ -149,32 +141,28 @@ void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
 
 bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const
 {
-  return strcmp(
-    this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" + lang),
-    "msvc") == 0;
+  return strcmp(this->GetMakefile()->GetSafeDefinition("CMAKE_NINJA_DEPTYPE_" +
+                                                       lang),
+                "msvc") == 0;
 }
 
 // TODO: Refactor with
 // void cmMakefileTargetGenerator::WriteTargetLanguageFlags().
-std::string
-cmNinjaTargetGenerator::
-ComputeDefines(cmSourceFile const* source, const std::string& language)
+std::string cmNinjaTargetGenerator::ComputeDefines(cmSourceFile const* source,
+                                                   const std::string& language)
 {
   std::set<std::string> defines;
-  this->LocalGenerator->AppendDefines
-    (defines,
-     source->GetProperty("COMPILE_DEFINITIONS"));
+  this->LocalGenerator->AppendDefines(
+    defines, source->GetProperty("COMPILE_DEFINITIONS"));
   {
-  std::string defPropName = "COMPILE_DEFINITIONS_";
-  defPropName += cmSystemTools::UpperCase(this->GetConfigName());
-  this->LocalGenerator->AppendDefines
-    (defines,
-     source->GetProperty(defPropName));
+    std::string defPropName = "COMPILE_DEFINITIONS_";
+    defPropName += cmSystemTools::UpperCase(this->GetConfigName());
+    this->LocalGenerator->AppendDefines(defines,
+                                        source->GetProperty(defPropName));
   }
 
   std::string definesString = this->GetDefines(language);
-  this->LocalGenerator->JoinDefines(defines, definesString,
-     language);
+  this->LocalGenerator->JoinDefines(defines, definesString, language);
 
   return definesString;
 }
@@ -188,58 +176,52 @@ cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
 
   cmComputeLinkInformation* cli =
     this->GeneratorTarget->GetLinkInformation(this->GetConfigName());
-  if(!cli)
+  if (!cli)
     return cmNinjaDeps();
 
-  const std::vector<std::string> &deps = cli->GetDepends();
+  const std::vector<std::string>& deps = cli->GetDepends();
   cmNinjaDeps result(deps.size());
   std::transform(deps.begin(), deps.end(), result.begin(), MapToNinjaPath());
 
   // Add a dependency on the link definitions file, if any.
-  if(this->ModuleDefinitionFile)
-    {
-    result.push_back(this->ConvertToNinjaPath(
-        this->ModuleDefinitionFile->GetFullPath()));
-    }
+  if (this->ModuleDefinitionFile) {
+    result.push_back(
+      this->ConvertToNinjaPath(this->ModuleDefinitionFile->GetFullPath()));
+  }
 
   // Add a dependency on user-specified manifest files, if any.
   std::vector<cmSourceFile const*> manifest_srcs;
   this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
   for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
-       mi != manifest_srcs.end(); ++mi)
-    {
+       mi != manifest_srcs.end(); ++mi) {
     result.push_back(this->ConvertToNinjaPath((*mi)->GetFullPath()));
-    }
+  }
 
   // Add user-specified dependencies.
   if (const char* linkDepends =
-      this->GeneratorTarget->GetProperty("LINK_DEPENDS"))
-    {
+        this->GeneratorTarget->GetProperty("LINK_DEPENDS")) {
     std::vector<std::string> linkDeps;
     cmSystemTools::ExpandListArgument(linkDepends, linkDeps);
     std::transform(linkDeps.begin(), linkDeps.end(),
                    std::back_inserter(result), MapToNinjaPath());
-    }
+  }
 
   return result;
 }
 
-std::string
-cmNinjaTargetGenerator
-::GetSourceFilePath(cmSourceFile const* source) const
+std::string cmNinjaTargetGenerator::GetSourceFilePath(
+  cmSourceFile const* source) const
 {
   return ConvertToNinjaPath(source->GetFullPath());
 }
 
-std::string
-cmNinjaTargetGenerator
-::GetObjectFilePath(cmSourceFile const* source) const
+std::string cmNinjaTargetGenerator::GetObjectFilePath(
+  cmSourceFile const* source) const
 {
   std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
-  if(!path.empty())
+  if (!path.empty())
     path += "/";
-  std::string const& objectName = this->GeneratorTarget
-                                      ->GetObjectName(source);
+  std::string const& objectName = this->GeneratorTarget->GetObjectName(source);
   path += this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
   path += "/";
   path += objectName;
@@ -252,9 +234,8 @@ std::string cmNinjaTargetGenerator::GetTargetOutputDir() const
   return ConvertToNinjaPath(dir);
 }
 
-std::string
-cmNinjaTargetGenerator
-::GetTargetFilePath(const std::string& name) const
+std::string cmNinjaTargetGenerator::GetTargetFilePath(
+  const std::string& name) const
 {
   std::string path = this->GetTargetOutputDir();
   if (path.empty() || path == ".")
@@ -269,63 +250,51 @@ std::string cmNinjaTargetGenerator::GetTargetName() const
   return this->GeneratorTarget->GetName();
 }
 
-
 bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(cmNinjaVars& vars) const
 {
   cmMakefile* mf = this->GetMakefile();
   if (mf->GetDefinition("MSVC_C_ARCHITECTURE_ID") ||
-      mf->GetDefinition("MSVC_CXX_ARCHITECTURE_ID"))
-    {
+      mf->GetDefinition("MSVC_CXX_ARCHITECTURE_ID")) {
     std::string pdbPath;
     std::string compilePdbPath;
-    if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
-       this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
-       this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
-       this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
-      {
+    if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
+        this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
+        this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
+        this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
       pdbPath = this->GeneratorTarget->GetPDBDirectory(this->GetConfigName());
       pdbPath += "/";
       pdbPath += this->GeneratorTarget->GetPDBName(this->GetConfigName());
-      }
-    if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
-      {
+    }
+    if (this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) {
       compilePdbPath =
-              this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName());
-      if(compilePdbPath.empty())
-        {
+        this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName());
+      if (compilePdbPath.empty()) {
         compilePdbPath = this->GeneratorTarget->GetSupportDirectory() + "/";
-        }
       }
+    }
 
     vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-                          ConvertToNinjaPath(pdbPath),
-                          cmLocalGenerator::SHELL);
+      ConvertToNinjaPath(pdbPath), cmLocalGenerator::SHELL);
     vars["TARGET_COMPILE_PDB"] =
       this->GetLocalGenerator()->ConvertToOutputFormat(
-        ConvertToNinjaPath(compilePdbPath),
-        cmLocalGenerator::SHELL);
+        ConvertToNinjaPath(compilePdbPath), cmLocalGenerator::SHELL);
 
     EnsureParentDirectoryExists(pdbPath);
     EnsureParentDirectoryExists(compilePdbPath);
     return true;
-    }
+  }
   return false;
 }
 
-void
-cmNinjaTargetGenerator
-::WriteLanguageRules(const std::string& language)
+void cmNinjaTargetGenerator::WriteLanguageRules(const std::string& language)
 {
 #ifdef NINJA_GEN_VERBOSE_FILES
-  this->GetRulesFileStream()
-    << "# Rules for language " << language << "\n\n";
+  this->GetRulesFileStream() << "# Rules for language " << language << "\n\n";
 #endif
   this->WriteCompileRule(language);
 }
 
-void
-cmNinjaTargetGenerator
-::WriteCompileRule(const std::string& lang)
+void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang)
 {
   cmLocalGenerator::RuleVariables vars;
   vars.RuleLauncher = "RULE_LAUNCH_COMPILE";
@@ -347,64 +316,55 @@ cmNinjaTargetGenerator
   std::string rspcontent;
   std::string responseFlag;
 
-  if (this->ForceResponseFile())
-    {
+  if (this->ForceResponseFile()) {
     rspfile = "$RSP_FILE";
     responseFlag = "@" + rspfile;
     rspcontent = " $DEFINES $INCLUDES $FLAGS";
     flags = responseFlag;
     vars.Defines = "";
     vars.Includes = "";
-    }
+  }
 
   // Tell ninja dependency format so all deps can be loaded into a database
   std::string deptype;
   std::string depfile;
   std::string cldeps;
-  if (this->NeedDepTypeMSVC(lang))
-    {
+  if (this->NeedDepTypeMSVC(lang)) {
     deptype = "msvc";
     depfile = "";
     flags += " /showIncludes";
-    }
-  else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_"+lang))
-    {
+  } else if (mf->IsOn("CMAKE_NINJA_CMCLDEPS_" + lang)) {
     // For the MS resource compiler we need cmcldeps, but skip dependencies
     // for source-file try_compile cases because they are always fresh.
-    if (!mf->GetIsSourceFileTryCompile())
-      {
+    if (!mf->GetIsSourceFileTryCompile()) {
       deptype = "gcc";
       depfile = "$DEP_FILE";
-      const std::string cl = mf->GetDefinition("CMAKE_C_COMPILER") ?
-                        mf->GetSafeDefinition("CMAKE_C_COMPILER") :
-                        mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
-      cldeps =  "\"";
+      const std::string cl = mf->GetDefinition("CMAKE_C_COMPILER")
+        ? mf->GetSafeDefinition("CMAKE_C_COMPILER")
+        : mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
+      cldeps = "\"";
       cldeps += cmSystemTools::GetCMClDepsCommand();
       cldeps += "\" " + lang + " $in \"$DEP_FILE\" $out \"";
       cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
       cldeps += "\" \"" + cl + "\" ";
-      }
     }
-  else
-    {
+  } else {
     deptype = "gcc";
     const char* langdeptype = mf->GetDefinition("CMAKE_NINJA_DEPTYPE_" + lang);
-    if (langdeptype)
-      {
+    if (langdeptype) {
       deptype = langdeptype;
-      }
+    }
     depfile = "$DEP_FILE";
     const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang;
     std::string depfileFlags = mf->GetSafeDefinition(flagsName);
-    if (!depfileFlags.empty())
-      {
+    if (!depfileFlags.empty()) {
       cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
-      cmSystemTools::ReplaceString(depfileFlags, "<OBJECT>",  "$out");
+      cmSystemTools::ReplaceString(depfileFlags, "<OBJECT>", "$out");
       cmSystemTools::ReplaceString(depfileFlags, "<CMAKE_C_COMPILER>",
                                    mf->GetDefinition("CMAKE_C_COMPILER"));
       flags += " " + depfileFlags;
-      }
     }
+  }
 
   vars.Flags = flags.c_str();
   vars.DependencyFile = depfile.c_str();
@@ -416,57 +376,49 @@ cmNinjaTargetGenerator
   cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
 
   // Maybe insert an include-what-you-use runner.
-  if (!compileCmds.empty() && (lang == "C" || lang == "CXX"))
-    {
+  if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
     std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
-    const char *iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
+    const char* iwyu = this->GeneratorTarget->GetProperty(iwyu_prop);
     std::string const tidy_prop = lang + "_CLANG_TIDY";
-    const char *tidy = this->GeneratorTarget->GetProperty(tidy_prop);
-    if ((iwyu && *iwyu) || (tidy && *tidy))
-      {
-      std::string run_iwyu =
-        this->GetLocalGenerator()->ConvertToOutputFormat(
-          cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
+    const char* tidy = this->GeneratorTarget->GetProperty(tidy_prop);
+    if ((iwyu && *iwyu) || (tidy && *tidy)) {
+      std::string run_iwyu = this->GetLocalGenerator()->ConvertToOutputFormat(
+        cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
       run_iwyu += " -E __run_iwyu";
-      if (iwyu && *iwyu)
-        {
+      if (iwyu && *iwyu) {
         run_iwyu += " --iwyu=";
         run_iwyu += this->GetLocalGenerator()->EscapeForShell(iwyu);
-        }
-      if (tidy && *tidy)
-        {
+      }
+      if (tidy && *tidy) {
         run_iwyu += " --tidy=";
         run_iwyu += this->GetLocalGenerator()->EscapeForShell(tidy);
         run_iwyu += " --source=$in";
-        }
+      }
       run_iwyu += " -- ";
       compileCmds.front().insert(0, run_iwyu);
-      }
     }
+  }
 
   // Maybe insert a compiler launcher like ccache or distcc
-  if (!compileCmds.empty() && (lang == "C" || lang == "CXX"))
-    {
+  if (!compileCmds.empty() && (lang == "C" || lang == "CXX")) {
     std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
-    const char *clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
-    if (clauncher && *clauncher)
-      {
+    const char* clauncher = this->GeneratorTarget->GetProperty(clauncher_prop);
+    if (clauncher && *clauncher) {
       std::vector<std::string> launcher_cmd;
       cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
       for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
-             e = launcher_cmd.end(); i != e; ++i)
-        {
+                                              e = launcher_cmd.end();
+           i != e; ++i) {
         *i = this->LocalGenerator->EscapeForShell(*i);
-        }
+      }
       std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
       compileCmds.front().insert(0, run_launcher);
-      }
     }
+  }
 
-  if (!compileCmds.empty())
-    {
+  if (!compileCmds.empty()) {
     compileCmds.front().insert(0, cldeps);
-    }
+  }
 
   for (std::vector<std::string>::iterator i = compileCmds.begin();
        i != compileCmds.end(); ++i)
@@ -475,121 +427,100 @@ cmNinjaTargetGenerator
   std::string cmdLine =
     this->GetLocalGenerator()->BuildCommandLine(compileCmds);
 
-
   // Write the rule for compiling file of the given language.
   std::ostringstream comment;
   comment << "Rule for compiling " << lang << " files.";
   std::ostringstream description;
   description << "Building " << lang << " object $out";
-  this->GetGlobalGenerator()->AddRule(this->LanguageCompilerRule(lang),
-                                      cmdLine,
-                                      description.str(),
-                                      comment.str(),
-                                      depfile,
-                                      deptype,
-                                      rspfile,
-                                      rspcontent,
-                                      /*restat*/ "",
-                                      /*generator*/ false);
+  this->GetGlobalGenerator()->AddRule(
+    this->LanguageCompilerRule(lang), cmdLine, description.str(),
+    comment.str(), depfile, deptype, rspfile, rspcontent,
+    /*restat*/ "",
+    /*generator*/ false);
 }
 
-void
-cmNinjaTargetGenerator
-::WriteObjectBuildStatements()
+void cmNinjaTargetGenerator::WriteObjectBuildStatements()
 {
   // Write comments.
   cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream());
   this->GetBuildFileStream()
     << "# Object build statements for "
     << cmState::GetTargetTypeName(this->GetGeneratorTarget()->GetType())
-    << " target "
-    << this->GetTargetName()
-    << "\n\n";
+    << " target " << this->GetTargetName() << "\n\n";
 
   std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
   std::vector<cmSourceFile const*> customCommands;
   this->GeneratorTarget->GetCustomCommands(customCommands, config);
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = customCommands.begin();
-      si != customCommands.end(); ++si)
-     {
-     cmCustomCommand const* cc = (*si)->GetCustomCommand();
-     this->GetLocalGenerator()->AddCustomCommandTarget(cc,
-         this->GetGeneratorTarget());
-     // Record the custom commands for this target. The container is used
-     // in WriteObjectBuildStatement when called in a loop below.
-     this->CustomCommands.push_back(cc);
-     }
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         customCommands.begin();
+       si != customCommands.end(); ++si) {
+    cmCustomCommand const* cc = (*si)->GetCustomCommand();
+    this->GetLocalGenerator()->AddCustomCommandTarget(
+      cc, this->GetGeneratorTarget());
+    // Record the custom commands for this target. The container is used
+    // in WriteObjectBuildStatement when called in a loop below.
+    this->CustomCommands.push_back(cc);
+  }
   std::vector<cmSourceFile const*> headerSources;
   this->GeneratorTarget->GetHeaderSources(headerSources, config);
   this->OSXBundleGenerator->GenerateMacOSXContentStatements(
-    headerSources,
-    this->MacOSXContentGenerator);
+    headerSources, this->MacOSXContentGenerator);
   std::vector<cmSourceFile const*> extraSources;
   this->GeneratorTarget->GetExtraSources(extraSources, config);
   this->OSXBundleGenerator->GenerateMacOSXContentStatements(
-    extraSources,
-    this->MacOSXContentGenerator);
+    extraSources, this->MacOSXContentGenerator);
   std::vector<cmSourceFile const*> externalObjects;
   this->GeneratorTarget->GetExternalObjects(externalObjects, config);
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = externalObjects.begin();
-      si != externalObjects.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         externalObjects.begin();
+       si != externalObjects.end(); ++si) {
     this->Objects.push_back(this->GetSourceFilePath(*si));
-    }
+  }
 
   cmNinjaDeps orderOnlyDeps;
   this->GetLocalGenerator()->AppendTargetDepends(this->GeneratorTarget,
                                                  orderOnlyDeps);
 
   // Add order-only dependencies on custom command outputs.
-  for(std::vector<cmCustomCommand const*>::const_iterator
-        cci = this->CustomCommands.begin();
-      cci != this->CustomCommands.end(); ++cci)
-    {
+  for (std::vector<cmCustomCommand const*>::const_iterator cci =
+         this->CustomCommands.begin();
+       cci != this->CustomCommands.end(); ++cci) {
     cmCustomCommand const* cc = *cci;
     cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
                                  this->GetLocalGenerator());
     const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
-    const std::vector<std::string>& ccbyproducts= ccg.GetByproducts();
+    const std::vector<std::string>& ccbyproducts = ccg.GetByproducts();
     std::transform(ccoutputs.begin(), ccoutputs.end(),
                    std::back_inserter(orderOnlyDeps), MapToNinjaPath());
     std::transform(ccbyproducts.begin(), ccbyproducts.end(),
                    std::back_inserter(orderOnlyDeps), MapToNinjaPath());
-    }
+  }
 
-  if (!orderOnlyDeps.empty())
-    {
+  if (!orderOnlyDeps.empty()) {
     cmNinjaDeps orderOnlyTarget;
     orderOnlyTarget.push_back(this->OrderDependsTargetForTarget());
-    this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
-                                                "Order-only phony target for "
-                                                  + this->GetTargetName(),
-                                                orderOnlyTarget,
-                                                cmNinjaDeps(),
-                                                cmNinjaDeps(),
-                                                orderOnlyDeps);
-    }
+    this->GetGlobalGenerator()->WritePhonyBuild(
+      this->GetBuildFileStream(),
+      "Order-only phony target for " + this->GetTargetName(), orderOnlyTarget,
+      cmNinjaDeps(), cmNinjaDeps(), orderOnlyDeps);
+  }
   std::vector<cmSourceFile const*> objectSources;
   this->GeneratorTarget->GetObjectSources(objectSources, config);
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = objectSources.begin(); si != objectSources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         objectSources.begin();
+       si != objectSources.end(); ++si) {
     this->WriteObjectBuildStatement(*si, !orderOnlyDeps.empty());
-    }
+  }
 
   this->GetBuildFileStream() << "\n";
 }
 
-void
-cmNinjaTargetGenerator
-::WriteObjectBuildStatement(
+void cmNinjaTargetGenerator::WriteObjectBuildStatement(
   cmSourceFile const* source, bool writeOrderDependsTargetForTarget)
 {
   std::string const language = source->GetLanguage();
   std::string const sourceFileName =
-    language=="RC" ? source->GetFullPath() : this->GetSourceFilePath(source);
+    language == "RC" ? source->GetFullPath() : this->GetSourceFilePath(source);
   std::string const objectDir = this->GeneratorTarget->GetSupportDirectory();
   std::string const objectFileName = this->GetObjectFilePath(source);
   std::string const objectFileDir =
@@ -599,17 +530,14 @@ cmNinjaTargetGenerator
   vars["FLAGS"] = this->ComputeFlagsForObject(source, language);
   vars["DEFINES"] = this->ComputeDefines(source, language);
   vars["INCLUDES"] = this->GetIncludes(language);
-  if (!this->NeedDepTypeMSVC(language))
-    {
+  if (!this->NeedDepTypeMSVC(language)) {
     vars["DEP_FILE"] =
       cmGlobalNinjaGenerator::EncodeDepfileSpace(objectFileName + ".d");
-    }
+  }
 
   this->ExportObjectCompileCommand(
-    language, sourceFileName,
-    objectDir, objectFileName, objectFileDir,
-    vars["FLAGS"], vars["DEFINES"], vars["INCLUDES"]
-    );
+    language, sourceFileName, objectDir, objectFileName, objectFileDir,
+    vars["FLAGS"], vars["DEFINES"], vars["INCLUDES"]);
 
   std::string comment;
   std::string rule = this->LanguageCompilerRule(language);
@@ -623,26 +551,23 @@ cmNinjaTargetGenerator
   explicitDeps.push_back(sourceFileName);
 
   cmNinjaDeps implicitDeps;
-  if(const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
+  if (const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
     std::vector<std::string> depList;
     cmSystemTools::ExpandListArgument(objectDeps, depList);
-    for(std::vector<std::string>::iterator odi = depList.begin();
-        odi != depList.end(); ++odi)
-      {
-      if (cmSystemTools::FileIsFullPath(*odi))
-        {
+    for (std::vector<std::string>::iterator odi = depList.begin();
+         odi != depList.end(); ++odi) {
+      if (cmSystemTools::FileIsFullPath(*odi)) {
         *odi = cmSystemTools::CollapseFullPath(*odi);
-        }
       }
+    }
     std::transform(depList.begin(), depList.end(),
                    std::back_inserter(implicitDeps), MapToNinjaPath());
   }
 
   cmNinjaDeps orderOnlyDeps;
-  if (writeOrderDependsTargetForTarget)
-    {
+  if (writeOrderDependsTargetForTarget) {
     orderOnlyDeps.push_back(this->OrderDependsTargetForTarget());
-    }
+  }
 
   // If the source file is GENERATED and does not have a custom command
   // (either attached to this source file or another one), assume that one of
@@ -657,78 +582,57 @@ cmNinjaTargetGenerator
   EnsureParentDirectoryExists(objectFileName);
 
   vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-                         ConvertToNinjaPath(objectDir),
-                         cmLocalGenerator::SHELL);
+    ConvertToNinjaPath(objectDir), cmLocalGenerator::SHELL);
   vars["OBJECT_FILE_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
-                              ConvertToNinjaPath(objectFileDir),
-                              cmLocalGenerator::SHELL);
+    ConvertToNinjaPath(objectFileDir), cmLocalGenerator::SHELL);
 
-  this->addPoolNinjaVariable("JOB_POOL_COMPILE",
-                             this->GetGeneratorTarget(), vars);
+  this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetGeneratorTarget(),
+                             vars);
 
   this->SetMsvcTargetPdbVariable(vars);
 
   int const commandLineLengthLimit = this->ForceResponseFile() ? -1 : 0;
   std::string const rspfile = objectFileName + ".rsp";
 
-  this->GetGlobalGenerator()->WriteBuild(this->GetBuildFileStream(),
-                                         comment,
-                                         rule,
-                                         outputs,
-                                         explicitDeps,
-                                         implicitDeps,
-                                         orderOnlyDeps,
-                                         vars,
-                                         rspfile,
-                                         commandLineLengthLimit);
-
+  this->GetGlobalGenerator()->WriteBuild(
+    this->GetBuildFileStream(), comment, rule, outputs, explicitDeps,
+    implicitDeps, orderOnlyDeps, vars, rspfile, commandLineLengthLimit);
 
-  if(const char* objectOutputs = source->GetProperty("OBJECT_OUTPUTS")) {
+  if (const char* objectOutputs = source->GetProperty("OBJECT_OUTPUTS")) {
     std::vector<std::string> outputList;
     cmSystemTools::ExpandListArgument(objectOutputs, outputList);
     std::transform(outputList.begin(), outputList.end(), outputList.begin(),
                    MapToNinjaPath());
     this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
                                                 "Additional output files.",
-                                                outputList,
-                                                outputs);
+                                                outputList, outputs);
   }
 }
 
-void
-cmNinjaTargetGenerator
-::ExportObjectCompileCommand(
-  std::string const& language,
-  std::string const& sourceFileName,
-  std::string const& objectDir,
-  std::string const& objectFileName,
-  std::string const& objectFileDir,
-  std::string const& flags,
-  std::string const& defines,
-  std::string const& includes
-  )
+void cmNinjaTargetGenerator::ExportObjectCompileCommand(
+  std::string const& language, std::string const& sourceFileName,
+  std::string const& objectDir, std::string const& objectFileName,
+  std::string const& objectFileDir, std::string const& flags,
+  std::string const& defines, std::string const& includes)
 {
-  if(!this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS"))
-    {
+  if (!this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS")) {
     return;
-    }
+  }
 
   cmLocalGenerator::RuleVariables compileObjectVars;
   compileObjectVars.Language = language.c_str();
 
   std::string escapedSourceFileName = sourceFileName;
 
-  if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str())) {
     escapedSourceFileName = cmSystemTools::CollapseFullPath(
-      escapedSourceFileName,
-      this->GetGlobalGenerator()->GetCMakeInstance()->
-      GetHomeOutputDirectory());
-    }
+      escapedSourceFileName, this->GetGlobalGenerator()
+                               ->GetCMakeInstance()
+                               ->GetHomeOutputDirectory());
+  }
 
-  escapedSourceFileName =
-    this->LocalGenerator->ConvertToOutputFormat(
-      escapedSourceFileName, cmLocalGenerator::SHELL);
+  escapedSourceFileName = this->LocalGenerator->ConvertToOutputFormat(
+    escapedSourceFileName, cmLocalGenerator::SHELL);
 
   compileObjectVars.Source = escapedSourceFileName.c_str();
   compileObjectVars.Object = objectFileName.c_str();
@@ -754,59 +658,49 @@ cmNinjaTargetGenerator
   std::string cmdLine =
     this->GetLocalGenerator()->BuildCommandLine(compileCmds);
 
-  this->GetGlobalGenerator()->AddCXXCompileCommand(cmdLine,
-                                                   sourceFileName);
+  this->GetGlobalGenerator()->AddCXXCompileCommand(cmdLine, sourceFileName);
 }
 
-void
-cmNinjaTargetGenerator
-::EnsureDirectoryExists(const std::string& path) const
+void cmNinjaTargetGenerator::EnsureDirectoryExists(
+  const std::string& path) const
 {
-  if (cmSystemTools::FileIsFullPath(path.c_str()))
-    {
+  if (cmSystemTools::FileIsFullPath(path.c_str())) {
     cmSystemTools::MakeDirectory(path.c_str());
-    }
-  else
-    {
-    const std::string fullPath = std::string(this->GetGlobalGenerator()->
-                                 GetCMakeInstance()->GetHomeOutputDirectory())
-                                   + "/" + path;
+  } else {
+    const std::string fullPath = std::string(this->GetGlobalGenerator()
+                                               ->GetCMakeInstance()
+                                               ->GetHomeOutputDirectory()) +
+      "/" + path;
     cmSystemTools::MakeDirectory(fullPath.c_str());
-    }
+  }
 }
 
-void
-cmNinjaTargetGenerator
-::EnsureParentDirectoryExists(const std::string& path) const
+void cmNinjaTargetGenerator::EnsureParentDirectoryExists(
+  const std::string& path) const
 {
   EnsureDirectoryExists(cmSystemTools::GetParentDirectory(path));
 }
 
-
-void
-cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
+void cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
   cmSourceFile const& source, const char* pkgloc)
 {
   // Skip OS X content when not building a Framework or Bundle.
-  if(!this->Generator->GetGeneratorTarget()->IsBundleOnApple())
-    {
+  if (!this->Generator->GetGeneratorTarget()->IsBundleOnApple()) {
     return;
-    }
+  }
 
   std::string macdir =
     this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc);
 
   // Get the input file location.
   std::string input = source.GetFullPath();
-  input =
-    this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(input);
+  input = this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(input);
 
   // Get the output file location.
   std::string output = macdir;
   output += "/";
   output += cmSystemTools::GetFilenameName(input);
-  output =
-    this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(output);
+  output = this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(output);
 
   // Write a build statement to copy the content into the bundle.
   this->Generator->GetGlobalGenerator()->WriteMacOSXContentBuild(input,
@@ -817,15 +711,13 @@ cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
 }
 
 void cmNinjaTargetGenerator::addPoolNinjaVariable(
-                                              const std::string& pool_property,
-                                              cmGeneratorTarget* target,
-                                              cmNinjaVars& vars)
+  const std::string& pool_property, cmGeneratorTarget* target,
+  cmNinjaVars& vars)
 {
-    const char* pool = target->GetProperty(pool_property);
-    if (pool)
-      {
-      vars["pool"] = pool;
-      }
+  const char* pool = target->GetProperty(pool_property);
+  if (pool) {
+    vars["pool"] = pool;
+  }
 }
 
 bool cmNinjaTargetGenerator::ForceResponseFile()
diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h
index 8225a60..414aa09 100644
--- a/Source/cmNinjaTargetGenerator.h
+++ b/Source/cmNinjaTargetGenerator.h
@@ -27,7 +27,7 @@ class cmMakefile;
 class cmSourceFile;
 class cmCustomCommand;
 
-class cmNinjaTargetGenerator: public cmCommonTargetGenerator
+class cmNinjaTargetGenerator : public cmCommonTargetGenerator
 {
 public:
   /// Create a cmNinjaTargetGenerator according to the @a target's type.
@@ -46,22 +46,24 @@ public:
   bool NeedDepTypeMSVC(const std::string& lang) const;
 
 protected:
-
   bool SetMsvcTargetPdbVariable(cmNinjaVars&) const;
 
   cmGeneratedFileStream& GetBuildFileStream() const;
   cmGeneratedFileStream& GetRulesFileStream() const;
 
   cmGeneratorTarget* GetGeneratorTarget() const
-  { return this->GeneratorTarget; }
+  {
+    return this->GeneratorTarget;
+  }
 
   cmLocalNinjaGenerator* GetLocalGenerator() const
-  { return this->LocalGenerator; }
+  {
+    return this->LocalGenerator;
+  }
 
   cmGlobalNinjaGenerator* GetGlobalGenerator() const;
 
-  cmMakefile* GetMakefile() const
-  { return this->Makefile; }
+  cmMakefile* GetMakefile() const { return this->Makefile; }
 
   std::string LanguageCompilerRule(const std::string& lang) const;
 
@@ -82,10 +84,12 @@ protected:
   std::string ComputeDefines(cmSourceFile const* source,
                              const std::string& language);
 
-  std::string ConvertToNinjaPath(const std::string& path) const {
+  std::string ConvertToNinjaPath(const std::string& path) const
+  {
     return this->GetGlobalGenerator()->ConvertToNinjaPath(path);
   }
-  cmGlobalNinjaGenerator::MapToNinjaPathImpl MapToNinjaPath() const {
+  cmGlobalNinjaGenerator::MapToNinjaPathImpl MapToNinjaPath() const
+  {
     return this->GetGlobalGenerator()->MapToNinjaPath();
   }
 
@@ -111,28 +115,24 @@ protected:
                                  bool writeOrderDependsTargetForTarget);
 
   void ExportObjectCompileCommand(
-    std::string const& language,
-    std::string const& sourceFileName,
-    std::string const& objectDir,
-    std::string const& objectFileName,
-    std::string const& objectFileDir,
-    std::string const& flags,
-    std::string const& defines,
-    std::string const& includes
-    );
-
-  cmNinjaDeps GetObjects() const
-  { return this->Objects; }
+    std::string const& language, std::string const& sourceFileName,
+    std::string const& objectDir, std::string const& objectFileName,
+    std::string const& objectFileDir, std::string const& flags,
+    std::string const& defines, std::string const& includes);
+
+  cmNinjaDeps GetObjects() const { return this->Objects; }
 
   void EnsureDirectoryExists(const std::string& dir) const;
   void EnsureParentDirectoryExists(const std::string& path) const;
 
   // write rules for Mac OS X Application Bundle content.
-  struct MacOSXContentGeneratorType :
-    cmOSXBundleGenerator::MacOSXContentGeneratorType
+  struct MacOSXContentGeneratorType
+    : cmOSXBundleGenerator::MacOSXContentGeneratorType
   {
-    MacOSXContentGeneratorType(cmNinjaTargetGenerator* g) :
-      Generator(g)  {}
+    MacOSXContentGeneratorType(cmNinjaTargetGenerator* g)
+      : Generator(g)
+    {
+    }
 
     void operator()(cmSourceFile const& source, const char* pkgloc);
 
@@ -141,15 +141,13 @@ protected:
   };
   friend struct MacOSXContentGeneratorType;
 
-
   MacOSXContentGeneratorType* MacOSXContentGenerator;
   // Properly initialized by sub-classes.
   cmOSXBundleGenerator* OSXBundleGenerator;
   std::set<std::string> MacContentFolders;
 
   void addPoolNinjaVariable(const std::string& pool_property,
-                            cmGeneratorTarget* target,
-                            cmNinjaVars& vars);
+                            cmGeneratorTarget* target, cmNinjaVars& vars);
 
   bool ForceResponseFile();
 
diff --git a/Source/cmNinjaUtilityTargetGenerator.cxx b/Source/cmNinjaUtilityTargetGenerator.cxx
index 735730e..b0b1147 100644
--- a/Source/cmNinjaUtilityTargetGenerator.cxx
+++ b/Source/cmNinjaUtilityTargetGenerator.cxx
@@ -20,10 +20,14 @@
 #include "cmSourceFile.h"
 
 cmNinjaUtilityTargetGenerator::cmNinjaUtilityTargetGenerator(
-    cmGeneratorTarget *target)
-  : cmNinjaTargetGenerator(target) {}
+  cmGeneratorTarget* target)
+  : cmNinjaTargetGenerator(target)
+{
+}
 
-cmNinjaUtilityTargetGenerator::~cmNinjaUtilityTargetGenerator() {}
+cmNinjaUtilityTargetGenerator::~cmNinjaUtilityTargetGenerator()
+{
+}
 
 void cmNinjaUtilityTargetGenerator::Generate()
 {
@@ -33,7 +37,7 @@ void cmNinjaUtilityTargetGenerator::Generate()
   std::vector<std::string> commands;
   cmNinjaDeps deps, outputs, util_outputs(1, utilCommandName);
 
-  const std::vector<cmCustomCommand> *cmdLists[2] = {
+  const std::vector<cmCustomCommand>* cmdLists[2] = {
     &this->GetGeneratorTarget()->GetPreBuildCommands(),
     &this->GetGeneratorTarget()->GetPostBuildCommands()
   };
@@ -41,8 +45,9 @@ void cmNinjaUtilityTargetGenerator::Generate()
   bool uses_terminal = false;
 
   for (unsigned i = 0; i != 2; ++i) {
-    for (std::vector<cmCustomCommand>::const_iterator
-         ci = cmdLists[i]->begin(); ci != cmdLists[i]->end(); ++ci) {
+    for (std::vector<cmCustomCommand>::const_iterator ci =
+           cmdLists[i]->begin();
+         ci != cmdLists[i]->end(); ++ci) {
       cmCustomCommandGenerator ccg(*ci, this->GetConfigName(),
                                    this->GetLocalGenerator());
       this->GetLocalGenerator()->AppendCustomCommandDeps(ccg, deps);
@@ -56,18 +61,16 @@ void cmNinjaUtilityTargetGenerator::Generate()
   }
 
   std::vector<cmSourceFile*> sources;
-  std::string config = this->GetMakefile()
-                           ->GetSafeDefinition("CMAKE_BUILD_TYPE");
+  std::string config =
+    this->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
   this->GetGeneratorTarget()->GetSourceFiles(sources, config);
-  for(std::vector<cmSourceFile*>::const_iterator source = sources.begin();
-      source != sources.end(); ++source)
-    {
-    if(cmCustomCommand* cc = (*source)->GetCustomCommand())
-      {
+  for (std::vector<cmSourceFile*>::const_iterator source = sources.begin();
+       source != sources.end(); ++source) {
+    if (cmCustomCommand* cc = (*source)->GetCustomCommand()) {
       cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
                                    this->GetLocalGenerator());
-      this->GetLocalGenerator()->AddCustomCommandTarget(cc,
-          this->GetGeneratorTarget());
+      this->GetLocalGenerator()->AddCustomCommandTarget(
+        cc, this->GetGeneratorTarget());
 
       // Depend on all custom command outputs.
       const std::vector<std::string>& ccOutputs = ccg.GetOutputs();
@@ -76,8 +79,8 @@ void cmNinjaUtilityTargetGenerator::Generate()
                      std::back_inserter(deps), MapToNinjaPath());
       std::transform(ccByproducts.begin(), ccByproducts.end(),
                      std::back_inserter(deps), MapToNinjaPath());
-      }
     }
+  }
 
   this->GetLocalGenerator()->AppendTargetOutputs(this->GetGeneratorTarget(),
                                                  outputs);
@@ -85,16 +88,14 @@ void cmNinjaUtilityTargetGenerator::Generate()
                                                  deps);
 
   if (commands.empty()) {
-    this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
-                                                "Utility command for "
-                                                  + this->GetTargetName(),
-                                                outputs,
-                                                deps);
+    this->GetGlobalGenerator()->WritePhonyBuild(
+      this->GetBuildFileStream(),
+      "Utility command for " + this->GetTargetName(), outputs, deps);
   } else {
     std::string command =
       this->GetLocalGenerator()->BuildCommandLine(commands);
-    const char *echoStr =
-        this->GetGeneratorTarget()->GetProperty("EchoString");
+    const char* echoStr =
+      this->GetGeneratorTarget()->GetProperty("EchoString");
     std::string desc;
     if (echoStr)
       desc = echoStr;
@@ -104,43 +105,38 @@ void cmNinjaUtilityTargetGenerator::Generate()
     // TODO: fix problematic global targets.  For now, search and replace the
     // makefile vars.
     cmSystemTools::ReplaceString(
-      command,
-      "$(CMAKE_SOURCE_DIR)",
-      this->GetLocalGenerator()->ConvertToOutputFormat(
-        this->GetLocalGenerator()->GetSourceDirectory(),
-        cmLocalGenerator::SHELL).c_str());
+      command, "$(CMAKE_SOURCE_DIR)",
+      this->GetLocalGenerator()
+        ->ConvertToOutputFormat(
+          this->GetLocalGenerator()->GetSourceDirectory(),
+          cmLocalGenerator::SHELL)
+        .c_str());
     cmSystemTools::ReplaceString(
-      command,
-      "$(CMAKE_BINARY_DIR)",
-      this->GetLocalGenerator()->ConvertToOutputFormat(
-        this->GetLocalGenerator()->GetBinaryDirectory(),
-        cmLocalGenerator::SHELL).c_str());
+      command, "$(CMAKE_BINARY_DIR)",
+      this->GetLocalGenerator()
+        ->ConvertToOutputFormat(
+          this->GetLocalGenerator()->GetBinaryDirectory(),
+          cmLocalGenerator::SHELL)
+        .c_str());
     cmSystemTools::ReplaceString(command, "$(ARGS)", "");
 
     if (command.find('$') != std::string::npos)
       return;
 
-    for (cmNinjaDeps::const_iterator
-           oi = util_outputs.begin(), oe = util_outputs.end();
-         oi != oe; ++oi)
-      {
+    for (cmNinjaDeps::const_iterator oi = util_outputs.begin(),
+                                     oe = util_outputs.end();
+         oi != oe; ++oi) {
       this->GetGlobalGenerator()->SeenCustomCommandOutput(*oi);
-      }
+    }
 
     this->GetGlobalGenerator()->WriteCustomCommandBuild(
-      command,
-      desc,
-      "Utility command for " + this->GetTargetName(),
+      command, desc, "Utility command for " + this->GetTargetName(),
       uses_terminal,
-      /*restat*/true,
-      util_outputs,
-      deps);
-
-    this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
-                                                "",
-                                                outputs,
-                                                cmNinjaDeps(1, utilCommandName)
-                                                );
+      /*restat*/ true, util_outputs, deps);
+
+    this->GetGlobalGenerator()->WritePhonyBuild(
+      this->GetBuildFileStream(), "", outputs,
+      cmNinjaDeps(1, utilCommandName));
   }
 
   this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),
diff --git a/Source/cmOSXBundleGenerator.cxx b/Source/cmOSXBundleGenerator.cxx
index 09b99bb..f62ba40 100644
--- a/Source/cmOSXBundleGenerator.cxx
+++ b/Source/cmOSXBundleGenerator.cxx
@@ -17,18 +17,16 @@
 
 #include <cassert>
 
-cmOSXBundleGenerator::
-cmOSXBundleGenerator(cmGeneratorTarget* target,
-                     const std::string& configName)
- : GT(target)
- , Makefile(target->Target->GetMakefile())
- , LocalGenerator(target->GetLocalGenerator())
- , ConfigName(configName)
- , MacContentFolders(0)
+cmOSXBundleGenerator::cmOSXBundleGenerator(cmGeneratorTarget* target,
+                                           const std::string& configName)
+  : GT(target)
+  , Makefile(target->Target->GetMakefile())
+  , LocalGenerator(target->GetLocalGenerator())
+  , ConfigName(configName)
+  , MacContentFolders(0)
 {
   if (this->MustSkip())
     return;
-
 }
 
 bool cmOSXBundleGenerator::MustSkip()
@@ -57,15 +55,14 @@ void cmOSXBundleGenerator::CreateAppBundle(const std::string& targetName,
   plist += "/";
   plist += this->GT->GetAppBundleDirectory(this->ConfigName, true);
   plist += "/Info.plist";
-  this->LocalGenerator->GenerateAppleInfoPList(this->GT,
-                                               targetName,
+  this->LocalGenerator->GenerateAppleInfoPList(this->GT, targetName,
                                                plist.c_str());
   this->Makefile->AddCMakeOutputFile(plist);
   outpath = newoutpath;
 }
 
-void cmOSXBundleGenerator::CreateFramework(
-  const std::string& targetName, const std::string& outpath)
+void cmOSXBundleGenerator::CreateFramework(const std::string& targetName,
+                                           const std::string& outpath)
 {
   if (this->MustSkip())
     return;
@@ -73,27 +70,25 @@ void cmOSXBundleGenerator::CreateFramework(
   assert(this->MacContentFolders);
 
   // Compute the location of the top-level foo.framework directory.
-  std::string contentdir = outpath + "/" +
-    this->GT->GetFrameworkDirectory(this->ConfigName, true);
+  std::string contentdir =
+    outpath + "/" + this->GT->GetFrameworkDirectory(this->ConfigName, true);
   contentdir += "/";
 
-  std::string newoutpath = outpath + "/" +
-    this->GT->GetFrameworkDirectory(this->ConfigName, false);
+  std::string newoutpath =
+    outpath + "/" + this->GT->GetFrameworkDirectory(this->ConfigName, false);
 
   std::string frameworkVersion = this->GT->GetFrameworkVersion();
 
   // Configure the Info.plist file
   std::string plist = newoutpath;
-  if (!this->Makefile->PlatformIsAppleIos())
-    {
+  if (!this->Makefile->PlatformIsAppleIos()) {
     // Put the Info.plist file into the Resources directory.
     this->MacContentFolders->insert("Resources");
     plist += "/Resources";
-    }
+  }
   plist += "/Info.plist";
   std::string name = cmSystemTools::GetFilenameName(targetName);
-  this->LocalGenerator->GenerateFrameworkInfoPList(this->GT,
-                                                   name,
+  this->LocalGenerator->GenerateFrameworkInfoPList(this->GT, name,
                                                    plist.c_str());
 
   // Generate Versions directory only for MacOSX frameworks
@@ -105,7 +100,6 @@ void cmOSXBundleGenerator::CreateFramework(
   std::string oldName;
   std::string newName;
 
-
   // Make foo.framework/Versions
   std::string versions = contentdir;
   versions += "Versions";
@@ -132,40 +126,37 @@ void cmOSXBundleGenerator::CreateFramework(
   this->Makefile->AddCMakeOutputFile(newName);
 
   // Resources -> Versions/Current/Resources
-  if(this->MacContentFolders->find("Resources") !=
-     this->MacContentFolders->end())
-    {
+  if (this->MacContentFolders->find("Resources") !=
+      this->MacContentFolders->end()) {
     oldName = "Versions/Current/Resources";
     newName = contentdir;
     newName += "Resources";
     cmSystemTools::RemoveFile(newName);
     cmSystemTools::CreateSymlink(oldName, newName);
     this->Makefile->AddCMakeOutputFile(newName);
-    }
+  }
 
   // Headers -> Versions/Current/Headers
-  if(this->MacContentFolders->find("Headers") !=
-     this->MacContentFolders->end())
-    {
+  if (this->MacContentFolders->find("Headers") !=
+      this->MacContentFolders->end()) {
     oldName = "Versions/Current/Headers";
     newName = contentdir;
     newName += "Headers";
     cmSystemTools::RemoveFile(newName);
     cmSystemTools::CreateSymlink(oldName, newName);
     this->Makefile->AddCMakeOutputFile(newName);
-    }
+  }
 
   // PrivateHeaders -> Versions/Current/PrivateHeaders
-  if(this->MacContentFolders->find("PrivateHeaders") !=
-     this->MacContentFolders->end())
-    {
+  if (this->MacContentFolders->find("PrivateHeaders") !=
+      this->MacContentFolders->end()) {
     oldName = "Versions/Current/PrivateHeaders";
     newName = contentdir;
     newName += "PrivateHeaders";
     cmSystemTools::RemoveFile(newName);
     cmSystemTools::CreateSymlink(oldName, newName);
     this->Makefile->AddCMakeOutputFile(newName);
-    }
+  }
 }
 
 void cmOSXBundleGenerator::CreateCFBundle(const std::string& targetName,
@@ -183,45 +174,38 @@ void cmOSXBundleGenerator::CreateCFBundle(const std::string& targetName,
 
   // Configure the Info.plist file.  Note that it needs the executable name
   // to be set.
-  std::string plist = root + "/" +
-    this->GT->GetCFBundleDirectory(this->ConfigName, true);
+  std::string plist =
+    root + "/" + this->GT->GetCFBundleDirectory(this->ConfigName, true);
   plist += "/Info.plist";
   std::string name = cmSystemTools::GetFilenameName(targetName);
-  this->LocalGenerator->GenerateAppleInfoPList(this->GT,
-                                               name,
-                                               plist.c_str());
+  this->LocalGenerator->GenerateAppleInfoPList(this->GT, name, plist.c_str());
   this->Makefile->AddCMakeOutputFile(plist);
 }
 
-void
-cmOSXBundleGenerator::
-GenerateMacOSXContentStatements(
-                              std::vector<cmSourceFile const*> const& sources,
-                              MacOSXContentGeneratorType* generator)
+void cmOSXBundleGenerator::GenerateMacOSXContentStatements(
+  std::vector<cmSourceFile const*> const& sources,
+  MacOSXContentGeneratorType* generator)
 {
   if (this->MustSkip())
     return;
 
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = sources.begin(); si != sources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si = sources.begin();
+       si != sources.end(); ++si) {
     cmGeneratorTarget::SourceFileFlags tsFlags =
       this->GT->GetTargetSourceFileFlags(*si);
-    if(tsFlags.Type != cmGeneratorTarget::SourceFileTypeNormal)
-      {
+    if (tsFlags.Type != cmGeneratorTarget::SourceFileTypeNormal) {
       (*generator)(**si, tsFlags.MacFolder);
-      }
     }
+  }
 }
 
-std::string
-cmOSXBundleGenerator::InitMacOSXContentDirectory(const char* pkgloc)
+std::string cmOSXBundleGenerator::InitMacOSXContentDirectory(
+  const char* pkgloc)
 {
   // Construct the full path to the content subdirectory.
 
-  std::string macdir =
-    this->GT->GetMacContentDirectory(this->ConfigName,
-                                         /*implib*/ false);
+  std::string macdir = this->GT->GetMacContentDirectory(this->ConfigName,
+                                                        /*implib*/ false);
   macdir += "/";
   macdir += pkgloc;
   cmSystemTools::MakeDirectory(macdir.c_str());
@@ -229,9 +213,9 @@ cmOSXBundleGenerator::InitMacOSXContentDirectory(const char* pkgloc)
   // Record use of this content location.  Only the first level
   // directory is needed.
   {
-  std::string loc = pkgloc;
-  loc = loc.substr(0, loc.find('/'));
-  this->MacContentFolders->insert(loc);
+    std::string loc = pkgloc;
+    loc = loc.substr(0, loc.find('/'));
+    this->MacContentFolders->insert(loc);
   }
 
   return macdir;
diff --git a/Source/cmOSXBundleGenerator.h b/Source/cmOSXBundleGenerator.h
index 3952e95..55a3c75 100644
--- a/Source/cmOSXBundleGenerator.h
+++ b/Source/cmOSXBundleGenerator.h
@@ -35,12 +35,10 @@ public:
   void CreateAppBundle(const std::string& targetName, std::string& root);
 
   // create a framework at a given root
-  void CreateFramework(const std::string& targetName,
-                       const std::string& root);
+  void CreateFramework(const std::string& targetName, const std::string& root);
 
   // create a cf bundle at a given root
-  void CreateCFBundle(const std::string& targetName,
-                      const std::string& root);
+  void CreateCFBundle(const std::string& targetName, const std::string& root);
 
   struct MacOSXContentGeneratorType
   {
@@ -55,7 +53,9 @@ public:
   std::string InitMacOSXContentDirectory(const char* pkgloc);
 
   void SetMacContentFolders(std::set<std::string>* macContentFolders)
-  { this->MacContentFolders = macContentFolders; }
+  {
+    this->MacContentFolders = macContentFolders;
+  }
 
 private:
   bool MustSkip();
@@ -68,5 +68,4 @@ private:
   std::set<std::string>* MacContentFolders;
 };
 
-
 #endif
diff --git a/Source/cmObject.h b/Source/cmObject.h
index ca6a54f..d883c52 100644
--- a/Source/cmObject.h
+++ b/Source/cmObject.h
@@ -36,16 +36,13 @@ public:
   /**
    * Returns true if this class is the given class, or a subclass of it.
    */
-  static bool IsTypeOf(const char *type)
-    { return !strcmp("cmObject", type); }
+  static bool IsTypeOf(const char* type) { return !strcmp("cmObject", type); }
 
   /**
    * Returns true if this object is an instance of the given class or
    * a subclass of it.
    */
-  virtual bool IsA(const char *type)
-    { return cmObject::IsTypeOf(type); }
+  virtual bool IsA(const char* type) { return cmObject::IsTypeOf(type); }
 };
 
 #endif
-
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index 92be5f1..f6f0ec3 100644
--- a/Source/cmOptionCommand.cxx
+++ b/Source/cmOptionCommand.cxx
@@ -12,53 +12,46 @@
 #include "cmOptionCommand.h"
 
 // cmOptionCommand
-bool cmOptionCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmOptionCommand::InitialPass(std::vector<std::string> const& args,
+                                  cmExecutionStatus&)
 {
   bool argError = false;
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     argError = true;
-    }
+  }
   // for VTK 4.0 we have to support the option command with more than 3
   // arguments if CMAKE_MINIMUM_REQUIRED_VERSION is not defined, if
   // CMAKE_MINIMUM_REQUIRED_VERSION is defined, then we can have stricter
   // checking.
-  if(this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"))
-    {
-    if(args.size() > 3)
-      {
+  if (this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION")) {
+    if (args.size() > 3) {
       argError = true;
-      }
     }
-  if(argError)
-    {
+  }
+  if (argError) {
     std::string m = "called with incorrect number of arguments: ";
     m += cmJoin(args, " ");
     this->SetError(m);
     return false;
-    }
+  }
 
   std::string initialValue = "Off";
   // Now check and see if the value has been stored in the cache
   // already, if so use that value and don't look for the program
   cmState* state = this->Makefile->GetState();
   const char* existingValue = state->GetCacheEntryValue(args[0]);
-  if(existingValue)
-    {
-    if (state->GetCacheEntryType(args[0]) != cmState::UNINITIALIZED)
-      {
+  if (existingValue) {
+    if (state->GetCacheEntryType(args[0]) != cmState::UNINITIALIZED) {
       state->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
       return true;
-      }
-    initialValue = existingValue;
     }
-  if(args.size() == 3)
-    {
+    initialValue = existingValue;
+  }
+  if (args.size() == 3) {
     initialValue = args[2];
-    }
+  }
   bool init = cmSystemTools::IsOn(initialValue.c_str());
-  this->Makefile->AddCacheDefinition(args[0], init? "ON":"OFF",
+  this->Makefile->AddCacheDefinition(args[0], init ? "ON" : "OFF",
                                      args[1].c_str(), cmState::BOOL);
   return true;
 }
diff --git a/Source/cmOptionCommand.h b/Source/cmOptionCommand.h
index 12a6472..491f45e 100644
--- a/Source/cmOptionCommand.h
+++ b/Source/cmOptionCommand.h
@@ -25,22 +25,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmOptionCommand;
-    }
+  virtual cmCommand* Clone() { return new cmOptionCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "option";}
+  virtual std::string GetName() const { return "option"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -50,6 +47,4 @@ public:
   cmTypeMacro(cmOptionCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmOrderDirectories.cxx b/Source/cmOrderDirectories.cxx
index a4d9558..00606c7 100644
--- a/Source/cmOrderDirectories.cxx
+++ b/Source/cmOrderDirectories.cxx
@@ -31,84 +31,77 @@ Directory ordering computation.
 class cmOrderDirectoriesConstraint
 {
 public:
-  cmOrderDirectoriesConstraint(cmOrderDirectories* od,
-                               std::string const& file):
-    OD(od), GlobalGenerator(od->GlobalGenerator)
-    {
+  cmOrderDirectoriesConstraint(cmOrderDirectories* od, std::string const& file)
+    : OD(od)
+    , GlobalGenerator(od->GlobalGenerator)
+  {
     this->FullPath = file;
 
-    if(file.rfind(".framework") != std::string::npos)
-      {
-      static cmsys::RegularExpression
-        splitFramework("^(.*)/(.*).framework/(.*)$");
-      if(splitFramework.find(file) &&
-        (std::string::npos !=
-         splitFramework.match(3).find(splitFramework.match(2))))
-        {
+    if (file.rfind(".framework") != std::string::npos) {
+      static cmsys::RegularExpression splitFramework(
+        "^(.*)/(.*).framework/(.*)$");
+      if (splitFramework.find(file) &&
+          (std::string::npos !=
+           splitFramework.match(3).find(splitFramework.match(2)))) {
         this->Directory = splitFramework.match(1);
         this->FileName =
           std::string(file.begin() + this->Directory.size() + 1, file.end());
-        }
       }
+    }
 
-    if(this->FileName.empty())
-      {
+    if (this->FileName.empty()) {
       this->Directory = cmSystemTools::GetFilenamePath(file);
       this->FileName = cmSystemTools::GetFilenameName(file);
-      }
     }
+  }
   virtual ~cmOrderDirectoriesConstraint() {}
 
   void AddDirectory()
-    {
+  {
     this->DirectoryIndex = this->OD->AddOriginalDirectory(this->Directory);
-    }
+  }
 
   virtual void Report(std::ostream& e) = 0;
 
   void FindConflicts(unsigned int index)
-    {
-    for(unsigned int i=0; i < this->OD->OriginalDirectories.size(); ++i)
-      {
+  {
+    for (unsigned int i = 0; i < this->OD->OriginalDirectories.size(); ++i) {
       // Check if this directory conflicts with the entry.
       std::string const& dir = this->OD->OriginalDirectories[i];
       if (!this->OD->IsSameDirectory(dir, this->Directory) &&
-          this->FindConflict(dir))
-        {
+          this->FindConflict(dir)) {
         // The library will be found in this directory but this is not
         // the directory named for it.  Add an entry to make sure the
         // desired directory comes before this one.
         cmOrderDirectories::ConflictPair p(this->DirectoryIndex, index);
         this->OD->ConflictGraph[i].push_back(p);
-        }
       }
     }
+  }
 
   void FindImplicitConflicts(std::ostringstream& w)
-    {
+  {
     bool first = true;
-    for(unsigned int i=0; i < this->OD->OriginalDirectories.size(); ++i)
-      {
+    for (unsigned int i = 0; i < this->OD->OriginalDirectories.size(); ++i) {
       // Check if this directory conflicts with the entry.
       std::string const& dir = this->OD->OriginalDirectories[i];
-      if(dir != this->Directory &&
-         cmSystemTools::GetRealPath(dir) !=
-         cmSystemTools::GetRealPath(this->Directory) &&
-         this->FindConflict(dir))
-        {
+      if (dir != this->Directory &&
+          cmSystemTools::GetRealPath(dir) !=
+            cmSystemTools::GetRealPath(this->Directory) &&
+          this->FindConflict(dir)) {
         // The library will be found in this directory but it is
         // supposed to be found in an implicit search directory.
-        if(first)
-          {
+        if (first) {
           first = false;
           w << "  ";
           this->Report(w);
           w << " in " << this->Directory << " may be hidden by files in:\n";
-          }
-        w << "    " << dir << "\n";
         }
+        w << "    " << dir << "\n";
       }
     }
+  }
+
 protected:
   virtual bool FindConflict(std::string const& dir) = 0;
 
@@ -133,12 +126,11 @@ bool cmOrderDirectoriesConstraint::FileMayConflict(std::string const& dir,
   std::string file = dir;
   file += "/";
   file += name;
-  if(cmSystemTools::FileExists(file.c_str(), true))
-    {
+  if (cmSystemTools::FileExists(file.c_str(), true)) {
     // The file conflicts only if it is not the same as the original
     // file due to a symlink or hardlink.
     return !cmSystemTools::SameFile(this->FullPath, file);
-    }
+  }
 
   // Check if the file will be built by cmake.
   std::set<std::string> const& files =
@@ -147,40 +139,37 @@ bool cmOrderDirectoriesConstraint::FileMayConflict(std::string const& dir,
   return fi != files.end();
 }
 
-class cmOrderDirectoriesConstraintSOName: public cmOrderDirectoriesConstraint
+class cmOrderDirectoriesConstraintSOName : public cmOrderDirectoriesConstraint
 {
 public:
   cmOrderDirectoriesConstraintSOName(cmOrderDirectories* od,
                                      std::string const& file,
-                                     const char* soname):
-    cmOrderDirectoriesConstraint(od, file), SOName(soname? soname : "")
-    {
-    if(this->SOName.empty())
-      {
+                                     const char* soname)
+    : cmOrderDirectoriesConstraint(od, file)
+    , SOName(soname ? soname : "")
+  {
+    if (this->SOName.empty()) {
       // Try to guess the soname.
       std::string soguess;
-      if(cmSystemTools::GuessLibrarySOName(file, soguess))
-        {
+      if (cmSystemTools::GuessLibrarySOName(file, soguess)) {
         this->SOName = soguess;
-        }
       }
     }
+  }
 
   virtual void Report(std::ostream& e)
-    {
+  {
     e << "runtime library [";
-    if(this->SOName.empty())
-      {
+    if (this->SOName.empty()) {
       e << this->FileName;
-      }
-    else
-      {
+    } else {
       e << this->SOName;
-      }
-    e << "]";
     }
+    e << "]";
+  }
 
   virtual bool FindConflict(std::string const& dir);
+
 private:
   // The soname of the shared library if it is known.
   std::string SOName;
@@ -189,50 +178,44 @@ private:
 bool cmOrderDirectoriesConstraintSOName::FindConflict(std::string const& dir)
 {
   // Determine which type of check to do.
-  if(!this->SOName.empty())
-    {
+  if (!this->SOName.empty()) {
     // We have the library soname.  Check if it will be found.
-    if(this->FileMayConflict(dir, this->SOName))
-      {
+    if (this->FileMayConflict(dir, this->SOName)) {
       return true;
-      }
     }
-  else
-    {
+  } else {
     // We do not have the soname.  Look for files in the directory
     // that may conflict.
     std::set<std::string> const& files =
-      (this->GlobalGenerator
-       ->GetDirectoryContent(dir, true));
+      (this->GlobalGenerator->GetDirectoryContent(dir, true));
 
     // Get the set of files that might conflict.  Since we do not
     // know the soname just look at all files that start with the
     // file name.  Usually the soname starts with the library name.
     std::string base = this->FileName;
     std::set<std::string>::const_iterator first = files.lower_bound(base);
-    ++base[base.size()-1];
+    ++base[base.size() - 1];
     std::set<std::string>::const_iterator last = files.upper_bound(base);
-    if(first != last)
-      {
+    if (first != last) {
       return true;
-      }
     }
+  }
   return false;
 }
 
-class cmOrderDirectoriesConstraintLibrary: public cmOrderDirectoriesConstraint
+class cmOrderDirectoriesConstraintLibrary : public cmOrderDirectoriesConstraint
 {
 public:
   cmOrderDirectoriesConstraintLibrary(cmOrderDirectories* od,
-                                      std::string const& file):
-    cmOrderDirectoriesConstraint(od, file)
-    {
-    }
+                                      std::string const& file)
+    : cmOrderDirectoriesConstraint(od, file)
+  {
+  }
 
   virtual void Report(std::ostream& e)
-    {
+  {
     e << "link library [" << this->FileName << "]";
-    }
+  }
 
   virtual bool FindConflict(std::string const& dir);
 };
@@ -240,33 +223,28 @@ public:
 bool cmOrderDirectoriesConstraintLibrary::FindConflict(std::string const& dir)
 {
   // We have the library file name.  Check if it will be found.
-  if(this->FileMayConflict(dir, this->FileName))
-    {
+  if (this->FileMayConflict(dir, this->FileName)) {
     return true;
-    }
+  }
 
   // Now check if the file exists with other extensions the linker
   // might consider.
-  if(!this->OD->LinkExtensions.empty() &&
-     this->OD->RemoveLibraryExtension.find(this->FileName))
-    {
+  if (!this->OD->LinkExtensions.empty() &&
+      this->OD->RemoveLibraryExtension.find(this->FileName)) {
     std::string lib = this->OD->RemoveLibraryExtension.match(1);
     std::string ext = this->OD->RemoveLibraryExtension.match(2);
-    for(std::vector<std::string>::iterator
-          i = this->OD->LinkExtensions.begin();
-        i != this->OD->LinkExtensions.end(); ++i)
-      {
-      if(*i != ext)
-        {
+    for (std::vector<std::string>::iterator i =
+           this->OD->LinkExtensions.begin();
+         i != this->OD->LinkExtensions.end(); ++i) {
+      if (*i != ext) {
         std::string fname = lib;
         fname += *i;
-        if(this->FileMayConflict(dir, fname))
-          {
+        if (this->FileMayConflict(dir, fname)) {
           return true;
-          }
         }
       }
     }
+  }
   return false;
 }
 
@@ -288,13 +266,12 @@ cmOrderDirectories::~cmOrderDirectories()
 
 std::vector<std::string> const& cmOrderDirectories::GetOrderedDirectories()
 {
-  if(!this->Computed)
-    {
+  if (!this->Computed) {
     this->Computed = true;
     this->CollectOriginalDirectories();
     this->FindConflicts();
     this->OrderDirectories();
-    }
+  }
   return this->OrderedDirectories;
 }
 
@@ -302,45 +279,38 @@ void cmOrderDirectories::AddRuntimeLibrary(std::string const& fullPath,
                                            const char* soname)
 {
   // Add the runtime library at most once.
-  if(this->EmmittedConstraintSOName.insert(fullPath).second)
-    {
+  if (this->EmmittedConstraintSOName.insert(fullPath).second) {
     // Implicit link directories need special handling.
-    if(!this->ImplicitDirectories.empty())
-      {
+    if (!this->ImplicitDirectories.empty()) {
       std::string dir = cmSystemTools::GetFilenamePath(fullPath);
 
-      if(fullPath.rfind(".framework") != std::string::npos)
-        {
-        static cmsys::RegularExpression
-          splitFramework("^(.*)/(.*).framework/(.*)$");
-        if(splitFramework.find(fullPath) &&
-          (std::string::npos !=
-           splitFramework.match(3).find(splitFramework.match(2))))
-          {
+      if (fullPath.rfind(".framework") != std::string::npos) {
+        static cmsys::RegularExpression splitFramework(
+          "^(.*)/(.*).framework/(.*)$");
+        if (splitFramework.find(fullPath) &&
+            (std::string::npos !=
+             splitFramework.match(3).find(splitFramework.match(2)))) {
           dir = splitFramework.match(1);
-          }
         }
+      }
 
-      if(this->ImplicitDirectories.find(dir) !=
-         this->ImplicitDirectories.end())
-        {
+      if (this->ImplicitDirectories.find(dir) !=
+          this->ImplicitDirectories.end()) {
         this->ImplicitDirEntries.push_back(
           new cmOrderDirectoriesConstraintSOName(this, fullPath, soname));
         return;
-        }
       }
+    }
 
     // Construct the runtime information entry for this library.
     this->ConstraintEntries.push_back(
       new cmOrderDirectoriesConstraintSOName(this, fullPath, soname));
-    }
-  else
-    {
+  } else {
     // This can happen if the same library is linked multiple times.
     // In that case the runtime information check need be done only
     // once anyway.  For shared libs we could add a check in AddItem
     // to not repeat them.
-    }
+  }
 }
 
 void cmOrderDirectories::AddLinkLibrary(std::string const& fullPath)
@@ -349,54 +319,47 @@ void cmOrderDirectories::AddLinkLibrary(std::string const& fullPath)
   assert(!this->LinkExtensions.empty());
 
   // Add the link library at most once.
-  if(this->EmmittedConstraintLibrary.insert(fullPath).second)
-    {
+  if (this->EmmittedConstraintLibrary.insert(fullPath).second) {
     // Implicit link directories need special handling.
-    if(!this->ImplicitDirectories.empty())
-      {
+    if (!this->ImplicitDirectories.empty()) {
       std::string dir = cmSystemTools::GetFilenamePath(fullPath);
-      if(this->ImplicitDirectories.find(dir) !=
-         this->ImplicitDirectories.end())
-        {
+      if (this->ImplicitDirectories.find(dir) !=
+          this->ImplicitDirectories.end()) {
         this->ImplicitDirEntries.push_back(
           new cmOrderDirectoriesConstraintLibrary(this, fullPath));
         return;
-        }
       }
+    }
 
     // Construct the link library entry.
     this->ConstraintEntries.push_back(
       new cmOrderDirectoriesConstraintLibrary(this, fullPath));
-    }
+  }
 }
 
-void
-cmOrderDirectories
-::AddUserDirectories(std::vector<std::string> const& extra)
+void cmOrderDirectories::AddUserDirectories(
+  std::vector<std::string> const& extra)
 {
-  this->UserDirectories.insert(this->UserDirectories.end(),
-                               extra.begin(), extra.end());
+  this->UserDirectories.insert(this->UserDirectories.end(), extra.begin(),
+                               extra.end());
 }
 
-void
-cmOrderDirectories
-::AddLanguageDirectories(std::vector<std::string> const& dirs)
+void cmOrderDirectories::AddLanguageDirectories(
+  std::vector<std::string> const& dirs)
 {
   this->LanguageDirectories.insert(this->LanguageDirectories.end(),
                                    dirs.begin(), dirs.end());
 }
 
-void
-cmOrderDirectories
-::SetImplicitDirectories(std::set<std::string> const& implicitDirs)
+void cmOrderDirectories::SetImplicitDirectories(
+  std::set<std::string> const& implicitDirs)
 {
   this->ImplicitDirectories = implicitDirs;
 }
 
-void
-cmOrderDirectories
-::SetLinkExtensionInfo(std::vector<std::string> const& linkExtensions,
-                       std::string const& removeExtRegex)
+void cmOrderDirectories::SetLinkExtensionInfo(
+  std::vector<std::string> const& linkExtensions,
+  std::string const& removeExtRegex)
 {
   this->LinkExtensions = linkExtensions;
   this->RemoveLibraryExtension.compile(removeExtRegex.c_str());
@@ -410,10 +373,9 @@ void cmOrderDirectories::CollectOriginalDirectories()
   this->AddOriginalDirectories(this->UserDirectories);
 
   // Add directories containing constraints.
-  for(unsigned int i=0; i < this->ConstraintEntries.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->ConstraintEntries.size(); ++i) {
     this->ConstraintEntries[i]->AddDirectory();
-    }
+  }
 
   // Add language runtime directories last.
   this->AddOriginalDirectories(this->LanguageDirectories);
@@ -422,42 +384,36 @@ void cmOrderDirectories::CollectOriginalDirectories()
 int cmOrderDirectories::AddOriginalDirectory(std::string const& dir)
 {
   // Add the runtime directory with a unique index.
-  std::map<std::string, int>::iterator i =
-    this->DirectoryIndex.find(dir);
-  if(i == this->DirectoryIndex.end())
-    {
-    std::map<std::string, int>::value_type
-      entry(dir, static_cast<int>(this->OriginalDirectories.size()));
+  std::map<std::string, int>::iterator i = this->DirectoryIndex.find(dir);
+  if (i == this->DirectoryIndex.end()) {
+    std::map<std::string, int>::value_type entry(
+      dir, static_cast<int>(this->OriginalDirectories.size()));
     i = this->DirectoryIndex.insert(entry).first;
     this->OriginalDirectories.push_back(dir);
-    }
+  }
 
   return i->second;
 }
 
-void
-cmOrderDirectories
-::AddOriginalDirectories(std::vector<std::string> const& dirs)
+void cmOrderDirectories::AddOriginalDirectories(
+  std::vector<std::string> const& dirs)
 {
-  for(std::vector<std::string>::const_iterator di = dirs.begin();
-      di != dirs.end(); ++di)
-    {
+  for (std::vector<std::string>::const_iterator di = dirs.begin();
+       di != dirs.end(); ++di) {
     // We never explicitly specify implicit link directories.
-    if(this->ImplicitDirectories.find(*di) !=
-       this->ImplicitDirectories.end())
-      {
+    if (this->ImplicitDirectories.find(*di) !=
+        this->ImplicitDirectories.end()) {
       continue;
-      }
+    }
 
     // Skip the empty string.
-    if(di->empty())
-      {
+    if (di->empty()) {
       continue;
-      }
+    }
 
     // Add this directory.
     this->AddOriginalDirectory(*di);
-    }
+  }
 }
 
 struct cmOrderDirectoriesCompare
@@ -467,11 +423,10 @@ struct cmOrderDirectoriesCompare
   // The conflict pair is unique based on just the directory
   // (first).  The second element is only used for displaying
   // information about why the entry is present.
-  bool operator()(ConflictPair const& l,
-                  ConflictPair const& r)
-    {
+  bool operator()(ConflictPair const& l, ConflictPair const& r)
+  {
     return l.first == r.first;
-    }
+  }
 };
 
 void cmOrderDirectories::FindConflicts()
@@ -481,16 +436,13 @@ void cmOrderDirectories::FindConflicts()
   this->DirectoryVisited.resize(this->OriginalDirectories.size(), 0);
 
   // Find directories conflicting with each entry.
-  for(unsigned int i=0; i < this->ConstraintEntries.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->ConstraintEntries.size(); ++i) {
     this->ConstraintEntries[i]->FindConflicts(i);
-    }
+  }
 
   // Clean up the conflict graph representation.
-  for(std::vector<ConflictList>::iterator
-        i = this->ConflictGraph.begin();
-      i != this->ConflictGraph.end(); ++i)
-    {
+  for (std::vector<ConflictList>::iterator i = this->ConflictGraph.begin();
+       i != this->ConflictGraph.end(); ++i) {
     // Sort the outgoing edges for each graph node so that the
     // original order will be preserved as much as possible.
     std::sort(i->begin(), i->end());
@@ -499,7 +451,7 @@ void cmOrderDirectories::FindConflicts()
     ConflictList::iterator last =
       std::unique(i->begin(), i->end(), cmOrderDirectoriesCompare());
     i->erase(last, i->end());
-    }
+  }
 
   // Check items in implicit link directories.
   this->FindImplicitConflicts();
@@ -510,29 +462,25 @@ void cmOrderDirectories::FindImplicitConflicts()
   // Check for items in implicit link directories that have conflicts
   // in the explicit directories.
   std::ostringstream conflicts;
-  for(unsigned int i=0; i < this->ImplicitDirEntries.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->ImplicitDirEntries.size(); ++i) {
     this->ImplicitDirEntries[i]->FindImplicitConflicts(conflicts);
-    }
+  }
 
   // Skip warning if there were no conflicts.
   std::string text = conflicts.str();
-  if(text.empty())
-    {
+  if (text.empty()) {
     return;
-    }
+  }
 
   // Warn about the conflicts.
   std::ostringstream w;
-  w << "Cannot generate a safe " << this->Purpose
-    << " for target " << this->Target->GetName()
+  w << "Cannot generate a safe " << this->Purpose << " for target "
+    << this->Target->GetName()
     << " because files in some directories may conflict with "
     << " libraries in implicit directories:\n"
-    << text
-    << "Some of these libraries may not be found correctly.";
-  this->GlobalGenerator->GetCMakeInstance()
-    ->IssueMessage(cmake::WARNING, w.str(),
-                   this->Target->GetBacktrace());
+    << text << "Some of these libraries may not be found correctly.";
+  this->GlobalGenerator->GetCMakeInstance()->IssueMessage(
+    cmake::WARNING, w.str(), this->Target->GetBacktrace());
 }
 
 void cmOrderDirectories::OrderDirectories()
@@ -542,38 +490,33 @@ void cmOrderDirectories::OrderDirectories()
   this->WalkId = 0;
 
   // Iterate through the directories in the original order.
-  for(unsigned int i=0; i < this->OriginalDirectories.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->OriginalDirectories.size(); ++i) {
     // Start a new DFS from this node.
     ++this->WalkId;
     this->VisitDirectory(i);
-    }
+  }
 }
 
 void cmOrderDirectories::VisitDirectory(unsigned int i)
 {
   // Skip nodes already visited.
-  if(this->DirectoryVisited[i])
-    {
-    if(this->DirectoryVisited[i] == this->WalkId)
-      {
+  if (this->DirectoryVisited[i]) {
+    if (this->DirectoryVisited[i] == this->WalkId) {
       // We have reached a node previously visited on this DFS.
       // There is a cycle.
       this->DiagnoseCycle();
-      }
-    return;
     }
+    return;
+  }
 
   // We are now visiting this node so mark it.
   this->DirectoryVisited[i] = this->WalkId;
 
   // Visit the neighbors of the node first.
   ConflictList const& clist = this->ConflictGraph[i];
-  for(ConflictList::const_iterator j = clist.begin();
-      j != clist.end(); ++j)
-    {
+  for (ConflictList::const_iterator j = clist.begin(); j != clist.end(); ++j) {
     this->VisitDirectory(j->first);
-    }
+  }
 
   // Now that all directories required to come before this one have
   // been emmitted, emit this directory.
@@ -583,35 +526,31 @@ void cmOrderDirectories::VisitDirectory(unsigned int i)
 void cmOrderDirectories::DiagnoseCycle()
 {
   // Report the cycle at most once.
-  if(this->CycleDiagnosed)
-    {
+  if (this->CycleDiagnosed) {
     return;
-    }
+  }
   this->CycleDiagnosed = true;
 
   // Construct the message.
   std::ostringstream e;
-  e << "Cannot generate a safe " << this->Purpose
-    << " for target " << this->Target->GetName()
+  e << "Cannot generate a safe " << this->Purpose << " for target "
+    << this->Target->GetName()
     << " because there is a cycle in the constraint graph:\n";
 
   // Display the conflict graph.
-  for(unsigned int i=0; i < this->ConflictGraph.size(); ++i)
-    {
+  for (unsigned int i = 0; i < this->ConflictGraph.size(); ++i) {
     ConflictList const& clist = this->ConflictGraph[i];
     e << "  dir " << i << " is [" << this->OriginalDirectories[i] << "]\n";
-    for(ConflictList::const_iterator j = clist.begin();
-        j != clist.end(); ++j)
-      {
+    for (ConflictList::const_iterator j = clist.begin(); j != clist.end();
+         ++j) {
       e << "    dir " << j->first << " must precede it due to ";
       this->ConstraintEntries[j->second]->Report(e);
       e << "\n";
-      }
     }
+  }
   e << "Some of these libraries may not be found correctly.";
-  this->GlobalGenerator->GetCMakeInstance()
-    ->IssueMessage(cmake::WARNING, e.str(),
-                   this->Target->GetBacktrace());
+  this->GlobalGenerator->GetCMakeInstance()->IssueMessage(
+    cmake::WARNING, e.str(), this->Target->GetBacktrace());
 }
 
 bool cmOrderDirectories::IsSameDirectory(std::string const& l,
@@ -625,11 +564,10 @@ std::string const& cmOrderDirectories::GetRealPath(std::string const& dir)
   std::map<std::string, std::string>::iterator i =
     this->RealPaths.lower_bound(dir);
   if (i == this->RealPaths.end() ||
-      this->RealPaths.key_comp()(dir, i->first))
-    {
+      this->RealPaths.key_comp()(dir, i->first)) {
     typedef std::map<std::string, std::string>::value_type value_type;
     i = this->RealPaths.insert(
       i, value_type(dir, cmSystemTools::GetRealPath(dir)));
-    }
+  }
   return i->second;
 }
diff --git a/Source/cmOrderDirectories.h b/Source/cmOrderDirectories.h
index 477216b..fc1a388 100644
--- a/Source/cmOrderDirectories.h
+++ b/Source/cmOrderDirectories.h
@@ -39,6 +39,7 @@ public:
                             std::string const& removeExtRegex);
 
   std::vector<std::string> const& GetOrderedDirectories();
+
 private:
   cmGlobalGenerator* GlobalGenerator;
   cmGeneratorTarget const* Target;
@@ -77,7 +78,9 @@ private:
   // element is the index of the runtime library that added the
   // constraint.
   typedef std::pair<int, int> ConflictPair;
-  struct ConflictList: public std::vector<ConflictPair> {};
+  struct ConflictList : public std::vector<ConflictPair>
+  {
+  };
   std::vector<ConflictList> ConflictGraph;
 
   // Compare directories after resolving symlinks.
diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx
index be14230..8e80bd0 100644
--- a/Source/cmOutputConverter.cxx
+++ b/Source/cmOutputConverter.cxx
@@ -20,37 +20,33 @@
 #include <string.h> /* strlen */
 
 cmOutputConverter::cmOutputConverter(cmState::Snapshot snapshot)
-  : StateSnapshot(snapshot), LinkScriptShell(false)
+  : StateSnapshot(snapshot)
+  , LinkScriptShell(false)
 {
   assert(this->StateSnapshot.IsValid());
 }
 
-std::string
-cmOutputConverter::ConvertToOutputForExistingCommon(const std::string& remote,
-                                                    std::string const& result,
-                                                    OutputFormat format) const
+std::string cmOutputConverter::ConvertToOutputForExistingCommon(
+  const std::string& remote, std::string const& result,
+  OutputFormat format) const
 {
   // If this is a windows shell, the result has a space, and the path
   // already exists, we can use a short-path to reference it without a
   // space.
-  if(this->GetState()->UseWindowsShell() && result.find(' ') != result.npos &&
-     cmSystemTools::FileExists(remote.c_str()))
-    {
+  if (this->GetState()->UseWindowsShell() && result.find(' ') != result.npos &&
+      cmSystemTools::FileExists(remote.c_str())) {
     std::string tmp;
-    if(cmSystemTools::GetShortPath(remote, tmp))
-      {
+    if (cmSystemTools::GetShortPath(remote, tmp)) {
       return this->ConvertToOutputFormat(tmp, format);
-      }
     }
+  }
 
   // Otherwise, leave it unchanged.
   return result;
 }
 
-std::string
-cmOutputConverter::ConvertToOutputForExisting(const std::string& remote,
-                                              RelativeRoot local,
-                                              OutputFormat format) const
+std::string cmOutputConverter::ConvertToOutputForExisting(
+  const std::string& remote, RelativeRoot local, OutputFormat format) const
 {
   static_cast<void>(local);
 
@@ -61,10 +57,8 @@ cmOutputConverter::ConvertToOutputForExisting(const std::string& remote,
   return this->ConvertToOutputForExistingCommon(remote, result, format);
 }
 
-std::string
-cmOutputConverter::ConvertToOutputForExisting(RelativeRoot remote,
-                                              const std::string& local,
-                                              OutputFormat format) const
+std::string cmOutputConverter::ConvertToOutputForExisting(
+  RelativeRoot remote, const std::string& local, OutputFormat format) const
 {
   // Perform standard conversion.
   std::string result = this->Convert(remote, local, format, true);
@@ -76,18 +70,18 @@ cmOutputConverter::ConvertToOutputForExisting(RelativeRoot remote,
 
 const char* cmOutputConverter::GetRelativeRootPath(RelativeRoot relroot) const
 {
-  switch (relroot)
-    {
-  case HOME:
-    return this->GetState()->GetSourceDirectory();
-  case START:
-    return this->StateSnapshot.GetDirectory().GetCurrentSource();
-  case HOME_OUTPUT:
-    return this->GetState()->GetBinaryDirectory();
-  case START_OUTPUT:
-    return this->StateSnapshot.GetDirectory().GetCurrentBinary();
-  default: break;
-    }
+  switch (relroot) {
+    case HOME:
+      return this->GetState()->GetSourceDirectory();
+    case START:
+      return this->StateSnapshot.GetDirectory().GetCurrentSource();
+    case HOME_OUTPUT:
+      return this->GetState()->GetBinaryDirectory();
+    case START_OUTPUT:
+      return this->StateSnapshot.GetDirectory().GetCurrentBinary();
+    default:
+      break;
+  }
   return 0;
 }
 
@@ -98,32 +92,31 @@ std::string cmOutputConverter::Convert(const std::string& source,
   // Convert the path to a relative path.
   std::string result = source;
 
-  switch (relative)
-    {
-  case HOME:
-    result = this->ConvertToRelativePath(
-          this->GetState()->GetSourceDirectoryComponents(), result);
-    break;
-  case START:
-    result = this->ConvertToRelativePath(
-          this->StateSnapshot.GetDirectory().GetCurrentSourceComponents(),
-          result);
-    break;
-  case HOME_OUTPUT:
-    result = this->ConvertToRelativePath(
-          this->GetState()->GetBinaryDirectoryComponents(), result);
-    break;
-  case START_OUTPUT:
-    result = this->ConvertToRelativePath(
-          this->StateSnapshot.GetDirectory().GetCurrentBinaryComponents(),
-          result);
-    break;
-  case FULL:
-    result = cmSystemTools::CollapseFullPath(result);
-    break;
-  case NONE:
-    break;
-    }
+  switch (relative) {
+    case HOME:
+      result = this->ConvertToRelativePath(
+        this->GetState()->GetSourceDirectoryComponents(), result);
+      break;
+    case START:
+      result = this->ConvertToRelativePath(
+        this->StateSnapshot.GetDirectory().GetCurrentSourceComponents(),
+        result);
+      break;
+    case HOME_OUTPUT:
+      result = this->ConvertToRelativePath(
+        this->GetState()->GetBinaryDirectoryComponents(), result);
+      break;
+    case START_OUTPUT:
+      result = this->ConvertToRelativePath(
+        this->StateSnapshot.GetDirectory().GetCurrentBinaryComponents(),
+        result);
+      break;
+    case FULL:
+      result = cmSystemTools::CollapseFullPath(result);
+      break;
+    case NONE:
+      break;
+  }
   return this->ConvertToOutputFormat(result, output);
 }
 
@@ -132,61 +125,52 @@ std::string cmOutputConverter::ConvertToOutputFormat(const std::string& source,
 {
   std::string result = source;
   // Convert it to an output path.
-  if (output == MAKERULE)
-    {
+  if (output == MAKERULE) {
     result = cmSystemTools::ConvertToOutputPath(result.c_str());
-    }
-  else if(output == SHELL || output == WATCOMQUOTE)
-    {
+  } else if (output == SHELL || output == WATCOMQUOTE) {
     result = this->ConvertDirectorySeparatorsForShell(source);
     result = this->EscapeForShell(result, true, false, output == WATCOMQUOTE);
-    }
-  else if(output == RESPONSE)
-    {
+  } else if (output == RESPONSE) {
     result = this->EscapeForShell(result, false, false, false);
-    }
+  }
   return result;
 }
 
 std::string cmOutputConverter::ConvertDirectorySeparatorsForShell(
-                                              const std::string& source) const
+  const std::string& source) const
 {
   std::string result = source;
   // For the MSYS shell convert drive letters to posix paths, so
   // that c:/some/path becomes /c/some/path.  This is needed to
   // avoid problems with the shell path translation.
-  if(this->GetState()->UseMSYSShell() && !this->LinkScriptShell)
-    {
-    if(result.size() > 2 && result[1] == ':')
-      {
+  if (this->GetState()->UseMSYSShell() && !this->LinkScriptShell) {
+    if (result.size() > 2 && result[1] == ':') {
       result[1] = result[0];
       result[0] = '/';
-      }
     }
-  if(this->GetState()->UseWindowsShell())
-    {
+  }
+  if (this->GetState()->UseWindowsShell()) {
     std::replace(result.begin(), result.end(), '/', '\\');
-    }
+  }
   return result;
 }
 
 std::string cmOutputConverter::Convert(RelativeRoot remote,
-                                      const std::string& local,
-                                      OutputFormat output,
-                                      bool optional) const
+                                       const std::string& local,
+                                       OutputFormat output,
+                                       bool optional) const
 {
   const char* remotePath = this->GetRelativeRootPath(remote);
 
   // The relative root must have a path (i.e. not FULL or NONE)
   assert(remotePath != 0);
 
-  if(!local.empty() && !optional)
-    {
+  if (!local.empty() && !optional) {
     std::vector<std::string> components;
     cmSystemTools::SplitPath(local, components);
     std::string result = this->ConvertToRelativePath(components, remotePath);
     return this->ConvertToOutputFormat(result, output);
-    }
+  }
 
   return this->ConvertToOutputFormat(remotePath, output);
 }
@@ -197,75 +181,67 @@ static bool cmOutputConverterNotAbove(const char* a, const char* b)
           cmSystemTools::IsSubDirectory(a, b));
 }
 
-std::string
-cmOutputConverter::ConvertToRelativePath(const std::vector<std::string>& local,
-                                        const std::string& in_remote,
-                                        bool force) const
+std::string cmOutputConverter::ConvertToRelativePath(
+  const std::vector<std::string>& local, const std::string& in_remote,
+  bool force) const
 {
   // The path should never be quoted.
   assert(in_remote[0] != '\"');
 
   // The local path should never have a trailing slash.
-  assert(!local.empty() && !(local[local.size()-1] == ""));
+  assert(!local.empty() && !(local[local.size() - 1] == ""));
 
   // If the path is already relative then just return the path.
-  if(!cmSystemTools::FileIsFullPath(in_remote.c_str()))
-    {
+  if (!cmSystemTools::FileIsFullPath(in_remote.c_str())) {
     return in_remote;
-    }
+  }
 
-  if(!force)
-    {
+  if (!force) {
     // Skip conversion if the path and local are not both in the source
     // or both in the binary tree.
     std::string local_path = cmSystemTools::JoinPath(local);
-    if(!((cmOutputConverterNotAbove(local_path.c_str(),
-              this->StateSnapshot.GetDirectory().GetRelativePathTopBinary())
-          && cmOutputConverterNotAbove(in_remote.c_str(),
-              this->StateSnapshot.GetDirectory().GetRelativePathTopBinary()))
-         || (cmOutputConverterNotAbove(local_path.c_str(),
-              this->StateSnapshot.GetDirectory().GetRelativePathTopSource())
-             && cmOutputConverterNotAbove(in_remote.c_str(),
-              this->StateSnapshot.GetDirectory().GetRelativePathTopSource()))))
-      {
+    if (!((cmOutputConverterNotAbove(
+             local_path.c_str(),
+             this->StateSnapshot.GetDirectory().GetRelativePathTopBinary()) &&
+           cmOutputConverterNotAbove(
+             in_remote.c_str(),
+             this->StateSnapshot.GetDirectory().GetRelativePathTopBinary())) ||
+          (cmOutputConverterNotAbove(
+             local_path.c_str(),
+             this->StateSnapshot.GetDirectory().GetRelativePathTopSource()) &&
+           cmOutputConverterNotAbove(in_remote.c_str(),
+                                     this->StateSnapshot.GetDirectory()
+                                       .GetRelativePathTopSource())))) {
       return in_remote;
-      }
     }
+  }
 
   // Identify the longest shared path component between the remote
   // path and the local path.
   std::vector<std::string> remote;
   cmSystemTools::SplitPath(in_remote, remote);
-  unsigned int common=0;
-  while(common < remote.size() &&
-        common < local.size() &&
-        cmSystemTools::ComparePath(remote[common],
-                                   local[common]))
-    {
+  unsigned int common = 0;
+  while (common < remote.size() && common < local.size() &&
+         cmSystemTools::ComparePath(remote[common], local[common])) {
     ++common;
-    }
+  }
 
   // If no part of the path is in common then return the full path.
-  if(common == 0)
-    {
+  if (common == 0) {
     return in_remote;
-    }
+  }
 
   // If the entire path is in common then just return a ".".
-  if(common == remote.size() &&
-     common == local.size())
-    {
+  if (common == remote.size() && common == local.size()) {
     return ".";
-    }
+  }
 
   // If the entire path is in common except for a trailing slash then
   // just return a "./".
-  if(common+1 == remote.size() &&
-     remote[common].empty() &&
-     common == local.size())
-    {
+  if (common + 1 == remote.size() && remote[common].empty() &&
+      common == local.size()) {
     return "./";
-    }
+  }
 
   // Construct the relative path.
   std::string relative;
@@ -274,14 +250,12 @@ cmOutputConverter::ConvertToRelativePath(const std::vector<std::string>& local,
   // of the path.  Leave off the trailing slash.  Note that the last
   // component of local will never be empty because local should never
   // have a trailing slash.
-  for(unsigned int i=common; i < local.size(); ++i)
-    {
+  for (unsigned int i = common; i < local.size(); ++i) {
     relative += "..";
-    if(i < local.size()-1)
-      {
+    if (i < local.size() - 1) {
       relative += "/";
-      }
     }
+  }
 
   // Now add the portion of the destination path that is not included
   // in the shared portion of the path.  Add a slash the first time
@@ -290,10 +264,9 @@ cmOutputConverter::ConvertToRelativePath(const std::vector<std::string>& local,
   // will add a slash followed by an empty string which will preserve
   // the trailing slash in the output.
 
-  if(!relative.empty() && !remote.empty())
-    {
+  if (!relative.empty() && !remote.empty()) {
     relative += "/";
-    }
+  }
   relative += cmJoin(cmMakeRange(remote).advance(common), "/");
 
   // Finally return the path.
@@ -303,8 +276,7 @@ cmOutputConverter::ConvertToRelativePath(const std::vector<std::string>& local,
 static bool cmOutputConverterIsShellOperator(const std::string& str)
 {
   static std::set<std::string> shellOperators;
-  if(shellOperators.empty())
-    {
+  if (shellOperators.empty()) {
     shellOperators.insert("<");
     shellOperators.insert(">");
     shellOperators.insert("<<");
@@ -317,71 +289,57 @@ static bool cmOutputConverterIsShellOperator(const std::string& str)
     shellOperators.insert("2>");
     shellOperators.insert("2>&1");
     shellOperators.insert("1>&2");
-    }
+  }
   return shellOperators.count(str) > 0;
 }
 
 std::string cmOutputConverter::EscapeForShell(const std::string& str,
-                                             bool makeVars,
-                                             bool forEcho,
-                                             bool useWatcomQuote) const
+                                              bool makeVars, bool forEcho,
+                                              bool useWatcomQuote) const
 {
   // Do not escape shell operators.
-  if(cmOutputConverterIsShellOperator(str))
-    {
+  if (cmOutputConverterIsShellOperator(str)) {
     return str;
-    }
+  }
 
   // Compute the flags for the target shell environment.
   int flags = 0;
-  if(this->GetState()->UseWindowsVSIDE())
-    {
+  if (this->GetState()->UseWindowsVSIDE()) {
     flags |= Shell_Flag_VSIDE;
-    }
-  else if(!this->LinkScriptShell)
-    {
+  } else if (!this->LinkScriptShell) {
     flags |= Shell_Flag_Make;
-    }
-  if(makeVars)
-    {
+  }
+  if (makeVars) {
     flags |= Shell_Flag_AllowMakeVariables;
-    }
-  if(forEcho)
-    {
+  }
+  if (forEcho) {
     flags |= Shell_Flag_EchoWindows;
-    }
-  if(useWatcomQuote)
-    {
+  }
+  if (useWatcomQuote) {
     flags |= Shell_Flag_WatcomQuote;
-    }
-  if(this->GetState()->UseWatcomWMake())
-    {
+  }
+  if (this->GetState()->UseWatcomWMake()) {
     flags |= Shell_Flag_WatcomWMake;
-    }
-  if(this->GetState()->UseMinGWMake())
-    {
+  }
+  if (this->GetState()->UseMinGWMake()) {
     flags |= Shell_Flag_MinGWMake;
-    }
-  if(this->GetState()->UseNMake())
-    {
+  }
+  if (this->GetState()->UseNMake()) {
     flags |= Shell_Flag_NMake;
-    }
+  }
 
   // Compute the buffer size needed.
-  int size = (this->GetState()->UseWindowsShell() ?
-              Shell_GetArgumentSizeForWindows(str.c_str(), flags) :
-              Shell_GetArgumentSizeForUnix(str.c_str(), flags));
+  int size = (this->GetState()->UseWindowsShell()
+                ? Shell_GetArgumentSizeForWindows(str.c_str(), flags)
+                : Shell_GetArgumentSizeForUnix(str.c_str(), flags));
 
   // Compute the shell argument itself.
   std::vector<char> arg(size);
-  if(this->GetState()->UseWindowsShell())
-    {
+  if (this->GetState()->UseWindowsShell()) {
     Shell_GetArgumentForWindows(str.c_str(), &arg[0], flags);
-    }
-  else
-    {
+  } else {
     Shell_GetArgumentForUnix(str.c_str(), &arg[0], flags);
-    }
+  }
   return std::string(&arg[0]);
 }
 
@@ -389,73 +347,59 @@ std::string cmOutputConverter::EscapeForCMake(const std::string& str)
 {
   // Always double-quote the argument to take care of most escapes.
   std::string result = "\"";
-  for(const char* c = str.c_str(); *c; ++c)
-    {
-    if(*c == '"')
-      {
+  for (const char* c = str.c_str(); *c; ++c) {
+    if (*c == '"') {
       // Escape the double quote to avoid ending the argument.
       result += "\\\"";
-      }
-    else if(*c == '$')
-      {
+    } else if (*c == '$') {
       // Escape the dollar to avoid expanding variables.
       result += "\\$";
-      }
-    else if(*c == '\\')
-      {
+    } else if (*c == '\\') {
       // Escape the backslash to avoid other escapes.
       result += "\\\\";
-      }
-    else
-      {
+    } else {
       // Other characters will be parsed correctly.
       result += *c;
-      }
     }
+  }
   result += "\"";
   return result;
 }
 
-std::string
-cmOutputConverter::EscapeWindowsShellArgument(const char* arg, int shell_flags)
+std::string cmOutputConverter::EscapeWindowsShellArgument(const char* arg,
+                                                          int shell_flags)
 {
   char local_buffer[1024];
   char* buffer = local_buffer;
   int size = Shell_GetArgumentSizeForWindows(arg, shell_flags);
-  if(size > 1024)
-    {
+  if (size > 1024) {
     buffer = new char[size];
-    }
+  }
   Shell_GetArgumentForWindows(arg, buffer, shell_flags);
   std::string result(buffer);
-  if(buffer != local_buffer)
-    {
-    delete [] buffer;
-    }
+  if (buffer != local_buffer) {
+    delete[] buffer;
+  }
   return result;
 }
 
-cmOutputConverter::FortranFormat
-cmOutputConverter::GetFortranFormat(const char* value)
+cmOutputConverter::FortranFormat cmOutputConverter::GetFortranFormat(
+  const char* value)
 {
   FortranFormat format = FortranFormatNone;
-  if(value && *value)
-    {
+  if (value && *value) {
     std::vector<std::string> fmt;
     cmSystemTools::ExpandListArgument(value, fmt);
-    for(std::vector<std::string>::iterator fi = fmt.begin();
-        fi != fmt.end(); ++fi)
-      {
-      if(*fi == "FIXED")
-        {
+    for (std::vector<std::string>::iterator fi = fmt.begin(); fi != fmt.end();
+         ++fi) {
+      if (*fi == "FIXED") {
         format = FortranFormatFixed;
-        }
-      if(*fi == "FREE")
-        {
+      }
+      if (*fi == "FREE") {
         format = FortranFormatFree;
-        }
       }
     }
+  }
   return format;
 }
 
@@ -511,47 +455,40 @@ int cmOutputConverter::Shell__CharIsWhitespace(char c)
 int cmOutputConverter::Shell__CharNeedsQuotesOnUnix(char c)
 {
   return ((c == '\'') || (c == '`') || (c == ';') || (c == '#') ||
-          (c == '&') || (c == '$') || (c == '(') || (c == ')') ||
-          (c == '~') || (c == '<') || (c == '>') || (c == '|') ||
-          (c == '*') || (c == '^') || (c == '\\'));
+          (c == '&') || (c == '$') || (c == '(') || (c == ')') || (c == '~') ||
+          (c == '<') || (c == '>') || (c == '|') || (c == '*') || (c == '^') ||
+          (c == '\\'));
 }
 
 int cmOutputConverter::Shell__CharNeedsQuotesOnWindows(char c)
 {
-  return ((c == '\'') || (c == '#') || (c == '&') ||
-          (c == '<') || (c == '>') || (c == '|') || (c == '^'));
+  return ((c == '\'') || (c == '#') || (c == '&') || (c == '<') ||
+          (c == '>') || (c == '|') || (c == '^'));
 }
 
 int cmOutputConverter::Shell__CharNeedsQuotes(char c, int isUnix, int flags)
 {
   /* On Windows the built-in command shell echo never needs quotes.  */
-  if(!isUnix && (flags & Shell_Flag_EchoWindows))
-    {
+  if (!isUnix && (flags & Shell_Flag_EchoWindows)) {
     return 0;
-    }
+  }
 
   /* On all platforms quotes are needed to preserve whitespace.  */
-  if(Shell__CharIsWhitespace(c))
-    {
+  if (Shell__CharIsWhitespace(c)) {
     return 1;
-    }
+  }
 
-  if(isUnix)
-    {
+  if (isUnix) {
     /* On UNIX several special characters need quotes to preserve them.  */
-    if(Shell__CharNeedsQuotesOnUnix(c))
-      {
+    if (Shell__CharNeedsQuotesOnUnix(c)) {
       return 1;
-      }
     }
-  else
-    {
+  } else {
     /* On Windows several special characters need quotes to preserve them.  */
-    if(Shell__CharNeedsQuotesOnWindows(c))
-      {
+    if (Shell__CharNeedsQuotesOnWindows(c)) {
       return 1;
-      }
     }
+  }
   return 0;
 }
 
@@ -562,22 +499,17 @@ int cmOutputConverter::Shell__CharIsMakeVariableName(char c)
 
 const char* cmOutputConverter::Shell__SkipMakeVariables(const char* c)
 {
-  while(*c == '$' && *(c+1) == '(')
-    {
-    const char* skip = c+2;
-    while(Shell__CharIsMakeVariableName(*skip))
-      {
+  while (*c == '$' && *(c + 1) == '(') {
+    const char* skip = c + 2;
+    while (Shell__CharIsMakeVariableName(*skip)) {
       ++skip;
-      }
-    if(*skip == ')')
-      {
-      c = skip+1;
-      }
-    else
-      {
+    }
+    if (*skip == ')') {
+      c = skip + 1;
+    } else {
       break;
-      }
     }
+  }
   return c;
 }
 
@@ -604,66 +536,58 @@ flag later when we understand applications of this better.
 */
 #define KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES 0
 
-int cmOutputConverter::Shell__ArgumentNeedsQuotes(const char* in,
-                                                  int isUnix, int flags)
+int cmOutputConverter::Shell__ArgumentNeedsQuotes(const char* in, int isUnix,
+                                                  int flags)
 {
   /* The empty string needs quotes.  */
-  if(!*in)
-    {
+  if (!*in) {
     return 1;
-    }
+  }
 
   /* Scan the string for characters that require quoting.  */
   {
-  const char* c;
-  for(c=in; *c; ++c)
-    {
-    /* Look for $(MAKEVAR) syntax if requested.  */
-    if(flags & Shell_Flag_AllowMakeVariables)
-      {
+    const char* c;
+    for (c = in; *c; ++c) {
+      /* Look for $(MAKEVAR) syntax if requested.  */
+      if (flags & Shell_Flag_AllowMakeVariables) {
 #if KWSYS_SYSTEM_SHELL_QUOTE_MAKE_VARIABLES
-      const char* skip = Shell__SkipMakeVariables(c);
-      if(skip != c)
-        {
-        /* We need to quote make variable references to preserve the
-           string with contents substituted in its place.  */
-        return 1;
+        const char* skip = Shell__SkipMakeVariables(c);
+        if (skip != c) {
+          /* We need to quote make variable references to preserve the
+             string with contents substituted in its place.  */
+          return 1;
         }
 #else
-      /* Skip over the make variable references if any are present.  */
-      c = Shell__SkipMakeVariables(c);
+        /* Skip over the make variable references if any are present.  */
+        c = Shell__SkipMakeVariables(c);
 
-      /* Stop if we have reached the end of the string.  */
-      if(!*c)
-        {
-        break;
+        /* Stop if we have reached the end of the string.  */
+        if (!*c) {
+          break;
         }
 #endif
       }
 
-    /* Check whether this character needs quotes.  */
-    if(Shell__CharNeedsQuotes(*c, isUnix, flags))
-      {
-      return 1;
+      /* Check whether this character needs quotes.  */
+      if (Shell__CharNeedsQuotes(*c, isUnix, flags)) {
+        return 1;
       }
     }
   }
 
   /* On Windows some single character arguments need quotes.  */
-  if(!isUnix && *in && !*(in+1))
-    {
+  if (!isUnix && *in && !*(in + 1)) {
     char c = *in;
-    if((c == '?') || (c == '&') || (c == '^') || (c == '|') || (c == '#'))
-      {
+    if ((c == '?') || (c == '&') || (c == '^') || (c == '|') || (c == '#')) {
       return 1;
-      }
     }
+  }
 
   return 0;
 }
 
-int cmOutputConverter::Shell__GetArgumentSize(const char* in,
-                                              int isUnix, int flags)
+int cmOutputConverter::Shell__GetArgumentSize(const char* in, int isUnix,
+                                              int flags)
 {
   /* Start with the length of the original argument, plus one for
      either a terminating null or a separating space.  */
@@ -676,122 +600,91 @@ int cmOutputConverter::Shell__GetArgumentSize(const char* in,
   int windows_backslashes = 0;
 
   /* Scan the string for characters that require escaping or quoting.  */
-  for(c=in; *c; ++c)
-    {
+  for (c = in; *c; ++c) {
     /* Look for $(MAKEVAR) syntax if requested.  */
-    if(flags & Shell_Flag_AllowMakeVariables)
-      {
+    if (flags & Shell_Flag_AllowMakeVariables) {
       /* Skip over the make variable references if any are present.  */
       c = Shell__SkipMakeVariables(c);
 
       /* Stop if we have reached the end of the string.  */
-      if(!*c)
-        {
+      if (!*c) {
         break;
-        }
       }
+    }
 
     /* Check whether this character needs escaping for the shell.  */
-    if(isUnix)
-      {
+    if (isUnix) {
       /* On Unix a few special characters need escaping even inside a
          quoted argument.  */
-      if(*c == '\\' || *c == '"' || *c == '`' || *c == '$')
-        {
+      if (*c == '\\' || *c == '"' || *c == '`' || *c == '$') {
         /* This character needs a backslash to escape it.  */
         ++size;
-        }
       }
-    else if(flags & Shell_Flag_EchoWindows)
-      {
+    } else if (flags & Shell_Flag_EchoWindows) {
       /* On Windows the built-in command shell echo never needs escaping.  */
-      }
-    else
-      {
+    } else {
       /* On Windows only backslashes and double-quotes need escaping.  */
-      if(*c == '\\')
-        {
+      if (*c == '\\') {
         /* Found a backslash.  It may need to be escaped later.  */
         ++windows_backslashes;
-        }
-      else if(*c == '"')
-        {
+      } else if (*c == '"') {
         /* Found a double-quote.  We need to escape it and all
            immediately preceding backslashes.  */
         size += windows_backslashes + 1;
         windows_backslashes = 0;
-        }
-      else
-        {
+      } else {
         /* Found another character.  This eliminates the possibility
            that any immediately preceding backslashes will be
            escaped.  */
         windows_backslashes = 0;
-        }
       }
+    }
 
     /* Check whether this character needs escaping for a make tool.  */
-    if(*c == '$')
-      {
-      if(flags & Shell_Flag_Make)
-        {
+    if (*c == '$') {
+      if (flags & Shell_Flag_Make) {
         /* In Makefiles a dollar is written $$ so we need one extra
            character.  */
         ++size;
-        }
-      else if(flags & Shell_Flag_VSIDE)
-        {
+      } else if (flags & Shell_Flag_VSIDE) {
         /* In a VS IDE a dollar is written "$" so we need two extra
            characters.  */
         size += 2;
-        }
       }
-    else if(*c == '#')
-      {
-      if((flags & Shell_Flag_Make) &&
-         (flags & Shell_Flag_WatcomWMake))
-        {
+    } else if (*c == '#') {
+      if ((flags & Shell_Flag_Make) && (flags & Shell_Flag_WatcomWMake)) {
         /* In Watcom WMake makefiles a pound is written $# so we need
            one extra character.  */
         ++size;
-        }
       }
-    else if(*c == '%')
-      {
-      if((flags & Shell_Flag_VSIDE) ||
-         ((flags & Shell_Flag_Make) &&
-          ((flags & Shell_Flag_MinGWMake) ||
-           (flags & Shell_Flag_NMake))))
-        {
+    } else if (*c == '%') {
+      if ((flags & Shell_Flag_VSIDE) ||
+          ((flags & Shell_Flag_Make) &&
+           ((flags & Shell_Flag_MinGWMake) || (flags & Shell_Flag_NMake)))) {
         /* In the VS IDE, NMake, or MinGW make a percent is written %%
            so we need one extra characters.  */
         size += 1;
-        }
       }
-    else if(*c == ';')
-      {
-      if(flags & Shell_Flag_VSIDE)
-        {
+    } else if (*c == ';') {
+      if (flags & Shell_Flag_VSIDE) {
         /* In a VS IDE a semicolon is written ";" so we need two extra
            characters.  */
         size += 2;
-        }
       }
     }
+  }
 
   /* Check whether the argument needs surrounding quotes.  */
-  if(Shell__ArgumentNeedsQuotes(in, isUnix, flags))
-    {
+  if (Shell__ArgumentNeedsQuotes(in, isUnix, flags)) {
     /* Surrounding quotes are needed.  Allocate space for them.  */
-    if((flags & Shell_Flag_WatcomQuote) && (isUnix))
-      {
-        size += 2;
-      }
+    if ((flags & Shell_Flag_WatcomQuote) && (isUnix)) {
+      size += 2;
+    }
     size += 2;
 
     /* We must escape all ending backslashes when quoting on windows.  */
     size += windows_backslashes;
-    }
+  }
 
   return size;
 }
@@ -807,106 +700,80 @@ char* cmOutputConverter::Shell__GetArgument(const char* in, char* out,
 
   /* Whether the argument must be quoted.  */
   int needQuotes = Shell__ArgumentNeedsQuotes(in, isUnix, flags);
-  if(needQuotes)
-    {
+  if (needQuotes) {
     /* Add the opening quote for this argument.  */
-    if(flags & Shell_Flag_WatcomQuote)
-      {
-      if(isUnix)
-        {
+    if (flags & Shell_Flag_WatcomQuote) {
+      if (isUnix) {
         *out++ = '"';
-        }
-      *out++ = '\'';
       }
-    else
-      {
+      *out++ = '\'';
+    } else {
       *out++ = '"';
-      }
     }
+  }
 
   /* Scan the string for characters that require escaping or quoting.  */
-  for(c=in; *c; ++c)
-    {
+  for (c = in; *c; ++c) {
     /* Look for $(MAKEVAR) syntax if requested.  */
-    if(flags & Shell_Flag_AllowMakeVariables)
-      {
+    if (flags & Shell_Flag_AllowMakeVariables) {
       const char* skip = Shell__SkipMakeVariables(c);
-      if(skip != c)
-        {
+      if (skip != c) {
         /* Copy to the end of the make variable references.  */
-        while(c != skip)
-          {
+        while (c != skip) {
           *out++ = *c++;
-          }
+        }
 
         /* The make variable reference eliminates any escaping needed
            for preceding backslashes.  */
         windows_backslashes = 0;
 
         /* Stop if we have reached the end of the string.  */
-        if(!*c)
-          {
+        if (!*c) {
           break;
-          }
         }
       }
+    }
 
     /* Check whether this character needs escaping for the shell.  */
-    if(isUnix)
-      {
+    if (isUnix) {
       /* On Unix a few special characters need escaping even inside a
          quoted argument.  */
-      if(*c == '\\' || *c == '"' || *c == '`' || *c == '$')
-        {
+      if (*c == '\\' || *c == '"' || *c == '`' || *c == '$') {
         /* This character needs a backslash to escape it.  */
         *out++ = '\\';
-        }
       }
-    else if(flags & Shell_Flag_EchoWindows)
-      {
+    } else if (flags & Shell_Flag_EchoWindows) {
       /* On Windows the built-in command shell echo never needs escaping.  */
-      }
-    else
-      {
+    } else {
       /* On Windows only backslashes and double-quotes need escaping.  */
-      if(*c == '\\')
-        {
+      if (*c == '\\') {
         /* Found a backslash.  It may need to be escaped later.  */
         ++windows_backslashes;
-        }
-      else if(*c == '"')
-        {
+      } else if (*c == '"') {
         /* Found a double-quote.  Escape all immediately preceding
            backslashes.  */
-        while(windows_backslashes > 0)
-          {
+        while (windows_backslashes > 0) {
           --windows_backslashes;
           *out++ = '\\';
-          }
+        }
 
         /* Add the backslash to escape the double-quote.  */
         *out++ = '\\';
-        }
-      else
-        {
+      } else {
         /* We encountered a normal character.  This eliminates any
            escaping needed for preceding backslashes.  */
         windows_backslashes = 0;
-        }
       }
+    }
 
     /* Check whether this character needs escaping for a make tool.  */
-    if(*c == '$')
-      {
-      if(flags & Shell_Flag_Make)
-        {
+    if (*c == '$') {
+      if (flags & Shell_Flag_Make) {
         /* In Makefiles a dollar is written $$.  The make tool will
            replace it with just $ before passing it to the shell.  */
         *out++ = '$';
         *out++ = '$';
-        }
-      else if(flags & Shell_Flag_VSIDE)
-        {
+      } else if (flags & Shell_Flag_VSIDE) {
         /* In a VS IDE a dollar is written "$".  If this is written in
            an un-quoted argument it starts a quoted segment, inserts
            the $ and ends the segment.  If it is written in a quoted
@@ -916,51 +783,34 @@ char* cmOutputConverter::Shell__GetArgument(const char* in, char* out,
         *out++ = '"';
         *out++ = '$';
         *out++ = '"';
-        }
-      else
-        {
+      } else {
         /* Otherwise a dollar is written just $. */
         *out++ = '$';
-        }
       }
-    else if(*c == '#')
-      {
-      if((flags & Shell_Flag_Make) &&
-         (flags & Shell_Flag_WatcomWMake))
-        {
+    } else if (*c == '#') {
+      if ((flags & Shell_Flag_Make) && (flags & Shell_Flag_WatcomWMake)) {
         /* In Watcom WMake makefiles a pound is written $#.  The make
            tool will replace it with just # before passing it to the
            shell.  */
         *out++ = '$';
         *out++ = '#';
-        }
-      else
-        {
+      } else {
         /* Otherwise a pound is written just #. */
         *out++ = '#';
-        }
       }
-    else if(*c == '%')
-      {
-      if((flags & Shell_Flag_VSIDE) ||
-         ((flags & Shell_Flag_Make) &&
-          ((flags & Shell_Flag_MinGWMake) ||
-           (flags & Shell_Flag_NMake))))
-        {
+    } else if (*c == '%') {
+      if ((flags & Shell_Flag_VSIDE) ||
+          ((flags & Shell_Flag_Make) &&
+           ((flags & Shell_Flag_MinGWMake) || (flags & Shell_Flag_NMake)))) {
         /* In the VS IDE, NMake, or MinGW make a percent is written %%.  */
         *out++ = '%';
         *out++ = '%';
-        }
-      else
-        {
+      } else {
         /* Otherwise a percent is written just %. */
         *out++ = '%';
-        }
       }
-    else if(*c == ';')
-      {
-      if(flags & Shell_Flag_VSIDE)
-        {
+    } else if (*c == ';') {
+      if (flags & Shell_Flag_VSIDE) {
         /* In a VS IDE a semicolon is written ";".  If this is written
            in an un-quoted argument it starts a quoted segment,
            inserts the ; and ends the segment.  If it is written in a
@@ -969,43 +819,33 @@ char* cmOutputConverter::Shell__GetArgument(const char* in, char* out,
         *out++ = '"';
         *out++ = ';';
         *out++ = '"';
-        }
-      else
-        {
+      } else {
         /* Otherwise a semicolon is written just ;. */
         *out++ = ';';
-        }
       }
-    else
-      {
+    } else {
       /* Store this character.  */
       *out++ = *c;
-      }
     }
+  }
 
-  if(needQuotes)
-    {
+  if (needQuotes) {
     /* Add enough backslashes to escape any trailing ones.  */
-    while(windows_backslashes > 0)
-      {
+    while (windows_backslashes > 0) {
       --windows_backslashes;
       *out++ = '\\';
-      }
+    }
 
     /* Add the closing quote for this argument.  */
-    if(flags & Shell_Flag_WatcomQuote)
-      {
+    if (flags & Shell_Flag_WatcomQuote) {
       *out++ = '\'';
-      if(isUnix)
-        {
+      if (isUnix) {
         *out++ = '"';
-        }
       }
-    else
-      {
+    } else {
       *out++ = '"';
-      }
     }
+  }
 
   /* Store a terminating null without incrementing.  */
   *out = 0;
@@ -1013,14 +853,14 @@ char* cmOutputConverter::Shell__GetArgument(const char* in, char* out,
   return out;
 }
 
-char* cmOutputConverter::Shell_GetArgumentForWindows(const char* in,
-                                                     char* out, int flags)
+char* cmOutputConverter::Shell_GetArgumentForWindows(const char* in, char* out,
+                                                     int flags)
 {
   return Shell__GetArgument(in, out, 0, flags);
 }
 
-char* cmOutputConverter::Shell_GetArgumentForUnix(const char* in,
-                                                  char* out, int flags)
+char* cmOutputConverter::Shell_GetArgumentForUnix(const char* in, char* out,
+                                                  int flags)
 {
   return Shell__GetArgument(in, out, 1, flags);
 }
@@ -1031,8 +871,7 @@ int cmOutputConverter::Shell_GetArgumentSizeForWindows(const char* in,
   return Shell__GetArgumentSize(in, 0, flags);
 }
 
-int cmOutputConverter::Shell_GetArgumentSizeForUnix(const char* in,
-                                                    int flags)
+int cmOutputConverter::Shell_GetArgumentSizeForUnix(const char* in, int flags)
 {
   return Shell__GetArgumentSize(in, 1, flags);
 }
diff --git a/Source/cmOutputConverter.h b/Source/cmOutputConverter.h
index 852df5d..75d6326 100644
--- a/Source/cmOutputConverter.h
+++ b/Source/cmOutputConverter.h
@@ -36,8 +36,23 @@ public:
    * optional: should any relative path operation be controlled by the rel
    * path setting
    */
-  enum RelativeRoot { NONE, FULL, HOME, START, HOME_OUTPUT, START_OUTPUT };
-  enum OutputFormat { UNCHANGED, MAKERULE, SHELL, WATCOMQUOTE, RESPONSE };
+  enum RelativeRoot
+  {
+    NONE,
+    FULL,
+    HOME,
+    START,
+    HOME_OUTPUT,
+    START_OUTPUT
+  };
+  enum OutputFormat
+  {
+    UNCHANGED,
+    MAKERULE,
+    SHELL,
+    WATCOMQUOTE,
+    RESPONSE
+  };
   std::string ConvertToOutputFormat(const std::string& source,
                                     OutputFormat output) const;
   std::string Convert(const std::string& remote, RelativeRoot local,
@@ -46,7 +61,7 @@ public:
                       OutputFormat output = UNCHANGED,
                       bool optional = false) const;
   std::string ConvertDirectorySeparatorsForShell(
-                                             const std::string& source) const;
+    const std::string& source) const;
 
   /**
     * Get path for the specified relative root.
@@ -75,33 +90,33 @@ public:
   enum Shell_Flag_e
   {
     /** The target shell is in a makefile.  */
-    Shell_Flag_Make               = (1<<0),
+    Shell_Flag_Make = (1 << 0),
 
     /** The target shell is in a VS project file.  Do not use with
         Shell_Flag_Make.  */
-    Shell_Flag_VSIDE              = (1<<1),
+    Shell_Flag_VSIDE = (1 << 1),
 
     /** In a windows shell the argument is being passed to "echo".  */
-    Shell_Flag_EchoWindows        = (1<<2),
+    Shell_Flag_EchoWindows = (1 << 2),
 
     /** The target shell is in a Watcom WMake makefile.  */
-    Shell_Flag_WatcomWMake        = (1<<3),
+    Shell_Flag_WatcomWMake = (1 << 3),
 
     /** The target shell is in a MinGW Make makefile.  */
-    Shell_Flag_MinGWMake          = (1<<4),
+    Shell_Flag_MinGWMake = (1 << 4),
 
     /** The target shell is in a NMake makefile.  */
-    Shell_Flag_NMake              = (1<<5),
+    Shell_Flag_NMake = (1 << 5),
 
     /** Make variable reference syntax $(MAKEVAR) should not be escaped
         to allow a build tool to replace it.  Replacement values
         containing spaces, quotes, backslashes, or other
         non-alphanumeric characters that have significance to some makes
         or shells produce undefined behavior.  */
-    Shell_Flag_AllowMakeVariables = (1<<6),
+    Shell_Flag_AllowMakeVariables = (1 << 6),
 
     /** The target shell quoting uses extra single Quotes for Watcom tools.  */
-    Shell_Flag_WatcomQuote        = (1<<7)
+    Shell_Flag_WatcomQuote = (1 << 7)
   };
 
   /**
@@ -123,10 +138,9 @@ public:
   static int Shell_GetArgumentSizeForWindows(const char* in, int flags);
   static int Shell_GetArgumentSizeForUnix(const char* in, int flags);
 
-  std::string EscapeForShell(const std::string& str,
-                                    bool makeVars = false,
-                                    bool forEcho = false,
-                                    bool useWatcomQuote = false) const;
+  std::string EscapeForShell(const std::string& str, bool makeVars = false,
+                             bool forEcho = false,
+                             bool useWatcomQuote = false) const;
 
   static std::string EscapeForCMake(const std::string& str);
 
@@ -136,11 +150,11 @@ public:
                                                 int shell_flags);
 
   enum FortranFormat
-    {
+  {
     FortranFormatNone,
     FortranFormatFixed,
     FortranFormatFree
-    };
+  };
   static FortranFormat GetFortranFormat(const char* value);
 
   /**
@@ -167,12 +181,10 @@ private:
   static int Shell__CharNeedsQuotes(char c, int isUnix, int flags);
   static int Shell__CharIsMakeVariableName(char c);
   static const char* Shell__SkipMakeVariables(const char* c);
-  static int Shell__ArgumentNeedsQuotes(const char* in,
-                                        int isUnix, int flags);
-  static int Shell__GetArgumentSize(const char* in,
-                                    int isUnix, int flags);
-  static char* Shell__GetArgument(const char* in, char* out,
-                                  int isUnix, int flags);
+  static int Shell__ArgumentNeedsQuotes(const char* in, int isUnix, int flags);
+  static int Shell__GetArgumentSize(const char* in, int isUnix, int flags);
+  static char* Shell__GetArgument(const char* in, char* out, int isUnix,
+                                  int flags);
 
 private:
   cmState::Snapshot StateSnapshot;
diff --git a/Source/cmOutputRequiredFilesCommand.cxx b/Source/cmOutputRequiredFilesCommand.cxx
index 3b98c87..29f1acc 100644
--- a/Source/cmOutputRequiredFilesCommand.cxx
+++ b/Source/cmOutputRequiredFilesCommand.cxx
@@ -26,7 +26,11 @@ public:
    * Construct with dependency generation marked not done; instance
    * not placed in cmMakefile's list.
    */
-  cmDependInformation(): DependDone(false), SourceFile(0) {}
+  cmDependInformation()
+    : DependDone(false)
+    , SourceFile(0)
+  {
+  }
 
   /**
    * The set of files on which this one depends.
@@ -44,7 +48,7 @@ public:
    * If this object corresponds to a cmSourceFile instance, this points
    * to it.
    */
-  const cmSourceFile *SourceFile;
+  const cmSourceFile* SourceFile;
 
   /**
    * Full path to this file.
@@ -66,9 +70,8 @@ public:
    */
   void AddDependencies(cmDependInformation* info)
   {
-  if(this != info)
-    {
-    this->DependencySet.insert(info);
+    if (this != info) {
+      this->DependencySet.insert(info);
     }
   }
 };
@@ -89,10 +92,7 @@ public:
   /**
    * Destructor.
    */
-  ~cmLBDepend()
-  {
-    cmDeleteAll(this->DependInformationMap);
-  }
+  ~cmLBDepend() { cmDeleteAll(this->DependInformationMap); }
 
   /**
    * Set the makefile that is used as a source of classes.
@@ -103,49 +103,41 @@ public:
 
     // Now extract the include file regular expression from the makefile.
     this->IncludeFileRegularExpression.compile(
-          this->Makefile->GetIncludeRegularExpression());
+      this->Makefile->GetIncludeRegularExpression());
     this->ComplainFileRegularExpression.compile(
-          this->Makefile->GetComplainRegularExpression());
+      this->Makefile->GetComplainRegularExpression());
 
     // Now extract any include paths from the targets
     std::set<std::string> uniqueIncludes;
     std::vector<std::string> orderedAndUniqueIncludes;
-    cmTargets &targets = this->Makefile->GetTargets();
-    for (cmTargets::iterator l = targets.begin();
-         l != targets.end(); ++l)
-      {
-      const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
-      if (!incDirProp)
-        {
+    cmTargets& targets = this->Makefile->GetTargets();
+    for (cmTargets::iterator l = targets.begin(); l != targets.end(); ++l) {
+      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);
 
       std::vector<std::string> includes;
       cmSystemTools::ExpandListArgument(incDirs, includes);
 
-      for(std::vector<std::string>::const_iterator j = includes.begin();
-          j != includes.end(); ++j)
-        {
+      for (std::vector<std::string>::const_iterator j = includes.begin();
+           j != includes.end(); ++j) {
         std::string path = *j;
         this->Makefile->ExpandVariablesInString(path);
-        if(uniqueIncludes.insert(path).second)
-          {
+        if (uniqueIncludes.insert(path).second) {
           orderedAndUniqueIncludes.push_back(path);
-          }
         }
       }
+    }
 
-    for(std::vector<std::string>::const_iterator
-        it = orderedAndUniqueIncludes.begin();
-        it != orderedAndUniqueIncludes.end();
-        ++it)
-      {
+    for (std::vector<std::string>::const_iterator it =
+           orderedAndUniqueIncludes.begin();
+         it != orderedAndUniqueIncludes.end(); ++it) {
       this->AddSearchPath(*it);
-      }
+    }
   }
 
   /**
@@ -162,7 +154,7 @@ public:
    */
   const cmDependInformation* FindDependencies(const char* file)
   {
-    cmDependInformation* info = this->GetDependInformation(file,0);
+    cmDependInformation* info = this->GetDependInformation(file, 0);
     this->GenerateDependInformation(info);
     return info;
   }
@@ -175,152 +167,124 @@ protected:
   void DependWalk(cmDependInformation* info)
   {
     cmsys::ifstream fin(info->FullPath.c_str());
-    if(!fin)
-      {
+    if (!fin) {
       cmSystemTools::Error("error can not open ", info->FullPath.c_str());
       return;
-      }
+    }
 
     std::string line;
-    while(cmSystemTools::GetLineFromStream(fin, line))
-      {
-      if(cmHasLiteralPrefix(line.c_str(), "#include"))
-        {
+    while (cmSystemTools::GetLineFromStream(fin, line)) {
+      if (cmHasLiteralPrefix(line.c_str(), "#include")) {
         // if it is an include line then create a string class
         std::string currentline = line;
         size_t qstart = currentline.find('\"', 8);
         size_t qend;
         // if a quote is not found look for a <
-        if(qstart == std::string::npos)
-          {
+        if (qstart == std::string::npos) {
           qstart = currentline.find('<', 8);
           // if a < is not found then move on
-          if(qstart == std::string::npos)
-            {
+          if (qstart == std::string::npos) {
             cmSystemTools::Error("unknown include directive ",
-                                 currentline.c_str() );
+                                 currentline.c_str());
             continue;
-            }
-          else
-            {
-            qend = currentline.find('>', qstart+1);
-            }
-          }
-        else
-          {
-          qend = currentline.find('\"', qstart+1);
+          } else {
+            qend = currentline.find('>', qstart + 1);
           }
+        } else {
+          qend = currentline.find('\"', qstart + 1);
+        }
         // extract the file being included
         std::string includeFile =
-          currentline.substr(qstart+1, qend - qstart-1);
+          currentline.substr(qstart + 1, qend - qstart - 1);
         // see if the include matches the regular expression
-        if(!this->IncludeFileRegularExpression.find(includeFile))
-          {
-          if(this->Verbose)
-            {
+        if (!this->IncludeFileRegularExpression.find(includeFile)) {
+          if (this->Verbose) {
             std::string message = "Skipping ";
             message += includeFile;
             message += " for file ";
             message += info->FullPath.c_str();
             cmSystemTools::Error(message.c_str(), 0);
-            }
-          continue;
           }
+          continue;
+        }
 
         // Add this file and all its dependencies.
         this->AddDependency(info, includeFile.c_str());
         /// add the cxx file if it exists
         std::string cxxFile = includeFile;
         std::string::size_type pos = cxxFile.rfind('.');
-        if(pos != std::string::npos)
-          {
+        if (pos != std::string::npos) {
           std::string root = cxxFile.substr(0, pos);
           cxxFile = root + ".cxx";
           bool found = false;
           // try jumping to .cxx .cpp and .c in order
-          if(cmSystemTools::FileExists(cxxFile.c_str()))
-            {
+          if (cmSystemTools::FileExists(cxxFile.c_str())) {
             found = true;
-            }
-          for(std::vector<std::string>::iterator i =
-              this->IncludeDirectories.begin();
-              i != this->IncludeDirectories.end(); ++i)
-            {
+          }
+          for (std::vector<std::string>::iterator i =
+                 this->IncludeDirectories.begin();
+               i != this->IncludeDirectories.end(); ++i) {
             std::string path = *i;
             path = path + "/";
             path = path + cxxFile;
-            if(cmSystemTools::FileExists(path.c_str()))
-              {
+            if (cmSystemTools::FileExists(path.c_str())) {
               found = true;
-              }
             }
-          if (!found)
-            {
+          }
+          if (!found) {
             cxxFile = root + ".cpp";
-            if(cmSystemTools::FileExists(cxxFile.c_str()))
-              {
+            if (cmSystemTools::FileExists(cxxFile.c_str())) {
               found = true;
-              }
-            for(std::vector<std::string>::iterator i =
-                this->IncludeDirectories.begin();
-                i != this->IncludeDirectories.end(); ++i)
-              {
+            }
+            for (std::vector<std::string>::iterator i =
+                   this->IncludeDirectories.begin();
+                 i != this->IncludeDirectories.end(); ++i) {
               std::string path = *i;
               path = path + "/";
               path = path + cxxFile;
-              if(cmSystemTools::FileExists(path.c_str()))
-                {
+              if (cmSystemTools::FileExists(path.c_str())) {
                 found = true;
-                }
               }
             }
-          if (!found)
-            {
+          }
+          if (!found) {
             cxxFile = root + ".c";
-            if(cmSystemTools::FileExists(cxxFile.c_str()))
-              {
+            if (cmSystemTools::FileExists(cxxFile.c_str())) {
               found = true;
-              }
-            for(std::vector<std::string>::iterator i =
-                this->IncludeDirectories.begin();
-                i != this->IncludeDirectories.end(); ++i)
-              {
+            }
+            for (std::vector<std::string>::iterator i =
+                   this->IncludeDirectories.begin();
+                 i != this->IncludeDirectories.end(); ++i) {
               std::string path = *i;
               path = path + "/";
               path = path + cxxFile;
-              if(cmSystemTools::FileExists(path.c_str()))
-                {
+              if (cmSystemTools::FileExists(path.c_str())) {
                 found = true;
-                }
               }
             }
-          if (!found)
-            {
+          }
+          if (!found) {
             cxxFile = root + ".txx";
-            if(cmSystemTools::FileExists(cxxFile.c_str()))
-              {
+            if (cmSystemTools::FileExists(cxxFile.c_str())) {
               found = true;
-              }
-            for(std::vector<std::string>::iterator i =
-                this->IncludeDirectories.begin();
-                i != this->IncludeDirectories.end(); ++i)
-              {
+            }
+            for (std::vector<std::string>::iterator i =
+                   this->IncludeDirectories.begin();
+                 i != this->IncludeDirectories.end(); ++i) {
               std::string path = *i;
               path = path + "/";
               path = path + cxxFile;
-              if(cmSystemTools::FileExists(path.c_str()))
-                {
+              if (cmSystemTools::FileExists(path.c_str())) {
                 found = true;
-                }
               }
             }
-          if (found)
-            {
+          }
+          if (found) {
             this->AddDependency(info, cxxFile.c_str());
-            }
           }
         }
       }
+    }
   }
 
   /**
@@ -329,7 +293,7 @@ protected:
   void AddDependency(cmDependInformation* info, const char* file)
   {
     cmDependInformation* dependInfo =
-        this->GetDependInformation(file, info->PathOnly.c_str());
+      this->GetDependInformation(file, info->PathOnly.c_str());
     this->GenerateDependInformation(dependInfo);
     info->AddDependencies(dependInfo);
   }
@@ -341,108 +305,88 @@ protected:
   void GenerateDependInformation(cmDependInformation* info)
   {
     // If dependencies are already done, stop now.
-    if(info->DependDone)
-      {
+    if (info->DependDone) {
       return;
-      }
-    else
-      {
+    } else {
       // Make sure we don't visit the same file more than once.
       info->DependDone = true;
-      }
+    }
     const char* path = info->FullPath.c_str();
-    if(!path)
-      {
+    if (!path) {
       cmSystemTools::Error(
-            "Attempt to find dependencies for file without path!");
+        "Attempt to find dependencies for file without path!");
       return;
-      }
+    }
 
     bool found = false;
 
     // If the file exists, use it to find dependency information.
-    if(cmSystemTools::FileExists(path, true))
-      {
+    if (cmSystemTools::FileExists(path, true)) {
       // Use the real file to find its dependencies.
       this->DependWalk(info);
       found = true;
-      }
-
+    }
 
     // See if the cmSourceFile for it has any files specified as
     // dependency hints.
-    if(info->SourceFile != 0)
-      {
+    if (info->SourceFile != 0) {
 
       // Get the cmSourceFile corresponding to this.
       const cmSourceFile& cFile = *(info->SourceFile);
       // See if there are any hints for finding dependencies for the missing
       // file.
-      if(!cFile.GetDepends().empty())
-        {
+      if (!cFile.GetDepends().empty()) {
         // Dependency hints have been given.  Use them to begin the
         // recursion.
-        for(std::vector<std::string>::const_iterator file =
-            cFile.GetDepends().begin(); file != cFile.GetDepends().end();
-            ++file)
-          {
+        for (std::vector<std::string>::const_iterator file =
+               cFile.GetDepends().begin();
+             file != cFile.GetDepends().end(); ++file) {
           this->AddDependency(info, file->c_str());
-          }
+        }
 
         // Found dependency information.  We are done.
         found = true;
-        }
       }
+    }
 
-    if(!found)
-      {
+    if (!found) {
       // Try to find the file amongst the sources
-      cmSourceFile *srcFile = this->Makefile->GetSource
-          (cmSystemTools::GetFilenameWithoutExtension(path));
-      if (srcFile)
-        {
-        if (srcFile->GetFullPath() == path)
-          {
-          found=true;
-          }
-        else
-          {
-          //try to guess which include path to use
-          for(std::vector<std::string>::iterator t =
-              this->IncludeDirectories.begin();
-              t != this->IncludeDirectories.end(); ++t)
-            {
+      cmSourceFile* srcFile = this->Makefile->GetSource(
+        cmSystemTools::GetFilenameWithoutExtension(path));
+      if (srcFile) {
+        if (srcFile->GetFullPath() == path) {
+          found = true;
+        } else {
+          // try to guess which include path to use
+          for (std::vector<std::string>::iterator t =
+                 this->IncludeDirectories.begin();
+               t != this->IncludeDirectories.end(); ++t) {
             std::string incpath = *t;
-            if (!incpath.empty() && incpath[incpath.size() - 1] != '/')
-              {
+            if (!incpath.empty() && incpath[incpath.size() - 1] != '/') {
               incpath = incpath + "/";
-              }
+            }
             incpath = incpath + path;
-            if (srcFile->GetFullPath() == incpath)
-              {
+            if (srcFile->GetFullPath() == incpath) {
               // set the path to the guessed path
               info->FullPath = incpath;
-              found=true;
-              }
+              found = true;
             }
           }
         }
       }
+    }
 
-    if(!found)
-      {
+    if (!found) {
       // Couldn't find any dependency information.
-      if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str()))
-        {
+      if (this->ComplainFileRegularExpression.find(
+            info->IncludeName.c_str())) {
         cmSystemTools::Error("error cannot find dependencies for ", path);
-        }
-      else
-        {
+      } else {
         // Destroy the name of the file so that it won't be output as a
         // dependency.
         info->FullPath = "";
-        }
       }
+    }
   }
 
   /**
@@ -450,21 +394,18 @@ protected:
    * name.
    */
   cmDependInformation* GetDependInformation(const char* file,
-                                            const char *extraPath)
+                                            const char* extraPath)
   {
     // Get the full path for the file so that lookup is unambiguous.
     std::string fullPath = this->FullPath(file, extraPath);
 
     // Try to find the file's instance of cmDependInformation.
     DependInformationMapType::const_iterator result =
-        this->DependInformationMap.find(fullPath);
-    if(result != this->DependInformationMap.end())
-      {
+      this->DependInformationMap.find(fullPath);
+    if (result != this->DependInformationMap.end()) {
       // Found an instance, return it.
       return result->second;
-      }
-    else
-      {
+    } else {
       // Didn't find an instance.  Create a new one and save it.
       cmDependInformation* info = new cmDependInformation;
       info->FullPath = fullPath;
@@ -472,7 +413,7 @@ protected:
       info->IncludeName = file;
       this->DependInformationMap[fullPath] = info;
       return info;
-      }
+    }
   }
 
   /**
@@ -480,70 +421,58 @@ protected:
    * This uses the include directories.
    * TODO: Cache path conversions to reduce FileExists calls.
    */
-  std::string FullPath(const char *fname, const char *extraPath)
+  std::string FullPath(const char* fname, const char* extraPath)
   {
     DirectoryToFileToPathMapType::iterator m;
-    if(extraPath)
-      {
+    if (extraPath) {
       m = this->DirectoryToFileToPathMap.find(extraPath);
-      }
-    else
-      {
+    } else {
       m = this->DirectoryToFileToPathMap.find("");
-      }
+    }
 
-    if(m != this->DirectoryToFileToPathMap.end())
-      {
+    if (m != this->DirectoryToFileToPathMap.end()) {
       FileToPathMapType& map = m->second;
       FileToPathMapType::iterator p = map.find(fname);
-      if(p != map.end())
-        {
+      if (p != map.end()) {
         return p->second;
-        }
       }
+    }
 
-    if(cmSystemTools::FileExists(fname, true))
-      {
+    if (cmSystemTools::FileExists(fname, true)) {
       std::string fp = cmSystemTools::CollapseFullPath(fname);
-      this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
+      this->DirectoryToFileToPathMap[extraPath ? extraPath : ""][fname] = fp;
       return fp;
-      }
+    }
 
-    for(std::vector<std::string>::iterator i =
-        this->IncludeDirectories.begin();
-        i != this->IncludeDirectories.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i =
+           this->IncludeDirectories.begin();
+         i != this->IncludeDirectories.end(); ++i) {
       std::string path = *i;
-      if (!path.empty() && path[path.size() - 1] != '/')
-        {
+      if (!path.empty() && path[path.size() - 1] != '/') {
         path = path + "/";
-        }
+      }
       path = path + fname;
-      if(cmSystemTools::FileExists(path.c_str(), true)
-         && !cmSystemTools::FileIsDirectory(path))
-        {
+      if (cmSystemTools::FileExists(path.c_str(), true) &&
+          !cmSystemTools::FileIsDirectory(path)) {
         std::string fp = cmSystemTools::CollapseFullPath(path);
-        this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
+        this->DirectoryToFileToPathMap[extraPath ? extraPath : ""][fname] = fp;
         return fp;
-        }
       }
+    }
 
-    if (extraPath)
-      {
+    if (extraPath) {
       std::string path = extraPath;
-      if (!path.empty() && path[path.size() - 1] != '/')
-        {
+      if (!path.empty() && path[path.size() - 1] != '/') {
         path = path + "/";
-        }
+      }
       path = path + fname;
-      if(cmSystemTools::FileExists(path.c_str(), true)
-         && !cmSystemTools::FileIsDirectory(path))
-        {
+      if (cmSystemTools::FileExists(path.c_str(), true) &&
+          !cmSystemTools::FileIsDirectory(path)) {
         std::string fp = cmSystemTools::CollapseFullPath(path);
         this->DirectoryToFileToPathMap[extraPath][fname] = fp;
         return fp;
-        }
       }
+    }
 
     // Couldn't find the file.
     return std::string(fname);
@@ -556,25 +485,25 @@ protected:
   std::vector<std::string> IncludeDirectories;
   typedef std::map<std::string, std::string> FileToPathMapType;
   typedef std::map<std::string, FileToPathMapType>
-  DirectoryToFileToPathMapType;
-  typedef std::map<std::string, cmDependInformation*>
-  DependInformationMapType;
+    DirectoryToFileToPathMapType;
+  typedef std::map<std::string, cmDependInformation*> DependInformationMapType;
   DependInformationMapType DependInformationMap;
   DirectoryToFileToPathMapType DirectoryToFileToPathMap;
 };
 
 // cmOutputRequiredFilesCommand
-bool cmOutputRequiredFilesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmOutputRequiredFilesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0032,
-      "The output_required_files command should not be called; see CMP0032."))
-    { return true; }
-  if(args.size() != 2 )
-    {
+  if (this->Disallowed(cmPolicies::CMP0032, "The output_required_files "
+                                            "command should not be called; "
+                                            "see CMP0032.")) {
+    return true;
+  }
+  if (args.size() != 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // store the arg for final pass
   this->File = args[0];
@@ -585,52 +514,44 @@ bool cmOutputRequiredFilesCommand
   md.SetMakefile(this->Makefile);
   md.AddSearchPath(this->Makefile->GetCurrentSourceDirectory());
   // find the depends for a file
-  const cmDependInformation *info = md.FindDependencies(this->File.c_str());
-  if (info)
-    {
+  const cmDependInformation* info = md.FindDependencies(this->File.c_str());
+  if (info) {
     // write them out
-    FILE *fout = cmsys::SystemTools::Fopen(this->OutputFile.c_str(),"w");
-    if(!fout)
-      {
+    FILE* fout = cmsys::SystemTools::Fopen(this->OutputFile.c_str(), "w");
+    if (!fout) {
       std::string err = "Can not open output file: ";
       err += this->OutputFile;
       this->SetError(err);
       return false;
-      }
+    }
     std::set<cmDependInformation const*> visited;
-    this->ListDependencies(info,fout, &visited);
+    this->ListDependencies(info, fout, &visited);
     fclose(fout);
-    }
+  }
 
   return true;
 }
 
-void cmOutputRequiredFilesCommand::
-ListDependencies(cmDependInformation const *info,
-                 FILE *fout,
-                 std::set<cmDependInformation const*> *visited)
+void cmOutputRequiredFilesCommand::ListDependencies(
+  cmDependInformation const* info, FILE* fout,
+  std::set<cmDependInformation const*>* visited)
 {
   // add info to the visited set
   visited->insert(info);
   // now recurse with info's dependencies
-  for(cmDependInformation::DependencySetType::const_iterator d =
-        info->DependencySet.begin();
-      d != info->DependencySet.end(); ++d)
-    {
-    if (visited->find(*d) == visited->end())
-      {
-      if(info->FullPath != "")
-        {
+  for (cmDependInformation::DependencySetType::const_iterator d =
+         info->DependencySet.begin();
+       d != info->DependencySet.end(); ++d) {
+    if (visited->find(*d) == visited->end()) {
+      if (info->FullPath != "") {
         std::string tmp = (*d)->FullPath;
         std::string::size_type pos = tmp.rfind('.');
-        if(pos != std::string::npos && (tmp.substr(pos) != ".h"))
-          {
+        if (pos != std::string::npos && (tmp.substr(pos) != ".h")) {
           tmp = tmp.substr(0, pos);
-          fprintf(fout,"%s\n",(*d)->FullPath.c_str());
-          }
+          fprintf(fout, "%s\n", (*d)->FullPath.c_str());
         }
-      this->ListDependencies(*d,fout,visited);
       }
+      this->ListDependencies(*d, fout, visited);
     }
+  }
 }
-
diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h
index b5eb932..7a6f5a6 100644
--- a/Source/cmOutputRequiredFilesCommand.h
+++ b/Source/cmOutputRequiredFilesCommand.h
@@ -22,17 +22,15 @@ public:
   cmTypeMacro(cmOutputRequiredFilesCommand, cmCommand);
   virtual cmCommand* Clone() { return new cmOutputRequiredFilesCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const { return "output_required_files";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "output_required_files"; }
+
+  void ListDependencies(cmDependInformation const* info, FILE* fout,
+                        std::set<cmDependInformation const*>* visited);
 
-  void ListDependencies(cmDependInformation const *info,
-                        FILE *fout,
-                        std::set<cmDependInformation const*> *visited);
 private:
   std::string File;
   std::string OutputFile;
 };
 
-
-
 #endif
diff --git a/Source/cmParseArgumentsCommand.cxx b/Source/cmParseArgumentsCommand.cxx
index 8d78921..8f524ec 100644
--- a/Source/cmParseArgumentsCommand.cxx
+++ b/Source/cmParseArgumentsCommand.cxx
@@ -15,19 +15,18 @@
 
 #include "cmAlgorithms.h"
 
-bool cmParseArgumentsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmParseArgumentsCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
   // cmake_parse_arguments(prefix options single multi <ARGN>)
   //                         1       2      3      4
-  if (args.size() < 4)
-    {
+  if (args.size() < 4) {
     this->SetError("must be called with at least 4 arguments.");
     return false;
-    }
+  }
 
   std::vector<std::string>::const_iterator argIter = args.begin(),
-                                           argEnd  = args.end();
+                                           argEnd = args.end();
   // the first argument is the prefix
   const std::string prefix = (*argIter++) + "_";
 
@@ -50,44 +49,38 @@ bool cmParseArgumentsCommand
   // the second argument is a (cmake) list of options without argument
   std::vector<std::string> list;
   cmSystemTools::ExpandListArgument(*argIter++, list);
-  for (std::vector<std::string>::const_iterator iter  = list.begin(),
-                                                end   = list.end();
-                                                iter != end; ++iter)
-    {
-    if (!used_keywords.insert(*iter).second)
-      {
+  for (std::vector<std::string>::const_iterator iter = list.begin(),
+                                                end = list.end();
+       iter != end; ++iter) {
+    if (!used_keywords.insert(*iter).second) {
       this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
-      }
-    options[*iter]; // default initialize
     }
+    options[*iter]; // default initialize
+  }
 
   // the third argument is a (cmake) list of single argument options
   list.clear();
   cmSystemTools::ExpandListArgument(*argIter++, list);
-  for (std::vector<std::string>::const_iterator iter  = list.begin(),
-                                                end   = list.end();
-                                                iter != end; ++iter)
-    {
-    if (!used_keywords.insert(*iter).second)
-      {
+  for (std::vector<std::string>::const_iterator iter = list.begin(),
+                                                end = list.end();
+       iter != end; ++iter) {
+    if (!used_keywords.insert(*iter).second) {
       this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
-      }
-    single[*iter]; // default initialize
     }
+    single[*iter]; // default initialize
+  }
 
   // the fourth argument is a (cmake) list of multi argument options
   list.clear();
   cmSystemTools::ExpandListArgument(*argIter++, list);
-  for (std::vector<std::string>::const_iterator iter  = list.begin(),
-                                                end   = list.end();
-                                                iter != end; ++iter)
-    {
-    if (!used_keywords.insert(*iter).second)
-      {
+  for (std::vector<std::string>::const_iterator iter = list.begin(),
+                                                end = list.end();
+       iter != end; ++iter) {
+    if (!used_keywords.insert(*iter).second) {
       this->GetMakefile()->IssueMessage(cmake::WARNING, dup_warning + *iter);
-      }
-    multi[*iter]; // default initialize
     }
+    multi[*iter]; // default initialize
+  }
 
   enum insideValues
   {
@@ -100,41 +93,35 @@ bool cmParseArgumentsCommand
   // Flatten ;-lists in the arguments into a single list as was done
   // by the original function(CMAKE_PARSE_ARGUMENTS).
   list.clear();
-  for(; argIter != argEnd; ++argIter)
-    {
+  for (; argIter != argEnd; ++argIter) {
     cmSystemTools::ExpandListArgument(*argIter, list);
-    }
+  }
 
   // iterate over the arguments list and fill in the values where applicable
-  for (argIter = list.begin(), argEnd = list.end();
-       argIter != argEnd; ++argIter)
-    {
+  for (argIter = list.begin(), argEnd = list.end(); argIter != argEnd;
+       ++argIter) {
     const options_map::iterator optIter = options.find(*argIter);
-    if (optIter != options.end())
-      {
+    if (optIter != options.end()) {
       insideValues = NONE;
       optIter->second = true;
       continue;
-      }
+    }
 
     const single_map::iterator singleIter = single.find(*argIter);
-    if (singleIter != single.end())
-      {
+    if (singleIter != single.end()) {
       insideValues = SINGLE;
       currentArgName = *argIter;
       continue;
-      }
+    }
 
     const multi_map::iterator multiIter = multi.find(*argIter);
-    if (multiIter != multi.end())
-      {
+    if (multiIter != multi.end()) {
       insideValues = MULTI;
       currentArgName = *argIter;
       continue;
-      }
+    }
 
-    switch(insideValues)
-      {
+    switch (insideValues) {
       case SINGLE:
         single[currentArgName] = *argIter;
         insideValues = NONE;
@@ -145,56 +132,43 @@ bool cmParseArgumentsCommand
       default:
         unparsed.push_back(*argIter);
         break;
-      }
     }
+  }
 
   // now iterate over the collected values and update their definition
   // within the current scope. undefine if necessary.
 
   for (options_map::const_iterator iter = options.begin(), end = options.end();
-                                   iter != end; ++iter)
-    {
+       iter != end; ++iter) {
     this->Makefile->AddDefinition(prefix + iter->first,
-                                  iter->second? "TRUE": "FALSE");
-    }
+                                  iter->second ? "TRUE" : "FALSE");
+  }
   for (single_map::const_iterator iter = single.begin(), end = single.end();
-                                  iter != end; ++iter)
-    {
-    if (!iter->second.empty())
-      {
+       iter != end; ++iter) {
+    if (!iter->second.empty()) {
       this->Makefile->AddDefinition(prefix + iter->first,
                                     iter->second.c_str());
-      }
-    else
-      {
+    } else {
       this->Makefile->RemoveDefinition(prefix + iter->first);
-      }
     }
+  }
 
   for (multi_map::const_iterator iter = multi.begin(), end = multi.end();
-                                  iter != end; ++iter)
-    {
-    if (!iter->second.empty())
-      {
-      this->Makefile->AddDefinition(prefix + iter->first,
-                                    cmJoin(cmMakeRange(iter->second), ";")
-                                      .c_str());
-      }
-    else
-      {
+       iter != end; ++iter) {
+    if (!iter->second.empty()) {
+      this->Makefile->AddDefinition(
+        prefix + iter->first, cmJoin(cmMakeRange(iter->second), ";").c_str());
+    } else {
       this->Makefile->RemoveDefinition(prefix + iter->first);
-      }
     }
+  }
 
-  if (!unparsed.empty())
-    {
+  if (!unparsed.empty()) {
     this->Makefile->AddDefinition(prefix + "UNPARSED_ARGUMENTS",
                                   cmJoin(cmMakeRange(unparsed), ";").c_str());
-    }
-  else
-    {
+  } else {
     this->Makefile->RemoveDefinition(prefix + "UNPARSED_ARGUMENTS");
-    }
+  }
 
   return true;
 }
diff --git a/Source/cmParseArgumentsCommand.h b/Source/cmParseArgumentsCommand.h
index 7fbf642..46d9daa 100644
--- a/Source/cmParseArgumentsCommand.h
+++ b/Source/cmParseArgumentsCommand.h
@@ -24,17 +24,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmParseArgumentsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmParseArgumentsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -44,11 +41,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "cmake_parse_arguments";}
+  virtual std::string GetName() const { return "cmake_parse_arguments"; }
 
   cmTypeMacro(cmParseArgumentsCommand, cmCommand);
-
 };
 
-
 #endif
diff --git a/Source/cmPathLabel.cxx b/Source/cmPathLabel.cxx
index f3b0864..491d2f0 100644
--- a/Source/cmPathLabel.cxx
+++ b/Source/cmPathLabel.cxx
@@ -13,26 +13,26 @@
 #include "cmPathLabel.h"
 
 cmPathLabel::cmPathLabel(const std::string& label)
-: Label(label), Hash(0)
+  : Label(label)
+  , Hash(0)
 {
   // Use a Jenkins one-at-a-time hash with under/over-flow protection
-  for(size_t i = 0; i < this->Label.size(); ++i)
-    {
+  for (size_t i = 0; i < this->Label.size(); ++i) {
     this->Hash += this->Label[i];
     this->Hash += ((this->Hash & 0x003FFFFF) << 10);
     this->Hash ^= ((this->Hash & 0xFFFFFFC0) >> 6);
-    }
+  }
   this->Hash += ((this->Hash & 0x1FFFFFFF) << 3);
   this->Hash ^= ((this->Hash & 0xFFFFF800) >> 11);
   this->Hash += ((this->Hash & 0x0001FFFF) << 15);
 }
 
-bool cmPathLabel::operator < (const cmPathLabel& l) const
+bool cmPathLabel::operator<(const cmPathLabel& l) const
 {
   return this->Hash < l.Hash;
 }
 
-bool cmPathLabel::operator == (const cmPathLabel& l) const
+bool cmPathLabel::operator==(const cmPathLabel& l) const
 {
   return this->Hash == l.Hash;
 }
diff --git a/Source/cmPathLabel.h b/Source/cmPathLabel.h
index 02d5261..39fbec3 100644
--- a/Source/cmPathLabel.h
+++ b/Source/cmPathLabel.h
@@ -28,8 +28,8 @@ public:
 
   // The comparison operators are only for quick sorting and searching and
   // in no way imply any lexicographical order of the label
-  bool operator < (const cmPathLabel& l) const;
-  bool operator == (const cmPathLabel& l) const;
+  bool operator<(const cmPathLabel& l) const;
+  bool operator==(const cmPathLabel& l) const;
 
   const std::string& GetLabel() const { return this->Label; }
   const unsigned int& GetHash() const { return this->Hash; }
diff --git a/Source/cmPolicies.cxx b/Source/cmPolicies.cxx
index b0ca675..85f0fa3 100644
--- a/Source/cmPolicies.cxx
+++ b/Source/cmPolicies.cxx
@@ -14,131 +14,111 @@
 static bool stringToId(const char* input, cmPolicies::PolicyID& pid)
 {
   assert(input);
-  if (strlen(input) != 7)
-    {
+  if (strlen(input) != 7) {
     return false;
-    }
-  if (!cmHasLiteralPrefix(input, "CMP"))
-    {
+  }
+  if (!cmHasLiteralPrefix(input, "CMP")) {
     return false;
-    }
-  if (cmHasLiteralSuffix(input, "0000"))
-    {
+  }
+  if (cmHasLiteralSuffix(input, "0000")) {
     pid = cmPolicies::CMP0000;
     return true;
-    }
-  for (int i = 3; i < 7; ++i)
-    {
-    if (!isdigit(*(input + i)))
-      {
+  }
+  for (int i = 3; i < 7; ++i) {
+    if (!isdigit(*(input + i))) {
       return false;
-      }
     }
+  }
   long id;
-  if (!cmSystemTools::StringToLong(input + 3, &id))
-    {
+  if (!cmSystemTools::StringToLong(input + 3, &id)) {
     return false;
-    }
-  if (id >= cmPolicies::CMPCOUNT)
-    {
+  }
+  if (id >= cmPolicies::CMPCOUNT) {
     return false;
-    }
+  }
   pid = cmPolicies::PolicyID(id);
   return true;
 }
 
 #define CM_SELECT_ID_VERSION(F, A1, A2, A3, A4, A5, A6) F(A1, A3, A4, A5)
-#define CM_FOR_EACH_POLICY_ID_VERSION(POLICY) \
+#define CM_FOR_EACH_POLICY_ID_VERSION(POLICY)                                 \
   CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID_VERSION)
 
 #define CM_SELECT_ID_DOC(F, A1, A2, A3, A4, A5, A6) F(A1, A2)
-#define CM_FOR_EACH_POLICY_ID_DOC(POLICY) \
+#define CM_FOR_EACH_POLICY_ID_DOC(POLICY)                                     \
   CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID_DOC)
 
 static const char* idToString(cmPolicies::PolicyID id)
 {
-  switch(id)
-    {
-#define POLICY_CASE(ID) \
-    case cmPolicies::ID: \
-      return #ID;
-  CM_FOR_EACH_POLICY_ID(POLICY_CASE)
+  switch (id) {
+#define POLICY_CASE(ID)                                                       \
+  case cmPolicies::ID:                                                        \
+    return #ID;
+    CM_FOR_EACH_POLICY_ID(POLICY_CASE)
 #undef POLICY_CASE
     case cmPolicies::CMPCOUNT:
       return 0;
-    }
+  }
   return 0;
 }
 
 static const char* idToVersion(cmPolicies::PolicyID id)
 {
-  switch(id)
-    {
-#define POLICY_CASE(ID, V_MAJOR, V_MINOR, V_PATCH) \
-    case cmPolicies::ID: \
-      return #V_MAJOR "." #V_MINOR "." #V_PATCH;
-  CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE)
+  switch (id) {
+#define POLICY_CASE(ID, V_MAJOR, V_MINOR, V_PATCH)                            \
+  case cmPolicies::ID:                                                        \
+    return #V_MAJOR "." #V_MINOR "." #V_PATCH;
+    CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE)
 #undef POLICY_CASE
     case cmPolicies::CMPCOUNT:
       return 0;
-    }
+  }
   return 0;
 }
 
-static bool isPolicyNewerThan(cmPolicies::PolicyID id,
-                       unsigned int majorV,
-                       unsigned int minorV,
-                       unsigned int patchV)
+static bool isPolicyNewerThan(cmPolicies::PolicyID id, unsigned int majorV,
+                              unsigned int minorV, unsigned int patchV)
 {
-  switch(id)
-    {
-#define POLICY_CASE(ID, V_MAJOR, V_MINOR, V_PATCH) \
-    case cmPolicies::ID: \
-      return (majorV < V_MAJOR || \
-             (majorV == V_MAJOR && \
-              minorV + 1 < V_MINOR + 1) || \
-             (majorV == V_MAJOR && \
-              minorV == V_MINOR && \
-              patchV + 1 < V_PATCH + 1));
-  CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE)
+  switch (id) {
+#define POLICY_CASE(ID, V_MAJOR, V_MINOR, V_PATCH)                            \
+  case cmPolicies::ID:                                                        \
+    return (                                                                  \
+      majorV < V_MAJOR || (majorV == V_MAJOR && minorV + 1 < V_MINOR + 1) ||  \
+      (majorV == V_MAJOR && minorV == V_MINOR && patchV + 1 < V_PATCH + 1));
+    CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE)
 #undef POLICY_CASE
     case cmPolicies::CMPCOUNT:
       return false;
-    }
+  }
   return false;
 }
 
 const char* idToShortDescription(cmPolicies::PolicyID id)
 {
-  switch(id)
-    {
-#define POLICY_CASE(ID, SHORT_DESCRIPTION) \
-    case cmPolicies::ID: \
-      return SHORT_DESCRIPTION;
-  CM_FOR_EACH_POLICY_ID_DOC(POLICY_CASE)
+  switch (id) {
+#define POLICY_CASE(ID, SHORT_DESCRIPTION)                                    \
+  case cmPolicies::ID:                                                        \
+    return SHORT_DESCRIPTION;
+    CM_FOR_EACH_POLICY_ID_DOC(POLICY_CASE)
 #undef POLICY_CASE
     case cmPolicies::CMPCOUNT:
       return 0;
-    }
+  }
   return 0;
 }
 
 static void DiagnoseAncientPolicies(
-    std::vector<cmPolicies::PolicyID> const& ancient,
-    unsigned int majorVer,
-    unsigned int minorVer,
-    unsigned int patchVer,
-    cmMakefile* mf)
+  std::vector<cmPolicies::PolicyID> const& ancient, unsigned int majorVer,
+  unsigned int minorVer, unsigned int patchVer, cmMakefile* mf)
 {
   std::ostringstream e;
   e << "The project requests behavior compatible with CMake version \""
     << majorVer << "." << minorVer << "." << patchVer
     << "\", which requires the OLD behavior for some policies:\n";
-  for(std::vector<cmPolicies::PolicyID>::const_iterator
-        i = ancient.begin(); i != ancient.end(); ++i)
-    {
+  for (std::vector<cmPolicies::PolicyID>::const_iterator i = ancient.begin();
+       i != ancient.end(); ++i) {
     e << "  " << idToString(*i) << ": " << idToShortDescription(*i) << "\n";
-    }
+  }
   e << "However, this version of CMake no longer supports the OLD "
     << "behavior for these policies.  "
     << "Please either update your CMakeLists.txt files to conform to "
@@ -152,39 +132,30 @@ static bool GetPolicyDefault(cmMakefile* mf, std::string const& policy,
 {
   std::string defaultVar = "CMAKE_POLICY_DEFAULT_" + policy;
   std::string defaultValue = mf->GetSafeDefinition(defaultVar);
-  if(defaultValue == "NEW")
-    {
+  if (defaultValue == "NEW") {
     *defaultSetting = cmPolicies::NEW;
-    }
-  else if(defaultValue == "OLD")
-    {
+  } else if (defaultValue == "OLD") {
     *defaultSetting = cmPolicies::OLD;
-    }
-  else if(defaultValue == "")
-    {
+  } else if (defaultValue == "") {
     *defaultSetting = cmPolicies::WARN;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << defaultVar << " has value \"" << defaultValue
       << "\" but must be \"OLD\", \"NEW\", or \"\" (empty).";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   return true;
 }
 
-bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
-                                    const char *version)
+bool cmPolicies::ApplyPolicyVersion(cmMakefile* mf, const char* version)
 {
   std::string ver = "2.4.0";
 
-  if (version && strlen(version) > 0)
-    {
+  if (version && strlen(version) > 0) {
     ver = version;
-    }
+  }
 
   unsigned int majorVer = 2;
   unsigned int minorVer = 0;
@@ -192,25 +163,24 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
   unsigned int tweakVer = 0;
 
   // parse the string
-  if(sscanf(ver.c_str(), "%u.%u.%u.%u",
-            &majorVer, &minorVer, &patchVer, &tweakVer) < 2)
-    {
+  if (sscanf(ver.c_str(), "%u.%u.%u.%u", &majorVer, &minorVer, &patchVer,
+             &tweakVer) < 2) {
     std::ostringstream e;
     e << "Invalid policy version value \"" << ver << "\".  "
       << "A numeric major.minor[.patch[.tweak]] must be given.";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   // it is an error if the policy version is less than 2.4
-  if (majorVer < 2 || (majorVer == 2 && minorVer < 4))
-    {
-    mf->IssueMessage(cmake::FATAL_ERROR,
+  if (majorVer < 2 || (majorVer == 2 && minorVer < 4)) {
+    mf->IssueMessage(
+      cmake::FATAL_ERROR,
       "Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.  "
       "For compatibility with older versions please use any CMake 2.8.x "
       "release or lower.");
     return false;
-    }
+  }
 
   // It is an error if the policy version is greater than the running
   // CMake.
@@ -223,8 +193,7 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
       (majorVer == cmVersion::GetMajorVersion() &&
        minorVer == cmVersion::GetMinorVersion() &&
        patchVer == cmVersion::GetPatchVersion() &&
-       tweakVer > cmVersion::GetTweakVersion()))
-    {
+       tweakVer > cmVersion::GetTweakVersion())) {
     std::ostringstream e;
     e << "An attempt was made to set the policy version of CMake to \""
       << version << "\" which is greater than this version of CMake.  "
@@ -233,67 +202,54 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
       << "You may need a newer CMake version to build this project.";
     mf->IssueMessage(cmake::FATAL_ERROR, e.str());
     return false;
-    }
+  }
 
   // now loop over all the policies and set them as appropriate
   std::vector<cmPolicies::PolicyID> ancientPolicies;
-  for(PolicyID pid = cmPolicies::CMP0000;
-      pid != cmPolicies::CMPCOUNT; pid = PolicyID(pid+1))
-    {
-    if (isPolicyNewerThan(pid, majorVer, minorVer, patchVer))
-      {
-      if(cmPolicies::GetPolicyStatus(pid) == cmPolicies::REQUIRED_ALWAYS)
-        {
+  for (PolicyID pid = cmPolicies::CMP0000; pid != cmPolicies::CMPCOUNT;
+       pid = PolicyID(pid + 1)) {
+    if (isPolicyNewerThan(pid, majorVer, minorVer, patchVer)) {
+      if (cmPolicies::GetPolicyStatus(pid) == cmPolicies::REQUIRED_ALWAYS) {
         ancientPolicies.push_back(pid);
-        }
-      else
-        {
+      } else {
         cmPolicies::PolicyStatus status = cmPolicies::WARN;
-        if(!GetPolicyDefault(mf, idToString(pid), &status) ||
-           !mf->SetPolicy(pid, status))
-          {
+        if (!GetPolicyDefault(mf, idToString(pid), &status) ||
+            !mf->SetPolicy(pid, status)) {
           return false;
-          }
-        if(pid == cmPolicies::CMP0001 &&
-           (status == cmPolicies::WARN || status == cmPolicies::OLD))
-          {
-          if(!(mf->GetState()
-               ->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
-            {
+        }
+        if (pid == cmPolicies::CMP0001 &&
+            (status == cmPolicies::WARN || status == cmPolicies::OLD)) {
+          if (!(mf->GetState()->GetInitializedCacheValue(
+                "CMAKE_BACKWARDS_COMPATIBILITY"))) {
             // Set it to 2.4 because that is the last version where the
             // variable had meaning.
-            mf->AddCacheDefinition
-              ("CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
-               "For backwards compatibility, what version of CMake "
-               "commands and "
-               "syntax should this version of CMake try to support.",
-               cmState::STRING);
-            }
+            mf->AddCacheDefinition(
+              "CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
+              "For backwards compatibility, what version of CMake "
+              "commands and "
+              "syntax should this version of CMake try to support.",
+              cmState::STRING);
           }
         }
       }
-    else
-      {
-      if (!mf->SetPolicy(pid, cmPolicies::NEW))
-        {
+    } else {
+      if (!mf->SetPolicy(pid, cmPolicies::NEW)) {
         return false;
-        }
       }
     }
+  }
 
   // Make sure the project does not use any ancient policies.
-  if(!ancientPolicies.empty())
-    {
-    DiagnoseAncientPolicies(ancientPolicies,
-                            majorVer, minorVer, patchVer, mf);
+  if (!ancientPolicies.empty()) {
+    DiagnoseAncientPolicies(ancientPolicies, majorVer, minorVer, patchVer, mf);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 
   return true;
 }
 
-bool cmPolicies::GetPolicyID(const char *id, cmPolicies::PolicyID &pid)
+bool cmPolicies::GetPolicyID(const char* id, cmPolicies::PolicyID& pid)
 {
   return stringToId(id, pid);
 }
@@ -302,45 +258,47 @@ bool cmPolicies::GetPolicyID(const char *id, cmPolicies::PolicyID &pid)
 std::string cmPolicies::GetPolicyWarning(cmPolicies::PolicyID id)
 {
   std::ostringstream msg;
-  msg <<
-    "Policy " << idToString(id) << " is not set: "
-    "" << idToShortDescription(id) << "  "
-    "Run \"cmake --help-policy " << idToString(id) << "\" for "
-    "policy details.  "
-    "Use the cmake_policy command to set the policy "
-    "and suppress this warning.";
+  msg << "Policy " << idToString(id) << " is not set: "
+                                        ""
+      << idToShortDescription(id) << "  "
+                                     "Run \"cmake --help-policy "
+      << idToString(id) << "\" for "
+                           "policy details.  "
+                           "Use the cmake_policy command to set the policy "
+                           "and suppress this warning.";
   return msg.str();
 }
 
-
 ///! return an error string for when a required policy is unspecified
 std::string cmPolicies::GetRequiredPolicyError(cmPolicies::PolicyID id)
 {
   std::ostringstream error;
-  error <<
-    "Policy " << idToString(id) << " is not set to NEW: "
-    "" << idToShortDescription(id) << "  "
-    "Run \"cmake --help-policy " << idToString(id) << "\" for "
-    "policy details.  "
-    "CMake now requires this policy to be set to NEW by the project.  "
-    "The policy may be set explicitly using the code\n"
-    "  cmake_policy(SET " << idToString(id) << " NEW)\n"
-    "or by upgrading all policies with the code\n"
-    "  cmake_policy(VERSION " << idToVersion(id) <<
-    ") # or later\n"
-    "Run \"cmake --help-command cmake_policy\" for more information.";
+  error << "Policy " << idToString(id) << " is not set to NEW: "
+                                          ""
+        << idToShortDescription(id) << "  "
+                                       "Run \"cmake --help-policy "
+        << idToString(id)
+        << "\" for "
+           "policy details.  "
+           "CMake now requires this policy to be set to NEW by the project.  "
+           "The policy may be set explicitly using the code\n"
+           "  cmake_policy(SET "
+        << idToString(id) << " NEW)\n"
+                             "or by upgrading all policies with the code\n"
+                             "  cmake_policy(VERSION "
+        << idToVersion(id)
+        << ") # or later\n"
+           "Run \"cmake --help-command cmake_policy\" for more information.";
   return error.str();
 }
 
 ///! Get the default status for a policy
-cmPolicies::PolicyStatus
-cmPolicies::GetPolicyStatus(cmPolicies::PolicyID)
+cmPolicies::PolicyStatus cmPolicies::GetPolicyStatus(cmPolicies::PolicyID)
 {
   return cmPolicies::WARN;
 }
 
-std::string
-cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
+std::string cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
 {
   std::string pid = idToString(id);
   std::ostringstream e;
@@ -357,19 +315,16 @@ cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
   return e.str();
 }
 
-cmPolicies::PolicyStatus
-cmPolicies::PolicyMap::Get(cmPolicies::PolicyID id) const
+cmPolicies::PolicyStatus cmPolicies::PolicyMap::Get(
+  cmPolicies::PolicyID id) const
 {
   PolicyStatus status = cmPolicies::WARN;
 
-  if (this->Status[(POLICY_STATUS_COUNT * id) + OLD])
-    {
+  if (this->Status[(POLICY_STATUS_COUNT * id) + OLD]) {
     status = cmPolicies::OLD;
-    }
-  else if (this->Status[(POLICY_STATUS_COUNT * id) + NEW])
-    {
+  } else if (this->Status[(POLICY_STATUS_COUNT * id) + NEW]) {
     status = cmPolicies::NEW;
-    }
+  }
   return status;
 }
 
@@ -383,9 +338,9 @@ void cmPolicies::PolicyMap::Set(cmPolicies::PolicyID id,
 
 bool cmPolicies::PolicyMap::IsDefined(cmPolicies::PolicyID id) const
 {
-  return this->Status[(POLICY_STATUS_COUNT * id) + OLD]
-      || this->Status[(POLICY_STATUS_COUNT * id) + WARN]
-      || this->Status[(POLICY_STATUS_COUNT * id) + NEW];
+  return this->Status[(POLICY_STATUS_COUNT * id) + OLD] ||
+    this->Status[(POLICY_STATUS_COUNT * id) + WARN] ||
+    this->Status[(POLICY_STATUS_COUNT * id) + NEW];
 }
 
 bool cmPolicies::PolicyMap::IsEmpty() const
diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h
index dbea895..ff49e31 100644
--- a/Source/cmPolicies.h
+++ b/Source/cmPolicies.h
@@ -19,235 +19,213 @@
 class cmMakefile;
 class cmPolicy;
 
-#define CM_FOR_EACH_POLICY_TABLE(POLICY, SELECT) \
-  SELECT(POLICY, CMP0000, \
-    "A minimum required CMake version must be specified.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0001, \
-    "CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0002, \
-  "Logical target names must be globally unique.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0003, \
-    "Libraries linked via full path no longer produce linker search paths.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0004, \
-    "Libraries linked may not have leading or trailing whitespace.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0005, \
-    "Preprocessor definition values are now escaped automatically.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0006, \
-    "Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0007, \
-    "list command no longer ignores empty elements.", \
-    2, 6, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0008, \
-    "Libraries linked by full-path must have a valid library file name.", \
-    2, 6, 1, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0009, \
-    "FILE GLOB_RECURSE calls should not follow symlinks by default.", \
-    2, 6, 2, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0010, \
-    "Bad variable reference syntax is an error.", \
-    2, 6, 3, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0011, \
-    "Included scripts do automatic cmake_policy PUSH and POP.", \
-    2, 6, 3, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0012, \
-    "if() recognizes numbers and boolean constants.", \
-    2, 8, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0013, \
-    "Duplicate binary directories are not allowed.", \
-    2, 8, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0014, \
-    "Input directories must have CMakeLists.txt.", \
-    2, 8, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0015, \
-    "link_directories() treats paths relative to the source dir.", \
-    2, 8, 1, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0016, \
-    "target_link_libraries() reports error if its only argument " \
-    "is not a target.", \
-    2, 8, 3, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0017, \
-    "Prefer files from the CMake module directory when including from " \
-    "there.", \
-    2, 8, 4, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0018, \
-    "Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.", \
-    2, 8, 9, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0019, \
-    "Do not re-expand variables in include and link information.", \
-    2, 8, 11, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0020, \
-    "Automatically link Qt executables to qtmain target on Windows.", \
-    2, 8, 11, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0021, \
-    "Fatal error on relative paths in INCLUDE_DIRECTORIES target property.", \
-    2, 8, 12, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0022, \
-    "INTERFACE_LINK_LIBRARIES defines the link interface.", \
-    2, 8, 12, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0023, \
-    "Plain and keyword target_link_libraries signatures cannot be mixed.", \
-    2, 8, 12, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0024, \
-    "Disallow include export result.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0025, \
-    "Compiler id for Apple Clang is now AppleClang.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0026, \
-    "Disallow use of the LOCATION target property.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0027, \
-    "Conditionally linked imported targets with missing include " \
-    "directories.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0028, \
-    "Double colon in target name means ALIAS or IMPORTED target.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0029, \
-    "The subdir_depends command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0030, \
-    "The use_mangled_mesa command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0031, \
-    "The load_command command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0032, \
-    "The output_required_files command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0033, \
-    "The export_library_dependencies command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0034, \
-    "The utility_source command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0035, \
-    "The variable_requires command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0036, \
-    "The build_name command should not be called.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0037, \
-    "Target names should not be reserved and should match a validity " \
-    "pattern.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0038, \
-    "Targets may not link directly to themselves.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0039, \
-    "Utility targets may not have link dependencies.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0040, \
-    "The target in the TARGET signature of add_custom_command() must " \
-    "exist.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0041, \
-    "Error on relative include with generator expression.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0042, \
-    "MACOSX_RPATH is enabled by default.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0043, \
-    "Ignore COMPILE_DEFINITIONS_<Config> properties.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0044, \
-    "Case sensitive <LANG>_COMPILER_ID generator expressions.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0045, \
-    "Error on non-existent target in get_target_property.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0046, \
-    "Error on non-existent dependency in add_dependencies.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0047, \
-    "Use QCC compiler id for the qcc drivers on QNX.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0048, \
-    "project() command manages VERSION variables.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0049, \
-    "Do not expand variables in target source entries.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0050, \
-    "Disallow add_custom_command SOURCE signatures.", \
-    3, 0, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0051, \
-    "List TARGET_OBJECTS in SOURCES target property.", \
-    3, 1, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0052, \
-    "Reject source and build dirs in installed " \
-    "INTERFACE_INCLUDE_DIRECTORIES.", \
-    3, 1, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0053, \
-    "Simplify variable reference and escape sequence evaluation.", \
-    3, 1, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0054, \
-    "Only interpret if() arguments as variables or keywords when unquoted.", \
-    3, 1, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0055, \
-    "Strict checking for break() command.", \
-    3, 2, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0056, \
-    "Honor link flags in try_compile() source-file signature.", \
-    3, 2, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0057, \
-    "Support new IN_LIST if() operator.", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0058, \
-    "Ninja requires custom command byproducts to be explicit.", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0059, \
-    "Do not treat DEFINITIONS as a built-in directory property.", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0060, \
-    "Link libraries by full path even in implicit directories.", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0061, \
-    "CTest does not by default tell make to ignore errors (-i).", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0062, \
-    "Disallow install() of export() result.", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0063, \
-    "Honor visibility properties for all target types.", \
-    3, 3, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0064, \
-    "Support new TEST if() operator.", \
-    3, 4, 0, cmPolicies::WARN) \
-  SELECT(POLICY, CMP0065, \
-    "Do not add flags to export symbols from executables without " \
-    "the ENABLE_EXPORTS target property.", \
-    3, 4, 0, cmPolicies::WARN)
+#define CM_FOR_EACH_POLICY_TABLE(POLICY, SELECT)                              \
+  SELECT(POLICY, CMP0000,                                                     \
+         "A minimum required CMake version must be specified.", 2, 6, 0,      \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0001,                                                     \
+         "CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.", 2, 6, 0,  \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0002, "Logical target names must be globally unique.", 2, \
+         6, 0, cmPolicies::WARN)                                              \
+  SELECT(                                                                     \
+    POLICY, CMP0003,                                                          \
+    "Libraries linked via full path no longer produce linker search paths.",  \
+    2, 6, 0, cmPolicies::WARN)                                                \
+  SELECT(POLICY, CMP0004,                                                     \
+         "Libraries linked may not have leading or trailing whitespace.", 2,  \
+         6, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0005,                                                     \
+         "Preprocessor definition values are now escaped automatically.", 2,  \
+         6, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0006,                                                     \
+         "Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.",   \
+         2, 6, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0007, "list command no longer ignores empty elements.",   \
+         2, 6, 0, cmPolicies::WARN)                                           \
+  SELECT(                                                                     \
+    POLICY, CMP0008,                                                          \
+    "Libraries linked by full-path must have a valid library file name.", 2,  \
+    6, 1, cmPolicies::WARN)                                                   \
+  SELECT(POLICY, CMP0009,                                                     \
+         "FILE GLOB_RECURSE calls should not follow symlinks by default.", 2, \
+         6, 2, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0010, "Bad variable reference syntax is an error.", 2, 6, \
+         3, cmPolicies::WARN)                                                 \
+  SELECT(POLICY, CMP0011,                                                     \
+         "Included scripts do automatic cmake_policy PUSH and POP.", 2, 6, 3, \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0012, "if() recognizes numbers and boolean constants.",   \
+         2, 8, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0013, "Duplicate binary directories are not allowed.", 2, \
+         8, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0014, "Input directories must have CMakeLists.txt.", 2,   \
+         8, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0015,                                                     \
+         "link_directories() treats paths relative to the source dir.", 2, 8, \
+         1, cmPolicies::WARN)                                                 \
+  SELECT(POLICY, CMP0016,                                                     \
+         "target_link_libraries() reports error if its only argument "        \
+         "is not a target.",                                                  \
+         2, 8, 3, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0017,                                                     \
+         "Prefer files from the CMake module directory when including from "  \
+         "there.",                                                            \
+         2, 8, 4, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0018,                                                     \
+         "Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.", 2, 8, 9,       \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0019,                                                     \
+         "Do not re-expand variables in include and link information.", 2, 8, \
+         11, cmPolicies::WARN)                                                \
+  SELECT(POLICY, CMP0020,                                                     \
+         "Automatically link Qt executables to qtmain target on Windows.", 2, \
+         8, 11, cmPolicies::WARN)                                             \
+  SELECT(                                                                     \
+    POLICY, CMP0021,                                                          \
+    "Fatal error on relative paths in INCLUDE_DIRECTORIES target property.",  \
+    2, 8, 12, cmPolicies::WARN)                                               \
+  SELECT(POLICY, CMP0022,                                                     \
+         "INTERFACE_LINK_LIBRARIES defines the link interface.", 2, 8, 12,    \
+         cmPolicies::WARN)                                                    \
+  SELECT(                                                                     \
+    POLICY, CMP0023,                                                          \
+    "Plain and keyword target_link_libraries signatures cannot be mixed.", 2, \
+    8, 12, cmPolicies::WARN)                                                  \
+  SELECT(POLICY, CMP0024, "Disallow include export result.", 3, 0, 0,         \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0025, "Compiler id for Apple Clang is now AppleClang.",   \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0026, "Disallow use of the LOCATION target property.", 3, \
+         0, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0027,                                                     \
+         "Conditionally linked imported targets with missing include "        \
+         "directories.",                                                      \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0028,                                                     \
+         "Double colon in target name means ALIAS or IMPORTED target.", 3, 0, \
+         0, cmPolicies::WARN)                                                 \
+  SELECT(POLICY, CMP0029, "The subdir_depends command should not be called.", \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0030,                                                     \
+         "The use_mangled_mesa command should not be called.", 3, 0, 0,       \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0031, "The load_command command should not be called.",   \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0032,                                                     \
+         "The output_required_files command should not be called.", 3, 0, 0,  \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0033,                                                     \
+         "The export_library_dependencies command should not be called.", 3,  \
+         0, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0034, "The utility_source command should not be called.", \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0035,                                                     \
+         "The variable_requires command should not be called.", 3, 0, 0,      \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0036, "The build_name command should not be called.", 3,  \
+         0, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0037,                                                     \
+         "Target names should not be reserved and should match a validity "   \
+         "pattern.",                                                          \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0038, "Targets may not link directly to themselves.", 3,  \
+         0, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0039, "Utility targets may not have link dependencies.",  \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0040,                                                     \
+         "The target in the TARGET signature of add_custom_command() must "   \
+         "exist.",                                                            \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0041,                                                     \
+         "Error on relative include with generator expression.", 3, 0, 0,     \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0042, "MACOSX_RPATH is enabled by default.", 3, 0, 0,     \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0043, "Ignore COMPILE_DEFINITIONS_<Config> properties.",  \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0044,                                                     \
+         "Case sensitive <LANG>_COMPILER_ID generator expressions.", 3, 0, 0, \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0045,                                                     \
+         "Error on non-existent target in get_target_property.", 3, 0, 0,     \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0046,                                                     \
+         "Error on non-existent dependency in add_dependencies.", 3, 0, 0,    \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0047, "Use QCC compiler id for the qcc drivers on QNX.",  \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0048, "project() command manages VERSION variables.", 3,  \
+         0, 0, cmPolicies::WARN)                                              \
+  SELECT(POLICY, CMP0049,                                                     \
+         "Do not expand variables in target source entries.", 3, 0, 0,        \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0050, "Disallow add_custom_command SOURCE signatures.",   \
+         3, 0, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0051, "List TARGET_OBJECTS in SOURCES target property.",  \
+         3, 1, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0052, "Reject source and build dirs in installed "        \
+                          "INTERFACE_INCLUDE_DIRECTORIES.",                   \
+         3, 1, 0, cmPolicies::WARN)                                           \
+  SELECT(POLICY, CMP0053,                                                     \
+         "Simplify variable reference and escape sequence evaluation.", 3, 1, \
+         0, cmPolicies::WARN)                                                 \
+  SELECT(                                                                     \
+    POLICY, CMP0054,                                                          \
+    "Only interpret if() arguments as variables or keywords when unquoted.",  \
+    3, 1, 0, cmPolicies::WARN)                                                \
+  SELECT(POLICY, CMP0055, "Strict checking for break() command.", 3, 2, 0,    \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0056,                                                     \
+         "Honor link flags in try_compile() source-file signature.", 3, 2, 0, \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0057, "Support new IN_LIST if() operator.", 3, 3, 0,      \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0058,                                                     \
+         "Ninja requires custom command byproducts to be explicit.", 3, 3, 0, \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0059,                                                     \
+         "Do not treat DEFINITIONS as a built-in directory property.", 3, 3,  \
+         0, cmPolicies::WARN)                                                 \
+  SELECT(POLICY, CMP0060,                                                     \
+         "Link libraries by full path even in implicit directories.", 3, 3,   \
+         0, cmPolicies::WARN)                                                 \
+  SELECT(POLICY, CMP0061,                                                     \
+         "CTest does not by default tell make to ignore errors (-i).", 3, 3,  \
+         0, cmPolicies::WARN)                                                 \
+  SELECT(POLICY, CMP0062, "Disallow install() of export() result.", 3, 3, 0,  \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0063,                                                     \
+         "Honor visibility properties for all target types.", 3, 3, 0,        \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0064, "Support new TEST if() operator.", 3, 4, 0,         \
+         cmPolicies::WARN)                                                    \
+  SELECT(POLICY, CMP0065,                                                     \
+         "Do not add flags to export symbols from executables without "       \
+         "the ENABLE_EXPORTS target property.",                               \
+         3, 4, 0, cmPolicies::WARN)
 
 #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1)
-#define CM_FOR_EACH_POLICY_ID(POLICY) \
+#define CM_FOR_EACH_POLICY_ID(POLICY)                                         \
   CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID)
 
-#define CM_FOR_EACH_TARGET_POLICY(F) \
-  F(CMP0003) \
-  F(CMP0004) \
-  F(CMP0008) \
-  F(CMP0020) \
-  F(CMP0021) \
-  F(CMP0022) \
-  F(CMP0027) \
-  F(CMP0038) \
-  F(CMP0041) \
-  F(CMP0042) \
-  F(CMP0046) \
-  F(CMP0052) \
-  F(CMP0060) \
-  F(CMP0063) \
+#define CM_FOR_EACH_TARGET_POLICY(F)                                          \
+  F(CMP0003)                                                                  \
+  F(CMP0004)                                                                  \
+  F(CMP0008)                                                                  \
+  F(CMP0020)                                                                  \
+  F(CMP0021)                                                                  \
+  F(CMP0022)                                                                  \
+  F(CMP0027)                                                                  \
+  F(CMP0038)                                                                  \
+  F(CMP0041)                                                                  \
+  F(CMP0042)                                                                  \
+  F(CMP0046)                                                                  \
+  F(CMP0052)                                                                  \
+  F(CMP0060)                                                                  \
+  F(CMP0063)                                                                  \
   F(CMP0065)
 
-
 /** \class cmPolicies
  * \brief Handles changes in CMake behavior and policies
  *
@@ -259,10 +237,11 @@ class cmPolicies
 {
 public:
   /// Status of a policy
-  enum PolicyStatus {
-    OLD, ///< Use old behavior
+  enum PolicyStatus
+  {
+    OLD,  ///< Use old behavior
     WARN, ///< Use old behavior but issue a warning
-    NEW, ///< Use new behavior
+    NEW,  ///< Use new behavior
     /// Issue an error if user doesn't set policy status to NEW and hits the
     /// check
     REQUIRED_IF_USED,
@@ -285,13 +264,13 @@ public:
   };
 
   ///! convert a string policy ID into a number
-  static bool GetPolicyID(const char *id, /* out */ cmPolicies::PolicyID &pid);
+  static bool GetPolicyID(const char* id, /* out */ cmPolicies::PolicyID& pid);
 
   ///! Get the default status for a policy
   static cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id);
 
   ///! Set a policy level for this listfile
-  static bool ApplyPolicyVersion(cmMakefile *mf, const char *version);
+  static bool ApplyPolicyVersion(cmMakefile* mf, const char* version);
 
   ///! return a warning string for a given policy
   static std::string GetPolicyWarning(cmPolicies::PolicyID id);
diff --git a/Source/cmProcessTools.cxx b/Source/cmProcessTools.cxx
index 41f6e26..446752e 100644
--- a/Source/cmProcessTools.cxx
+++ b/Source/cmProcessTools.cxx
@@ -13,74 +13,66 @@
 
 #include <cmsys/Process.h>
 
-void cmProcessTools::RunProcess(struct cmsysProcess_s* cp,
-                                OutputParser* out, OutputParser* err)
+void cmProcessTools::RunProcess(struct cmsysProcess_s* cp, OutputParser* out,
+                                OutputParser* err)
 {
   cmsysProcess_Execute(cp);
   char* data = 0;
   int length = 0;
   int p;
-  while((out||err) && (p=cmsysProcess_WaitForData(cp, &data, &length, 0), p))
-    {
-    if(out && p == cmsysProcess_Pipe_STDOUT)
-      {
-      if(!out->Process(data, length))
-        {
+  while ((out || err) &&
+         (p = cmsysProcess_WaitForData(cp, &data, &length, 0), p)) {
+    if (out && p == cmsysProcess_Pipe_STDOUT) {
+      if (!out->Process(data, length)) {
         out = 0;
-        }
       }
-    else if(err && p == cmsysProcess_Pipe_STDERR)
-      {
-      if(!err->Process(data, length))
-        {
+    } else if (err && p == cmsysProcess_Pipe_STDERR) {
+      if (!err->Process(data, length)) {
         err = 0;
-        }
       }
     }
+  }
   cmsysProcess_WaitForExit(cp, 0);
 }
 
-
-cmProcessTools::LineParser::LineParser(char sep, bool ignoreCR):
-   Log(0), Prefix(0), Separator(sep), LineEnd('\0'), IgnoreCR(ignoreCR)
+cmProcessTools::LineParser::LineParser(char sep, bool ignoreCR)
+  : Log(0)
+  , Prefix(0)
+  , Separator(sep)
+  , LineEnd('\0')
+  , IgnoreCR(ignoreCR)
 {
 }
 
 void cmProcessTools::LineParser::SetLog(std::ostream* log, const char* prefix)
 {
   this->Log = log;
-  this->Prefix = prefix? prefix : "";
+  this->Prefix = prefix ? prefix : "";
 }
 
 bool cmProcessTools::LineParser::ProcessChunk(const char* first, int length)
 {
   const char* last = first + length;
-  for(const char* c = first; c != last; ++c)
-    {
-    if(*c == this->Separator || *c == '\0')
-      {
+  for (const char* c = first; c != last; ++c) {
+    if (*c == this->Separator || *c == '\0') {
       this->LineEnd = *c;
 
       // Log this line.
-      if(this->Log && this->Prefix)
-        {
+      if (this->Log && this->Prefix) {
         *this->Log << this->Prefix << this->Line << "\n";
-        }
+      }
 
       // Hand this line to the subclass implementation.
-      if(!this->ProcessLine())
-        {
+      if (!this->ProcessLine()) {
         this->Line = "";
         return false;
-        }
+      }
 
       this->Line = "";
-      }
-    else if(*c != '\r' || !this->IgnoreCR)
-      {
+    } else if (*c != '\r' || !this->IgnoreCR) {
       // Append this character to the line under construction.
       this->Line.append(1, *c);
-      }
     }
+  }
   return true;
 }
diff --git a/Source/cmProcessTools.h b/Source/cmProcessTools.h
index 23833ca..a48e52b 100644
--- a/Source/cmProcessTools.h
+++ b/Source/cmProcessTools.h
@@ -29,9 +29,13 @@ public:
         done incrementally.  Returns true if the parser is interested
         in any more data and false if it is done.  */
     bool Process(const char* data, int length)
-      { return this->ProcessChunk(data, length); }
+    {
+      return this->ProcessChunk(data, length);
+    }
     bool Process(const char* data)
-      { return this->Process(data, static_cast<int>(strlen(data))); }
+    {
+      return this->Process(data, static_cast<int>(strlen(data)));
+    }
 
     virtual ~OutputParser() {}
   protected:
@@ -41,7 +45,7 @@ public:
   };
 
   /** Process output parser that extracts one line at a time.  */
-  class LineParser: public OutputParser
+  class LineParser : public OutputParser
   {
   public:
     /** Construct with line separation character and choose whether to
@@ -50,6 +54,7 @@ public:
 
     /** Configure logging of lines as they are extracted.  */
     void SetLog(std::ostream* log, const char* prefix);
+
   protected:
     std::ostream* Log;
     const char* Prefix;
@@ -65,18 +70,21 @@ public:
   };
 
   /** Trivial line handler for simple logging.  */
-  class OutputLogger: public LineParser
+  class OutputLogger : public LineParser
   {
   public:
     OutputLogger(std::ostream& log, const char* prefix = 0)
-      { this->SetLog(&log, prefix); }
+    {
+      this->SetLog(&log, prefix);
+    }
+
   private:
     virtual bool ProcessLine() { return true; }
   };
 
   /** Run a process and send output to given parsers.  */
-  static void RunProcess(struct cmsysProcess_s* cp,
-                         OutputParser* out, OutputParser* err = 0);
+  static void RunProcess(struct cmsysProcess_s* cp, OutputParser* out,
+                         OutputParser* err = 0);
 };
 
 #endif
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index 7123125..139303b 100644
--- a/Source/cmProjectCommand.cxx
+++ b/Source/cmProjectCommand.cxx
@@ -12,14 +12,13 @@
 #include "cmProjectCommand.h"
 
 // cmProjectCommand
-bool cmProjectCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
+                                   cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("PROJECT called with incorrect number of arguments");
     return false;
-    }
+  }
   this->Makefile->SetProjectName(args[0]);
 
   std::string bindir = args[0];
@@ -27,22 +26,20 @@ bool cmProjectCommand
   std::string srcdir = args[0];
   srcdir += "_SOURCE_DIR";
 
-  this->Makefile->AddCacheDefinition
-    (bindir,
-     this->Makefile->GetCurrentBinaryDirectory(),
-     "Value Computed by CMake", cmState::STATIC);
-  this->Makefile->AddCacheDefinition
-    (srcdir,
-     this->Makefile->GetCurrentSourceDirectory(),
-     "Value Computed by CMake", cmState::STATIC);
+  this->Makefile->AddCacheDefinition(
+    bindir, this->Makefile->GetCurrentBinaryDirectory(),
+    "Value Computed by CMake", cmState::STATIC);
+  this->Makefile->AddCacheDefinition(
+    srcdir, this->Makefile->GetCurrentSourceDirectory(),
+    "Value Computed by CMake", cmState::STATIC);
 
   bindir = "PROJECT_BINARY_DIR";
   srcdir = "PROJECT_SOURCE_DIR";
 
   this->Makefile->AddDefinition(bindir,
-          this->Makefile->GetCurrentBinaryDirectory());
+                                this->Makefile->GetCurrentBinaryDirectory());
   this->Makefile->AddDefinition(srcdir,
-          this->Makefile->GetCurrentSourceDirectory());
+                                this->Makefile->GetCurrentSourceDirectory());
 
   this->Makefile->AddDefinition("PROJECT_NAME", args[0].c_str());
 
@@ -52,117 +49,100 @@ bool cmProjectCommand
   // CMakeLists.txt file, then go with the last one, so that
   // CMAKE_PROJECT_NAME will match PROJECT_NAME, and cmake --build
   // will work.
-  if(!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME")
-     || (this->Makefile->IsRootMakefile()))
-    {
+  if (!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME") ||
+      (this->Makefile->IsRootMakefile())) {
     this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", args[0].c_str());
-    this->Makefile->AddCacheDefinition
-      ("CMAKE_PROJECT_NAME",
-       args[0].c_str(),
-       "Value Computed by CMake", cmState::STATIC);
-    }
+    this->Makefile->AddCacheDefinition("CMAKE_PROJECT_NAME", args[0].c_str(),
+                                       "Value Computed by CMake",
+                                       cmState::STATIC);
+  }
 
   bool haveVersion = false;
   bool haveLanguages = false;
   std::string version;
   std::vector<std::string> languages;
-  enum Doing { DoingLanguages, DoingVersion };
+  enum Doing
+  {
+    DoingLanguages,
+    DoingVersion
+  };
   Doing doing = DoingLanguages;
-  for(size_t i = 1; i < args.size(); ++i)
-    {
-    if(args[i] == "LANGUAGES")
-      {
-      if(haveLanguages)
-        {
-        this->Makefile->IssueMessage
-          (cmake::FATAL_ERROR, "LANGUAGES may be specified at most once.");
+  for (size_t i = 1; i < args.size(); ++i) {
+    if (args[i] == "LANGUAGES") {
+      if (haveLanguages) {
+        this->Makefile->IssueMessage(
+          cmake::FATAL_ERROR, "LANGUAGES may be specified at most once.");
         cmSystemTools::SetFatalErrorOccured();
         return true;
-        }
+      }
       haveLanguages = true;
       doing = DoingLanguages;
-      }
-    else if (args[i] == "VERSION")
-      {
-      if(haveVersion)
-        {
-        this->Makefile->IssueMessage
-          (cmake::FATAL_ERROR, "VERSION may be specified at most once.");
+    } else if (args[i] == "VERSION") {
+      if (haveVersion) {
+        this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+                                     "VERSION may be specified at most once.");
         cmSystemTools::SetFatalErrorOccured();
         return true;
-        }
+      }
       haveVersion = true;
       doing = DoingVersion;
-      }
-    else if(doing == DoingVersion)
-      {
+    } else if (doing == DoingVersion) {
       doing = DoingLanguages;
       version = args[i];
-      }
-    else // doing == DoingLanguages
-      {
+    } else // doing == DoingLanguages
+    {
       languages.push_back(args[i]);
-      }
     }
+  }
 
-  if (haveVersion && !haveLanguages && !languages.empty())
-    {
-    this->Makefile->IssueMessage
-      (cmake::FATAL_ERROR,
-       "project with VERSION must use LANGUAGES before language names.");
+  if (haveVersion && !haveLanguages && !languages.empty()) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "project with VERSION must use LANGUAGES before language names.");
     cmSystemTools::SetFatalErrorOccured();
     return true;
-    }
-  if (haveLanguages && languages.empty())
-    {
+  }
+  if (haveLanguages && languages.empty()) {
     languages.push_back("NONE");
-    }
+  }
 
   cmPolicies::PolicyStatus cmp0048 =
     this->Makefile->GetPolicyStatus(cmPolicies::CMP0048);
-  if (haveVersion)
-    {
+  if (haveVersion) {
     // Set project VERSION variables to given values
-    if (cmp0048 == cmPolicies::OLD ||
-        cmp0048 == cmPolicies::WARN)
-      {
-      this->Makefile->IssueMessage
-        (cmake::FATAL_ERROR,
-         "VERSION not allowed unless CMP0048 is set to NEW");
+    if (cmp0048 == cmPolicies::OLD || cmp0048 == cmPolicies::WARN) {
+      this->Makefile->IssueMessage(
+        cmake::FATAL_ERROR,
+        "VERSION not allowed unless CMP0048 is set to NEW");
       cmSystemTools::SetFatalErrorOccured();
       return true;
-      }
+    }
 
-    cmsys::RegularExpression
-      vx("^([0-9]+(\\.[0-9]+(\\.[0-9]+(\\.[0-9]+)?)?)?)?$");
-    if(!vx.find(version))
-      {
+    cmsys::RegularExpression vx(
+      "^([0-9]+(\\.[0-9]+(\\.[0-9]+(\\.[0-9]+)?)?)?)?$");
+    if (!vx.find(version)) {
       std::string e = "VERSION \"" + version + "\" format invalid.";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e);
       cmSystemTools::SetFatalErrorOccured();
       return true;
-      }
+    }
 
     std::string vs;
     const char* sep = "";
     char vb[4][64];
-    unsigned int v[4] = {0,0,0,0};
-    int vc = sscanf(version.c_str(), "%u.%u.%u.%u",
-                    &v[0], &v[1], &v[2], &v[3]);
-    for(int i=0; i < 4; ++i)
-      {
-      if(i < vc)
-        {
+    unsigned int v[4] = { 0, 0, 0, 0 };
+    int vc =
+      sscanf(version.c_str(), "%u.%u.%u.%u", &v[0], &v[1], &v[2], &v[3]);
+    for (int i = 0; i < 4; ++i) {
+      if (i < vc) {
         sprintf(vb[i], "%u", v[i]);
         vs += sep;
         vs += vb[i];
         sep = ".";
-        }
-      else
-        {
+      } else {
         vb[i][0] = 0;
-        }
       }
+    }
 
     std::string vv;
     vv = args[0] + "_VERSION";
@@ -180,9 +160,7 @@ bool cmProjectCommand
     vv = args[0] + "_VERSION_TWEAK";
     this->Makefile->AddDefinition("PROJECT_VERSION_TWEAK", vb[3]);
     this->Makefile->AddDefinition(vv, vb[3]);
-    }
-  else if(cmp0048 != cmPolicies::OLD)
-    {
+  } else if (cmp0048 != cmPolicies::OLD) {
     // Set project VERSION variables to empty
     std::vector<std::string> vv;
     vv.push_back("PROJECT_VERSION");
@@ -196,55 +174,43 @@ bool cmProjectCommand
     vv.push_back(args[0] + "_VERSION_PATCH");
     vv.push_back(args[0] + "_VERSION_TWEAK");
     std::string vw;
-    for(std::vector<std::string>::iterator i = vv.begin();
-        i != vv.end(); ++i)
-      {
+    for (std::vector<std::string>::iterator i = vv.begin(); i != vv.end();
+         ++i) {
       const char* v = this->Makefile->GetDefinition(*i);
-      if(v && *v)
-        {
-        if(cmp0048 == cmPolicies::WARN)
-          {
+      if (v && *v) {
+        if (cmp0048 == cmPolicies::WARN) {
           vw += "\n  ";
           vw += *i;
-          }
-        else
-          {
+        } else {
           this->Makefile->AddDefinition(*i, "");
-          }
         }
       }
-    if(!vw.empty())
-      {
+    }
+    if (!vw.empty()) {
       std::ostringstream w;
       w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0048)
         << "\nThe following variable(s) would be set to empty:" << vw;
       this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
-      }
     }
+  }
 
-  if (languages.empty())
-    {
+  if (languages.empty()) {
     // if no language is specified do c and c++
     languages.push_back("C");
     languages.push_back("CXX");
-    }
+  }
   this->Makefile->EnableLanguage(languages, false);
   std::string extraInclude = "CMAKE_PROJECT_" + args[0] + "_INCLUDE";
   const char* include = this->Makefile->GetDefinition(extraInclude);
-  if(include)
-    {
-    bool readit =
-      this->Makefile->ReadDependentFile(include);
-    if(!readit && !cmSystemTools::GetFatalErrorOccured())
-      {
-      std::string m =
-        "could not find file:\n"
-        "  ";
+  if (include) {
+    bool readit = this->Makefile->ReadDependentFile(include);
+    if (!readit && !cmSystemTools::GetFatalErrorOccured()) {
+      std::string m = "could not find file:\n"
+                      "  ";
       m += include;
       this->SetError(m);
       return false;
-      }
     }
+  }
   return true;
 }
-
diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h
index 7aacb55..a4e6367 100644
--- a/Source/cmProjectCommand.h
+++ b/Source/cmProjectCommand.h
@@ -28,26 +28,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmProjectCommand;
-    }
+  virtual cmCommand* Clone() { return new cmProjectCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "project";}
+  virtual std::string GetName() const { return "project"; }
 
   cmTypeMacro(cmProjectCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmProperty.cxx b/Source/cmProperty.cxx
index 4cdf650..4910616 100644
--- a/Source/cmProperty.cxx
+++ b/Source/cmProperty.cxx
@@ -13,27 +13,25 @@
 
 #include "cmSystemTools.h"
 
-void cmProperty::Set(const char *value)
+void cmProperty::Set(const char* value)
 {
   this->Value = value;
   this->ValueHasBeenSet = true;
 }
 
-void cmProperty::Append(const char *value, bool asString)
+void cmProperty::Append(const char* value, bool asString)
 {
-  if(!this->Value.empty() && *value && !asString)
-    {
+  if (!this->Value.empty() && *value && !asString) {
     this->Value += ";";
-    }
+  }
   this->Value += value;
   this->ValueHasBeenSet = true;
 }
 
-const char *cmProperty::GetValue() const
+const char* cmProperty::GetValue() const
 {
-  if (this->ValueHasBeenSet)
-    {
+  if (this->ValueHasBeenSet) {
     return this->Value.c_str();
-    }
+  }
   return 0;
 }
diff --git a/Source/cmProperty.h b/Source/cmProperty.h
index e026372..1736136 100644
--- a/Source/cmProperty.h
+++ b/Source/cmProperty.h
@@ -17,17 +17,27 @@
 class cmProperty
 {
 public:
-  enum ScopeType { TARGET, SOURCE_FILE, DIRECTORY, GLOBAL, CACHE,
-                   TEST, VARIABLE, CACHED_VARIABLE, INSTALL };
+  enum ScopeType
+  {
+    TARGET,
+    SOURCE_FILE,
+    DIRECTORY,
+    GLOBAL,
+    CACHE,
+    TEST,
+    VARIABLE,
+    CACHED_VARIABLE,
+    INSTALL
+  };
 
   // set this property
-  void Set(const char *value);
+  void Set(const char* value);
 
   // append to this property
-  void Append(const char *value, bool asString = false);
+  void Append(const char* value, bool asString = false);
 
   // get the value
-  const char *GetValue() const;
+  const char* GetValue() const;
 
   // construct with the value not set
   cmProperty() { this->ValueHasBeenSet = false; }
diff --git a/Source/cmPropertyDefinition.cxx b/Source/cmPropertyDefinition.cxx
index 9bb812e..546146b 100644
--- a/Source/cmPropertyDefinition.cxx
+++ b/Source/cmPropertyDefinition.cxx
@@ -13,22 +13,19 @@
 
 #include "cmSystemTools.h"
 
-void cmPropertyDefinition
-::DefineProperty(const std::string& name, cmProperty::ScopeType scope,
-                 const char *shortDescription,
-                 const char *fullDescription,
-                 bool chain)
+void cmPropertyDefinition::DefineProperty(const std::string& name,
+                                          cmProperty::ScopeType scope,
+                                          const char* shortDescription,
+                                          const char* fullDescription,
+                                          bool chain)
 {
   this->Name = name;
   this->Scope = scope;
   this->Chained = chain;
-  if (shortDescription)
-    {
+  if (shortDescription) {
     this->ShortDescription = shortDescription;
-    }
-  if (fullDescription)
-    {
+  }
+  if (fullDescription) {
     this->FullDescription = fullDescription;
-    }
+  }
 }
-
diff --git a/Source/cmPropertyDefinition.h b/Source/cmPropertyDefinition.h
index 098fadb..5733917 100644
--- a/Source/cmPropertyDefinition.h
+++ b/Source/cmPropertyDefinition.h
@@ -28,9 +28,8 @@ class cmPropertyDefinition
 public:
   /// Define this property
   void DefineProperty(const std::string& name, cmProperty::ScopeType scope,
-                      const char *ShortDescription,
-                      const char *FullDescription,
-                      bool chained);
+                      const char* ShortDescription,
+                      const char* FullDescription, bool chained);
 
   /// Default constructor
   cmPropertyDefinition() { this->Chained = false; }
@@ -39,16 +38,19 @@ public:
   bool IsChained() const { return this->Chained; }
 
   /// Get the scope
-  cmProperty::ScopeType GetScope() const {
-    return this->Scope; }
+  cmProperty::ScopeType GetScope() const { return this->Scope; }
 
   /// Get the documentation (short version)
-  const std::string &GetShortDescription() const {
-    return this->ShortDescription; }
+  const std::string& GetShortDescription() const
+  {
+    return this->ShortDescription;
+  }
 
   /// Get the documentation (full version)
-  const std::string &GetFullDescription() const {
-    return this->FullDescription; }
+  const std::string& GetFullDescription() const
+  {
+    return this->FullDescription;
+  }
 
 protected:
   std::string Name;
diff --git a/Source/cmPropertyDefinitionMap.cxx b/Source/cmPropertyDefinitionMap.cxx
index cba2b5a..ebc2caa 100644
--- a/Source/cmPropertyDefinitionMap.cxx
+++ b/Source/cmPropertyDefinitionMap.cxx
@@ -14,29 +14,27 @@
 #include "cmDocumentationSection.h"
 #include "cmSystemTools.h"
 
-void cmPropertyDefinitionMap
-::DefineProperty(const std::string& name, cmProperty::ScopeType scope,
-                 const char *ShortDescription,
-                 const char *FullDescription,
-                 bool chain)
+void cmPropertyDefinitionMap::DefineProperty(const std::string& name,
+                                             cmProperty::ScopeType scope,
+                                             const char* ShortDescription,
+                                             const char* FullDescription,
+                                             bool chain)
 {
   cmPropertyDefinitionMap::iterator it = this->find(name);
-  cmPropertyDefinition *prop;
-  if (it == this->end())
-    {
+  cmPropertyDefinition* prop;
+  if (it == this->end()) {
     prop = &(*this)[name];
-    prop->DefineProperty(name,scope,ShortDescription, FullDescription,
+    prop->DefineProperty(name, scope, ShortDescription, FullDescription,
                          chain);
-    }
+  }
 }
 
 bool cmPropertyDefinitionMap::IsPropertyDefined(const std::string& name) const
 {
   cmPropertyDefinitionMap::const_iterator it = this->find(name);
-  if (it == this->end())
-    {
+  if (it == this->end()) {
     return false;
-    }
+  }
 
   return true;
 }
@@ -44,10 +42,9 @@ bool cmPropertyDefinitionMap::IsPropertyDefined(const std::string& name) const
 bool cmPropertyDefinitionMap::IsPropertyChained(const std::string& name) const
 {
   cmPropertyDefinitionMap::const_iterator it = this->find(name);
-  if (it == this->end())
-    {
+  if (it == this->end()) {
     return false;
-    }
+  }
 
   return it->second.IsChained();
 }
diff --git a/Source/cmPropertyDefinitionMap.h b/Source/cmPropertyDefinitionMap.h
index f95c721..fbc9a18 100644
--- a/Source/cmPropertyDefinitionMap.h
+++ b/Source/cmPropertyDefinitionMap.h
@@ -16,15 +16,14 @@
 
 class cmDocumentationSection;
 
-class cmPropertyDefinitionMap :
-public std::map<std::string,cmPropertyDefinition>
+class cmPropertyDefinitionMap
+  : public std::map<std::string, cmPropertyDefinition>
 {
 public:
   // define the property
   void DefineProperty(const std::string& name, cmProperty::ScopeType scope,
-                      const char *ShortDescription,
-                      const char *FullDescription,
-                      bool chain);
+                      const char* ShortDescription,
+                      const char* FullDescription, bool chain);
 
   // has a named property been defined
   bool IsPropertyDefined(const std::string& name) const;
@@ -34,4 +33,3 @@ public:
 };
 
 #endif
-
diff --git a/Source/cmPropertyMap.cxx b/Source/cmPropertyMap.cxx
index 2b25023..74e04da 100644
--- a/Source/cmPropertyMap.cxx
+++ b/Source/cmPropertyMap.cxx
@@ -17,30 +17,26 @@
 
 #include <assert.h>
 
-cmProperty *cmPropertyMap::GetOrCreateProperty(const std::string& name)
+cmProperty* cmPropertyMap::GetOrCreateProperty(const std::string& name)
 {
   cmPropertyMap::iterator it = this->find(name);
-  cmProperty *prop;
-  if (it == this->end())
-    {
+  cmProperty* prop;
+  if (it == this->end()) {
     prop = &(*this)[name];
-    }
-  else
-    {
+  } else {
     prop = &(it->second);
-    }
+  }
   return prop;
 }
 
-void cmPropertyMap::SetProperty(const std::string& name, const char *value)
+void cmPropertyMap::SetProperty(const std::string& name, const char* value)
 {
-  if(!value)
-    {
+  if (!value) {
     this->erase(name);
     return;
-    }
+  }
 
-  cmProperty *prop = this->GetOrCreateProperty(name);
+  cmProperty* prop = this->GetOrCreateProperty(name);
   prop->Set(value);
 }
 
@@ -48,25 +44,21 @@ void cmPropertyMap::AppendProperty(const std::string& name, const char* value,
                                    bool asString)
 {
   // Skip if nothing to append.
-  if(!value || !*value)
-    {
+  if (!value || !*value) {
     return;
-    }
+  }
 
-  cmProperty *prop = this->GetOrCreateProperty(name);
-  prop->Append(value,asString);
+  cmProperty* prop = this->GetOrCreateProperty(name);
+  prop->Append(value, asString);
 }
 
-const char *cmPropertyMap
-::GetPropertyValue(const std::string& name) const
+const char* cmPropertyMap::GetPropertyValue(const std::string& name) const
 {
   assert(!name.empty());
 
   cmPropertyMap::const_iterator it = this->find(name);
-  if (it == this->end())
-    {
+  if (it == this->end()) {
     return 0;
-    }
+  }
   return it->second.GetValue();
 }
-
diff --git a/Source/cmPropertyMap.h b/Source/cmPropertyMap.h
index a9062db..4e98750 100644
--- a/Source/cmPropertyMap.h
+++ b/Source/cmPropertyMap.h
@@ -14,18 +14,17 @@
 
 #include "cmProperty.h"
 
-class cmPropertyMap : public std::map<std::string,cmProperty>
+class cmPropertyMap : public std::map<std::string, cmProperty>
 {
 public:
-  cmProperty *GetOrCreateProperty(const std::string& name);
+  cmProperty* GetOrCreateProperty(const std::string& name);
 
-  void SetProperty(const std::string& name, const char *value);
+  void SetProperty(const std::string& name, const char* value);
 
   void AppendProperty(const std::string& name, const char* value,
-                      bool asString=false);
+                      bool asString = false);
 
-  const char *GetPropertyValue(const std::string& name) const;
+  const char* GetPropertyValue(const std::string& name) const;
 };
 
 #endif
-
diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx
index aae1bb9..f63672b 100644
--- a/Source/cmQTWrapCPPCommand.cxx
+++ b/Source/cmQTWrapCPPCommand.cxx
@@ -13,13 +13,12 @@
 
 // cmQTWrapCPPCommand
 bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args,
-                                     cmExecutionStatus &)
+                                     cmExecutionStatus&)
 {
-  if(args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Get the moc executable to run in the custom command.
   const char* moc_exe =
@@ -27,56 +26,43 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args,
 
   // Get the variable holding the list of sources.
   std::string const& sourceList = args[1];
-  std::string sourceListValue =
-    this->Makefile->GetSafeDefinition(sourceList);
+  std::string sourceListValue = this->Makefile->GetSafeDefinition(sourceList);
 
   // Create a rule for all sources listed.
-  for(std::vector<std::string>::const_iterator j = (args.begin() + 2);
-      j != args.end(); ++j)
-    {
-    cmSourceFile *curr = this->Makefile->GetSource(*j);
+  for (std::vector<std::string>::const_iterator j = (args.begin() + 2);
+       j != args.end(); ++j) {
+    cmSourceFile* curr = this->Makefile->GetSource(*j);
     // if we should wrap the class
-    if(!(curr && curr->GetPropertyAsBool("WRAP_EXCLUDE")))
-      {
+    if (!(curr && curr->GetPropertyAsBool("WRAP_EXCLUDE"))) {
       // Compute the name of the file to generate.
-      std::string srcName =
-        cmSystemTools::GetFilenameWithoutLastExtension(*j);
+      std::string srcName = cmSystemTools::GetFilenameWithoutLastExtension(*j);
       std::string newName = this->Makefile->GetCurrentBinaryDirectory();
       newName += "/moc_";
       newName += srcName;
       newName += ".cxx";
-      cmSourceFile* sf =
-        this->Makefile->GetOrCreateSource(newName, true);
-      if (curr)
-        {
+      cmSourceFile* sf = this->Makefile->GetOrCreateSource(newName, true);
+      if (curr) {
         sf->SetProperty("ABSTRACT", curr->GetProperty("ABSTRACT"));
-        }
+      }
 
       // Compute the name of the header from which to generate the file.
       std::string hname;
-      if(cmSystemTools::FileIsFullPath(j->c_str()))
-        {
+      if (cmSystemTools::FileIsFullPath(j->c_str())) {
         hname = *j;
-        }
-      else
-        {
-        if(curr && curr->GetPropertyAsBool("GENERATED"))
-          {
+      } else {
+        if (curr && curr->GetPropertyAsBool("GENERATED")) {
           hname = this->Makefile->GetCurrentBinaryDirectory();
-          }
-        else
-          {
+        } else {
           hname = this->Makefile->GetCurrentSourceDirectory();
-          }
+        }
         hname += "/";
         hname += *j;
-        }
+      }
 
       // Append the generated source file to the list.
-      if(!sourceListValue.empty())
-        {
+      if (!sourceListValue.empty()) {
         sourceListValue += ";";
-        }
+      }
       sourceListValue += newName;
 
       // Create the custom command to generate the file.
@@ -95,17 +81,13 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args,
 
       std::string no_main_dependency = "";
       const char* no_working_dir = 0;
-      this->Makefile->AddCustomCommandToOutput(newName,
-                                               depends,
-                                               no_main_dependency,
-                                               commandLines,
-                                               "Qt Wrapped File",
-                                               no_working_dir);
-      }
+      this->Makefile->AddCustomCommandToOutput(
+        newName, depends, no_main_dependency, commandLines, "Qt Wrapped File",
+        no_working_dir);
     }
+  }
 
   // Store the final list of source files.
-  this->Makefile->AddDefinition(sourceList,
-                                sourceListValue.c_str());
+  this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
   return true;
 }
diff --git a/Source/cmQTWrapCPPCommand.h b/Source/cmQTWrapCPPCommand.h
index 85729dd..2014828 100644
--- a/Source/cmQTWrapCPPCommand.h
+++ b/Source/cmQTWrapCPPCommand.h
@@ -30,24 +30,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmQTWrapCPPCommand;
-    }
+  virtual cmCommand* Clone() { return new cmQTWrapCPPCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "qt_wrap_cpp";}
+  virtual std::string GetName() const { return "qt_wrap_cpp"; }
 };
 
-
-
 #endif
diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx
index 3adea29..4c1da36 100644
--- a/Source/cmQTWrapUICommand.cxx
+++ b/Source/cmQTWrapUICommand.cxx
@@ -13,13 +13,12 @@
 
 // cmQTWrapUICommand
 bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
-                                    cmExecutionStatus &)
+                                    cmExecutionStatus&)
 {
-  if(args.size() < 4 )
-    {
+  if (args.size() < 4) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Get the uic and moc executables to run in the custom commands.
   const char* uic_exe =
@@ -30,22 +29,17 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
   // Get the variable holding the list of sources.
   std::string const& headerList = args[1];
   std::string const& sourceList = args[2];
-  std::string headerListValue =
-    this->Makefile->GetSafeDefinition(headerList);
-  std::string sourceListValue =
-    this->Makefile->GetSafeDefinition(sourceList);
+  std::string headerListValue = this->Makefile->GetSafeDefinition(headerList);
+  std::string sourceListValue = this->Makefile->GetSafeDefinition(sourceList);
 
   // Create rules for all sources listed.
-  for(std::vector<std::string>::const_iterator j = (args.begin() + 3);
-      j != args.end(); ++j)
-    {
-    cmSourceFile *curr = this->Makefile->GetSource(*j);
+  for (std::vector<std::string>::const_iterator j = (args.begin() + 3);
+       j != args.end(); ++j) {
+    cmSourceFile* curr = this->Makefile->GetSource(*j);
     // if we should wrap the class
-    if(!(curr && curr->GetPropertyAsBool("WRAP_EXCLUDE")))
-      {
+    if (!(curr && curr->GetPropertyAsBool("WRAP_EXCLUDE"))) {
       // Compute the name of the files to generate.
-      std::string srcName =
-        cmSystemTools::GetFilenameWithoutLastExtension(*j);
+      std::string srcName = cmSystemTools::GetFilenameWithoutLastExtension(*j);
       std::string hName = this->Makefile->GetCurrentBinaryDirectory();
       hName += "/";
       hName += srcName;
@@ -61,36 +55,28 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
 
       // Compute the name of the ui file from which to generate others.
       std::string uiName;
-      if(cmSystemTools::FileIsFullPath(j->c_str()))
-        {
+      if (cmSystemTools::FileIsFullPath(j->c_str())) {
         uiName = *j;
-        }
-      else
-        {
-        if(curr && curr->GetPropertyAsBool("GENERATED"))
-          {
+      } else {
+        if (curr && curr->GetPropertyAsBool("GENERATED")) {
           uiName = this->Makefile->GetCurrentBinaryDirectory();
-          }
-        else
-          {
+        } else {
           uiName = this->Makefile->GetCurrentSourceDirectory();
-          }
+        }
         uiName += "/";
         uiName += *j;
-        }
+      }
 
       // create the list of headers
-      if(!headerListValue.empty())
-        {
+      if (!headerListValue.empty()) {
         headerListValue += ";";
-        }
+      }
       headerListValue += hName;
 
       // create the list of sources
-      if(!sourceListValue.empty())
-        {
+      if (!sourceListValue.empty()) {
         sourceListValue += ";";
-        }
+      }
       sourceListValue += cxxName;
       sourceListValue += ";";
       sourceListValue += mocName;
@@ -127,36 +113,25 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
       std::string no_main_dependency = "";
       const char* no_comment = 0;
       const char* no_working_dir = 0;
-      this->Makefile->AddCustomCommandToOutput(hName,
-                                               depends,
-                                               no_main_dependency,
-                                               hCommandLines,
-                                               no_comment,
-                                               no_working_dir);
+      this->Makefile->AddCustomCommandToOutput(
+        hName, depends, no_main_dependency, hCommandLines, no_comment,
+        no_working_dir);
 
       depends.push_back(hName);
-      this->Makefile->AddCustomCommandToOutput(cxxName,
-                                               depends,
-                                               no_main_dependency,
-                                               cxxCommandLines,
-                                               no_comment,
-                                               no_working_dir);
+      this->Makefile->AddCustomCommandToOutput(
+        cxxName, depends, no_main_dependency, cxxCommandLines, no_comment,
+        no_working_dir);
 
       depends.clear();
       depends.push_back(hName);
-      this->Makefile->AddCustomCommandToOutput(mocName,
-                                               depends,
-                                               no_main_dependency,
-                                               mocCommandLines,
-                                               no_comment,
-                                               no_working_dir);
-      }
+      this->Makefile->AddCustomCommandToOutput(
+        mocName, depends, no_main_dependency, mocCommandLines, no_comment,
+        no_working_dir);
     }
+  }
 
   // Store the final list of source files and headers.
-  this->Makefile->AddDefinition(sourceList,
-                                sourceListValue.c_str());
-  this->Makefile->AddDefinition(headerList,
-                                headerListValue.c_str());
+  this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
+  this->Makefile->AddDefinition(headerList, headerListValue.c_str());
   return true;
 }
diff --git a/Source/cmQTWrapUICommand.h b/Source/cmQTWrapUICommand.h
index 4aa9a61..48cfc77 100644
--- a/Source/cmQTWrapUICommand.h
+++ b/Source/cmQTWrapUICommand.h
@@ -28,24 +28,19 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmQTWrapUICommand;
-    }
+  virtual cmCommand* Clone() { return new cmQTWrapUICommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "qt_wrap_ui";}
+  virtual std::string GetName() const { return "qt_wrap_ui"; }
 };
 
-
-
 #endif
diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx
index 9b2362a..0388a95 100644
--- a/Source/cmQtAutoGeneratorInitializer.cxx
+++ b/Source/cmQtAutoGeneratorInitializer.cxx
@@ -22,19 +22,17 @@
 #include <cmsys/FStream.hxx>
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-# include "cmGlobalVisualStudioGenerator.h"
+#include "cmGlobalVisualStudioGenerator.h"
 #endif
 
-static std::string GetAutogenTargetName(
-    cmGeneratorTarget const* target)
+static std::string GetAutogenTargetName(cmGeneratorTarget const* target)
 {
   std::string autogenTargetName = target->GetName();
   autogenTargetName += "_automoc";
   return autogenTargetName;
 }
 
-static std::string GetAutogenTargetDir(
-    cmGeneratorTarget const* target)
+static std::string GetAutogenTargetDir(cmGeneratorTarget const* target)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
   std::string targetDir = makefile->GetCurrentBinaryDirectory();
@@ -45,8 +43,7 @@ static std::string GetAutogenTargetDir(
   return targetDir;
 }
 
-static std::string GetAutogenTargetBuildDir(
-    cmGeneratorTarget const* target)
+static std::string GetAutogenTargetBuildDir(cmGeneratorTarget const* target)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
   std::string targetDir = makefile->GetCurrentBinaryDirectory();
@@ -56,16 +53,15 @@ static std::string GetAutogenTargetBuildDir(
   return targetDir;
 }
 
-static std::string GetSourceRelativePath(
-    cmGeneratorTarget const* target,
-    const std::string& fileName)
+static std::string GetSourceRelativePath(cmGeneratorTarget const* target,
+                                         const std::string& fileName)
 {
   std::string pathRel;
   // Test if the file is child to any of the known directories
   {
     const std::string fileNameReal = cmsys::SystemTools::GetRealPath(fileName);
     std::string parentDirectory;
-    bool match ( false );
+    bool match(false);
     {
       std::string testDirs[4];
       {
@@ -75,42 +71,38 @@ static std::string GetSourceRelativePath(
         testDirs[2] = makefile->GetHomeDirectory();
         testDirs[3] = makefile->GetHomeOutputDirectory();
       }
-      for(int ii=0; ii != sizeof(testDirs)/sizeof(std::string); ++ii )
-        {
-        const ::std::string testDir = cmsys::SystemTools::GetRealPath(
-                                                                 testDirs[ii]);
-        if (!testDir.empty()
-            && cmsys::SystemTools::IsSubDirectory(fileNameReal, testDir) )
-          {
+      for (int ii = 0; ii != sizeof(testDirs) / sizeof(std::string); ++ii) {
+        const ::std::string testDir =
+          cmsys::SystemTools::GetRealPath(testDirs[ii]);
+        if (!testDir.empty() &&
+            cmsys::SystemTools::IsSubDirectory(fileNameReal, testDir)) {
           parentDirectory = testDir;
           match = true;
           break;
-          }
         }
+      }
     }
     // Use root as fallback parent directory
-    if (!match)
-      {
+    if (!match) {
       cmsys::SystemTools::SplitPathRootComponent(fileNameReal,
                                                  &parentDirectory);
-      }
+    }
     pathRel = cmsys::SystemTools::RelativePath(
       parentDirectory, cmsys::SystemTools::GetParentDirectory(fileNameReal));
   }
   // Sanitize relative path
-  if (!pathRel.empty())
-    {
+  if (!pathRel.empty()) {
     pathRel += '/';
     cmSystemTools::ReplaceString(pathRel, "..", "__");
-    }
+  }
   return pathRel;
 }
 
 static void SetupSourceFiles(cmGeneratorTarget const* target,
-                                   std::vector<std::string>& skipMoc,
-                                   std::vector<std::string>& mocSources,
-                                   std::vector<std::string>& mocHeaders,
-                                   std::vector<std::string>& skipUic)
+                             std::vector<std::string>& skipMoc,
+                             std::vector<std::string>& mocSources,
+                             std::vector<std::string>& mocHeaders,
+                             std::vector<std::string>& skipUic)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
 
@@ -119,84 +111,67 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
 
   std::vector<std::string> newRccFiles;
 
-  for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
-      fileIt != srcFiles.end();
-      ++fileIt)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
+       fileIt != srcFiles.end(); ++fileIt) {
     cmSourceFile* sf = *fileIt;
-    std::string absFile = cmsys::SystemTools::GetRealPath(
-                                                    sf->GetFullPath());
+    std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
     bool skipFileForMoc =
-        cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
+      cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
     bool generated = cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"));
 
-    if(cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC")))
-      {
+    if (cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"))) {
       skipUic.push_back(absFile);
-      }
+    }
 
     std::string ext = sf->GetExtension();
 
-    if (target->GetPropertyAsBool("AUTORCC"))
-      {
-      if (ext == "qrc"
-          && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")))
-        {
+    if (target->GetPropertyAsBool("AUTORCC")) {
+      if (ext == "qrc" &&
+          !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) {
 
         std::string rcc_output_dir = GetAutogenTargetBuildDir(target);
-        rcc_output_dir += GetSourceRelativePath(target,absFile);
+        rcc_output_dir += GetSourceRelativePath(target, absFile);
         cmSystemTools::MakeDirectory(rcc_output_dir.c_str());
 
-        std::string basename = cmsys::SystemTools::
-                                      GetFilenameWithoutLastExtension(absFile);
+        std::string basename =
+          cmsys::SystemTools::GetFilenameWithoutLastExtension(absFile);
 
         std::string rcc_output_file = rcc_output_dir;
         rcc_output_file += "qrc_" + basename + ".cpp";
         makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
-                                rcc_output_file.c_str(), false);
+                                 rcc_output_file.c_str(), false);
         makefile->GetOrCreateSource(rcc_output_file, true);
         newRccFiles.push_back(rcc_output_file);
-        }
       }
+    }
 
-    if (!generated)
-      {
-      if (skipFileForMoc)
-        {
+    if (!generated) {
+      if (skipFileForMoc) {
         skipMoc.push_back(absFile);
-        }
-      else
-        {
-        cmSystemTools::FileFormat fileType = cmSystemTools::GetFileFormat(
-                                                                ext.c_str());
-        if (fileType == cmSystemTools::CXX_FILE_FORMAT)
-          {
+      } else {
+        cmSystemTools::FileFormat fileType =
+          cmSystemTools::GetFileFormat(ext.c_str());
+        if (fileType == cmSystemTools::CXX_FILE_FORMAT) {
           mocSources.push_back(absFile);
-          }
-        else if (fileType == cmSystemTools::HEADER_FILE_FORMAT)
-          {
+        } else if (fileType == cmSystemTools::HEADER_FILE_FORMAT) {
           mocHeaders.push_back(absFile);
-          }
         }
       }
     }
+  }
 
-  for(std::vector<std::string>::const_iterator fileIt = newRccFiles.begin();
-      fileIt != newRccFiles.end();
-      ++fileIt)
-    {
+  for (std::vector<std::string>::const_iterator fileIt = newRccFiles.begin();
+       fileIt != newRccFiles.end(); ++fileIt) {
     const_cast<cmGeneratorTarget*>(target)->AddSource(*fileIt);
-    }
+  }
 }
 
 static void GetCompileDefinitionsAndDirectories(
-  cmGeneratorTarget const* target,
-  const std::string& config,
-  std::string &incs,
-  std::string &defs)
+  cmGeneratorTarget const* target, const std::string& config,
+  std::string& incs, std::string& defs)
 {
   std::vector<std::string> includeDirs;
-  cmLocalGenerator *localGen = target->GetLocalGenerator();
+  cmLocalGenerator* localGen = target->GetLocalGenerator();
   // Get the include dirs for this target, without stripping the implicit
   // include dirs off, see http://public.kitware.com/Bug/view.php?id=13667
   localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
@@ -209,24 +184,26 @@ static void GetCompileDefinitionsAndDirectories(
   defs += cmJoin(defines, ";");
 }
 
-static void SetupAutoMocTarget(cmGeneratorTarget const* target,
-                          const std::string &autogenTargetName,
-                          std::vector<std::string> const& skipMoc,
-                          std::vector<std::string> const& mocHeaders,
-                          std::map<std::string, std::string> &configIncludes,
-                          std::map<std::string, std::string> &configDefines)
+static void SetupAutoMocTarget(
+  cmGeneratorTarget const* target, const std::string& autogenTargetName,
+  std::vector<std::string> const& skipMoc,
+  std::vector<std::string> const& mocHeaders,
+  std::map<std::string, std::string>& configIncludes,
+  std::map<std::string, std::string>& configDefines)
 {
   cmLocalGenerator* lg = target->GetLocalGenerator();
   cmMakefile* makefile = target->Target->GetMakefile();
 
   const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
-  std::string _moc_options = (tmp!=0 ? tmp : "");
-  makefile->AddDefinition("_moc_options",
-          cmOutputConverter::EscapeForCMake(_moc_options).c_str());
-  makefile->AddDefinition("_skip_moc",
-          cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
-  makefile->AddDefinition("_moc_headers",
-          cmOutputConverter::EscapeForCMake(cmJoin(mocHeaders, ";")).c_str());
+  std::string _moc_options = (tmp != 0 ? tmp : "");
+  makefile->AddDefinition(
+    "_moc_options", cmOutputConverter::EscapeForCMake(_moc_options).c_str());
+  makefile->AddDefinition(
+    "_skip_moc",
+    cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
+  makefile->AddDefinition(
+    "_moc_headers",
+    cmOutputConverter::EscapeForCMake(cmJoin(mocHeaders, ";")).c_str());
   bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
   makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
 
@@ -234,146 +211,124 @@ static void SetupAutoMocTarget(cmGeneratorTarget const* target,
   std::string _moc_compile_defs;
   std::vector<std::string> configs;
   const std::string& config = makefile->GetConfigurations(configs);
-  GetCompileDefinitionsAndDirectories(target, config,
-                                      _moc_incs, _moc_compile_defs);
+  GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
+                                      _moc_compile_defs);
 
-  makefile->AddDefinition("_moc_incs",
-          cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
-  makefile->AddDefinition("_moc_compile_defs",
-          cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());
+  makefile->AddDefinition(
+    "_moc_incs", cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
+  makefile->AddDefinition(
+    "_moc_compile_defs",
+    cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());
 
   for (std::vector<std::string>::const_iterator li = configs.begin();
-       li != configs.end(); ++li)
-    {
+       li != configs.end(); ++li) {
     std::string config_moc_incs;
     std::string config_moc_compile_defs;
-    GetCompileDefinitionsAndDirectories(target, *li,
-                                        config_moc_incs,
+    GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
                                         config_moc_compile_defs);
-    if (config_moc_incs != _moc_incs)
-      {
-      configIncludes[*li] =
-                    cmOutputConverter::EscapeForCMake(config_moc_incs);
-      if(_moc_incs.empty())
-        {
+    if (config_moc_incs != _moc_incs) {
+      configIncludes[*li] = cmOutputConverter::EscapeForCMake(config_moc_incs);
+      if (_moc_incs.empty()) {
         _moc_incs = config_moc_incs;
-        }
       }
-    if (config_moc_compile_defs != _moc_compile_defs)
-      {
+    }
+    if (config_moc_compile_defs != _moc_compile_defs) {
       configDefines[*li] =
-            cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
-      if(_moc_compile_defs.empty())
-        {
+        cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
+      if (_moc_compile_defs.empty()) {
         _moc_compile_defs = config_moc_compile_defs;
-        }
       }
     }
+  }
 
-  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
-  if (strcmp(qtVersion, "5") == 0)
-    {
-    cmGeneratorTarget *qt5Moc =
-        lg->FindGeneratorTargetToUse("Qt5::moc");
-    if (!qt5Moc)
-      {
+  const char* qtVersion = makefile->GetDefinition("_target_qt_version");
+  if (strcmp(qtVersion, "5") == 0) {
+    cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
+    if (!qt5Moc) {
       cmSystemTools::Error("Qt5::moc target not found ",
-                          autogenTargetName.c_str());
+                           autogenTargetName.c_str());
       return;
-      }
+    }
     makefile->AddDefinition("_qt_moc_executable",
                             qt5Moc->ImportedGetLocation(""));
-    }
-  else if (strcmp(qtVersion, "4") == 0)
-    {
-    cmGeneratorTarget *qt4Moc =
-        lg->FindGeneratorTargetToUse("Qt4::moc");
-    if (!qt4Moc)
-      {
+  } else if (strcmp(qtVersion, "4") == 0) {
+    cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
+    if (!qt4Moc) {
       cmSystemTools::Error("Qt4::moc target not found ",
-                          autogenTargetName.c_str());
+                           autogenTargetName.c_str());
       return;
-      }
+    }
     makefile->AddDefinition("_qt_moc_executable",
                             qt4Moc->ImportedGetLocation(""));
-    }
-  else
-    {
+  } else {
     cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and "
-                        "Qt 5 ", autogenTargetName.c_str());
-    }
+                         "Qt 5 ",
+                         autogenTargetName.c_str());
+  }
 }
 
 static void GetUicOpts(cmGeneratorTarget const* target,
-                       const std::string& config,
-                       std::string &optString)
+                       const std::string& config, std::string& optString)
 {
   std::vector<std::string> opts;
   target->GetAutoUicOptions(opts, config);
   optString = cmJoin(opts, ";");
 }
 
-static void SetupAutoUicTarget(cmGeneratorTarget const* target,
-                          std::vector<std::string> const& skipUic,
-                          std::map<std::string, std::string> &configUicOptions)
+static void SetupAutoUicTarget(
+  cmGeneratorTarget const* target, std::vector<std::string> const& skipUic,
+  std::map<std::string, std::string>& configUicOptions)
 {
   cmLocalGenerator* lg = target->GetLocalGenerator();
-  cmMakefile *makefile = target->Target->GetMakefile();
+  cmMakefile* makefile = target->Target->GetMakefile();
 
   std::set<std::string> skipped;
   skipped.insert(skipUic.begin(), skipUic.end());
 
-  makefile->AddDefinition("_skip_uic",
-          cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());
+  makefile->AddDefinition(
+    "_skip_uic",
+    cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());
 
-  std::vector<cmSourceFile*> uiFilesWithOptions
-                                        = makefile->GetQtUiFilesWithOptions();
+  std::vector<cmSourceFile*> uiFilesWithOptions =
+    makefile->GetQtUiFilesWithOptions();
 
-  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
+  const char* qtVersion = makefile->GetDefinition("_target_qt_version");
 
   std::string _uic_opts;
   std::vector<std::string> configs;
   const std::string& config = makefile->GetConfigurations(configs);
   GetUicOpts(target, config, _uic_opts);
 
-  if (!_uic_opts.empty())
-    {
+  if (!_uic_opts.empty()) {
     _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts);
     makefile->AddDefinition("_uic_target_options", _uic_opts.c_str());
-    }
+  }
   for (std::vector<std::string>::const_iterator li = configs.begin();
-       li != configs.end(); ++li)
-    {
+       li != configs.end(); ++li) {
     std::string config_uic_opts;
     GetUicOpts(target, *li, config_uic_opts);
-    if (config_uic_opts != _uic_opts)
-      {
+    if (config_uic_opts != _uic_opts) {
       configUicOptions[*li] =
-                    cmOutputConverter::EscapeForCMake(config_uic_opts);
-      if(_uic_opts.empty())
-        {
+        cmOutputConverter::EscapeForCMake(config_uic_opts);
+      if (_uic_opts.empty()) {
         _uic_opts = config_uic_opts;
-        }
       }
     }
+  }
 
   std::string uiFileFiles;
   std::string uiFileOptions;
   const char* sep = "";
 
-  for(std::vector<cmSourceFile*>::const_iterator fileIt =
-      uiFilesWithOptions.begin();
-      fileIt != uiFilesWithOptions.end();
-      ++fileIt)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator fileIt =
+         uiFilesWithOptions.begin();
+       fileIt != uiFilesWithOptions.end(); ++fileIt) {
     cmSourceFile* sf = *fileIt;
-    std::string absFile = cmsys::SystemTools::GetRealPath(
-                                                    sf->GetFullPath());
+    std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
 
-    if (!skipped.insert(absFile).second)
-      {
+    if (!skipped.insert(absFile).second) {
       continue;
-      }
+    }
     uiFileFiles += sep;
     uiFileFiles += absFile;
     uiFileOptions += sep;
@@ -381,139 +336,108 @@ static void SetupAutoUicTarget(cmGeneratorTarget const* target,
     cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
     uiFileOptions += opts;
     sep = ";";
-    }
+  }
 
-  makefile->AddDefinition("_qt_uic_options_files",
-              cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
-  makefile->AddDefinition("_qt_uic_options_options",
-            cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());
+  makefile->AddDefinition(
+    "_qt_uic_options_files",
+    cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
+  makefile->AddDefinition(
+    "_qt_uic_options_options",
+    cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());
 
   std::string targetName = target->GetName();
-  if (strcmp(qtVersion, "5") == 0)
-    {
-    cmGeneratorTarget *qt5Uic =
-        lg->FindGeneratorTargetToUse("Qt5::uic");
-    if (!qt5Uic)
-      {
+  if (strcmp(qtVersion, "5") == 0) {
+    cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
+    if (!qt5Uic) {
       // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
-      }
-    else
-      {
+    } else {
       makefile->AddDefinition("_qt_uic_executable",
                               qt5Uic->ImportedGetLocation(""));
-      }
     }
-  else if (strcmp(qtVersion, "4") == 0)
-    {
-    cmGeneratorTarget *qt4Uic =
-        lg->FindGeneratorTargetToUse("Qt4::uic");
-    if (!qt4Uic)
-      {
-      cmSystemTools::Error("Qt4::uic target not found ",
-                          targetName.c_str());
+  } else if (strcmp(qtVersion, "4") == 0) {
+    cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
+    if (!qt4Uic) {
+      cmSystemTools::Error("Qt4::uic target not found ", targetName.c_str());
       return;
-      }
+    }
     makefile->AddDefinition("_qt_uic_executable",
                             qt4Uic->ImportedGetLocation(""));
-    }
-  else
-    {
+  } else {
     cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
-                        "Qt 5 ", targetName.c_str());
-    }
+                         "Qt 5 ",
+                         targetName.c_str());
+  }
 }
 
 static std::string GetRccExecutable(cmGeneratorTarget const* target)
 {
   cmLocalGenerator* lg = target->GetLocalGenerator();
-  cmMakefile *makefile = target->Target->GetMakefile();
-  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
-  if (!qtVersion)
-    {
+  cmMakefile* makefile = target->Target->GetMakefile();
+  const char* qtVersion = makefile->GetDefinition("_target_qt_version");
+  if (!qtVersion) {
     qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
-    if (!qtVersion)
-      {
+    if (!qtVersion) {
       qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR");
-      }
-    if (const char *targetQtVersion =
-        target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION",
-                                                        ""))
-      {
+    }
+    if (const char* targetQtVersion =
+          target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION",
+                                                          "")) {
       qtVersion = targetQtVersion;
-      }
     }
+  }
 
   std::string targetName = target->GetName();
-  if (strcmp(qtVersion, "5") == 0)
-    {
-    cmGeneratorTarget *qt5Rcc =
-        lg->FindGeneratorTargetToUse("Qt5::rcc");
-    if (!qt5Rcc)
-      {
-      cmSystemTools::Error("Qt5::rcc target not found ",
-                          targetName.c_str());
+  if (strcmp(qtVersion, "5") == 0) {
+    cmGeneratorTarget* qt5Rcc = lg->FindGeneratorTargetToUse("Qt5::rcc");
+    if (!qt5Rcc) {
+      cmSystemTools::Error("Qt5::rcc target not found ", targetName.c_str());
       return std::string();
-      }
-    return qt5Rcc->ImportedGetLocation("");
     }
-  else if (strcmp(qtVersion, "4") == 0)
-    {
-    cmGeneratorTarget *qt4Rcc =
-        lg->FindGeneratorTargetToUse("Qt4::rcc");
-    if (!qt4Rcc)
-      {
-      cmSystemTools::Error("Qt4::rcc target not found ",
-                          targetName.c_str());
+    return qt5Rcc->ImportedGetLocation("");
+  } else if (strcmp(qtVersion, "4") == 0) {
+    cmGeneratorTarget* qt4Rcc = lg->FindGeneratorTargetToUse("Qt4::rcc");
+    if (!qt4Rcc) {
+      cmSystemTools::Error("Qt4::rcc target not found ", targetName.c_str());
       return std::string();
-      }
-    return qt4Rcc->ImportedGetLocation("");
     }
+    return qt4Rcc->ImportedGetLocation("");
+  }
 
   cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and "
-                      "Qt 5 ", targetName.c_str());
+                       "Qt 5 ",
+                       targetName.c_str());
   return std::string();
 }
 
-static void MergeRccOptions(std::vector<std::string> &opts,
-                         const std::vector<std::string> &fileOpts,
-                         bool isQt5)
+static void MergeRccOptions(std::vector<std::string>& opts,
+                            const std::vector<std::string>& fileOpts,
+                            bool isQt5)
 {
-  static const char* valueOptions[] = {
-    "name",
-    "root",
-    "compress",
-    "threshold"
-  };
+  static const char* valueOptions[] = { "name", "root", "compress",
+                                        "threshold" };
   std::vector<std::string> extraOpts;
-  for(std::vector<std::string>::const_iterator it = fileOpts.begin();
-      it != fileOpts.end(); ++it)
-    {
-    std::vector<std::string>::iterator existingIt
-                                  = std::find(opts.begin(), opts.end(), *it);
-    if (existingIt != opts.end())
-      {
-      const char *o = it->c_str();
-      if (*o == '-')
-        {
+  for (std::vector<std::string>::const_iterator it = fileOpts.begin();
+       it != fileOpts.end(); ++it) {
+    std::vector<std::string>::iterator existingIt =
+      std::find(opts.begin(), opts.end(), *it);
+    if (existingIt != opts.end()) {
+      const char* o = it->c_str();
+      if (*o == '-') {
         ++o;
-        }
-      if (isQt5 && *o == '-')
-        {
+      }
+      if (isQt5 && *o == '-') {
         ++o;
-        }
+      }
       if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
-                  cmStrCmp(*it)) != cmArrayEnd(valueOptions))
-        {
+                       cmStrCmp(*it)) != cmArrayEnd(valueOptions)) {
         assert(existingIt + 1 != opts.end());
         *(existingIt + 1) = *(it + 1);
         ++it;
-        }
       }
-    else
-      {
+    } else {
       extraOpts.push_back(*it);
-      }
     }
+  }
   opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
 }
 
@@ -522,20 +446,18 @@ static void copyTargetProperty(cmTarget* destinationTarget,
                                const std::string& propertyName)
 {
   const char* propertyValue = sourceTarget->GetProperty(propertyName);
-  if (propertyValue)
-    {
+  if (propertyValue) {
     destinationTarget->SetProperty(propertyName, propertyValue);
-    }
+  }
 }
 
 static std::string cmQtAutoGeneratorsStripCR(std::string const& line)
 {
   // Strip CR characters rcc may have printed (possibly more than one!).
   std::string::size_type cr = line.find('\r');
-  if (cr != line.npos)
-    {
+  if (cr != line.npos) {
     return line.substr(0, cr);
-    }
+  }
   return line;
 }
 
@@ -549,27 +471,24 @@ static std::string ReadAll(const std::string& filename)
 }
 
 static std::string ListQt5RccInputs(cmSourceFile* sf,
-                                            cmGeneratorTarget const* target,
-                                            std::vector<std::string>& depends)
+                                    cmGeneratorTarget const* target,
+                                    std::vector<std::string>& depends)
 {
-  std::string rccCommand
-      = GetRccExecutable(target);
+  std::string rccCommand = GetRccExecutable(target);
 
   bool hasDashDashList = false;
   {
-  std::vector<std::string> command;
-  command.push_back(rccCommand);
-  command.push_back("--help");
-  std::string rccStdOut;
-  std::string rccStdErr;
-  int retVal = 0;
-  bool result = cmSystemTools::RunSingleCommand(
-    command, &rccStdOut, &rccStdErr,
-    &retVal, 0, cmSystemTools::OUTPUT_NONE);
-  if (result && retVal == 0 &&
-      rccStdOut.find("--list") != std::string::npos)
-    {
-    hasDashDashList = true;
+    std::vector<std::string> command;
+    command.push_back(rccCommand);
+    command.push_back("--help");
+    std::string rccStdOut;
+    std::string rccStdErr;
+    int retVal = 0;
+    bool result = cmSystemTools::RunSingleCommand(
+      command, &rccStdOut, &rccStdErr, &retVal, 0, cmSystemTools::OUTPUT_NONE);
+    if (result && retVal == 0 &&
+        rccStdOut.find("--list") != std::string::npos) {
+      hasDashDashList = true;
     }
   }
 
@@ -577,10 +496,9 @@ static std::string ListQt5RccInputs(cmSourceFile* sf,
 
   std::vector<std::string> command;
   command.push_back(rccCommand);
-  command.push_back(hasDashDashList? "--list" : "-list");
+  command.push_back(hasDashDashList ? "--list" : "-list");
 
-  std::string absFile = cmsys::SystemTools::GetRealPath(
-                                              sf->GetFullPath());
+  std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
 
   command.push_back(absFile);
 
@@ -588,52 +506,47 @@ static std::string ListQt5RccInputs(cmSourceFile* sf,
   std::string rccStdErr;
   int retVal = 0;
   bool result = cmSystemTools::RunSingleCommand(
-    command, &rccStdOut, &rccStdErr,
-    &retVal, 0, cmSystemTools::OUTPUT_NONE);
-  if (!result || retVal)
-    {
+    command, &rccStdOut, &rccStdErr, &retVal, 0, cmSystemTools::OUTPUT_NONE);
+  if (!result || retVal) {
     std::stringstream err;
     err << "AUTOGEN: error: Rcc list process for " << sf->GetFullPath()
-        << " failed:\n" << rccStdOut << "\n" << rccStdErr << std::endl;
+        << " failed:\n"
+        << rccStdOut << "\n"
+        << rccStdErr << std::endl;
     std::cerr << err.str();
     return std::string();
-    }
+  }
 
   {
-  std::istringstream ostr(rccStdOut);
-  std::string oline;
-  while(std::getline(ostr, oline))
-    {
-    oline = cmQtAutoGeneratorsStripCR(oline);
-    if(!oline.empty())
-      {
-      qrcEntries.push_back(oline);
+    std::istringstream ostr(rccStdOut);
+    std::string oline;
+    while (std::getline(ostr, oline)) {
+      oline = cmQtAutoGeneratorsStripCR(oline);
+      if (!oline.empty()) {
+        qrcEntries.push_back(oline);
       }
     }
   }
 
   {
-  std::istringstream estr(rccStdErr);
-  std::string eline;
-  while(std::getline(estr, eline))
-    {
-    eline = cmQtAutoGeneratorsStripCR(eline);
-    if (cmHasLiteralPrefix(eline, "RCC: Error in"))
-      {
-      static std::string searchString = "Cannot find file '";
-
-      std::string::size_type pos = eline.find(searchString);
-      if (pos == std::string::npos)
-        {
-        std::stringstream err;
-        err << "AUTOGEN: error: Rcc lists unparsable output "
-            << eline << std::endl;
-        std::cerr << err.str();
-        return std::string();
+    std::istringstream estr(rccStdErr);
+    std::string eline;
+    while (std::getline(estr, eline)) {
+      eline = cmQtAutoGeneratorsStripCR(eline);
+      if (cmHasLiteralPrefix(eline, "RCC: Error in")) {
+        static std::string searchString = "Cannot find file '";
+
+        std::string::size_type pos = eline.find(searchString);
+        if (pos == std::string::npos) {
+          std::stringstream err;
+          err << "AUTOGEN: error: Rcc lists unparsable output " << eline
+              << std::endl;
+          std::cerr << err.str();
+          return std::string();
         }
-      pos += searchString.length();
-      std::string::size_type sz = eline.size() - pos - 1;
-      qrcEntries.push_back(eline.substr(pos, sz));
+        pos += searchString.length();
+        std::string::size_type sz = eline.size() - pos - 1;
+        qrcEntries.push_back(eline.substr(pos, sz));
       }
     }
   }
@@ -643,7 +556,7 @@ static std::string ListQt5RccInputs(cmSourceFile* sf,
 }
 
 static std::string ListQt4RccInputs(cmSourceFile* sf,
-                                            std::vector<std::string>& depends)
+                                    std::vector<std::string>& depends)
 {
   const std::string qrcContents = ReadAll(sf->GetFullPath());
 
@@ -653,8 +566,7 @@ static std::string ListQt4RccInputs(cmSourceFile* sf,
   const char* sep = "";
 
   size_t offset = 0;
-  while (fileMatchRegex.find(qrcContents.c_str() + offset))
-    {
+  while (fileMatchRegex.find(qrcContents.c_str() + offset)) {
     std::string qrcEntry = fileMatchRegex.match(1);
 
     offset += qrcEntry.size();
@@ -665,16 +577,15 @@ static std::string ListQt4RccInputs(cmSourceFile* sf,
 
     qrcEntry = qrcEntry.substr(tag.size());
 
-    if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str()))
-      {
+    if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str())) {
       qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry;
-      }
+    }
 
     entriesList += sep;
     entriesList += qrcEntry;
     sep = "@list_sep@";
     depends.push_back(qrcEntry);
-    }
+  }
   return entriesList;
 }
 
@@ -682,7 +593,7 @@ static void SetupAutoRccTarget(cmGeneratorTarget const* target)
 {
   std::string _rcc_files;
   const char* sepRccFiles = "";
-  cmMakefile *makefile = target->Target->GetMakefile();
+  cmMakefile* makefile = target->Target->GetMakefile();
 
   std::vector<cmSourceFile*> srcFiles;
   target->GetConfigCommonSourceFiles(srcFiles);
@@ -692,134 +603,117 @@ static void SetupAutoRccTarget(cmGeneratorTarget const* target)
 
   std::string rccFileFiles;
   std::string rccFileOptions;
-  const char *optionSep = "";
+  const char* optionSep = "";
 
-  const char *qtVersion = makefile->GetDefinition("_target_qt_version");
+  const char* qtVersion = makefile->GetDefinition("_target_qt_version");
 
   std::vector<std::string> rccOptions;
-  if (const char* opts = target->GetProperty("AUTORCC_OPTIONS"))
-    {
+  if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) {
     cmSystemTools::ExpandListArgument(opts, rccOptions);
-    }
+  }
   std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR");
-  if (qtMajorVersion == "")
-    {
+  if (qtMajorVersion == "") {
     qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
-    }
+  }
 
-  for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
-      fileIt != srcFiles.end();
-      ++fileIt)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
+       fileIt != srcFiles.end(); ++fileIt) {
     cmSourceFile* sf = *fileIt;
     std::string ext = sf->GetExtension();
-    if (ext == "qrc")
-      {
-      std::string absFile = cmsys::SystemTools::GetRealPath(
-                                                  sf->GetFullPath());
+    if (ext == "qrc") {
+      std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
       bool skip = cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"));
 
-      if (!skip)
-        {
+      if (!skip) {
         _rcc_files += sepRccFiles;
         _rcc_files += absFile;
         sepRccFiles = ";";
 
-        if (const char *prop = sf->GetProperty("AUTORCC_OPTIONS"))
-          {
+        if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
           std::vector<std::string> optsVec;
           cmSystemTools::ExpandListArgument(prop, optsVec);
-          MergeRccOptions(rccOptions, optsVec,
-                                strcmp(qtVersion, "5") == 0);
-          }
+          MergeRccOptions(rccOptions, optsVec, strcmp(qtVersion, "5") == 0);
+        }
 
-        if (!rccOptions.empty())
-          {
+        if (!rccOptions.empty()) {
           rccFileFiles += optionSep;
           rccFileFiles += absFile;
           rccFileOptions += optionSep;
-          }
-        const char *listSep = "";
-        for(std::vector<std::string>::const_iterator it = rccOptions.begin();
-            it != rccOptions.end();
-            ++it)
-          {
+        }
+        const char* listSep = "";
+        for (std::vector<std::string>::const_iterator it = rccOptions.begin();
+             it != rccOptions.end(); ++it) {
           rccFileOptions += listSep;
           rccFileOptions += *it;
           listSep = "@list_sep@";
-          }
+        }
         optionSep = ";";
 
         std::vector<std::string> depends;
 
         std::string entriesList;
-        if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")))
-          {
-          if (qtMajorVersion == "5")
-            {
+        if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
+          if (qtMajorVersion == "5") {
             entriesList = ListQt5RccInputs(sf, target, depends);
-            }
-          else
-            {
+          } else {
             entriesList = ListQt4RccInputs(sf, depends);
-            }
-          if (entriesList.empty())
-            {
+          }
+          if (entriesList.empty()) {
             return;
-            }
           }
+        }
         qrcInputs += qrcInputsSep;
         qrcInputs += entriesList;
         qrcInputsSep = ";";
-        }
       }
     }
-  makefile->AddDefinition("_qt_rcc_inputs_" + target->GetName(),
-                      cmOutputConverter::EscapeForCMake(qrcInputs).c_str());
+  }
+  makefile->AddDefinition(
+    "_qt_rcc_inputs_" + target->GetName(),
+    cmOutputConverter::EscapeForCMake(qrcInputs).c_str());
 
-  makefile->AddDefinition("_rcc_files",
-          cmOutputConverter::EscapeForCMake(_rcc_files).c_str());
+  makefile->AddDefinition(
+    "_rcc_files", cmOutputConverter::EscapeForCMake(_rcc_files).c_str());
 
-  makefile->AddDefinition("_qt_rcc_options_files",
-              cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
-  makefile->AddDefinition("_qt_rcc_options_options",
-            cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());
+  makefile->AddDefinition(
+    "_qt_rcc_options_files",
+    cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
+  makefile->AddDefinition(
+    "_qt_rcc_options_options",
+    cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());
 
   makefile->AddDefinition("_qt_rcc_executable",
-              GetRccExecutable(target).c_str());
+                          GetRccExecutable(target).c_str());
 }
 
 void cmQtAutoGeneratorInitializer::InitializeAutogenSources(
-    cmGeneratorTarget* target)
+  cmGeneratorTarget* target)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
 
-  if (target->GetPropertyAsBool("AUTOMOC"))
-    {
+  if (target->GetPropertyAsBool("AUTOMOC")) {
     std::string automocTargetName = GetAutogenTargetName(target);
     std::string mocCppFile = makefile->GetCurrentBinaryDirectory();
     mocCppFile += "/";
     mocCppFile += automocTargetName;
     mocCppFile += ".cpp";
     makefile->GetOrCreateSource(mocCppFile, true);
-    makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
-                            mocCppFile.c_str(), false);
+    makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", mocCppFile.c_str(),
+                             false);
 
     target->AddSource(mocCppFile);
-    }
+  }
 }
 
 void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
-                                                 cmLocalGenerator* lg,
-                                                 cmGeneratorTarget* target)
+  cmLocalGenerator* lg, cmGeneratorTarget* target)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
 
   std::string qtMajorVersion = makefile->GetSafeDefinition("QT_VERSION_MAJOR");
-  if (qtMajorVersion == "")
-    {
+  if (qtMajorVersion == "") {
     qtMajorVersion = makefile->GetSafeDefinition("Qt5Core_VERSION_MAJOR");
-    }
+  }
 
   // create a custom target for running generators at buildtime:
   std::string autogenTargetName = GetAutogenTargetName(target);
@@ -836,48 +730,41 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
   cmCustomCommandLines commandLines;
   commandLines.push_back(currentLine);
 
-  std::string workingDirectory = cmSystemTools::CollapseFullPath(
-                                    "", makefile->GetCurrentBinaryDirectory());
+  std::string workingDirectory =
+    cmSystemTools::CollapseFullPath("", makefile->GetCurrentBinaryDirectory());
 
   std::vector<std::string> depends;
-  if (const char *autogenDepends =
-                                target->GetProperty("AUTOGEN_TARGET_DEPENDS"))
-    {
+  if (const char* autogenDepends =
+        target->GetProperty("AUTOGEN_TARGET_DEPENDS")) {
     cmSystemTools::ExpandListArgument(autogenDepends, depends);
-    }
+  }
   std::vector<std::string> toolNames;
-  if (target->GetPropertyAsBool("AUTOMOC"))
-    {
+  if (target->GetPropertyAsBool("AUTOMOC")) {
     toolNames.push_back("moc");
-    }
-  if (target->GetPropertyAsBool("AUTOUIC"))
-    {
+  }
+  if (target->GetPropertyAsBool("AUTOUIC")) {
     toolNames.push_back("uic");
-    }
-  if (target->GetPropertyAsBool("AUTORCC"))
-    {
+  }
+  if (target->GetPropertyAsBool("AUTORCC")) {
     toolNames.push_back("rcc");
-    }
+  }
 
   std::string tools = toolNames[0];
   toolNames.erase(toolNames.begin());
-  while (toolNames.size() > 1)
-    {
+  while (toolNames.size() > 1) {
     tools += ", " + toolNames[0];
     toolNames.erase(toolNames.begin());
-    }
-  if (toolNames.size() == 1)
-    {
+  }
+  if (toolNames.size() == 1) {
     tools += " and " + toolNames[0];
-    }
+  }
   std::string autogenComment = "Automatic " + tools + " for target ";
   autogenComment += target->GetName();
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
   bool usePRE_BUILD = false;
   cmGlobalGenerator* gg = lg->GetGlobalGenerator();
-  if(gg->GetName().find("Visual Studio") != std::string::npos)
-    {
+  if (gg->GetName().find("Visual Studio") != std::string::npos) {
     cmGlobalVisualStudioGenerator* vsgg =
       static_cast<cmGlobalVisualStudioGenerator*>(gg);
     // Under VS >= 7 use a PRE_BUILD event instead of a separate target to
@@ -885,85 +772,70 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
     // This also works around a VS 11 bug that may skip updating the target:
     //  https://connect.microsoft.com/VisualStudio/feedback/details/769495
     usePRE_BUILD = vsgg->GetVersion() >= cmGlobalVisualStudioGenerator::VS7;
-    if(usePRE_BUILD)
-      {
+    if (usePRE_BUILD) {
       for (std::vector<std::string>::iterator it = depends.begin();
-            it != depends.end(); ++it)
-        {
-        if(!makefile->FindTargetToUse(it->c_str()))
-          {
+           it != depends.end(); ++it) {
+        if (!makefile->FindTargetToUse(it->c_str())) {
           usePRE_BUILD = false;
           break;
-          }
         }
       }
     }
+  }
 #endif
 
   std::vector<std::string> rcc_output;
-  bool const isNinja =
-    lg->GetGlobalGenerator()->GetName() == "Ninja";
-  if(isNinja
+  bool const isNinja = lg->GetGlobalGenerator()->GetName() == "Ninja";
+  if (isNinja
 #if defined(_WIN32) && !defined(__CYGWIN__)
-        || usePRE_BUILD
+      || usePRE_BUILD
 #endif
-        )
-    {
+      ) {
     std::vector<cmSourceFile*> srcFiles;
     target->GetConfigCommonSourceFiles(srcFiles);
-    for(std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
-        fileIt != srcFiles.end();
-        ++fileIt)
-      {
+    for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
+         fileIt != srcFiles.end(); ++fileIt) {
       cmSourceFile* sf = *fileIt;
-      std::string absFile = cmsys::SystemTools::GetRealPath(
-                                                sf->GetFullPath());
+      std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
 
       std::string ext = sf->GetExtension();
 
-      if (target->GetPropertyAsBool("AUTORCC"))
-        {
-        if (ext == "qrc"
-            && !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC")))
-          {
+      if (target->GetPropertyAsBool("AUTORCC")) {
+        if (ext == "qrc" &&
+            !cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"))) {
 
           {
             std::string rcc_output_dir = GetAutogenTargetBuildDir(target);
-            rcc_output_dir += GetSourceRelativePath(target,absFile);
+            rcc_output_dir += GetSourceRelativePath(target, absFile);
             cmSystemTools::MakeDirectory(rcc_output_dir.c_str());
 
-            std::string basename = cmsys::SystemTools::
-                                    GetFilenameWithoutLastExtension(absFile);
+            std::string basename =
+              cmsys::SystemTools::GetFilenameWithoutLastExtension(absFile);
             std::string rcc_output_file = rcc_output_dir;
             rcc_output_file += "qrc_" + basename + ".cpp";
             rcc_output.push_back(rcc_output_file);
           }
 
-          if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED")))
-            {
-            if (qtMajorVersion == "5")
-              {
+          if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
+            if (qtMajorVersion == "5") {
               ListQt5RccInputs(sf, target, depends);
-              }
-            else
-              {
+            } else {
               ListQt4RccInputs(sf, depends);
-              }
+            }
 #if defined(_WIN32) && !defined(__CYGWIN__)
             // Cannot use PRE_BUILD because the resource files themselves
             // may not be sources within the target so VS may not know the
             // target needs to re-build at all.
             usePRE_BUILD = false;
 #endif
-            }
           }
         }
       }
     }
+  }
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  if(usePRE_BUILD)
-    {
+  if (usePRE_BUILD) {
     // Add the pre-build command directly to bypass the OBJECT_LIBRARY
     // rejection in cmMakefile::AddCustomCommandToTarget because we know
     // PRE_BUILD will work for an OBJECT_LIBRARY in this specific case.
@@ -975,43 +847,37 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
     cc.SetEscapeOldStyle(false);
     cc.SetEscapeAllowMakeVars(true);
     target->Target->AddPreBuildCommand(cc);
-    }
-  else
+  } else
 #endif
-    {
+  {
     cmTarget* autogenTarget = makefile->AddUtilityCommand(
-                                autogenTargetName, true,
-                                workingDirectory.c_str(),
-                                /*byproducts=*/rcc_output, depends,
-                                commandLines, false, autogenComment.c_str());
+      autogenTargetName, true, workingDirectory.c_str(),
+      /*byproducts=*/rcc_output, depends, commandLines, false,
+      autogenComment.c_str());
 
     cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
     lg->AddGeneratorTarget(gt);
 
     // Set target folder
-    const char* autogenFolder = makefile->GetState()
-                                ->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
-    if (!autogenFolder)
-      {
-      autogenFolder = makefile->GetState()
-                                ->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
-      }
-    if (autogenFolder && *autogenFolder)
-      {
+    const char* autogenFolder =
+      makefile->GetState()->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
+    if (!autogenFolder) {
+      autogenFolder =
+        makefile->GetState()->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
+    }
+    if (autogenFolder && *autogenFolder) {
       autogenTarget->SetProperty("FOLDER", autogenFolder);
-      }
-    else
-      {
+    } else {
       // inherit FOLDER property from target (#13688)
       copyTargetProperty(gt->Target, target->Target, "FOLDER");
-      }
+    }
 
     target->Target->AddUtility(autogenTargetName);
-    }
+  }
 }
 
 void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
-    cmGeneratorTarget const* target)
+  cmGeneratorTarget const* target)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
 
@@ -1022,27 +888,27 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   // create a custom target for running generators at buildtime:
   std::string autogenTargetName = GetAutogenTargetName(target);
 
-  makefile->AddDefinition("_moc_target_name",
-          cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
-  makefile->AddDefinition("_origin_target_name",
-          cmOutputConverter::EscapeForCMake(target->GetName()).c_str());
+  makefile->AddDefinition(
+    "_moc_target_name",
+    cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
+  makefile->AddDefinition(
+    "_origin_target_name",
+    cmOutputConverter::EscapeForCMake(target->GetName()).c_str());
 
   std::string targetDir = GetAutogenTargetDir(target);
 
-  const char *qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
-  if (!qtVersion)
-    {
+  const char* qtVersion = makefile->GetDefinition("Qt5Core_VERSION_MAJOR");
+  if (!qtVersion) {
     qtVersion = makefile->GetDefinition("QT_VERSION_MAJOR");
-    }
-  if (const char *targetQtVersion =
-      target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION", ""))
-    {
+  }
+  if (const char* targetQtVersion =
+        target->GetLinkInterfaceDependentStringProperty("QT_MAJOR_VERSION",
+                                                        "")) {
     qtVersion = targetQtVersion;
-    }
-  if (qtVersion)
-    {
+  }
+  if (qtVersion) {
     makefile->AddDefinition("_target_qt_version", qtVersion);
-    }
+  }
 
   std::vector<std::string> skipUic;
   std::vector<std::string> skipMoc;
@@ -1052,37 +918,34 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   std::map<std::string, std::string> configDefines;
   std::map<std::string, std::string> configUicOptions;
 
-  if (target->GetPropertyAsBool("AUTOMOC")
-      || target->GetPropertyAsBool("AUTOUIC")
-      || target->GetPropertyAsBool("AUTORCC"))
-    {
+  if (target->GetPropertyAsBool("AUTOMOC") ||
+      target->GetPropertyAsBool("AUTOUIC") ||
+      target->GetPropertyAsBool("AUTORCC")) {
     SetupSourceFiles(target, skipMoc, mocSources, mocHeaders, skipUic);
-    }
-  makefile->AddDefinition("_cpp_files",
-          cmOutputConverter::EscapeForCMake(cmJoin(mocSources, ";")).c_str());
-  if (target->GetPropertyAsBool("AUTOMOC"))
-    {
-    SetupAutoMocTarget(target, autogenTargetName,
-                             skipMoc, mocHeaders,
-                             configIncludes, configDefines);
-    }
-  if (target->GetPropertyAsBool("AUTOUIC"))
-    {
+  }
+  makefile->AddDefinition(
+    "_cpp_files",
+    cmOutputConverter::EscapeForCMake(cmJoin(mocSources, ";")).c_str());
+  if (target->GetPropertyAsBool("AUTOMOC")) {
+    SetupAutoMocTarget(target, autogenTargetName, skipMoc, mocHeaders,
+                       configIncludes, configDefines);
+  }
+  if (target->GetPropertyAsBool("AUTOUIC")) {
     SetupAutoUicTarget(target, skipUic, configUicOptions);
-    }
-  if (target->GetPropertyAsBool("AUTORCC"))
-    {
+  }
+  if (target->GetPropertyAsBool("AUTORCC")) {
     SetupAutoRccTarget(target);
-    }
+  }
 
   std::string inputFile = cmSystemTools::GetCMakeRoot();
   inputFile += "/Modules/AutogenInfo.cmake.in";
   std::string outputFile = targetDir;
   outputFile += "/AutogenInfo.cmake";
-  makefile->AddDefinition("_qt_rcc_inputs",
-              makefile->GetDefinition("_qt_rcc_inputs_" + target->GetName()));
-  makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(),
-                          false, true, false);
+  makefile->AddDefinition(
+    "_qt_rcc_inputs",
+    makefile->GetDefinition("_qt_rcc_inputs_" + target->GetName()));
+  makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(), false, true,
+                          false);
 
   // Ensure we have write permission in case .in was read-only.
   mode_t perm = 0;
@@ -1092,52 +955,45 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   mode_t mode_write = S_IWUSR;
 #endif
   cmSystemTools::GetPermissions(outputFile, perm);
-  if (!(perm & mode_write))
-    {
+  if (!(perm & mode_write)) {
     cmSystemTools::SetPermissions(outputFile, perm | mode_write);
-    }
-  if (!configDefines.empty()
-      || !configIncludes.empty()
-      || !configUicOptions.empty())
-    {
+  }
+  if (!configDefines.empty() || !configIncludes.empty() ||
+      !configUicOptions.empty()) {
     cmsys::ofstream infoFile(outputFile.c_str(), std::ios::app);
-    if ( !infoFile )
-      {
+    if (!infoFile) {
       std::string error = "Internal CMake error when trying to open file: ";
       error += outputFile.c_str();
       error += " for writing.";
       cmSystemTools::Error(error.c_str());
       return;
-      }
-    if (!configDefines.empty())
-      {
+    }
+    if (!configDefines.empty()) {
       for (std::map<std::string, std::string>::iterator
-            it = configDefines.begin(), end = configDefines.end();
-            it != end; ++it)
-        {
-        infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first <<
-          " " << it->second << ")\n";
-        }
+             it = configDefines.begin(),
+             end = configDefines.end();
+           it != end; ++it) {
+        infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
+                 << it->second << ")\n";
       }
-    if (!configIncludes.empty())
-      {
+    }
+    if (!configIncludes.empty()) {
       for (std::map<std::string, std::string>::iterator
-            it = configIncludes.begin(), end = configIncludes.end();
-            it != end; ++it)
-        {
-        infoFile << "set(AM_MOC_INCLUDES_" << it->first <<
-          " " << it->second << ")\n";
-        }
+             it = configIncludes.begin(),
+             end = configIncludes.end();
+           it != end; ++it) {
+        infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
+                 << ")\n";
       }
-    if (!configUicOptions.empty())
-      {
+    }
+    if (!configUicOptions.empty()) {
       for (std::map<std::string, std::string>::iterator
-            it = configUicOptions.begin(), end = configUicOptions.end();
-            it != end; ++it)
-        {
-        infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first <<
-          " " << it->second << ")\n";
-        }
+             it = configUicOptions.begin(),
+             end = configUicOptions.end();
+           it != end; ++it) {
+        infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
+                 << it->second << ")\n";
       }
     }
+  }
 }
diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx
index a55a3f3..cb1801f 100644
--- a/Source/cmQtAutoGenerators.cxx
+++ b/Source/cmQtAutoGenerators.cxx
@@ -31,140 +31,113 @@
 #include <unistd.h>
 #endif
 
-static bool requiresMocing(const std::string& text, std::string &macroName)
+static bool requiresMocing(const std::string& text, std::string& macroName)
 {
   // this simple check is much much faster than the regexp
-  if (strstr(text.c_str(), "Q_OBJECT") == NULL
-      && strstr(text.c_str(), "Q_GADGET") == NULL)
-    {
+  if (strstr(text.c_str(), "Q_OBJECT") == NULL &&
+      strstr(text.c_str(), "Q_GADGET") == NULL) {
     return false;
-    }
+  }
 
   cmsys::RegularExpression qObjectRegExp("[\n][ \t]*Q_OBJECT[^a-zA-Z0-9_]");
-  if (qObjectRegExp.find(text))
-    {
+  if (qObjectRegExp.find(text)) {
     macroName = "Q_OBJECT";
     return true;
-    }
+  }
   cmsys::RegularExpression qGadgetRegExp("[\n][ \t]*Q_GADGET[^a-zA-Z0-9_]");
-  if (qGadgetRegExp.find(text))
-    {
+  if (qGadgetRegExp.find(text)) {
     macroName = "Q_GADGET";
     return true;
-    }
+  }
   return false;
 }
 
-
-static std::string findMatchingHeader(const std::string& absPath,
-                                      const std::string& mocSubDir,
-                                      const std::string& basename,
-                              const std::vector<std::string>& headerExtensions)
+static std::string findMatchingHeader(
+  const std::string& absPath, const std::string& mocSubDir,
+  const std::string& basename,
+  const std::vector<std::string>& headerExtensions)
 {
   std::string header;
-  for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
-      ext != headerExtensions.end();
-      ++ext)
-    {
+  for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+       ext != headerExtensions.end(); ++ext) {
     std::string sourceFilePath = absPath + basename + "." + (*ext);
-    if (cmsys::SystemTools::FileExists(sourceFilePath.c_str()))
-      {
+    if (cmsys::SystemTools::FileExists(sourceFilePath.c_str())) {
       header = sourceFilePath;
       break;
-      }
-    if (!mocSubDir.empty())
-      {
+    }
+    if (!mocSubDir.empty()) {
       sourceFilePath = mocSubDir + basename + "." + (*ext);
-      if (cmsys::SystemTools::FileExists(sourceFilePath.c_str()))
-        {
+      if (cmsys::SystemTools::FileExists(sourceFilePath.c_str())) {
         header = sourceFilePath;
         break;
-        }
       }
     }
+  }
 
   return header;
 }
 
-
 static std::string extractSubDir(const std::string& absPath,
                                  const std::string& currentMoc)
 {
   std::string subDir;
-  if (currentMoc.find_first_of('/') != std::string::npos)
-    {
-    subDir = absPath
-                  + cmsys::SystemTools::GetFilenamePath(currentMoc) + '/';
-    }
+  if (currentMoc.find_first_of('/') != std::string::npos) {
+    subDir = absPath + cmsys::SystemTools::GetFilenamePath(currentMoc) + '/';
+  }
   return subDir;
 }
 
 cmQtAutoGenerators::cmQtAutoGenerators()
-:Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0)
-,ColorOutput(true)
-,RunMocFailed(false)
-,RunUicFailed(false)
-,RunRccFailed(false)
-,GenerateAll(false)
+  : Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0)
+  , ColorOutput(true)
+  , RunMocFailed(false)
+  , RunUicFailed(false)
+  , RunRccFailed(false)
+  , GenerateAll(false)
 {
 
   std::string colorEnv = "";
   cmsys::SystemTools::GetEnv("COLOR", colorEnv);
-  if(!colorEnv.empty())
-    {
-    if(cmSystemTools::IsOn(colorEnv.c_str()))
-      {
+  if (!colorEnv.empty()) {
+    if (cmSystemTools::IsOn(colorEnv.c_str())) {
       this->ColorOutput = true;
-      }
-    else
-      {
+    } else {
       this->ColorOutput = false;
-      }
     }
+  }
 }
 
-void cmQtAutoGenerators::MergeUicOptions(std::vector<std::string> &opts,
-                         const std::vector<std::string> &fileOpts,
-                         bool isQt5)
+void cmQtAutoGenerators::MergeUicOptions(
+  std::vector<std::string>& opts, const std::vector<std::string>& fileOpts,
+  bool isQt5)
 {
-  static const char* valueOptions[] = {
-    "tr",
-    "translate",
-    "postfix",
-    "generator",
-    "include", // Since Qt 5.3
-    "g"
-  };
+  static const char* valueOptions[] = { "tr",      "translate",
+                                        "postfix", "generator",
+                                        "include", // Since Qt 5.3
+                                        "g" };
   std::vector<std::string> extraOpts;
-  for(std::vector<std::string>::const_iterator it = fileOpts.begin();
-      it != fileOpts.end(); ++it)
-    {
-    std::vector<std::string>::iterator existingIt
-                                  = std::find(opts.begin(), opts.end(), *it);
-    if (existingIt != opts.end())
-      {
-      const char *o = it->c_str();
-      if (*o == '-')
-        {
+  for (std::vector<std::string>::const_iterator it = fileOpts.begin();
+       it != fileOpts.end(); ++it) {
+    std::vector<std::string>::iterator existingIt =
+      std::find(opts.begin(), opts.end(), *it);
+    if (existingIt != opts.end()) {
+      const char* o = it->c_str();
+      if (*o == '-') {
         ++o;
-        }
-      if (isQt5 && *o == '-')
-        {
+      }
+      if (isQt5 && *o == '-') {
         ++o;
-        }
+      }
       if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
-                  cmStrCmp(*it)) != cmArrayEnd(valueOptions))
-        {
+                       cmStrCmp(*it)) != cmArrayEnd(valueOptions)) {
         assert(existingIt + 1 != opts.end());
         *(existingIt + 1) = *(it + 1);
         ++it;
-        }
       }
-    else
-      {
+    } else {
       extraOpts.push_back(*it);
-      }
     }
+  }
   opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
 }
 
@@ -190,160 +163,144 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory,
 
   this->Init();
 
-  if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5")
-    {
+  if (this->QtMajorVersion == "4" || this->QtMajorVersion == "5") {
     success = this->RunAutogen(mf.get());
-    }
+  }
 
   this->WriteOldMocDefinitionsFile(targetDirectory);
 
   return success;
 }
 
-bool cmQtAutoGenerators::ReadAutogenInfoFile(cmMakefile* makefile,
-                                      const std::string& targetDirectory,
-                                      const std::string& config)
+bool cmQtAutoGenerators::ReadAutogenInfoFile(
+  cmMakefile* makefile, const std::string& targetDirectory,
+  const std::string& config)
 {
-  std::string filename(
-      cmSystemTools::CollapseFullPath(targetDirectory));
+  std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
   filename += "/AutogenInfo.cmake";
 
-  if (!makefile->ReadListFile(filename.c_str()))
-    {
+  if (!makefile->ReadListFile(filename.c_str())) {
     cmSystemTools::Error("Error processing file: ", filename.c_str());
     return false;
-    }
+  }
 
   this->QtMajorVersion = makefile->GetSafeDefinition("AM_QT_VERSION_MAJOR");
-  if (this->QtMajorVersion == "")
-    {
-    this->QtMajorVersion = makefile->GetSafeDefinition(
-                                     "AM_Qt5Core_VERSION_MAJOR");
-    }
+  if (this->QtMajorVersion == "") {
+    this->QtMajorVersion =
+      makefile->GetSafeDefinition("AM_Qt5Core_VERSION_MAJOR");
+  }
   this->Sources = makefile->GetSafeDefinition("AM_SOURCES");
   {
-  std::string rccSources = makefile->GetSafeDefinition("AM_RCC_SOURCES");
-  cmSystemTools::ExpandListArgument(rccSources, this->RccSources);
+    std::string rccSources = makefile->GetSafeDefinition("AM_RCC_SOURCES");
+    cmSystemTools::ExpandListArgument(rccSources, this->RccSources);
   }
   this->SkipMoc = makefile->GetSafeDefinition("AM_SKIP_MOC");
   this->SkipUic = makefile->GetSafeDefinition("AM_SKIP_UIC");
   this->Headers = makefile->GetSafeDefinition("AM_HEADERS");
-  this->IncludeProjectDirsBefore = makefile->IsOn(
-                                "AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
+  this->IncludeProjectDirsBefore =
+    makefile->IsOn("AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE");
   this->Srcdir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_SOURCE_DIR");
   this->Builddir = makefile->GetSafeDefinition("AM_CMAKE_CURRENT_BINARY_DIR");
   this->MocExecutable = makefile->GetSafeDefinition("AM_QT_MOC_EXECUTABLE");
   this->UicExecutable = makefile->GetSafeDefinition("AM_QT_UIC_EXECUTABLE");
   this->RccExecutable = makefile->GetSafeDefinition("AM_QT_RCC_EXECUTABLE");
   {
-  std::string compileDefsPropOrig = "AM_MOC_COMPILE_DEFINITIONS";
-  std::string compileDefsProp = compileDefsPropOrig;
-  if(!config.empty())
-    {
-    compileDefsProp += "_";
-    compileDefsProp += config;
-    }
-  const char *compileDefs = makefile->GetDefinition(compileDefsProp);
-  this->MocCompileDefinitionsStr = compileDefs ? compileDefs
-                  : makefile->GetSafeDefinition(compileDefsPropOrig);
+    std::string compileDefsPropOrig = "AM_MOC_COMPILE_DEFINITIONS";
+    std::string compileDefsProp = compileDefsPropOrig;
+    if (!config.empty()) {
+      compileDefsProp += "_";
+      compileDefsProp += config;
+    }
+    const char* compileDefs = makefile->GetDefinition(compileDefsProp);
+    this->MocCompileDefinitionsStr = compileDefs
+      ? compileDefs
+      : makefile->GetSafeDefinition(compileDefsPropOrig);
   }
   {
-  std::string includesPropOrig = "AM_MOC_INCLUDES";
-  std::string includesProp = includesPropOrig;
-  if(!config.empty())
-    {
-    includesProp += "_";
-    includesProp += config;
-    }
-  const char *includes = makefile->GetDefinition(includesProp);
-  this->MocIncludesStr = includes ? includes
-                      : makefile->GetSafeDefinition(includesPropOrig);
+    std::string includesPropOrig = "AM_MOC_INCLUDES";
+    std::string includesProp = includesPropOrig;
+    if (!config.empty()) {
+      includesProp += "_";
+      includesProp += config;
+    }
+    const char* includes = makefile->GetDefinition(includesProp);
+    this->MocIncludesStr =
+      includes ? includes : makefile->GetSafeDefinition(includesPropOrig);
   }
   this->MocOptionsStr = makefile->GetSafeDefinition("AM_MOC_OPTIONS");
   this->ProjectBinaryDir = makefile->GetSafeDefinition("AM_CMAKE_BINARY_DIR");
   this->ProjectSourceDir = makefile->GetSafeDefinition("AM_CMAKE_SOURCE_DIR");
   this->TargetName = makefile->GetSafeDefinition("AM_TARGET_NAME");
-  this->OriginTargetName
-                      = makefile->GetSafeDefinition("AM_ORIGIN_TARGET_NAME");
+  this->OriginTargetName =
+    makefile->GetSafeDefinition("AM_ORIGIN_TARGET_NAME");
 
   {
-  const char *uicOptionsFiles
-                        = makefile->GetSafeDefinition("AM_UIC_OPTIONS_FILES");
-  std::string uicOptionsPropOrig = "AM_UIC_TARGET_OPTIONS";
-  std::string uicOptionsProp = uicOptionsPropOrig;
-  if(!config.empty())
-    {
-    uicOptionsProp += "_";
-    uicOptionsProp += config;
-    }
-  const char *uicTargetOptions
-                        = makefile->GetSafeDefinition(uicOptionsProp);
-  cmSystemTools::ExpandListArgument(
+    const char* uicOptionsFiles =
+      makefile->GetSafeDefinition("AM_UIC_OPTIONS_FILES");
+    std::string uicOptionsPropOrig = "AM_UIC_TARGET_OPTIONS";
+    std::string uicOptionsProp = uicOptionsPropOrig;
+    if (!config.empty()) {
+      uicOptionsProp += "_";
+      uicOptionsProp += config;
+    }
+    const char* uicTargetOptions = makefile->GetSafeDefinition(uicOptionsProp);
+    cmSystemTools::ExpandListArgument(
       uicTargetOptions ? uicTargetOptions
-                    : makefile->GetSafeDefinition(uicOptionsPropOrig),
-    this->UicTargetOptions);
-  const char *uicOptionsOptions
-                      = makefile->GetSafeDefinition("AM_UIC_OPTIONS_OPTIONS");
-  std::vector<std::string> uicFilesVec;
-  cmSystemTools::ExpandListArgument(uicOptionsFiles, uicFilesVec);
-  std::vector<std::string> uicOptionsVec;
-  cmSystemTools::ExpandListArgument(uicOptionsOptions, uicOptionsVec);
-  if (uicFilesVec.size() != uicOptionsVec.size())
-    {
-    return false;
+                       : makefile->GetSafeDefinition(uicOptionsPropOrig),
+      this->UicTargetOptions);
+    const char* uicOptionsOptions =
+      makefile->GetSafeDefinition("AM_UIC_OPTIONS_OPTIONS");
+    std::vector<std::string> uicFilesVec;
+    cmSystemTools::ExpandListArgument(uicOptionsFiles, uicFilesVec);
+    std::vector<std::string> uicOptionsVec;
+    cmSystemTools::ExpandListArgument(uicOptionsOptions, uicOptionsVec);
+    if (uicFilesVec.size() != uicOptionsVec.size()) {
+      return false;
     }
-  for (std::vector<std::string>::iterator fileIt = uicFilesVec.begin(),
+    for (std::vector<std::string>::iterator fileIt = uicFilesVec.begin(),
                                             optionIt = uicOptionsVec.begin();
-                                            fileIt != uicFilesVec.end();
-                                            ++fileIt, ++optionIt)
-    {
-    cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
-    this->UicOptions[*fileIt] = *optionIt;
+         fileIt != uicFilesVec.end(); ++fileIt, ++optionIt) {
+      cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
+      this->UicOptions[*fileIt] = *optionIt;
     }
   }
   {
-  const char *rccOptionsFiles
-                        = makefile->GetSafeDefinition("AM_RCC_OPTIONS_FILES");
-  const char *rccOptionsOptions
-                      = makefile->GetSafeDefinition("AM_RCC_OPTIONS_OPTIONS");
-  std::vector<std::string> rccFilesVec;
-  cmSystemTools::ExpandListArgument(rccOptionsFiles, rccFilesVec);
-  std::vector<std::string> rccOptionsVec;
-  cmSystemTools::ExpandListArgument(rccOptionsOptions, rccOptionsVec);
-  if (rccFilesVec.size() != rccOptionsVec.size())
-    {
-    return false;
+    const char* rccOptionsFiles =
+      makefile->GetSafeDefinition("AM_RCC_OPTIONS_FILES");
+    const char* rccOptionsOptions =
+      makefile->GetSafeDefinition("AM_RCC_OPTIONS_OPTIONS");
+    std::vector<std::string> rccFilesVec;
+    cmSystemTools::ExpandListArgument(rccOptionsFiles, rccFilesVec);
+    std::vector<std::string> rccOptionsVec;
+    cmSystemTools::ExpandListArgument(rccOptionsOptions, rccOptionsVec);
+    if (rccFilesVec.size() != rccOptionsVec.size()) {
+      return false;
     }
-  for (std::vector<std::string>::iterator fileIt = rccFilesVec.begin(),
+    for (std::vector<std::string>::iterator fileIt = rccFilesVec.begin(),
                                             optionIt = rccOptionsVec.begin();
-                                            fileIt != rccFilesVec.end();
-                                            ++fileIt, ++optionIt)
-    {
-    cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
-    this->RccOptions[*fileIt] = *optionIt;
+         fileIt != rccFilesVec.end(); ++fileIt, ++optionIt) {
+      cmSystemTools::ReplaceString(*optionIt, "@list_sep@", ";");
+      this->RccOptions[*fileIt] = *optionIt;
     }
 
-  const char *rccInputs = makefile->GetSafeDefinition("AM_RCC_INPUTS");
-  std::vector<std::string> rccInputLists;
-  cmSystemTools::ExpandListArgument(rccInputs, rccInputLists);
+    const char* rccInputs = makefile->GetSafeDefinition("AM_RCC_INPUTS");
+    std::vector<std::string> rccInputLists;
+    cmSystemTools::ExpandListArgument(rccInputs, rccInputLists);
 
-  if (this->RccSources.size() != rccInputLists.size())
-    {
-    cmSystemTools::Error("Error processing file: ", filename.c_str());
-    return false;
+    if (this->RccSources.size() != rccInputLists.size()) {
+      cmSystemTools::Error("Error processing file: ", filename.c_str());
+      return false;
     }
 
-  for (std::vector<std::string>::iterator fileIt = this->RccSources.begin(),
+    for (std::vector<std::string>::iterator fileIt = this->RccSources.begin(),
                                             inputIt = rccInputLists.begin();
-                                            fileIt != this->RccSources.end();
-                                            ++fileIt, ++inputIt)
-    {
-    cmSystemTools::ReplaceString(*inputIt, "@list_sep@", ";");
-    std::vector<std::string> rccInputFiles;
-    cmSystemTools::ExpandListArgument(*inputIt, rccInputFiles);
+         fileIt != this->RccSources.end(); ++fileIt, ++inputIt) {
+      cmSystemTools::ReplaceString(*inputIt, "@list_sep@", ";");
+      std::vector<std::string> rccInputFiles;
+      cmSystemTools::ExpandListArgument(*inputIt, rccInputFiles);
 
-    this->RccInputs[*fileIt] = rccInputFiles;
+      this->RccInputs[*fileIt] = rccInputFiles;
     }
   }
   this->CurrentCompileSettingsStr = this->MakeCompileSettingsString(makefile);
@@ -353,7 +310,6 @@ bool cmQtAutoGenerators::ReadAutogenInfoFile(cmMakefile* makefile,
   return true;
 }
 
-
 std::string cmQtAutoGenerators::MakeCompileSettingsString(cmMakefile* makefile)
 {
   std::string s;
@@ -370,44 +326,36 @@ std::string cmQtAutoGenerators::MakeCompileSettingsString(cmMakefile* makefile)
   return s;
 }
 
-
-bool cmQtAutoGenerators::ReadOldMocDefinitionsFile(cmMakefile* makefile,
-                                            const std::string& targetDirectory)
+bool cmQtAutoGenerators::ReadOldMocDefinitionsFile(
+  cmMakefile* makefile, const std::string& targetDirectory)
 {
-  std::string filename(
-      cmSystemTools::CollapseFullPath(targetDirectory));
+  std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
   filename += "/AutomocOldMocDefinitions.cmake";
 
-  if (makefile->ReadListFile(filename.c_str()))
-    {
+  if (makefile->ReadListFile(filename.c_str())) {
     this->OldCompileSettingsStr =
-                        makefile->GetSafeDefinition("AM_OLD_COMPILE_SETTINGS");
-    }
+      makefile->GetSafeDefinition("AM_OLD_COMPILE_SETTINGS");
+  }
   return true;
 }
 
-
-void
-cmQtAutoGenerators::WriteOldMocDefinitionsFile(
-                                            const std::string& targetDirectory)
+void cmQtAutoGenerators::WriteOldMocDefinitionsFile(
+  const std::string& targetDirectory)
 {
-  std::string filename(
-      cmSystemTools::CollapseFullPath(targetDirectory));
+  std::string filename(cmSystemTools::CollapseFullPath(targetDirectory));
   cmSystemTools::ConvertToUnixSlashes(filename);
   filename += "/AutomocOldMocDefinitions.cmake";
 
   cmsys::ofstream outfile;
-  outfile.open(filename.c_str(),
-               std::ios::trunc);
+  outfile.open(filename.c_str(), std::ios::trunc);
   outfile << "set(AM_OLD_COMPILE_SETTINGS "
-              << cmOutputConverter::EscapeForCMake(
-                 this->CurrentCompileSettingsStr) << ")\n";
+          << cmOutputConverter::EscapeForCMake(this->CurrentCompileSettingsStr)
+          << ")\n";
 
   outfile.close();
 }
 
-
 void cmQtAutoGenerators::Init()
 {
   this->TargetBuildSubDir = this->TargetName;
@@ -419,12 +367,10 @@ void cmQtAutoGenerators::Init()
 
   std::vector<std::string> cdefList;
   cmSystemTools::ExpandListArgument(this->MocCompileDefinitionsStr, cdefList);
-  for(std::vector<std::string>::const_iterator it = cdefList.begin();
-      it != cdefList.end();
-      ++it)
-    {
+  for (std::vector<std::string>::const_iterator it = cdefList.begin();
+       it != cdefList.end(); ++it) {
     this->MocDefinitions.push_back("-D" + (*it));
-    }
+  }
 
   cmSystemTools::ExpandListArgument(this->MocOptionsStr, this->MocOptions);
 
@@ -432,69 +378,55 @@ void cmQtAutoGenerators::Init()
   cmSystemTools::ExpandListArgument(this->MocIncludesStr, incPaths);
 
   std::set<std::string> frameworkPaths;
-  for(std::vector<std::string>::const_iterator it = incPaths.begin();
-      it != incPaths.end();
-      ++it)
-    {
-    const std::string &path = *it;
+  for (std::vector<std::string>::const_iterator it = incPaths.begin();
+       it != incPaths.end(); ++it) {
+    const std::string& path = *it;
     this->MocIncludes.push_back("-I" + path);
-    if (cmHasLiteralSuffix(path, ".framework/Headers"))
-      {
+    if (cmHasLiteralSuffix(path, ".framework/Headers")) {
       // Go up twice to get to the framework root
       std::vector<std::string> pathComponents;
       cmsys::SystemTools::SplitPath(path, pathComponents);
-      std::string frameworkPath =cmsys::SystemTools::JoinPath(
-                             pathComponents.begin(), pathComponents.end() - 2);
+      std::string frameworkPath = cmsys::SystemTools::JoinPath(
+        pathComponents.begin(), pathComponents.end() - 2);
       frameworkPaths.insert(frameworkPath);
-      }
     }
+  }
 
   for (std::set<std::string>::const_iterator it = frameworkPaths.begin();
-         it != frameworkPaths.end(); ++it)
-    {
+       it != frameworkPaths.end(); ++it) {
     this->MocIncludes.push_back("-F");
     this->MocIncludes.push_back(*it);
-    }
-
+  }
 
-    if (this->IncludeProjectDirsBefore)
-      {
-      const std::string binDir = "-I" + this->ProjectBinaryDir;
+  if (this->IncludeProjectDirsBefore) {
+    const std::string binDir = "-I" + this->ProjectBinaryDir;
 
-      const std::string srcDir = "-I" + this->ProjectSourceDir;
+    const std::string srcDir = "-I" + this->ProjectSourceDir;
 
-      std::list<std::string> sortedMocIncludes;
-      std::list<std::string>::iterator it = this->MocIncludes.begin();
-      while (it != this->MocIncludes.end())
-        {
-        if (cmsys::SystemTools::StringStartsWith(*it, binDir.c_str()))
-          {
-          sortedMocIncludes.push_back(*it);
-          it = this->MocIncludes.erase(it);
-          }
-        else
-          {
-          ++it;
-          }
-        }
-      it = this->MocIncludes.begin();
-      while (it != this->MocIncludes.end())
-        {
-        if (cmsys::SystemTools::StringStartsWith(*it, srcDir.c_str()))
-          {
-          sortedMocIncludes.push_back(*it);
-          it = this->MocIncludes.erase(it);
-          }
-        else
-          {
-          ++it;
-          }
-        }
-      sortedMocIncludes.insert(sortedMocIncludes.end(),
-                           this->MocIncludes.begin(), this->MocIncludes.end());
-      this->MocIncludes = sortedMocIncludes;
+    std::list<std::string> sortedMocIncludes;
+    std::list<std::string>::iterator it = this->MocIncludes.begin();
+    while (it != this->MocIncludes.end()) {
+      if (cmsys::SystemTools::StringStartsWith(*it, binDir.c_str())) {
+        sortedMocIncludes.push_back(*it);
+        it = this->MocIncludes.erase(it);
+      } else {
+        ++it;
+      }
     }
-
+    it = this->MocIncludes.begin();
+    while (it != this->MocIncludes.end()) {
+      if (cmsys::SystemTools::StringStartsWith(*it, srcDir.c_str())) {
+        sortedMocIncludes.push_back(*it);
+        it = this->MocIncludes.erase(it);
+      } else {
+        ++it;
+      }
+    }
+    sortedMocIncludes.insert(sortedMocIncludes.end(),
+                             this->MocIncludes.begin(),
+                             this->MocIncludes.end());
+    this->MocIncludes = sortedMocIncludes;
+  }
 }
 
 static std::string ReadAll(const std::string& filename)
@@ -508,11 +440,10 @@ static std::string ReadAll(const std::string& filename)
 
 bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
 {
-  if (!cmsys::SystemTools::FileExists(this->OutMocCppFilenameAbs.c_str())
-    || (this->OldCompileSettingsStr != this->CurrentCompileSettingsStr))
-    {
+  if (!cmsys::SystemTools::FileExists(this->OutMocCppFilenameAbs.c_str()) ||
+      (this->OldCompileSettingsStr != this->CurrentCompileSettingsStr)) {
     this->GenerateAll = true;
-    }
+  }
 
   // the program goes through all .cpp files to see which moc files are
   // included. It is not really interesting how the moc file is named, but
@@ -531,7 +462,7 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
   cmSystemTools::ExpandListArgument(this->Sources, sourceFiles);
 
   const std::vector<std::string>& headerExtensions =
-      makefile->GetCMakeInstance()->GetHeaderExtensions();
+    makefile->GetCMakeInstance()->GetHeaderExtensions();
 
   std::map<std::string, std::vector<std::string> > includedUis;
   std::map<std::string, std::vector<std::string> > skippedUis;
@@ -539,51 +470,40 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
   cmSystemTools::ExpandListArgument(this->SkipUic, uicSkipped);
 
   for (std::vector<std::string>::const_iterator it = sourceFiles.begin();
-       it != sourceFiles.end();
-       ++it)
-    {
-    const bool skipUic = std::find(uicSkipped.begin(), uicSkipped.end(), *it)
-        != uicSkipped.end();
-    std::map<std::string, std::vector<std::string> >& uiFiles
-                                          = skipUic ? skippedUis : includedUis;
-    const std::string &absFilename = *it;
-    if (this->Verbose)
-      {
+       it != sourceFiles.end(); ++it) {
+    const bool skipUic =
+      std::find(uicSkipped.begin(), uicSkipped.end(), *it) != uicSkipped.end();
+    std::map<std::string, std::vector<std::string> >& uiFiles =
+      skipUic ? skippedUis : includedUis;
+    const std::string& absFilename = *it;
+    if (this->Verbose) {
       std::stringstream err;
       err << "AUTOGEN: Checking " << absFilename << std::endl;
       this->LogInfo(err.str());
-      }
-    if (this->RelaxedMode)
-      {
-      this->ParseCppFile(absFilename, headerExtensions, includedMocs,
-                         uiFiles);
-      }
-    else
-      {
+    }
+    if (this->RelaxedMode) {
+      this->ParseCppFile(absFilename, headerExtensions, includedMocs, uiFiles);
+    } else {
       this->StrictParseCppFile(absFilename, headerExtensions, includedMocs,
                                uiFiles);
-      }
-    this->SearchHeadersForCppFile(absFilename, headerExtensions, headerFiles);
     }
+    this->SearchHeadersForCppFile(absFilename, headerExtensions, headerFiles);
+  }
 
   {
-  std::vector<std::string> mocSkipped;
-  cmSystemTools::ExpandListArgument(this->SkipMoc, mocSkipped);
-  for (std::vector<std::string>::const_iterator it = mocSkipped.begin();
-       it != mocSkipped.end();
-       ++it)
-    {
-    if (std::find(uicSkipped.begin(), uicSkipped.end(), *it)
-        != uicSkipped.end())
-      {
-      const std::string &absFilename = *it;
-      if (this->Verbose)
-        {
-        std::stringstream err;
-        err << "AUTOGEN: Checking " << absFilename << std::endl;
-        this->LogInfo(err.str());
+    std::vector<std::string> mocSkipped;
+    cmSystemTools::ExpandListArgument(this->SkipMoc, mocSkipped);
+    for (std::vector<std::string>::const_iterator it = mocSkipped.begin();
+         it != mocSkipped.end(); ++it) {
+      if (std::find(uicSkipped.begin(), uicSkipped.end(), *it) !=
+          uicSkipped.end()) {
+        const std::string& absFilename = *it;
+        if (this->Verbose) {
+          std::stringstream err;
+          err << "AUTOGEN: Checking " << absFilename << std::endl;
+          this->LogInfo(err.str());
         }
-      this->ParseForUic(absFilename, includedUis);
+        this->ParseForUic(absFilename, includedUis);
       }
     }
   }
@@ -596,70 +516,66 @@ bool cmQtAutoGenerators::RunAutogen(cmMakefile* makefile)
   std::map<std::string, std::string> notIncludedMocs;
   this->ParseHeaders(headerFiles, includedMocs, notIncludedMocs, includedUis);
 
-  if(!this->MocExecutable.empty())
-    {
-    this->GenerateMocFiles ( includedMocs, notIncludedMocs );
-    }
-  if(!this->UicExecutable.empty())
-    {
-    this->GenerateUiFiles ( includedUis );
-    }
-  if(!this->RccExecutable.empty())
-    {
+  if (!this->MocExecutable.empty()) {
+    this->GenerateMocFiles(includedMocs, notIncludedMocs);
+  }
+  if (!this->UicExecutable.empty()) {
+    this->GenerateUiFiles(includedUis);
+  }
+  if (!this->RccExecutable.empty()) {
     this->GenerateQrcFiles();
-    }
+  }
 
-  if (this->RunMocFailed)
-    {
-    std::stringstream err; err << "moc failed..." << std::endl;
+  if (this->RunMocFailed) {
+    std::stringstream err;
+    err << "moc failed..." << std::endl;
     this->LogError(err.str());
     return false;
-    }
-  if (this->RunUicFailed)
-    {
-    std::stringstream err; err << "uic failed..." << std::endl;
+  }
+  if (this->RunUicFailed) {
+    std::stringstream err;
+    err << "uic failed..." << std::endl;
     this->LogError(err.str());
     return false;
-    }
-  if (this->RunRccFailed)
-    {
-    std::stringstream err; err << "rcc failed..." << std::endl;
+  }
+  if (this->RunRccFailed) {
+    std::stringstream err;
+    err << "rcc failed..." << std::endl;
     this->LogError(err.str());
     return false;
-    }
+  }
 
   return true;
 }
 
-
-void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
-                const std::vector<std::string>& headerExtensions,
-                std::map<std::string, std::string>& includedMocs,
-                std::map<std::string, std::vector<std::string> > &includedUis)
+void cmQtAutoGenerators::ParseCppFile(
+  const std::string& absFilename,
+  const std::vector<std::string>& headerExtensions,
+  std::map<std::string, std::string>& includedMocs,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
   cmsys::RegularExpression mocIncludeRegExp(
-              "[\n][ \t]*#[ \t]*include[ \t]+"
-              "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
+    "[\n][ \t]*#[ \t]*include[ \t]+"
+    "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
 
   const std::string contentsString = ReadAll(absFilename);
-  if (contentsString.empty())
-    {
+  if (contentsString.empty()) {
     std::stringstream err;
     err << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
         << std::endl;
     this->LogError(err.str());
     return;
-    }
+  }
   this->ParseForUic(absFilename, contentsString, includedUis);
-  if (this->MocExecutable.empty())
-    {
+  if (this->MocExecutable.empty()) {
     return;
-    }
+  }
 
   const std::string absPath = cmsys::SystemTools::GetFilenamePath(
-                   cmsys::SystemTools::GetRealPath(absFilename)) + '/';
-  const std::string scannedFileBasename = cmsys::SystemTools::
-                                  GetFilenameWithoutLastExtension(absFilename);
+                                cmsys::SystemTools::GetRealPath(absFilename)) +
+    '/';
+  const std::string scannedFileBasename =
+    cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
   std::string macroName;
   const bool requiresMoc = requiresMocing(contentsString, macroName);
   bool dotMocIncluded = false;
@@ -672,16 +588,14 @@ void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
   // first a simple string check for "moc" is *much* faster than the regexp,
   // and if the string search already fails, we don't have to try the
   // expensive regexp
-  if ((strstr(contentsString.c_str(), "moc") != NULL)
-                                    && (mocIncludeRegExp.find(contentsString)))
-    {
+  if ((strstr(contentsString.c_str(), "moc") != NULL) &&
+      (mocIncludeRegExp.find(contentsString))) {
     // for every moc include in the file
-    do
-      {
+    do {
       const std::string currentMoc = mocIncludeRegExp.match(1);
 
-      std::string basename = cmsys::SystemTools::
-                                   GetFilenameWithoutLastExtension(currentMoc);
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(currentMoc);
       const bool moc_style = cmHasLiteralPrefix(basename, "moc_");
 
       // If the moc include is of the moc_foo.cpp style we expect
@@ -690,178 +604,160 @@ void cmQtAutoGenerators::ParseCppFile(const std::string& absFilename,
       // a Q_OBJECT macro in the current source file, if it contains the
       // macro we generate the moc file from the source file.
       // Q_OBJECT
-      if (moc_style)
-        {
+      if (moc_style) {
         // basename should be the part of the moc filename used for
         // finding the correct header, so we need to remove the moc_ part
         basename = basename.substr(4);
         std::string mocSubDir = extractSubDir(absPath, currentMoc);
-        std::string headerToMoc = findMatchingHeader(
-                               absPath, mocSubDir, basename, headerExtensions);
+        std::string headerToMoc =
+          findMatchingHeader(absPath, mocSubDir, basename, headerExtensions);
 
-        if (!headerToMoc.empty())
-          {
+        if (!headerToMoc.empty()) {
           includedMocs[headerToMoc] = currentMoc;
-          if (basename == scannedFileBasename)
-            {
+          if (basename == scannedFileBasename) {
             mocUnderscoreIncluded = true;
             ownMocUnderscoreFile = currentMoc;
             ownMocHeaderFile = headerToMoc;
-            }
           }
-        else
-          {
+        } else {
           std::stringstream err;
           err << "AUTOGEN: error: " << absFilename << ": The file "
               << "includes the moc file \"" << currentMoc << "\", "
-              << "but could not find header \"" << basename
-              << '{' << this->JoinExts(headerExtensions) << "}\" ";
-          if (mocSubDir.empty())
-            {
+              << "but could not find header \"" << basename << '{'
+              << this->JoinExts(headerExtensions) << "}\" ";
+          if (mocSubDir.empty()) {
             err << "in " << absPath << "\n" << std::endl;
-            }
-          else
-            {
-            err << "neither in " << absPath
-                << " nor in " << mocSubDir << "\n" << std::endl;
-            }
+          } else {
+            err << "neither in " << absPath << " nor in " << mocSubDir << "\n"
+                << std::endl;
+          }
           this->LogError(err.str());
           ::exit(EXIT_FAILURE);
-          }
         }
-      else
-        {
+      } else {
         std::string fileToMoc = absFilename;
-        if ((basename != scannedFileBasename) || (requiresMoc==false))
-          {
+        if ((basename != scannedFileBasename) || (requiresMoc == false)) {
           std::string mocSubDir = extractSubDir(absPath, currentMoc);
-          std::string headerToMoc = findMatchingHeader(
-                              absPath, mocSubDir, basename, headerExtensions);
-          if (!headerToMoc.empty())
-            {
+          std::string headerToMoc =
+            findMatchingHeader(absPath, mocSubDir, basename, headerExtensions);
+          if (!headerToMoc.empty()) {
             // this is for KDE4 compatibility:
             fileToMoc = headerToMoc;
-            if ((requiresMoc==false) &&(basename==scannedFileBasename))
-              {
+            if ((requiresMoc == false) && (basename == scannedFileBasename)) {
               std::stringstream err;
-              err << "AUTOGEN: warning: " << absFilename << ": The file "
-                     "includes the moc file \"" << currentMoc <<
-                     "\", but does not contain a " << macroName
+              err << "AUTOGEN: warning: " << absFilename
+                  << ": The file "
+                     "includes the moc file \""
+                  << currentMoc << "\", but does not contain a " << macroName
                   << " macro. Running moc on "
-                  << "\"" << headerToMoc << "\" ! Include \"moc_"
-                  << basename << ".cpp\" for a compatibility with "
+                  << "\"" << headerToMoc << "\" ! Include \"moc_" << basename
+                  << ".cpp\" for a compatibility with "
                      "strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
                   << std::endl;
               this->LogError(err.str());
-              }
-            else
-              {
+            } else {
               std::stringstream err;
-              err << "AUTOGEN: warning: " << absFilename << ": The file "
-                     "includes the moc file \"" << currentMoc <<
-                     "\" instead of \"moc_" << basename << ".cpp\". "
+              err << "AUTOGEN: warning: " << absFilename
+                  << ": The file "
+                     "includes the moc file \""
+                  << currentMoc << "\" instead of \"moc_" << basename
+                  << ".cpp\". "
                      "Running moc on "
-                  << "\"" << headerToMoc << "\" ! Include \"moc_"
-                  << basename << ".cpp\" for compatibility with "
+                  << "\"" << headerToMoc << "\" ! Include \"moc_" << basename
+                  << ".cpp\" for compatibility with "
                      "strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
                   << std::endl;
               this->LogError(err.str());
-              }
             }
-          else
-            {
+          } else {
             std::stringstream err;
-            err << "AUTOGEN: error: " << absFilename << ": The file "
-                   "includes the moc file \"" << currentMoc <<
-                   "\", which seems to be the moc file from a different "
+            err << "AUTOGEN: error: " << absFilename
+                << ": The file "
+                   "includes the moc file \""
+                << currentMoc
+                << "\", which seems to be the moc file from a different "
                    "source file. CMake also could not find a matching "
-                   "header.\n" << std::endl;
+                   "header.\n"
+                << std::endl;
             this->LogError(err.str());
             ::exit(EXIT_FAILURE);
-            }
           }
-        else
-          {
+        } else {
           dotMocIncluded = true;
           ownDotMocFile = currentMoc;
-          }
-        includedMocs[fileToMoc] = currentMoc;
         }
+        includedMocs[fileToMoc] = currentMoc;
+      }
       matchOffset += mocIncludeRegExp.end();
-      } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
-    }
+    } while (mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
+  }
 
   // In this case, check whether the scanned file itself contains a Q_OBJECT.
   // If this is the case, the moc_foo.cpp should probably be generated from
   // foo.cpp instead of foo.h, because otherwise it won't build.
   // But warn, since this is not how it is supposed to be used.
-  if ((dotMocIncluded == false) && (requiresMoc == true))
-    {
-    if (mocUnderscoreIncluded == true)
-      {
+  if ((dotMocIncluded == false) && (requiresMoc == true)) {
+    if (mocUnderscoreIncluded == true) {
       // this is for KDE4 compatibility:
       std::stringstream err;
       err << "AUTOGEN: warning: " << absFilename << ": The file "
           << "contains a " << macroName << " macro, but does not "
-             "include "
+                                           "include "
           << "\"" << scannedFileBasename << ".moc\", but instead "
-             "includes "
-          << "\"" << ownMocUnderscoreFile  << "\". Running moc on "
+                                            "includes "
+          << "\"" << ownMocUnderscoreFile << "\". Running moc on "
           << "\"" << absFilename << "\" ! Better include \""
-          << scannedFileBasename << ".moc\" for compatibility with "
+          << scannedFileBasename
+          << ".moc\" for compatibility with "
              "strict mode (see CMAKE_AUTOMOC_RELAXED_MODE).\n"
           << std::endl;
       this->LogError(err.str());
 
       includedMocs[absFilename] = ownMocUnderscoreFile;
       includedMocs.erase(ownMocHeaderFile);
-      }
-    else
-      {
+    } else {
       // otherwise always error out since it will not compile:
       std::stringstream err;
       err << "AUTOGEN: error: " << absFilename << ": The file "
           << "contains a " << macroName << " macro, but does not "
-             "include "
+                                           "include "
           << "\"" << scannedFileBasename << ".moc\" !\n"
           << std::endl;
       this->LogError(err.str());
 
       ::exit(EXIT_FAILURE);
-      }
     }
-
+  }
 }
 
-
-void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
-                const std::vector<std::string>& headerExtensions,
-                std::map<std::string, std::string>& includedMocs,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::StrictParseCppFile(
+  const std::string& absFilename,
+  const std::vector<std::string>& headerExtensions,
+  std::map<std::string, std::string>& includedMocs,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
   cmsys::RegularExpression mocIncludeRegExp(
-              "[\n][ \t]*#[ \t]*include[ \t]+"
-              "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
+    "[\n][ \t]*#[ \t]*include[ \t]+"
+    "[\"<](([^ \">]+/)?moc_[^ \">/]+\\.cpp|[^ \">]+\\.moc)[\">]");
 
   const std::string contentsString = ReadAll(absFilename);
-  if (contentsString.empty())
-    {
+  if (contentsString.empty()) {
     std::stringstream err;
     err << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
         << std::endl;
     this->LogError(err.str());
     return;
-    }
+  }
   this->ParseForUic(absFilename, contentsString, includedUis);
-  if (this->MocExecutable.empty())
-    {
+  if (this->MocExecutable.empty()) {
     return;
-    }
+  }
 
   const std::string absPath = cmsys::SystemTools::GetFilenamePath(
-                   cmsys::SystemTools::GetRealPath(absFilename)) + '/';
-  const std::string scannedFileBasename = cmsys::SystemTools::
-                                  GetFilenameWithoutLastExtension(absFilename);
+                                cmsys::SystemTools::GetRealPath(absFilename)) +
+    '/';
+  const std::string scannedFileBasename =
+    cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
 
   bool dotMocIncluded = false;
 
@@ -869,16 +765,14 @@ void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
   // first a simple string check for "moc" is *much* faster than the regexp,
   // and if the string search already fails, we don't have to try the
   // expensive regexp
-  if ((strstr(contentsString.c_str(), "moc") != NULL)
-                                    && (mocIncludeRegExp.find(contentsString)))
-    {
+  if ((strstr(contentsString.c_str(), "moc") != NULL) &&
+      (mocIncludeRegExp.find(contentsString))) {
     // for every moc include in the file
-    do
-      {
+    do {
       const std::string currentMoc = mocIncludeRegExp.match(1);
 
-      std::string basename = cmsys::SystemTools::
-                                   GetFilenameWithoutLastExtension(currentMoc);
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(currentMoc);
       const bool mocUnderscoreStyle = cmHasLiteralPrefix(basename, "moc_");
 
       // If the moc include is of the moc_foo.cpp style we expect
@@ -886,68 +780,61 @@ void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
       // If the moc include is of the foo.moc style we need to look for
       // a Q_OBJECT macro in the current source file, if it contains the
       // macro we generate the moc file from the source file.
-      if (mocUnderscoreStyle)
-        {
+      if (mocUnderscoreStyle) {
         // basename should be the part of the moc filename used for
         // finding the correct header, so we need to remove the moc_ part
         basename = basename.substr(4);
         std::string mocSubDir = extractSubDir(absPath, currentMoc);
-        std::string headerToMoc = findMatchingHeader(
-                               absPath, mocSubDir, basename, headerExtensions);
+        std::string headerToMoc =
+          findMatchingHeader(absPath, mocSubDir, basename, headerExtensions);
 
-        if (!headerToMoc.empty())
-          {
+        if (!headerToMoc.empty()) {
           includedMocs[headerToMoc] = currentMoc;
-          }
-        else
-          {
+        } else {
           std::stringstream err;
           err << "AUTOGEN: error: " << absFilename << " The file "
               << "includes the moc file \"" << currentMoc << "\", "
-              << "but could not find header \"" << basename
-              << '{' << this->JoinExts(headerExtensions) << "}\" ";
-          if (mocSubDir.empty())
-            {
+              << "but could not find header \"" << basename << '{'
+              << this->JoinExts(headerExtensions) << "}\" ";
+          if (mocSubDir.empty()) {
             err << "in " << absPath << "\n" << std::endl;
-            }
-          else
-            {
-            err << "neither in " << absPath
-                << " nor in " << mocSubDir << "\n" << std::endl;
-            }
+          } else {
+            err << "neither in " << absPath << " nor in " << mocSubDir << "\n"
+                << std::endl;
+          }
           this->LogError(err.str());
           ::exit(EXIT_FAILURE);
-          }
         }
-      else
-        {
-        if (basename != scannedFileBasename)
-          {
+      } else {
+        if (basename != scannedFileBasename) {
           std::stringstream err;
-          err << "AUTOGEN: error: " << absFilename << ": The file "
-                 "includes the moc file \"" << currentMoc <<
-                 "\", which seems to be the moc file from a different "
+          err << "AUTOGEN: error: " << absFilename
+              << ": The file "
+                 "includes the moc file \""
+              << currentMoc
+              << "\", which seems to be the moc file from a different "
                  "source file. This is not supported. "
-                 "Include \"" << scannedFileBasename << ".moc\" to run "
-                 "moc on this source file.\n" << std::endl;
+                 "Include \""
+              << scannedFileBasename << ".moc\" to run "
+                                        "moc on this source file.\n"
+              << std::endl;
           this->LogError(err.str());
           ::exit(EXIT_FAILURE);
-          }
+        }
         dotMocIncluded = true;
         includedMocs[absFilename] = currentMoc;
-        }
+      }
       matchOffset += mocIncludeRegExp.end();
-      } while(mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
-    }
+    } while (mocIncludeRegExp.find(contentsString.c_str() + matchOffset));
+  }
 
   // In this case, check whether the scanned file itself contains a Q_OBJECT.
   // If this is the case, the moc_foo.cpp should probably be generated from
   // foo.cpp instead of foo.h, because otherwise it won't build.
   // But warn, since this is not how it is supposed to be used.
   std::string macroName;
-  if ((dotMocIncluded == false) && (requiresMocing(contentsString,
-                                                     macroName)))
-    {
+  if ((dotMocIncluded == false) &&
+      (requiresMocing(contentsString, macroName))) {
     // otherwise always error out since it will not compile:
     std::stringstream err;
     err << "AUTOGEN: error: " << absFilename << ": The file "
@@ -956,58 +843,50 @@ void cmQtAutoGenerators::StrictParseCppFile(const std::string& absFilename,
         << std::endl;
     this->LogError(err.str());
     ::exit(EXIT_FAILURE);
-    }
-
+  }
 }
 
-
-void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::ParseForUic(
+  const std::string& absFilename,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
-  if (this->UicExecutable.empty())
-    {
+  if (this->UicExecutable.empty()) {
     return;
-    }
+  }
   const std::string contentsString = ReadAll(absFilename);
-  if (contentsString.empty())
-    {
+  if (contentsString.empty()) {
     std::stringstream err;
     err << "AUTOGEN: warning: " << absFilename << ": file is empty\n"
         << std::endl;
     this->LogError(err.str());
     return;
-    }
+  }
   this->ParseForUic(absFilename, contentsString, includedUis);
 }
 
-
-void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
-                const std::string& contentsString,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::ParseForUic(
+  const std::string& absFilename, const std::string& contentsString,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
-  if (this->UicExecutable.empty())
-    {
+  if (this->UicExecutable.empty()) {
     return;
-    }
+  }
   cmsys::RegularExpression uiIncludeRegExp(
-              "[\n][ \t]*#[ \t]*include[ \t]+"
-              "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
+    "[\n][ \t]*#[ \t]*include[ \t]+"
+    "[\"<](([^ \">]+/)?ui_[^ \">/]+\\.h)[\">]");
 
   std::string::size_type matchOffset = 0;
 
-  const std::string realName =
-                   cmsys::SystemTools::GetRealPath(absFilename);
+  const std::string realName = cmsys::SystemTools::GetRealPath(absFilename);
 
   matchOffset = 0;
-  if ((strstr(contentsString.c_str(), "ui_") != NULL)
-                                    && (uiIncludeRegExp.find(contentsString)))
-    {
-    do
-      {
+  if ((strstr(contentsString.c_str(), "ui_") != NULL) &&
+      (uiIncludeRegExp.find(contentsString))) {
+    do {
       const std::string currentUi = uiIncludeRegExp.match(1);
 
-      std::string basename = cmsys::SystemTools::
-                                  GetFilenameWithoutLastExtension(currentUi);
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(currentUi);
 
       // basename should be the part of the ui filename used for
       // finding the correct header, so we need to remove the ui_ part
@@ -1016,235 +895,202 @@ void cmQtAutoGenerators::ParseForUic(const std::string& absFilename,
       includedUis[realName].push_back(basename);
 
       matchOffset += uiIncludeRegExp.end();
-      } while(uiIncludeRegExp.find(contentsString.c_str() + matchOffset));
-    }
+    } while (uiIncludeRegExp.find(contentsString.c_str() + matchOffset));
+  }
 }
 
-
-void
-cmQtAutoGenerators::SearchHeadersForCppFile(const std::string& absFilename,
-                              const std::vector<std::string>& headerExtensions,
-                              std::set<std::string>& absHeaders)
+void cmQtAutoGenerators::SearchHeadersForCppFile(
+  const std::string& absFilename,
+  const std::vector<std::string>& headerExtensions,
+  std::set<std::string>& absHeaders)
 {
   // search for header files and private header files we may need to moc:
   const std::string basename =
-              cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
+    cmsys::SystemTools::GetFilenameWithoutLastExtension(absFilename);
   const std::string absPath = cmsys::SystemTools::GetFilenamePath(
-                   cmsys::SystemTools::GetRealPath(absFilename)) + '/';
+                                cmsys::SystemTools::GetRealPath(absFilename)) +
+    '/';
 
-  for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
-      ext != headerExtensions.end();
-      ++ext)
-    {
+  for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+       ext != headerExtensions.end(); ++ext) {
     const std::string headerName = absPath + basename + "." + (*ext);
-    if (cmsys::SystemTools::FileExists(headerName.c_str()))
-      {
+    if (cmsys::SystemTools::FileExists(headerName.c_str())) {
       absHeaders.insert(headerName);
       break;
-      }
     }
-  for(std::vector<std::string>::const_iterator ext = headerExtensions.begin();
-      ext != headerExtensions.end();
-      ++ext)
-    {
-    const std::string privateHeaderName = absPath+basename+"_p."+(*ext);
-    if (cmsys::SystemTools::FileExists(privateHeaderName.c_str()))
-      {
+  }
+  for (std::vector<std::string>::const_iterator ext = headerExtensions.begin();
+       ext != headerExtensions.end(); ++ext) {
+    const std::string privateHeaderName = absPath + basename + "_p." + (*ext);
+    if (cmsys::SystemTools::FileExists(privateHeaderName.c_str())) {
       absHeaders.insert(privateHeaderName);
       break;
-      }
     }
-
+  }
 }
 
-
-void cmQtAutoGenerators::ParseHeaders(const std::set<std::string>& absHeaders,
-                const std::map<std::string, std::string>& includedMocs,
-                std::map<std::string, std::string>& notIncludedMocs,
-                std::map<std::string, std::vector<std::string> >& includedUis)
+void cmQtAutoGenerators::ParseHeaders(
+  const std::set<std::string>& absHeaders,
+  const std::map<std::string, std::string>& includedMocs,
+  std::map<std::string, std::string>& notIncludedMocs,
+  std::map<std::string, std::vector<std::string> >& includedUis)
 {
-  for(std::set<std::string>::const_iterator hIt=absHeaders.begin();
-      hIt!=absHeaders.end();
-      ++hIt)
-    {
+  for (std::set<std::string>::const_iterator hIt = absHeaders.begin();
+       hIt != absHeaders.end(); ++hIt) {
     const std::string& headerName = *hIt;
     const std::string contents = ReadAll(headerName);
 
-    if (!this->MocExecutable.empty()
-        && includedMocs.find(headerName) == includedMocs.end())
-      {
-      if (this->Verbose)
-        {
+    if (!this->MocExecutable.empty() &&
+        includedMocs.find(headerName) == includedMocs.end()) {
+      if (this->Verbose) {
         std::stringstream err;
         err << "AUTOGEN: Checking " << headerName << std::endl;
         this->LogInfo(err.str());
-        }
+      }
 
       std::string macroName;
-      if (requiresMocing(contents, macroName))
-        {
-        const std::string parentDir = this->TargetBuildSubDir
-          + this->SourceRelativePath ( headerName );
-        const std::string basename = cmsys::SystemTools::
-          GetFilenameWithoutLastExtension(headerName);
+      if (requiresMocing(contents, macroName)) {
+        const std::string parentDir =
+          this->TargetBuildSubDir + this->SourceRelativePath(headerName);
+        const std::string basename =
+          cmsys::SystemTools::GetFilenameWithoutLastExtension(headerName);
         const std::string currentMoc = parentDir + "moc_" + basename + ".cpp";
         notIncludedMocs[headerName] = currentMoc;
-        }
       }
-    this->ParseForUic(headerName, contents, includedUis);
     }
+    this->ParseForUic(headerName, contents, includedUis);
+  }
 }
 
-
 bool cmQtAutoGenerators::GenerateMocFiles(
-                    const std::map<std::string, std::string>& includedMocs,
-                    const std::map<std::string, std::string>& notIncludedMocs )
+  const std::map<std::string, std::string>& includedMocs,
+  const std::map<std::string, std::string>& notIncludedMocs)
 {
   // look for name collisions
   {
     std::multimap<std::string, std::string> collisions;
     // Test merged map of included and notIncluded
-    std::map<std::string, std::string> mergedMocs ( includedMocs );
-    mergedMocs.insert ( notIncludedMocs.begin(), notIncludedMocs.end() );
-    if( this->NameCollisionTest ( mergedMocs, collisions ) )
-      {
+    std::map<std::string, std::string> mergedMocs(includedMocs);
+    mergedMocs.insert(notIncludedMocs.begin(), notIncludedMocs.end());
+    if (this->NameCollisionTest(mergedMocs, collisions)) {
       std::stringstream err;
-      err <<
-        "AUTOGEN: error: "
-        "The same moc file will be generated "
-        "from different sources." << std::endl <<
-        "To avoid this error either" << std::endl <<
-        "- rename the source files or" << std::endl <<
-        "- do not include the (moc_NAME.cpp|NAME.moc) file" << std::endl;
-      this->NameCollisionLog ( err.str(), collisions );
+      err << "AUTOGEN: error: "
+             "The same moc file will be generated "
+             "from different sources."
+          << std::endl
+          << "To avoid this error either" << std::endl
+          << "- rename the source files or" << std::endl
+          << "- do not include the (moc_NAME.cpp|NAME.moc) file" << std::endl;
+      this->NameCollisionLog(err.str(), collisions);
       ::exit(EXIT_FAILURE);
-      }
+    }
   }
 
   // generate moc files that are included by source files.
-  for(std::map<std::string, std::string>::const_iterator
-      it = includedMocs.begin(); it != includedMocs.end(); ++it)
-    {
-    if (!this->GenerateMoc(it->first, it->second))
-      {
-      if (this->RunMocFailed)
-        {
+  for (std::map<std::string, std::string>::const_iterator it =
+         includedMocs.begin();
+       it != includedMocs.end(); ++it) {
+    if (!this->GenerateMoc(it->first, it->second)) {
+      if (this->RunMocFailed) {
         return false;
-        }
       }
     }
+  }
 
   // generate moc files that are _not_ included by source files.
   bool automocCppChanged = false;
-  for(std::map<std::string, std::string>::const_iterator
-      it = notIncludedMocs.begin(); it != notIncludedMocs.end(); ++it)
-    {
-    if (this->GenerateMoc(it->first, it->second))
-      {
+  for (std::map<std::string, std::string>::const_iterator it =
+         notIncludedMocs.begin();
+       it != notIncludedMocs.end(); ++it) {
+    if (this->GenerateMoc(it->first, it->second)) {
       automocCppChanged = true;
-      }
-    else
-      {
-      if (this->RunMocFailed)
-        {
+    } else {
+      if (this->RunMocFailed) {
         return false;
-        }
       }
     }
+  }
 
   // compose _automoc.cpp content
   std::string automocSource;
-    {
+  {
     std::stringstream outStream;
     outStream << "/* This file is autogenerated, do not edit*/\n";
-    if( notIncludedMocs.empty() )
-      {
+    if (notIncludedMocs.empty()) {
       outStream << "enum some_compilers { need_more_than_nothing };\n";
-      }
-    else
-      {
-      for(std::map<std::string, std::string>::const_iterator
-          it = notIncludedMocs.begin();
-          it != notIncludedMocs.end();
-          ++it)
-        {
+    } else {
+      for (std::map<std::string, std::string>::const_iterator it =
+             notIncludedMocs.begin();
+           it != notIncludedMocs.end(); ++it) {
         outStream << "#include \"" << it->second << "\"\n";
-        }
       }
+    }
     outStream.flush();
     automocSource = outStream.str();
-    }
+  }
 
   // check if we even need to update _automoc.cpp
-  if (!automocCppChanged)
-    {
+  if (!automocCppChanged) {
     // compare contents of the _automoc.cpp file
     const std::string oldContents = ReadAll(this->OutMocCppFilenameAbs);
-    if (oldContents == automocSource)
-      {
+    if (oldContents == automocSource) {
       // nothing changed: don't touch the _automoc.cpp file
-      if (this->Verbose)
-        {
+      if (this->Verbose) {
         std::stringstream err;
-        err << "AUTOGEN: " << this->OutMocCppFilenameRel
-            << " still up to date" << std::endl;
+        err << "AUTOGEN: " << this->OutMocCppFilenameRel << " still up to date"
+            << std::endl;
         this->LogInfo(err.str());
-        }
-      return true;
       }
+      return true;
     }
+  }
 
   // actually write _automoc.cpp
-    {
+  {
     std::string msg = "Generating moc compilation ";
     msg += this->OutMocCppFilenameRel;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                     |cmsysTerminal_Color_ForegroundBold,
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
                                      msg.c_str(), true, this->ColorOutput);
-    }
-    {
+  }
+  {
     cmsys::ofstream outfile;
-    outfile.open(this->OutMocCppFilenameAbs.c_str(),
-                 std::ios::trunc);
+    outfile.open(this->OutMocCppFilenameAbs.c_str(), std::ios::trunc);
     outfile << automocSource;
     outfile.close();
-    }
+  }
 
   return true;
 }
 
-
 bool cmQtAutoGenerators::GenerateMoc(const std::string& sourceFile,
-                              const std::string& mocFileName)
+                                     const std::string& mocFileName)
 {
   const std::string mocFilePath = this->Builddir + mocFileName;
   int sourceNewerThanMoc = 0;
-  bool success = cmsys::SystemTools::FileTimeCompare(sourceFile,
-                                                     mocFilePath,
+  bool success = cmsys::SystemTools::FileTimeCompare(sourceFile, mocFilePath,
                                                      &sourceNewerThanMoc);
-  if (this->GenerateAll || !success || sourceNewerThanMoc >= 0)
-    {
+  if (this->GenerateAll || !success || sourceNewerThanMoc >= 0) {
     // make sure the directory for the resulting moc file exists
     std::string mocDir = mocFilePath.substr(0, mocFilePath.rfind('/'));
-    if (!cmsys::SystemTools::FileExists(mocDir.c_str(), false))
-      {
+    if (!cmsys::SystemTools::FileExists(mocDir.c_str(), false)) {
       cmsys::SystemTools::MakeDirectory(mocDir.c_str());
-      }
+    }
 
     std::string msg = "Generating moc source ";
     msg += mocFileName;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                           |cmsysTerminal_Color_ForegroundBold,
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
                                      msg.c_str(), true, this->ColorOutput);
 
     std::vector<std::string> command;
     command.push_back(this->MocExecutable);
-    command.insert(command.end(),
-                   this->MocIncludes.begin(), this->MocIncludes.end());
-    command.insert(command.end(),
-                   this->MocDefinitions.begin(), this->MocDefinitions.end());
-    command.insert(command.end(),
-                   this->MocOptions.begin(), this->MocOptions.end());
+    command.insert(command.end(), this->MocIncludes.begin(),
+                   this->MocIncludes.end());
+    command.insert(command.end(), this->MocDefinitions.begin(),
+                   this->MocDefinitions.end());
+    command.insert(command.end(), this->MocOptions.begin(),
+                   this->MocOptions.end());
 #ifdef _WIN32
     command.push_back("-DWIN32");
 #endif
@@ -1252,39 +1098,36 @@ bool cmQtAutoGenerators::GenerateMoc(const std::string& sourceFile,
     command.push_back(mocFilePath);
     command.push_back(sourceFile);
 
-    if (this->Verbose)
-      {
+    if (this->Verbose) {
       this->LogCommand(command);
-      }
+    }
 
     std::string output;
     int retVal = 0;
-    bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                                  &retVal);
-    if (!result || retVal)
-      {
+    bool result =
+      cmSystemTools::RunSingleCommand(command, &output, &output, &retVal);
+    if (!result || retVal) {
       std::stringstream err;
-      err << "AUTOGEN: error: process for " << mocFilePath <<" failed:\n"
+      err << "AUTOGEN: error: process for " << mocFilePath << " failed:\n"
           << output << std::endl;
       this->LogError(err.str());
       this->RunMocFailed = true;
       cmSystemTools::RemoveFile(mocFilePath);
-      }
-    return true;
     }
+    return true;
+  }
   return false;
 }
 
-
 bool cmQtAutoGenerators::GenerateUiFiles(
-      const std::map<std::string, std::vector<std::string> >& includedUis )
+  const std::map<std::string, std::vector<std::string> >& includedUis)
 {
   // single map with input / output names
   std::map<std::string, std::map<std::string, std::string> > uiGenMap;
   std::map<std::string, std::string> testMap;
-  for(std::map<std::string, std::vector<std::string> >::const_iterator
-      it = includedUis.begin(); it != includedUis.end(); ++it)
-    {
+  for (std::map<std::string, std::vector<std::string> >::const_iterator it =
+         includedUis.begin();
+       it != includedUis.end(); ++it) {
     // source file path
     std::string sourcePath = cmsys::SystemTools::GetFilenamePath(it->first);
     sourcePath += '/';
@@ -1292,118 +1135,106 @@ bool cmQtAutoGenerators::GenerateUiFiles(
     uiGenMap[it->first] = std::map<std::string, std::string>();
     std::map<std::string, std::string>& sourceMap = uiGenMap[it->first];
     for (std::vector<std::string>::const_iterator sit = it->second.begin();
-         sit != it->second.end();
-         ++sit)
-      {
-      const std::string & uiFileName = *sit;
+         sit != it->second.end(); ++sit) {
+      const std::string& uiFileName = *sit;
       const std::string uiInputFile = sourcePath + uiFileName + ".ui";
       const std::string uiOutputFile = "ui_" + uiFileName + ".h";
       sourceMap[uiInputFile] = uiOutputFile;
       testMap[uiInputFile] = uiOutputFile;
-      }
     }
+  }
 
   // look for name collisions
   {
     std::multimap<std::string, std::string> collisions;
-    if( this->NameCollisionTest ( testMap, collisions ) )
-      {
+    if (this->NameCollisionTest(testMap, collisions)) {
       std::stringstream err;
       err << "AUTOGEN: error: The same ui_NAME.h file will be generated "
-             "from different sources." << std::endl
+             "from different sources."
+          << std::endl
           << "To avoid this error rename the source files." << std::endl;
-      this->NameCollisionLog ( err.str(), collisions );
+      this->NameCollisionLog(err.str(), collisions);
       ::exit(EXIT_FAILURE);
-      }
+    }
   }
   testMap.clear();
 
   // generate ui files
-  for(std::map<std::string, std::map<std::string, std::string> >::
-      const_iterator it = uiGenMap.begin(); it != uiGenMap.end(); ++it)
-    {
-    for(std::map<std::string, std::string>::const_iterator
-        sit = it->second.begin();
-        sit != it->second.end();
-        ++sit)
-      {
-      if (!this->GenerateUi(it->first, sit->first, sit->second) )
-        {
-        if (this->RunUicFailed)
-          {
+  for (std::map<std::string,
+                std::map<std::string, std::string> >::const_iterator it =
+         uiGenMap.begin();
+       it != uiGenMap.end(); ++it) {
+    for (std::map<std::string, std::string>::const_iterator sit =
+           it->second.begin();
+         sit != it->second.end(); ++sit) {
+      if (!this->GenerateUi(it->first, sit->first, sit->second)) {
+        if (this->RunUicFailed) {
           return false;
-          }
         }
       }
     }
+  }
 
   return true;
 }
 
-
 bool cmQtAutoGenerators::GenerateUi(const std::string& realName,
                                     const std::string& uiInputFile,
                                     const std::string& uiOutputFile)
 {
-  if (!cmsys::SystemTools::FileExists(this->Builddir.c_str(), false))
-    {
+  if (!cmsys::SystemTools::FileExists(this->Builddir.c_str(), false)) {
     cmsys::SystemTools::MakeDirectory(this->Builddir.c_str());
-    }
+  }
 
   const ::std::string uiBuildFile = this->Builddir + uiOutputFile;
 
   int sourceNewerThanUi = 0;
-  bool success = cmsys::SystemTools::FileTimeCompare(uiInputFile,
-                                                     uiBuildFile,
+  bool success = cmsys::SystemTools::FileTimeCompare(uiInputFile, uiBuildFile,
                                                      &sourceNewerThanUi);
-  if (this->GenerateAll || !success || sourceNewerThanUi >= 0)
-    {
+  if (this->GenerateAll || !success || sourceNewerThanUi >= 0) {
     std::string msg = "Generating ui header ";
     msg += uiOutputFile;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                          |cmsysTerminal_Color_ForegroundBold,
-                                      msg.c_str(), true, this->ColorOutput);
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
+                                     msg.c_str(), true, this->ColorOutput);
 
     std::vector<std::string> command;
     command.push_back(this->UicExecutable);
 
     std::vector<std::string> opts = this->UicTargetOptions;
-    std::map<std::string, std::string>::const_iterator optionIt
-            = this->UicOptions.find(uiInputFile);
-    if (optionIt != this->UicOptions.end())
-      {
+    std::map<std::string, std::string>::const_iterator optionIt =
+      this->UicOptions.find(uiInputFile);
+    if (optionIt != this->UicOptions.end()) {
       std::vector<std::string> fileOpts;
       cmSystemTools::ExpandListArgument(optionIt->second, fileOpts);
       cmQtAutoGenerators::MergeUicOptions(opts, fileOpts,
                                           this->QtMajorVersion == "5");
-      }
+    }
     command.insert(command.end(), opts.begin(), opts.end());
 
     command.push_back("-o");
     command.push_back(uiBuildFile);
     command.push_back(uiInputFile);
 
-    if (this->Verbose)
-      {
+    if (this->Verbose) {
       this->LogCommand(command);
-      }
+    }
     std::string output;
     int retVal = 0;
-    bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                                  &retVal);
-    if (!result || retVal)
-      {
+    bool result =
+      cmSystemTools::RunSingleCommand(command, &output, &output, &retVal);
+    if (!result || retVal) {
       std::stringstream err;
-      err << "AUTOUIC: error: process for " << uiOutputFile <<
-             " needed by\n \"" << realName << "\"\nfailed:\n" << output
-          << std::endl;
+      err << "AUTOUIC: error: process for " << uiOutputFile
+          << " needed by\n \"" << realName << "\"\nfailed:\n"
+          << output << std::endl;
       this->LogError(err.str());
       this->RunUicFailed = true;
       cmSystemTools::RemoveFile(uiOutputFile);
       return false;
-      }
-    return true;
     }
+    return true;
+  }
   return false;
 }
 
@@ -1412,17 +1243,14 @@ bool cmQtAutoGenerators::InputFilesNewerThanQrc(const std::string& qrcFile,
 {
   std::vector<std::string> const& files = this->RccInputs[qrcFile];
   for (std::vector<std::string>::const_iterator it = files.begin();
-       it != files.end(); ++it)
-    {
+       it != files.end(); ++it) {
     int inputNewerThanQrc = 0;
-    bool success = cmsys::SystemTools::FileTimeCompare(*it,
-                                                      rccOutput,
-                                                      &inputNewerThanQrc);
-    if (!success || inputNewerThanQrc >= 0)
-      {
+    bool success =
+      cmsys::SystemTools::FileTimeCompare(*it, rccOutput, &inputNewerThanQrc);
+    if (!success || inputNewerThanQrc >= 0) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -1430,88 +1258,78 @@ bool cmQtAutoGenerators::GenerateQrcFiles()
 {
   // generate single map with input / output names
   std::map<std::string, std::string> qrcGenMap;
-  for(std::vector<std::string>::const_iterator si = this->RccSources.begin();
-      si != this->RccSources.end(); ++si)
-    {
+  for (std::vector<std::string>::const_iterator si = this->RccSources.begin();
+       si != this->RccSources.end(); ++si) {
     const std::string ext = cmsys::SystemTools::GetFilenameLastExtension(*si);
-    if (ext == ".qrc")
-      {
-      std::string basename = cmsys::SystemTools::
-        GetFilenameWithoutLastExtension(*si);
-      std::string qrcOutputFile = this->TargetBuildSubDir
-        + this->SourceRelativePath ( *si )
-        + "qrc_" + basename + ".cpp";
-      //std::string qrcOutputFile = "CMakeFiles/" + this->OriginTargetName
+    if (ext == ".qrc") {
+      std::string basename =
+        cmsys::SystemTools::GetFilenameWithoutLastExtension(*si);
+      std::string qrcOutputFile = this->TargetBuildSubDir +
+        this->SourceRelativePath(*si) + "qrc_" + basename + ".cpp";
+      // std::string qrcOutputFile = "CMakeFiles/" + this->OriginTargetName
       //                         + ".dir/qrc_" + basename + ".cpp";
       qrcGenMap[*si] = qrcOutputFile;
-      }
     }
+  }
 
   // look for name collisions
   {
     std::multimap<std::string, std::string> collisions;
-    if( this->NameCollisionTest ( qrcGenMap, collisions ) )
-      {
+    if (this->NameCollisionTest(qrcGenMap, collisions)) {
       std::stringstream err;
       err << "AUTOGEN: error: The same qrc_NAME.cpp file"
-             " will be generated from different sources." << std::endl
-          << "To avoid this error rename the source .qrc files."
-          << std::endl;
-      this->NameCollisionLog ( err.str(), collisions );
+             " will be generated from different sources."
+          << std::endl
+          << "To avoid this error rename the source .qrc files." << std::endl;
+      this->NameCollisionLog(err.str(), collisions);
       ::exit(EXIT_FAILURE);
-      }
+    }
   }
 
   // generate qrc files
-  for(std::map<std::string, std::string>::const_iterator
-      si = qrcGenMap.begin(); si != qrcGenMap.end(); ++si)
-    {
-    if (!this->GenerateQrc( si->first, si->second))
-      {
-      if (this->RunRccFailed)
-        {
+  for (std::map<std::string, std::string>::const_iterator si =
+         qrcGenMap.begin();
+       si != qrcGenMap.end(); ++si) {
+    if (!this->GenerateQrc(si->first, si->second)) {
+      if (this->RunRccFailed) {
         return false;
-        }
       }
     }
+  }
   return true;
 }
 
-bool cmQtAutoGenerators::GenerateQrc (
-  const std::string& qrcInputFile,
-  const std::string& qrcOutputFile )
+bool cmQtAutoGenerators::GenerateQrc(const std::string& qrcInputFile,
+                                     const std::string& qrcOutputFile)
 {
-  std::string relName = this->SourceRelativePath ( qrcInputFile );
+  std::string relName = this->SourceRelativePath(qrcInputFile);
   cmSystemTools::ReplaceString(relName, "/", "_");
   relName += cmsys::SystemTools::GetFilenameWithoutLastExtension(qrcInputFile);
 
   const ::std::string qrcBuildFile = this->Builddir + qrcOutputFile;
 
   int sourceNewerThanQrc = 0;
-  bool generateQrc = !cmsys::SystemTools::FileTimeCompare(qrcInputFile,
-                                                          qrcBuildFile,
-                                                          &sourceNewerThanQrc);
+  bool generateQrc = !cmsys::SystemTools::FileTimeCompare(
+    qrcInputFile, qrcBuildFile, &sourceNewerThanQrc);
   generateQrc = generateQrc || (sourceNewerThanQrc >= 0);
-  generateQrc = generateQrc || this->InputFilesNewerThanQrc(qrcInputFile,
-                                                            qrcBuildFile);
+  generateQrc =
+    generateQrc || this->InputFilesNewerThanQrc(qrcInputFile, qrcBuildFile);
 
-  if (this->GenerateAll || generateQrc)
-    {
+  if (this->GenerateAll || generateQrc) {
     std::string msg = "Generating qrc source ";
     msg += qrcOutputFile;
-    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue
-                                     |cmsysTerminal_Color_ForegroundBold,
+    cmSystemTools::MakefileColorEcho(cmsysTerminal_Color_ForegroundBlue |
+                                       cmsysTerminal_Color_ForegroundBold,
                                      msg.c_str(), true, this->ColorOutput);
 
     std::vector<std::string> command;
     command.push_back(this->RccExecutable);
 
-    std::map<std::string, std::string>::const_iterator optionIt
-      = this->RccOptions.find(qrcInputFile);
-    if (optionIt != this->RccOptions.end())
-      {
+    std::map<std::string, std::string>::const_iterator optionIt =
+      this->RccOptions.find(qrcInputFile);
+    if (optionIt != this->RccOptions.end()) {
       cmSystemTools::ExpandListArgument(optionIt->second, command);
-      }
+    }
 
     command.push_back("-name");
     command.push_back(relName);
@@ -1519,25 +1337,23 @@ bool cmQtAutoGenerators::GenerateQrc (
     command.push_back(qrcBuildFile);
     command.push_back(qrcInputFile);
 
-    if (this->Verbose)
-      {
+    if (this->Verbose) {
       this->LogCommand(command);
-      }
+    }
     std::string output;
     int retVal = 0;
-    bool result = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                                  &retVal);
-    if (!result || retVal)
-      {
+    bool result =
+      cmSystemTools::RunSingleCommand(command, &output, &output, &retVal);
+    if (!result || retVal) {
       std::stringstream err;
-      err << "AUTORCC: error: process for " << qrcOutputFile <<
-             " failed:\n" << output << std::endl;
+      err << "AUTORCC: error: process for " << qrcOutputFile << " failed:\n"
+          << output << std::endl;
       this->LogError(err.str());
       this->RunRccFailed = true;
       cmSystemTools::RemoveFile(qrcBuildFile);
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -1547,44 +1363,40 @@ std::string cmQtAutoGenerators::SourceRelativePath(const std::string& filename)
 
   // Test if the file is child to any of the known directories
   {
-    std::string fileNameReal = cmsys::SystemTools::GetRealPath( filename );
+    std::string fileNameReal = cmsys::SystemTools::GetRealPath(filename);
     std::string parentDirectory;
-    bool match ( false );
+    bool match(false);
     {
       const ::std::string* testDirs[4];
       testDirs[0] = &(this->Srcdir);
       testDirs[1] = &(this->Builddir);
       testDirs[2] = &(this->ProjectSourceDir);
       testDirs[3] = &(this->ProjectBinaryDir);
-      for(int ii=0; ii != sizeof(testDirs)/sizeof(const ::std::string*); ++ii )
-        {
-        const ::std::string testDir = cmsys::SystemTools::GetRealPath(
-                                                          *(testDirs[ii]));
-        if (cmsys::SystemTools::IsSubDirectory(fileNameReal,
-                                               testDir) )
-          {
+      for (int ii = 0; ii != sizeof(testDirs) / sizeof(const ::std::string*);
+           ++ii) {
+        const ::std::string testDir =
+          cmsys::SystemTools::GetRealPath(*(testDirs[ii]));
+        if (cmsys::SystemTools::IsSubDirectory(fileNameReal, testDir)) {
           parentDirectory = testDir;
           match = true;
           break;
-          }
         }
+      }
     }
     // Use root as fallback parent directory
-    if ( !match )
-      {
+    if (!match) {
       cmsys::SystemTools::SplitPathRootComponent(fileNameReal,
                                                  &parentDirectory);
-      }
+    }
     pathRel = cmsys::SystemTools::RelativePath(
       parentDirectory, cmsys::SystemTools::GetParentDirectory(fileNameReal));
   }
 
   // Sanitize relative path
-  if (!pathRel.empty())
-    {
+  if (!pathRel.empty()) {
     pathRel += '/';
     cmSystemTools::ReplaceString(pathRel, "..", "__");
-    }
+  }
   return pathRel;
 }
 
@@ -1593,39 +1405,34 @@ std::string cmQtAutoGenerators::SourceRelativePath(const std::string& filename)
  * @return True if there were collisions
  */
 bool cmQtAutoGenerators::NameCollisionTest(
-                          const std::map<std::string, std::string >& genFiles,
-                          std::multimap<std::string, std::string>& collisions)
+  const std::map<std::string, std::string>& genFiles,
+  std::multimap<std::string, std::string>& collisions)
 {
   typedef std::map<std::string, std::string>::const_iterator Iter;
   typedef std::map<std::string, std::string>::value_type VType;
-  for(Iter ait = genFiles.begin(); ait != genFiles.end(); ++ait )
-    {
-    bool first_match ( true );
-    for (Iter bit = (++Iter(ait)); bit != genFiles.end(); ++bit)
-      {
-      if(ait->second == bit->second)
-        {
-        if (first_match)
-          {
-          if (collisions.find(ait->second) != collisions.end())
-            {
+  for (Iter ait = genFiles.begin(); ait != genFiles.end(); ++ait) {
+    bool first_match(true);
+    for (Iter bit = (++Iter(ait)); bit != genFiles.end(); ++bit) {
+      if (ait->second == bit->second) {
+        if (first_match) {
+          if (collisions.find(ait->second) != collisions.end()) {
             // We already know of this collision from before
             break;
-            }
+          }
           collisions.insert(VType(ait->second, ait->first));
           first_match = false;
-          }
-        collisions.insert(VType(bit->second, bit->first));
         }
+        collisions.insert(VType(bit->second, bit->first));
       }
     }
+  }
 
   return !collisions.empty();
 }
 
 void cmQtAutoGenerators::NameCollisionLog(
-                     const std::string& message,
-                     const std::multimap<std::string, std::string>& collisions)
+  const std::string& message,
+  const std::multimap<std::string, std::string>& collisions)
 {
   typedef std::multimap<std::string, std::string>::const_iterator Iter;
 
@@ -1633,10 +1440,9 @@ void cmQtAutoGenerators::NameCollisionLog(
   // Add message
   err << message;
   // Append collision list
-  for(Iter it = collisions.begin(); it != collisions.end(); ++it )
-    {
-      err << it->first << " : " << it->second << std::endl;
-    }
+  for (Iter it = collisions.begin(); it != collisions.end(); ++it) {
+    err << it->first << " : " << it->second << std::endl;
+  }
   this->LogError(err.str());
 }
 
@@ -1653,42 +1459,34 @@ void cmQtAutoGenerators::LogError(const std::string& message)
 void cmQtAutoGenerators::LogCommand(const std::vector<std::string>& command)
 {
   std::stringstream sbuf;
-  for(std::vector<std::string>::const_iterator cmdIt = command.begin();
-      cmdIt != command.end();
-      ++cmdIt)
-    {
-    if ( cmdIt != command.begin() )
-      {
+  for (std::vector<std::string>::const_iterator cmdIt = command.begin();
+       cmdIt != command.end(); ++cmdIt) {
+    if (cmdIt != command.begin()) {
       sbuf << " ";
-      }
-    sbuf << *cmdIt;
     }
-  if ( !sbuf.str().empty() )
-    {
+    sbuf << *cmdIt;
+  }
+  if (!sbuf.str().empty()) {
     sbuf << std::endl;
-    this->LogInfo ( sbuf.str() );
-    }
+    this->LogInfo(sbuf.str());
+  }
 }
 
 std::string cmQtAutoGenerators::JoinExts(const std::vector<std::string>& lst)
 {
-    if (lst.empty())
-      {
-      return "";
-      }
+  if (lst.empty()) {
+    return "";
+  }
 
-    std::string result;
-    std::string separator = ",";
-    for (std::vector<std::string>::const_iterator it = lst.begin();
-         it != lst.end();
-         ++it)
-      {
-      if(it != lst.begin())
-        {
-        result += separator;
-        }
-      result += '.' + (*it);
-      }
-    result.erase(result.end() - 1);
-    return result;
+  std::string result;
+  std::string separator = ",";
+  for (std::vector<std::string>::const_iterator it = lst.begin();
+       it != lst.end(); ++it) {
+    if (it != lst.begin()) {
+      result += separator;
+    }
+    result += '.' + (*it);
+  }
+  result.erase(result.end() - 1);
+  return result;
 }
diff --git a/Source/cmQtAutoGenerators.h b/Source/cmQtAutoGenerators.h
index 315e915..5e7fab5 100644
--- a/Source/cmQtAutoGenerators.h
+++ b/Source/cmQtAutoGenerators.h
@@ -30,7 +30,6 @@ public:
   bool Run(const std::string& targetDirectory, const std::string& config);
 
 private:
-
   bool ReadAutogenInfoFile(cmMakefile* makefile,
                            const std::string& targetDirectory,
                            const std::string& config);
@@ -42,59 +41,64 @@ private:
 
   bool RunAutogen(cmMakefile* makefile);
   bool GenerateMocFiles(
-              const std::map<std::string, std::string>& includedMocs,
-              const std::map<std::string, std::string>& notIncludedMocs);
+    const std::map<std::string, std::string>& includedMocs,
+    const std::map<std::string, std::string>& notIncludedMocs);
   bool GenerateMoc(const std::string& sourceFile,
                    const std::string& mocFileName);
   bool GenerateUiFiles(
-        const std::map<std::string, std::vector<std::string> >& includedUis );
-  bool GenerateUi(const std::string& realName,
-                  const std::string& uiInputFile,
-                  const std::string& uiOutputFile );
+    const std::map<std::string, std::vector<std::string> >& includedUis);
+  bool GenerateUi(const std::string& realName, const std::string& uiInputFile,
+                  const std::string& uiOutputFile);
   bool GenerateQrcFiles();
   bool GenerateQrc(const std::string& qrcInputFile,
                    const std::string& qrcOutputFile);
-  void ParseCppFile(const std::string& absFilename,
-              const std::vector<std::string>& headerExtensions,
-              std::map<std::string, std::string>& includedMocs,
-              std::map<std::string, std::vector<std::string> >& includedUis);
-  void StrictParseCppFile(const std::string& absFilename,
-              const std::vector<std::string>& headerExtensions,
-              std::map<std::string, std::string>& includedMocs,
-              std::map<std::string, std::vector<std::string> >& includedUis);
-  void SearchHeadersForCppFile(const std::string& absFilename,
-                              const std::vector<std::string>& headerExtensions,
-                              std::set<std::string>& absHeaders);
-
-  void ParseHeaders(const std::set<std::string>& absHeaders,
-              const std::map<std::string, std::string>& includedMocs,
-              std::map<std::string, std::string>& notIncludedMocs,
-              std::map<std::string, std::vector<std::string> >& includedUis);
-
-  void ParseForUic(const std::string& fileName,
-              const std::string& contentsString,
-              std::map<std::string, std::vector<std::string> >& includedUis);
-
-  void ParseForUic(const std::string& fileName,
-              std::map<std::string, std::vector<std::string> >& includedUis);
+  void ParseCppFile(
+    const std::string& absFilename,
+    const std::vector<std::string>& headerExtensions,
+    std::map<std::string, std::string>& includedMocs,
+    std::map<std::string, std::vector<std::string> >& includedUis);
+  void StrictParseCppFile(
+    const std::string& absFilename,
+    const std::vector<std::string>& headerExtensions,
+    std::map<std::string, std::string>& includedMocs,
+    std::map<std::string, std::vector<std::string> >& includedUis);
+  void SearchHeadersForCppFile(
+    const std::string& absFilename,
+    const std::vector<std::string>& headerExtensions,
+    std::set<std::string>& absHeaders);
+
+  void ParseHeaders(
+    const std::set<std::string>& absHeaders,
+    const std::map<std::string, std::string>& includedMocs,
+    std::map<std::string, std::string>& notIncludedMocs,
+    std::map<std::string, std::vector<std::string> >& includedUis);
+
+  void ParseForUic(
+    const std::string& fileName, const std::string& contentsString,
+    std::map<std::string, std::vector<std::string> >& includedUis);
+
+  void ParseForUic(
+    const std::string& fileName,
+    std::map<std::string, std::vector<std::string> >& includedUis);
 
   void Init();
 
   std::string SourceRelativePath(const std::string& filename);
 
-  bool NameCollisionTest(const std::map<std::string, std::string >& genFiles,
-    std::multimap<std::string, std::string>& collisions );
+  bool NameCollisionTest(const std::map<std::string, std::string>& genFiles,
+                         std::multimap<std::string, std::string>& collisions);
   void NameCollisionLog(
-                 const std::string& message,
-                 const std::multimap<std::string, std::string>& collisions );
+    const std::string& message,
+    const std::multimap<std::string, std::string>& collisions);
 
   void LogInfo(const std::string& message);
   void LogError(const std::string& message);
   void LogCommand(const std::vector<std::string>& command);
   std::string JoinExts(const std::vector<std::string>& lst);
 
-  static void MergeUicOptions(std::vector<std::string> &opts,
-                       const std::vector<std::string> &fileOpts, bool isQt5);
+  static void MergeUicOptions(std::vector<std::string>& opts,
+                              const std::vector<std::string>& fileOpts,
+                              bool isQt5);
 
   bool InputFilesNewerThanQrc(const std::string& qrcFile,
                               const std::string& rccOutput);
diff --git a/Source/cmRST.cxx b/Source/cmRST.cxx
index ad545aa..10d1cda 100644
--- a/Source/cmRST.cxx
+++ b/Source/cmRST.cxx
@@ -17,36 +17,36 @@
 #include <cmsys/FStream.hxx>
 #include <ctype.h>
 
-cmRST::cmRST(std::ostream& os, std::string const& docroot):
-  OS(os),
-  DocRoot(docroot),
-  IncludeDepth(0),
-  OutputLinePending(false),
-  LastLineEndedInColonColon(false),
-  Markup(MarkupNone),
-  Directive(DirectiveNone),
-  CMakeDirective("^.. (cmake:)?("
-                 "command|variable"
-                 ")::[ \t]+([^ \t\n]+)$"),
-  CMakeModuleDirective("^.. cmake-module::[ \t]+([^ \t\n]+)$"),
-  ParsedLiteralDirective("^.. parsed-literal::[ \t]*(.*)$"),
-  CodeBlockDirective("^.. code-block::[ \t]*(.*)$"),
-  ReplaceDirective("^.. (\\|[^|]+\\|) replace::[ \t]*(.*)$"),
-  IncludeDirective("^.. include::[ \t]+([^ \t\n]+)$"),
-  TocTreeDirective("^.. toctree::[ \t]*(.*)$"),
-  ProductionListDirective("^.. productionlist::[ \t]*(.*)$"),
-  NoteDirective("^.. note::[ \t]*(.*)$"),
-  ModuleRST("^#\\[(=*)\\[\\.rst:$"),
-  CMakeRole("(:cmake)?:("
-            "command|generator|variable|module|policy|"
-            "prop_cache|prop_dir|prop_gbl|prop_inst|prop_sf|"
-            "prop_test|prop_tgt|"
-            "manual"
-            "):`(<*([^`<]|[^` \t]<)*)([ \t]+<[^`]*>)?`"),
-  Substitution("(^|[^A-Za-z0-9_])"
-               "((\\|[^| \t\r\n]([^|\r\n]*[^| \t\r\n])?\\|)(__|_|))"
-               "([^A-Za-z0-9_]|$)"),
-  TocTreeLink("^.*[ \t]+<([^>]+)>$")
+cmRST::cmRST(std::ostream& os, std::string const& docroot)
+  : OS(os)
+  , DocRoot(docroot)
+  , IncludeDepth(0)
+  , OutputLinePending(false)
+  , LastLineEndedInColonColon(false)
+  , Markup(MarkupNone)
+  , Directive(DirectiveNone)
+  , CMakeDirective("^.. (cmake:)?("
+                   "command|variable"
+                   ")::[ \t]+([^ \t\n]+)$")
+  , CMakeModuleDirective("^.. cmake-module::[ \t]+([^ \t\n]+)$")
+  , ParsedLiteralDirective("^.. parsed-literal::[ \t]*(.*)$")
+  , CodeBlockDirective("^.. code-block::[ \t]*(.*)$")
+  , ReplaceDirective("^.. (\\|[^|]+\\|) replace::[ \t]*(.*)$")
+  , IncludeDirective("^.. include::[ \t]+([^ \t\n]+)$")
+  , TocTreeDirective("^.. toctree::[ \t]*(.*)$")
+  , ProductionListDirective("^.. productionlist::[ \t]*(.*)$")
+  , NoteDirective("^.. note::[ \t]*(.*)$")
+  , ModuleRST("^#\\[(=*)\\[\\.rst:$")
+  , CMakeRole("(:cmake)?:("
+              "command|generator|variable|module|policy|"
+              "prop_cache|prop_dir|prop_gbl|prop_inst|prop_sf|"
+              "prop_test|prop_tgt|"
+              "manual"
+              "):`(<*([^`<]|[^` \t]<)*)([ \t]+<[^`]*>)?`")
+  , Substitution("(^|[^A-Za-z0-9_])"
+                 "((\\|[^| \t\r\n]([^|\r\n]*[^| \t\r\n])?\\|)(__|_|))"
+                 "([^A-Za-z0-9_]|$)")
+  , TocTreeLink("^.*[ \t]+<([^>]+)>$")
 {
   this->Replace["|release|"] = cmVersion::GetCMakeVersion();
 }
@@ -54,30 +54,25 @@ cmRST::cmRST(std::ostream& os, std::string const& docroot):
 bool cmRST::ProcessFile(std::string const& fname, bool isModule)
 {
   cmsys::ifstream fin(fname.c_str());
-  if(fin)
-    {
+  if (fin) {
     this->DocDir = cmSystemTools::GetFilenamePath(fname);
-    if(isModule)
-      {
+    if (isModule) {
       this->ProcessModule(fin);
-      }
-    else
-      {
+    } else {
       this->ProcessRST(fin);
-      }
+    }
     this->OutputLinePending = true;
     return true;
-    }
+  }
   return false;
 }
 
 void cmRST::ProcessRST(std::istream& is)
 {
   std::string line;
-  while(cmSystemTools::GetLineFromStream(is, line))
-    {
+  while (cmSystemTools::GetLineFromStream(is, line)) {
     this->ProcessLine(line);
-    }
+  }
   this->Reset();
 }
 
@@ -85,80 +80,71 @@ void cmRST::ProcessModule(std::istream& is)
 {
   std::string line;
   std::string rst;
-  while(cmSystemTools::GetLineFromStream(is, line))
-    {
-    if(!rst.empty() && rst != "#")
-      {
+  while (cmSystemTools::GetLineFromStream(is, line)) {
+    if (!rst.empty() && rst != "#") {
       // Bracket mode: check for end bracket
       std::string::size_type pos = line.find(rst);
-      if(pos == line.npos)
-        {
+      if (pos == line.npos) {
         this->ProcessLine(line);
-        }
-      else
-        {
-        if(line[0] != '#')
-          {
+      } else {
+        if (line[0] != '#') {
           this->ProcessLine(line.substr(0, pos));
-          }
+        }
         rst = "";
         this->Reset();
         this->OutputLinePending = true;
-        }
       }
-    else
-      {
+    } else {
       // Line mode: check for .rst start (bracket or line)
-      if(rst == "#")
-        {
-        if(line == "#")
-          {
+      if (rst == "#") {
+        if (line == "#") {
           this->ProcessLine("");
           continue;
-          }
-        else if(line.substr(0, 2) == "# ")
-          {
+        } else if (line.substr(0, 2) == "# ") {
           this->ProcessLine(line.substr(2, line.npos));
           continue;
-          }
-        else
-          {
+        } else {
           rst = "";
           this->Reset();
           this->OutputLinePending = true;
-          }
         }
-      if(line == "#.rst:")
-        {
+      }
+      if (line == "#.rst:") {
         rst = "#";
-        }
-      else if(this->ModuleRST.find(line))
-        {
+      } else if (this->ModuleRST.find(line)) {
         rst = "]" + this->ModuleRST.match(1) + "]";
-        }
       }
     }
-  if(rst == "#")
-    {
+  }
+  if (rst == "#") {
     this->Reset();
-    }
+  }
 }
 
 void cmRST::Reset()
 {
-  if(!this->MarkupLines.empty())
-    {
+  if (!this->MarkupLines.empty()) {
     this->UnindentLines(this->MarkupLines);
-    }
-  switch(this->Directive)
-    {
-    case DirectiveNone: break;
-    case DirectiveParsedLiteral: this->ProcessDirectiveParsedLiteral(); break;
-    case DirectiveLiteralBlock: this->ProcessDirectiveLiteralBlock(); break;
-    case DirectiveCodeBlock: this->ProcessDirectiveCodeBlock(); break;
-    case DirectiveReplace: this->ProcessDirectiveReplace(); break;
-    case DirectiveTocTree: this->ProcessDirectiveTocTree(); break;
-    }
+  }
+  switch (this->Directive) {
+    case DirectiveNone:
+      break;
+    case DirectiveParsedLiteral:
+      this->ProcessDirectiveParsedLiteral();
+      break;
+    case DirectiveLiteralBlock:
+      this->ProcessDirectiveLiteralBlock();
+      break;
+    case DirectiveCodeBlock:
+      this->ProcessDirectiveCodeBlock();
+      break;
+    case DirectiveReplace:
+      this->ProcessDirectiveReplace();
+      break;
+    case DirectiveTocTree:
+      this->ProcessDirectiveTocTree();
+      break;
+  }
   this->Markup = MarkupNone;
   this->Directive = DirectiveNone;
   this->MarkupLines.clear();
@@ -170,105 +156,82 @@ void cmRST::ProcessLine(std::string const& line)
   this->LastLineEndedInColonColon = false;
 
   // A line starting in .. is an explicit markup start.
-  if(line == ".." || (line.size() >= 3 && line[0] == '.' &&
-                      line[1] == '.' && isspace(line[2])))
-    {
+  if (line == ".." || (line.size() >= 3 && line[0] == '.' && line[1] == '.' &&
+                       isspace(line[2]))) {
     this->Reset();
-    this->Markup = (line.find_first_not_of(" \t", 2) == line.npos ?
-                    MarkupEmpty : MarkupNormal);
-    if(this->CMakeDirective.find(line))
-      {
+    this->Markup =
+      (line.find_first_not_of(" \t", 2) == line.npos ? MarkupEmpty
+                                                     : MarkupNormal);
+    if (this->CMakeDirective.find(line)) {
       // Output cmake domain directives and their content normally.
       this->NormalLine(line);
-      }
-    else if(this->CMakeModuleDirective.find(line))
-      {
+    } else if (this->CMakeModuleDirective.find(line)) {
       // Process cmake-module directive: scan .cmake file comments.
       std::string file = this->CMakeModuleDirective.match(1);
-      if(file.empty() || !this->ProcessInclude(file, IncludeModule))
-        {
+      if (file.empty() || !this->ProcessInclude(file, IncludeModule)) {
         this->NormalLine(line);
-        }
       }
-    else if(this->ParsedLiteralDirective.find(line))
-      {
+    } else if (this->ParsedLiteralDirective.find(line)) {
       // Record the literal lines to output after whole block.
       this->Directive = DirectiveParsedLiteral;
       this->MarkupLines.push_back(this->ParsedLiteralDirective.match(1));
-      }
-    else if(this->CodeBlockDirective.find(line))
-      {
+    } else if (this->CodeBlockDirective.find(line)) {
       // Record the literal lines to output after whole block.
       // Ignore the language spec and record the opening line as blank.
       this->Directive = DirectiveCodeBlock;
       this->MarkupLines.push_back("");
-      }
-    else if(this->ReplaceDirective.find(line))
-      {
+    } else if (this->ReplaceDirective.find(line)) {
       // Record the replace directive content.
       this->Directive = DirectiveReplace;
       this->ReplaceName = this->ReplaceDirective.match(1);
       this->MarkupLines.push_back(this->ReplaceDirective.match(2));
-      }
-    else if(this->IncludeDirective.find(line))
-      {
+    } else if (this->IncludeDirective.find(line)) {
       // Process the include directive or output the directive and its
       // content normally if it fails.
       std::string file = this->IncludeDirective.match(1);
-      if(file.empty() || !this->ProcessInclude(file, IncludeNormal))
-        {
+      if (file.empty() || !this->ProcessInclude(file, IncludeNormal)) {
         this->NormalLine(line);
-        }
       }
-    else if(this->TocTreeDirective.find(line))
-      {
+    } else if (this->TocTreeDirective.find(line)) {
       // Record the toctree entries to process after whole block.
       this->Directive = DirectiveTocTree;
       this->MarkupLines.push_back(this->TocTreeDirective.match(1));
-      }
-    else if(this->ProductionListDirective.find(line))
-      {
+    } else if (this->ProductionListDirective.find(line)) {
       // Output productionlist directives and their content normally.
       this->NormalLine(line);
-      }
-    else if(this->NoteDirective.find(line))
-      {
+    } else if (this->NoteDirective.find(line)) {
       // Output note directives and their content normally.
       this->NormalLine(line);
-      }
     }
+  }
   // An explicit markup start followed nothing but whitespace and a
   // blank line does not consume any indented text following.
-  else if(this->Markup == MarkupEmpty && line.empty())
-    {
+  else if (this->Markup == MarkupEmpty && line.empty()) {
     this->NormalLine(line);
-    }
+  }
   // Indented lines following an explicit markup start are explicit markup.
-  else if(this->Markup && (line.empty() || isspace(line[0])))
-    {
+  else if (this->Markup && (line.empty() || isspace(line[0]))) {
     this->Markup = MarkupNormal;
     // Record markup lines if the start line was recorded.
-    if(!this->MarkupLines.empty())
-      {
+    if (!this->MarkupLines.empty()) {
       this->MarkupLines.push_back(line);
-      }
     }
+  }
   // A blank line following a paragraph ending in "::" starts a literal block.
-  else if(lastLineEndedInColonColon && line.empty())
-    {
+  else if (lastLineEndedInColonColon && line.empty()) {
     // Record the literal lines to output after whole block.
     this->Markup = MarkupNormal;
     this->Directive = DirectiveLiteralBlock;
     this->MarkupLines.push_back("");
     this->OutputLine("", false);
-    }
+  }
   // Print non-markup lines.
-  else
-    {
+  else {
     this->NormalLine(line);
-    this->LastLineEndedInColonColon = (line.size() >= 2
-      && line[line.size()-2] == ':' && line[line.size()-1] == ':');
-    }
+    this->LastLineEndedInColonColon =
+      (line.size() >= 2 && line[line.size() - 2] == ':' &&
+       line[line.size() - 1] == ':');
+  }
 }
 
 void cmRST::NormalLine(std::string const& line)
@@ -279,109 +242,92 @@ void cmRST::NormalLine(std::string const& line)
 
 void cmRST::OutputLine(std::string const& line_in, bool inlineMarkup)
 {
-  if(this->OutputLinePending)
-    {
+  if (this->OutputLinePending) {
     this->OS << "\n";
     this->OutputLinePending = false;
-    }
-  if(inlineMarkup)
-    {
+  }
+  if (inlineMarkup) {
     std::string line = this->ReplaceSubstitutions(line_in);
     std::string::size_type pos = 0;
-    while(this->CMakeRole.find(line.c_str()+pos))
-      {
+    while (this->CMakeRole.find(line.c_str() + pos)) {
       this->OS << line.substr(pos, this->CMakeRole.start());
       std::string text = this->CMakeRole.match(3);
       // If a command reference has no explicit target and
       // no explicit "(...)" then add "()" to the text.
-      if(this->CMakeRole.match(2) == "command" &&
-         this->CMakeRole.match(5).empty() &&
-         text.find_first_of("()") == text.npos)
-        {
+      if (this->CMakeRole.match(2) == "command" &&
+          this->CMakeRole.match(5).empty() &&
+          text.find_first_of("()") == text.npos) {
         text += "()";
-        }
+      }
       this->OS << "``" << text << "``";
       pos += this->CMakeRole.end();
-      }
-    this->OS << line.substr(pos) << "\n";
     }
-  else
-    {
+    this->OS << line.substr(pos) << "\n";
+  } else {
     this->OS << line_in << "\n";
-    }
+  }
 }
 
 std::string cmRST::ReplaceSubstitutions(std::string const& line)
 {
   std::string out;
   std::string::size_type pos = 0;
-  while(this->Substitution.find(line.c_str()+pos))
-    {
+  while (this->Substitution.find(line.c_str() + pos)) {
     std::string::size_type start = this->Substitution.start(2);
     std::string::size_type end = this->Substitution.end(2);
     std::string substitute = this->Substitution.match(3);
-    std::map<std::string, std::string>::iterator
-      replace = this->Replace.find(substitute);
-    if(replace != this->Replace.end())
-      {
+    std::map<std::string, std::string>::iterator replace =
+      this->Replace.find(substitute);
+    if (replace != this->Replace.end()) {
       std::pair<std::set<std::string>::iterator, bool> replaced =
         this->Replaced.insert(substitute);
-      if(replaced.second)
-        {
+      if (replaced.second) {
         substitute = this->ReplaceSubstitutions(replace->second);
         this->Replaced.erase(replaced.first);
-        }
       }
+    }
     out += line.substr(pos, start);
     out += substitute;
     pos += end;
-    }
+  }
   out += line.substr(pos);
   return out;
 }
 
 void cmRST::OutputMarkupLines(bool inlineMarkup)
 {
-  for(std::vector<std::string>::iterator i = this->MarkupLines.begin();
-      i != this->MarkupLines.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->MarkupLines.begin();
+       i != this->MarkupLines.end(); ++i) {
     std::string line = *i;
-    if(!line.empty())
-      {
+    if (!line.empty()) {
       line = " " + line;
-      }
-    this->OutputLine(line, inlineMarkup);
     }
+    this->OutputLine(line, inlineMarkup);
+  }
   this->OutputLinePending = true;
 }
 
 bool cmRST::ProcessInclude(std::string file, IncludeType type)
 {
   bool found = false;
-  if(this->IncludeDepth < 10)
-    {
+  if (this->IncludeDepth < 10) {
     cmRST r(this->OS, this->DocRoot);
     r.IncludeDepth = this->IncludeDepth + 1;
     r.OutputLinePending = this->OutputLinePending;
-    if(type != IncludeTocTree)
-      {
+    if (type != IncludeTocTree) {
       r.Replace = this->Replace;
-      }
-    if(file[0] == '/')
-      {
+    }
+    if (file[0] == '/') {
       file = this->DocRoot + file;
-      }
-    else
-      {
+    } else {
       file = this->DocDir + "/" + file;
-      }
+    }
     found = r.ProcessFile(file, type == IncludeModule);
-    if(type != IncludeTocTree)
-      {
+    if (type != IncludeTocTree) {
       this->Replace = r.Replace;
-      }
-    this->OutputLinePending = r.OutputLinePending;
     }
+    this->OutputLinePending = r.OutputLinePending;
+  }
   return found;
 }
 
@@ -411,23 +357,18 @@ void cmRST::ProcessDirectiveReplace()
 void cmRST::ProcessDirectiveTocTree()
 {
   // Process documents referenced by toctree directive.
-  for(std::vector<std::string>::iterator i = this->MarkupLines.begin();
-      i != this->MarkupLines.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->MarkupLines.begin();
+       i != this->MarkupLines.end(); ++i) {
     std::string const& line = *i;
-    if (!line.empty() && line[0] != ':')
-      {
-      if (this->TocTreeLink.find(line))
-        {
+    if (!line.empty() && line[0] != ':') {
+      if (this->TocTreeLink.find(line)) {
         std::string const& link = this->TocTreeLink.match(1);
         this->ProcessInclude(link + ".rst", IncludeTocTree);
-        }
-      else
-        {
+      } else {
         this->ProcessInclude(line + ".rst", IncludeTocTree);
-        }
       }
     }
+  }
 }
 
 void cmRST::UnindentLines(std::vector<std::string>& lines)
@@ -436,57 +377,48 @@ void cmRST::UnindentLines(std::vector<std::string>& lines)
   std::string indentText;
   std::string::size_type indentEnd = 0;
   bool first = true;
-  for(size_t i = 1; i < lines.size(); ++i)
-    {
+  for (size_t i = 1; i < lines.size(); ++i) {
     std::string const& line = lines[i];
 
     // Do not consider empty lines.
-    if(line.empty())
-      {
+    if (line.empty()) {
       continue;
-      }
+    }
 
     // Record indentation on first non-empty line.
-    if(first)
-      {
+    if (first) {
       first = false;
       indentEnd = line.find_first_not_of(" \t");
       indentText = line.substr(0, indentEnd);
       continue;
-      }
+    }
 
     // Truncate indentation to match that on this line.
     indentEnd = std::min(indentEnd, line.size());
-    for(std::string::size_type j = 0; j != indentEnd; ++j)
-      {
-      if(line[j] != indentText[j])
-        {
+    for (std::string::size_type j = 0; j != indentEnd; ++j) {
+      if (line[j] != indentText[j]) {
         indentEnd = j;
         break;
-        }
       }
     }
+  }
 
   // Update second and later lines.
-  for(size_t i = 1; i < lines.size(); ++i)
-    {
+  for (size_t i = 1; i < lines.size(); ++i) {
     std::string& line = lines[i];
-    if(!line.empty())
-      {
+    if (!line.empty()) {
       line = line.substr(indentEnd);
-      }
     }
+  }
 
   std::vector<std::string>::const_iterator it = lines.begin();
   size_t leadingEmpty = std::distance(it, cmFindNot(lines, std::string()));
 
   std::vector<std::string>::const_reverse_iterator rit = lines.rbegin();
-  size_t trailingEmpty = std::distance(rit,
-                            cmFindNot(cmReverseRange(lines), std::string()));
+  size_t trailingEmpty =
+    std::distance(rit, cmFindNot(cmReverseRange(lines), std::string()));
 
-  std::vector<std::string>::iterator contentEnd
-      = cmRotate(lines.begin(),
-                 lines.begin() + leadingEmpty,
-                 lines.end() - trailingEmpty);
+  std::vector<std::string>::iterator contentEnd = cmRotate(
+    lines.begin(), lines.begin() + leadingEmpty, lines.end() - trailingEmpty);
   lines.erase(contentEnd, lines.end());
 }
diff --git a/Source/cmRST.h b/Source/cmRST.h
index 098afab..0e379b6 100644
--- a/Source/cmRST.h
+++ b/Source/cmRST.h
@@ -31,6 +31,7 @@ class cmRST
 public:
   cmRST(std::ostream& os, std::string const& docroot);
   bool ProcessFile(std::string const& fname, bool isModule = false);
+
 private:
   enum IncludeType
   {
diff --git a/Source/cmRemoveCommand.cxx b/Source/cmRemoveCommand.cxx
index bad38be..955f712 100644
--- a/Source/cmRemoveCommand.cxx
+++ b/Source/cmRemoveCommand.cxx
@@ -12,24 +12,21 @@
 #include "cmRemoveCommand.h"
 
 // cmRemoveCommand
-bool cmRemoveCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmRemoveCommand::InitialPass(std::vector<std::string> const& args,
+                                  cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
 
   const char* variable = args[0].c_str(); // VAR is always first
   // get the old value
-  const char* cacheValue
-    = this->Makefile->GetDefinition(variable);
+  const char* cacheValue = this->Makefile->GetDefinition(variable);
 
   // if there is no old value then return
-  if (!cacheValue)
-    {
+  if (!cacheValue) {
     return true;
-    }
+  }
 
   // expand the variable
   std::vector<std::string> varArgsExpanded;
@@ -44,30 +41,24 @@ bool cmRemoveCommand
 
   // now create the new value
   std::string value;
-  for(unsigned int j = 0; j < varArgsExpanded.size(); ++j)
-    {
+  for (unsigned int j = 0; j < varArgsExpanded.size(); ++j) {
     int found = 0;
-    for(unsigned int k = 0; k < argsExpanded.size(); ++k)
-      {
-      if (varArgsExpanded[j] == argsExpanded[k])
-        {
+    for (unsigned int k = 0; k < argsExpanded.size(); ++k) {
+      if (varArgsExpanded[j] == argsExpanded[k]) {
         found = 1;
         break;
-        }
       }
-    if (!found)
-      {
-      if (!value.empty())
-        {
+    }
+    if (!found) {
+      if (!value.empty()) {
         value += ";";
-        }
-      value += varArgsExpanded[j];
       }
+      value += varArgsExpanded[j];
     }
+  }
 
   // add the definition
   this->Makefile->AddDefinition(variable, value.c_str());
 
   return true;
 }
-
diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h
index 410b370..c226a54 100644
--- a/Source/cmRemoveCommand.h
+++ b/Source/cmRemoveCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmRemoveCommand;
-    }
+  virtual cmCommand* Clone() { return new cmRemoveCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "remove";}
+  virtual std::string GetName() const { return "remove"; }
 
   cmTypeMacro(cmRemoveCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmRemoveDefinitionsCommand.cxx b/Source/cmRemoveDefinitionsCommand.cxx
index b4be0f5..638eda6 100644
--- a/Source/cmRemoveDefinitionsCommand.cxx
+++ b/Source/cmRemoveDefinitionsCommand.cxx
@@ -12,20 +12,17 @@
 #include "cmRemoveDefinitionsCommand.h"
 
 // cmRemoveDefinitionsCommand
-bool cmRemoveDefinitionsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmRemoveDefinitionsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   // it is OK to have no arguments
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     return true;
-    }
+  }
 
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
     this->Makefile->RemoveDefineFlag(i->c_str());
-    }
+  }
   return true;
 }
-
diff --git a/Source/cmRemoveDefinitionsCommand.h b/Source/cmRemoveDefinitionsCommand.h
index cac94be..b440307 100644
--- a/Source/cmRemoveDefinitionsCommand.h
+++ b/Source/cmRemoveDefinitionsCommand.h
@@ -27,26 +27,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmRemoveDefinitionsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmRemoveDefinitionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "remove_definitions";}
+  virtual std::string GetName() const { return "remove_definitions"; }
 
   cmTypeMacro(cmRemoveDefinitionsCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmReturnCommand.cxx b/Source/cmReturnCommand.cxx
index 51cc83f..1de649f 100644
--- a/Source/cmReturnCommand.cxx
+++ b/Source/cmReturnCommand.cxx
@@ -13,9 +13,8 @@
 
 // cmReturnCommand
 bool cmReturnCommand::InitialPass(std::vector<std::string> const&,
-                                  cmExecutionStatus &status)
+                                  cmExecutionStatus& status)
 {
   status.SetReturnInvoked(true);
   return true;
 }
-
diff --git a/Source/cmReturnCommand.h b/Source/cmReturnCommand.h
index 4ff81ef..44cd4c8 100644
--- a/Source/cmReturnCommand.h
+++ b/Source/cmReturnCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmReturnCommand;
-    }
+  virtual cmCommand* Clone() { return new cmReturnCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "return";}
+  virtual std::string GetName() const { return "return"; }
 
   cmTypeMacro(cmReturnCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmScriptGenerator.cxx b/Source/cmScriptGenerator.cxx
index 3b8a20e..5fed107 100644
--- a/Source/cmScriptGenerator.cxx
+++ b/Source/cmScriptGenerator.cxx
@@ -13,26 +13,24 @@
 
 #include "cmSystemTools.h"
 
-cmScriptGenerator
-::cmScriptGenerator(const std::string& config_var,
-                    std::vector<std::string> const& configurations):
-  RuntimeConfigVariable(config_var),
-  Configurations(configurations),
-  ConfigurationName(""),
-  ConfigurationTypes(0),
-  ActionsPerConfig(false)
+cmScriptGenerator::cmScriptGenerator(
+  const std::string& config_var,
+  std::vector<std::string> const& configurations)
+  : RuntimeConfigVariable(config_var)
+  , Configurations(configurations)
+  , ConfigurationName("")
+  , ConfigurationTypes(0)
+  , ActionsPerConfig(false)
 {
 }
 
-cmScriptGenerator
-::~cmScriptGenerator()
+cmScriptGenerator::~cmScriptGenerator()
 {
 }
 
-void
-cmScriptGenerator
-::Generate(std::ostream& os, const std::string& config,
-           std::vector<std::string> const& configurationTypes)
+void cmScriptGenerator::Generate(
+  std::ostream& os, const std::string& config,
+  std::vector<std::string> const& configurationTypes)
 {
   this->ConfigurationName = config;
   this->ConfigurationTypes = &configurationTypes;
@@ -44,57 +42,48 @@ cmScriptGenerator
 static void cmScriptGeneratorEncodeConfig(const std::string& config,
                                           std::string& result)
 {
-  for(const char* c = config.c_str(); *c; ++c)
-    {
-    if(*c >= 'a' && *c <= 'z')
-      {
+  for (const char* c = config.c_str(); *c; ++c) {
+    if (*c >= 'a' && *c <= 'z') {
       result += "[";
       result += static_cast<char>(*c + 'A' - 'a');
       result += *c;
       result += "]";
-      }
-    else if(*c >= 'A' && *c <= 'Z')
-      {
+    } else if (*c >= 'A' && *c <= 'Z') {
       result += "[";
       result += *c;
       result += static_cast<char>(*c + 'a' - 'A');
       result += "]";
-      }
-    else
-      {
+    } else {
       result += *c;
-      }
     }
+  }
 }
 
-std::string
-cmScriptGenerator::CreateConfigTest(const std::string& config)
+std::string cmScriptGenerator::CreateConfigTest(const std::string& config)
 {
   std::string result = "\"${";
   result += this->RuntimeConfigVariable;
   result += "}\" MATCHES \"^(";
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     cmScriptGeneratorEncodeConfig(config, result);
-    }
+  }
   result += ")$\"";
   return result;
 }
 
-std::string
-cmScriptGenerator::CreateConfigTest(std::vector<std::string> const& configs)
+std::string cmScriptGenerator::CreateConfigTest(
+  std::vector<std::string> const& configs)
 {
   std::string result = "\"${";
   result += this->RuntimeConfigVariable;
   result += "}\" MATCHES \"^(";
   const char* sep = "";
-  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) {
     result += sep;
     sep = "|";
     cmScriptGeneratorEncodeConfig(*ci, result);
-    }
+  }
   result += ")$\"";
   return result;
 }
@@ -111,25 +100,21 @@ void cmScriptGenerator::GenerateScript(std::ostream& os)
 void cmScriptGenerator::GenerateScriptConfigs(std::ostream& os,
                                               Indent const& indent)
 {
-  if(this->ActionsPerConfig)
-    {
+  if (this->ActionsPerConfig) {
     this->GenerateScriptActionsPerConfig(os, indent);
-    }
-  else
-    {
+  } else {
     this->GenerateScriptActionsOnce(os, indent);
-    }
+  }
 }
 
 void cmScriptGenerator::GenerateScriptActions(std::ostream& os,
                                               Indent const& indent)
 {
-  if(this->ActionsPerConfig)
-    {
+  if (this->ActionsPerConfig) {
     // This is reached for single-configuration build generators in a
     // per-config script generator.
     this->GenerateScriptForConfig(os, this->ConfigurationName, indent);
-    }
+  }
 }
 
 void cmScriptGenerator::GenerateScriptForConfig(std::ostream&,
@@ -142,84 +127,71 @@ void cmScriptGenerator::GenerateScriptForConfig(std::ostream&,
 bool cmScriptGenerator::GeneratesForConfig(const std::string& config)
 {
   // If this is not a configuration-specific rule then we install.
-  if(this->Configurations.empty())
-    {
+  if (this->Configurations.empty()) {
     return true;
-    }
+  }
 
   // This is a configuration-specific rule.  Check if the config
   // matches this rule.
   std::string config_upper = cmSystemTools::UpperCase(config);
-  for(std::vector<std::string>::const_iterator i =
-        this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
-    if(cmSystemTools::UpperCase(*i) == config_upper)
-      {
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
+    if (cmSystemTools::UpperCase(*i) == config_upper) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 void cmScriptGenerator::GenerateScriptActionsOnce(std::ostream& os,
                                                   Indent const& indent)
 {
-  if(this->Configurations.empty())
-    {
+  if (this->Configurations.empty()) {
     // This rule is for all configurations.
     this->GenerateScriptActions(os, indent);
-    }
-  else
-    {
+  } else {
     // Generate a per-configuration block.
     std::string config_test = this->CreateConfigTest(this->Configurations);
     os << indent << "if(" << config_test << ")\n";
     this->GenerateScriptActions(os, indent.Next());
     os << indent << "endif(" << config_test << ")\n";
-    }
+  }
 }
 
 void cmScriptGenerator::GenerateScriptActionsPerConfig(std::ostream& os,
                                                        Indent const& indent)
 {
-  if(this->ConfigurationTypes->empty())
-    {
+  if (this->ConfigurationTypes->empty()) {
     // In a single-configuration generator there is only one action
     // and it applies if the runtime-requested configuration is among
     // the rule's allowed configurations.  The configuration built in
     // the tree does not matter for this decision but will be used to
     // generate proper target file names into the code.
     this->GenerateScriptActionsOnce(os, indent);
-    }
-  else
-    {
+  } else {
     // In a multi-configuration generator we produce a separate rule
     // in a block for each configuration that is built.  We restrict
     // the list of configurations to those to which this rule applies.
     bool first = true;
-    for(std::vector<std::string>::const_iterator i =
-          this->ConfigurationTypes->begin();
-        i != this->ConfigurationTypes->end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i =
+           this->ConfigurationTypes->begin();
+         i != this->ConfigurationTypes->end(); ++i) {
       const char* config = i->c_str();
-      if(this->GeneratesForConfig(config))
-        {
+      if (this->GeneratesForConfig(config)) {
         // Generate a per-configuration block.
         std::string config_test = this->CreateConfigTest(config);
-        os << indent << (first? "if(" : "elseif(") << config_test << ")\n";
+        os << indent << (first ? "if(" : "elseif(") << config_test << ")\n";
         this->GenerateScriptForConfig(os, config, indent.Next());
         first = false;
-        }
       }
-    if(!first)
-      {
-      if(this->NeedsScriptNoConfig())
-        {
+    }
+    if (!first) {
+      if (this->NeedsScriptNoConfig()) {
         os << indent << "else()\n";
         this->GenerateScriptNoConfig(os, indent.Next());
-        }
-      os << indent << "endif()\n";
       }
+      os << indent << "endif()\n";
     }
+  }
 }
diff --git a/Source/cmScriptGenerator.h b/Source/cmScriptGenerator.h
index bc9372f..ef0766f 100644
--- a/Source/cmScriptGenerator.h
+++ b/Source/cmScriptGenerator.h
@@ -17,19 +17,25 @@
 class cmScriptGeneratorIndent
 {
 public:
-  cmScriptGeneratorIndent(): Level(0) {}
-  cmScriptGeneratorIndent(int level): Level(level) {}
+  cmScriptGeneratorIndent()
+    : Level(0)
+  {
+  }
+  cmScriptGeneratorIndent(int level)
+    : Level(level)
+  {
+  }
   void Write(std::ostream& os) const
-    {
-    for(int i=0; i < this->Level; ++i)
-      {
+  {
+    for (int i = 0; i < this->Level; ++i) {
       os << " ";
-      }
     }
+  }
   cmScriptGeneratorIndent Next(int step = 2) const
-    {
+  {
     return cmScriptGeneratorIndent(this->Level + step);
-    }
+  }
+
 private:
   int Level;
 };
diff --git a/Source/cmSearchPath.cxx b/Source/cmSearchPath.cxx
index 28798c1..a0cce12 100644
--- a/Source/cmSearchPath.cxx
+++ b/Source/cmSearchPath.cxx
@@ -15,7 +15,7 @@
 #include "cmFindCommon.h"
 
 cmSearchPath::cmSearchPath(cmFindCommon* findCmd)
-: FC(findCmd)
+  : FC(findCmd)
 {
 }
 
@@ -23,23 +23,19 @@ cmSearchPath::~cmSearchPath()
 {
 }
 
-
 void cmSearchPath::ExtractWithout(const std::set<std::string>& ignore,
                                   std::vector<std::string>& outPaths,
                                   bool clear) const
 {
-  if(clear)
-    {
+  if (clear) {
     outPaths.clear();
-    }
-  for(std::vector<std::string>::const_iterator p = this->Paths.begin();
-      p != this->Paths.end(); ++p)
-    {
-    if(ignore.count(*p) == 0)
-      {
+  }
+  for (std::vector<std::string>::const_iterator p = this->Paths.begin();
+       p != this->Paths.end(); ++p) {
+    if (ignore.count(*p) == 0) {
       outPaths.push_back(*p);
-      }
     }
+  }
 }
 
 void cmSearchPath::AddPath(const std::string& path)
@@ -57,11 +53,10 @@ void cmSearchPath::AddUserPath(const std::string& path)
   // it.
   cmSystemTools::KeyWOW64 view = cmSystemTools::KeyWOW64_32;
   cmSystemTools::KeyWOW64 other_view = cmSystemTools::KeyWOW64_64;
-  if(this->FC->Makefile->PlatformIs64Bit())
-    {
+  if (this->FC->Makefile->PlatformIs64Bit()) {
     view = cmSystemTools::KeyWOW64_64;
     other_view = cmSystemTools::KeyWOW64_32;
-    }
+  }
 
   // Expand using the view of the target application.
   std::string expanded = path;
@@ -70,19 +65,17 @@ void cmSearchPath::AddUserPath(const std::string& path)
 
   // Executables can be either 32-bit or 64-bit, so expand using the
   // alternative view.
-  if(expanded != path && this->FC->CMakePathName == "PROGRAM")
-    {
+  if (expanded != path && this->FC->CMakePathName == "PROGRAM") {
     expanded = path;
     cmSystemTools::ExpandRegistryValues(expanded, other_view);
     cmSystemTools::GlobDirs(expanded, outPaths);
-    }
+  }
 
   // Process them all from the current directory
-  for(std::vector<std::string>::const_iterator p = outPaths.begin();
-      p != outPaths.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p = outPaths.begin();
+       p != outPaths.end(); ++p) {
     this->AddPathInternal(*p, this->FC->Makefile->GetCurrentSourceDirectory());
-    }
+  }
 }
 
 void cmSearchPath::AddCMakePath(const std::string& variable)
@@ -90,29 +83,26 @@ void cmSearchPath::AddCMakePath(const std::string& variable)
   assert(this->FC != NULL);
 
   // Get a path from a CMake variable.
-  if(const char* value = this->FC->Makefile->GetDefinition(variable))
-    {
+  if (const char* value = this->FC->Makefile->GetDefinition(variable)) {
     std::vector<std::string> expanded;
     cmSystemTools::ExpandListArgument(value, expanded);
 
-    for(std::vector<std::string>::const_iterator p = expanded.begin();
-        p!= expanded.end(); ++p)
-      {
+    for (std::vector<std::string>::const_iterator p = expanded.begin();
+         p != expanded.end(); ++p) {
       this->AddPathInternal(*p,
                             this->FC->Makefile->GetCurrentSourceDirectory());
-      }
     }
+  }
 }
 
 void cmSearchPath::AddEnvPath(const std::string& variable)
 {
   std::vector<std::string> expanded;
   cmSystemTools::GetPath(expanded, variable.c_str());
-  for(std::vector<std::string>::const_iterator p = expanded.begin();
-      p!= expanded.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p = expanded.begin();
+       p != expanded.end(); ++p) {
     this->AddPathInternal(*p);
-    }
+  }
 }
 
 void cmSearchPath::AddCMakePrefixPath(const std::string& variable)
@@ -120,39 +110,33 @@ void cmSearchPath::AddCMakePrefixPath(const std::string& variable)
   assert(this->FC != NULL);
 
   // Get a path from a CMake variable.
-  if(const char* value = this->FC->Makefile->GetDefinition(variable))
-    {
+  if (const char* value = this->FC->Makefile->GetDefinition(variable)) {
     std::vector<std::string> expanded;
     cmSystemTools::ExpandListArgument(value, expanded);
 
     this->AddPrefixPaths(expanded,
                          this->FC->Makefile->GetCurrentSourceDirectory());
-    }
+  }
 }
 
 static std::string cmSearchPathStripBin(std::string const& s)
 {
   // If the path is a PREFIX/bin case then add its parent instead.
-  if((cmHasLiteralSuffix(s, "/bin")) ||
-     (cmHasLiteralSuffix(s, "/sbin")))
-    {
+  if ((cmHasLiteralSuffix(s, "/bin")) || (cmHasLiteralSuffix(s, "/sbin"))) {
     return cmSystemTools::GetFilenamePath(s);
-    }
-  else
-    {
+  } else {
     return s;
-    }
+  }
 }
 
 void cmSearchPath::AddEnvPrefixPath(const std::string& variable, bool stripBin)
 {
   std::vector<std::string> expanded;
   cmSystemTools::GetPath(expanded, variable.c_str());
-  if (stripBin)
-    {
+  if (stripBin) {
     std::transform(expanded.begin(), expanded.end(), expanded.begin(),
                    cmSearchPathStripBin);
-    }
+  }
   this->AddPrefixPaths(expanded);
 }
 
@@ -160,102 +144,85 @@ void cmSearchPath::AddSuffixes(const std::vector<std::string>& suffixes)
 {
   std::vector<std::string> inPaths;
   inPaths.swap(this->Paths);
-  this->Paths.reserve(inPaths.size()*(suffixes.size()+1));
+  this->Paths.reserve(inPaths.size() * (suffixes.size() + 1));
 
-  for(std::vector<std::string>::iterator ip = inPaths.begin();
-      ip != inPaths.end(); ++ip)
-    {
+  for (std::vector<std::string>::iterator ip = inPaths.begin();
+       ip != inPaths.end(); ++ip) {
     cmSystemTools::ConvertToUnixSlashes(*ip);
 
     // if *i is only / then do not add a //
     // this will get incorrectly considered a network
     // path on windows and cause huge delays.
     std::string p = *ip;
-    if(!p.empty() && *p.rbegin() != '/')
-      {
+    if (!p.empty() && *p.rbegin() != '/') {
       p += "/";
-      }
+    }
 
     // Combine with all the suffixes
-    for(std::vector<std::string>::const_iterator s = suffixes.begin();
-        s != suffixes.end(); ++s)
-      {
-      this->Paths.push_back(p+*s);
-      }
+    for (std::vector<std::string>::const_iterator s = suffixes.begin();
+         s != suffixes.end(); ++s) {
+      this->Paths.push_back(p + *s);
+    }
 
     // And now the original w/o any suffix
     this->Paths.push_back(*ip);
-    }
+  }
 }
 
 void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths,
-                                  const char *base)
+                                  const char* base)
 {
   assert(this->FC != NULL);
 
   // default for programs
   std::string subdir = "bin";
 
-  if (this->FC->CMakePathName == "INCLUDE")
-    {
+  if (this->FC->CMakePathName == "INCLUDE") {
     subdir = "include";
-    }
-  else if (this->FC->CMakePathName == "LIBRARY")
-    {
+  } else if (this->FC->CMakePathName == "LIBRARY") {
     subdir = "lib";
-    }
-  else if (this->FC->CMakePathName == "FRAMEWORK")
-    {
-    subdir = "";  // ? what to do for frameworks ?
-    }
+  } else if (this->FC->CMakePathName == "FRAMEWORK") {
+    subdir = ""; // ? what to do for frameworks ?
+  }
 
-  for(std::vector<std::string>::const_iterator p = paths.begin();
-      p != paths.end(); ++p)
-    {
+  for (std::vector<std::string>::const_iterator p = paths.begin();
+       p != paths.end(); ++p) {
     std::string dir = *p;
-    if(!subdir.empty() && !dir.empty() && *dir.rbegin() != '/')
-      {
+    if (!subdir.empty() && !dir.empty() && *dir.rbegin() != '/') {
       dir += "/";
-      }
-    if(subdir == "include" || subdir == "lib")
-      {
+    }
+    if (subdir == "include" || subdir == "lib") {
       const char* arch =
         this->FC->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE");
-      if(arch && *arch)
-        {
-        this->AddPathInternal(dir+subdir+"/"+arch, base);
-        }
+      if (arch && *arch) {
+        this->AddPathInternal(dir + subdir + "/" + arch, base);
       }
+    }
     std::string add = dir + subdir;
-    if(add != "/")
-      {
+    if (add != "/") {
       this->AddPathInternal(add, base);
-      }
-    if (subdir == "bin")
-      {
-      this->AddPathInternal(dir+"sbin", base);
-      }
-    if(!subdir.empty() && *p != "/")
-      {
+    }
+    if (subdir == "bin") {
+      this->AddPathInternal(dir + "sbin", base);
+    }
+    if (!subdir.empty() && *p != "/") {
       this->AddPathInternal(*p, base);
-      }
     }
+  }
 }
 
-void cmSearchPath::AddPathInternal(const std::string& path, const char *base)
+void cmSearchPath::AddPathInternal(const std::string& path, const char* base)
 {
   assert(this->FC != NULL);
 
   std::string collapsed = cmSystemTools::CollapseFullPath(path, base);
 
-   if(collapsed.empty())
-    {
+  if (collapsed.empty()) {
     return;
-    }
+  }
 
   // Insert the path if has not already been emitted.
-  if(this->FC->SearchPathsEmitted.insert(collapsed).second)
-    {
+  if (this->FC->SearchPathsEmitted.insert(collapsed).second) {
     this->Paths.push_back(collapsed);
-    }
+  }
 }
diff --git a/Source/cmSearchPath.h b/Source/cmSearchPath.h
index 41c680d..4b37a3a 100644
--- a/Source/cmSearchPath.h
+++ b/Source/cmSearchPath.h
@@ -47,10 +47,10 @@ public:
 
 protected:
   void AddPrefixPaths(const std::vector<std::string>& paths,
-                      const char *base = 0);
-  void AddPathInternal(const std::string& path, const char *base = 0);
+                      const char* base = 0);
+  void AddPathInternal(const std::string& path, const char* base = 0);
 
-  cmFindCommon *FC;
+  cmFindCommon* FC;
   std::vector<std::string> Paths;
 };
 
diff --git a/Source/cmSeparateArgumentsCommand.cxx b/Source/cmSeparateArgumentsCommand.cxx
index 8e6c311..3438321 100644
--- a/Source/cmSeparateArgumentsCommand.cxx
+++ b/Source/cmSeparateArgumentsCommand.cxx
@@ -12,98 +12,89 @@
 #include "cmSeparateArgumentsCommand.h"
 
 // cmSeparateArgumentsCommand
-bool cmSeparateArgumentsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSeparateArgumentsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.empty())
-    {
+  if (args.empty()) {
     this->SetError("must be given at least one argument.");
     return false;
-    }
+  }
 
   std::string var;
   std::string command;
-  enum Mode { ModeOld, ModeUnix, ModeWindows };
+  enum Mode
+  {
+    ModeOld,
+    ModeUnix,
+    ModeWindows
+  };
   Mode mode = ModeOld;
-  enum Doing { DoingNone, DoingVariable, DoingMode, DoingCommand };
+  enum Doing
+  {
+    DoingNone,
+    DoingVariable,
+    DoingMode,
+    DoingCommand
+  };
   Doing doing = DoingVariable;
-  for(unsigned int i=0; i < args.size(); ++i)
-    {
-    if(doing == DoingVariable)
-      {
+  for (unsigned int i = 0; i < args.size(); ++i) {
+    if (doing == DoingVariable) {
       var = args[i];
       doing = DoingMode;
-      }
-    else if(doing == DoingMode && args[i] == "UNIX_COMMAND")
-      {
+    } else if (doing == DoingMode && args[i] == "UNIX_COMMAND") {
       mode = ModeUnix;
       doing = DoingCommand;
-      }
-    else if(doing == DoingMode && args[i] == "WINDOWS_COMMAND")
-      {
+    } else if (doing == DoingMode && args[i] == "WINDOWS_COMMAND") {
       mode = ModeWindows;
       doing = DoingCommand;
-      }
-    else if(doing == DoingCommand)
-      {
+    } else if (doing == DoingCommand) {
       command = args[i];
       doing = DoingNone;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "given unknown argument " << args[i];
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
-  if(mode == ModeOld)
-    {
+  if (mode == ModeOld) {
     // Original space-replacement version of command.
-    if(const char* def = this->Makefile->GetDefinition(var))
-      {
+    if (const char* def = this->Makefile->GetDefinition(var)) {
       std::string value = def;
       cmSystemTools::ReplaceString(value, " ", ";");
       this->Makefile->AddDefinition(var, value.c_str());
-      }
     }
-  else
-    {
+  } else {
     // Parse the command line.
     std::vector<std::string> vec;
-    if(mode == ModeUnix)
-      {
+    if (mode == ModeUnix) {
       cmSystemTools::ParseUnixCommandLine(command.c_str(), vec);
-      }
-    else // if(mode == ModeWindows)
-      {
+    } else // if(mode == ModeWindows)
+    {
       cmSystemTools::ParseWindowsCommandLine(command.c_str(), vec);
-      }
+    }
 
     // Construct the result list value.
     std::string value;
     const char* sep = "";
-    for(std::vector<std::string>::const_iterator vi = vec.begin();
-        vi != vec.end(); ++vi)
-      {
+    for (std::vector<std::string>::const_iterator vi = vec.begin();
+         vi != vec.end(); ++vi) {
       // Separate from the previous argument.
       value += sep;
       sep = ";";
 
       // Preserve semicolons.
-      for(std::string::const_iterator si = vi->begin();
-          si != vi->end(); ++si)
-        {
-        if(*si == ';')
-          {
+      for (std::string::const_iterator si = vi->begin(); si != vi->end();
+           ++si) {
+        if (*si == ';') {
           value += '\\';
-          }
-        value += *si;
         }
+        value += *si;
       }
-    this->Makefile->AddDefinition(var, value.c_str());
     }
+    this->Makefile->AddDefinition(var, value.c_str());
+  }
 
   return true;
 }
diff --git a/Source/cmSeparateArgumentsCommand.h b/Source/cmSeparateArgumentsCommand.h
index a527ae7..47246c9 100644
--- a/Source/cmSeparateArgumentsCommand.h
+++ b/Source/cmSeparateArgumentsCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmSeparateArgumentsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSeparateArgumentsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "separate_arguments";}
+  virtual std::string GetName() const { return "separate_arguments"; }
 
   cmTypeMacro(cmSeparateArgumentsCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index 1d70ad6..5f4cfee 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -12,63 +12,56 @@
 #include "cmSetCommand.h"
 
 // cmSetCommand
-bool cmSetCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSetCommand::InitialPass(std::vector<std::string> const& args,
+                               cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // watch for ENV signatures
   const char* variable = args[0].c_str(); // VAR is always first
-  if (cmHasLiteralPrefix(variable, "ENV{") && strlen(variable) > 5)
-    {
+  if (cmHasLiteralPrefix(variable, "ENV{") && strlen(variable) > 5) {
     // what is the variable name
-    char *varName = new char [strlen(variable)];
-    strncpy(varName,variable+4,strlen(variable)-5);
-    varName[strlen(variable)-5] = '\0';
+    char* varName = new char[strlen(variable)];
+    strncpy(varName, variable + 4, strlen(variable) - 5);
+    varName[strlen(variable) - 5] = '\0';
     std::string putEnvArg = varName;
     putEnvArg += "=";
 
     // what is the current value if any
-    const char *currValue = getenv(varName);
-    delete [] varName;
+    const char* currValue = getenv(varName);
+    delete[] varName;
 
     // will it be set to something, then set it
-    if (args.size() > 1 && !args[1].empty())
-      {
+    if (args.size() > 1 && !args[1].empty()) {
       // but only if it is different from current value
-      if (!currValue || strcmp(currValue,args[1].c_str()))
-        {
+      if (!currValue || strcmp(currValue, args[1].c_str())) {
         putEnvArg += args[1];
         cmSystemTools::PutEnv(putEnvArg);
-        }
-      return true;
       }
+      return true;
+    }
 
     // if it will be cleared, then clear it if it isn't already clear
-    if (currValue)
-      {
+    if (currValue) {
       cmSystemTools::PutEnv(putEnvArg);
-      }
-    return true;
     }
+    return true;
+  }
 
   // SET (VAR) // Removes the definition of VAR.
-  if (args.size() == 1)
-    {
+  if (args.size() == 1) {
     this->Makefile->RemoveDefinition(variable);
     return true;
-    }
+  }
   // SET (VAR PARENT_SCOPE) // Removes the definition of VAR
-                            // in the parent scope.
-  else if (args.size() == 2 && args[args.size()-1] == "PARENT_SCOPE")
-    {
+  // in the parent scope.
+  else if (args.size() == 2 && args[args.size() - 1] == "PARENT_SCOPE") {
     this->Makefile->RaiseScope(variable, 0);
     return true;
-    }
+  }
 
   // here are the remaining options
   //  SET (VAR value )
@@ -79,91 +72,74 @@ bool cmSetCommand
   bool cache = false; // optional
   bool force = false; // optional
   bool parentScope = false;
-  cmState::CacheEntryType type
-    = cmState::STRING; // required if cache
-  const char* docstring = 0; // required if cache
+  cmState::CacheEntryType type = cmState::STRING; // required if cache
+  const char* docstring = 0;                      // required if cache
 
   unsigned int ignoreLastArgs = 0;
   // look for PARENT_SCOPE argument
-  if (args.size() > 1 && args[args.size()-1] == "PARENT_SCOPE")
-    {
+  if (args.size() > 1 && args[args.size() - 1] == "PARENT_SCOPE") {
     parentScope = true;
     ignoreLastArgs++;
-    }
-  else
-    {
+  } else {
     // look for FORCE argument
-    if (args.size() > 4 && args[args.size()-1] == "FORCE")
-      {
+    if (args.size() > 4 && args[args.size() - 1] == "FORCE") {
       force = true;
       ignoreLastArgs++;
-      }
+    }
 
     // check for cache signature
-    if (args.size() > 3 && args[args.size() - 3 - (force ? 1 : 0)] == "CACHE")
-      {
+    if (args.size() > 3 &&
+        args[args.size() - 3 - (force ? 1 : 0)] == "CACHE") {
       cache = true;
-      ignoreLastArgs+=3;
-      }
+      ignoreLastArgs += 3;
     }
+  }
 
   // collect any values into a single semi-colon separated value list
   value = cmJoin(cmMakeRange(args).advance(1).retreat(ignoreLastArgs), ";");
 
-  if (parentScope)
-    {
+  if (parentScope) {
     this->Makefile->RaiseScope(variable, value.c_str());
     return true;
-    }
-
+  }
 
   // we should be nice and try to catch some simple screwups if the last or
   // next to last args are CACHE then they screwed up.  If they used FORCE
   // without CACHE they screwed up
   if ((args[args.size() - 1] == "CACHE") ||
       (args.size() > 1 && args[args.size() - 2] == "CACHE") ||
-      (force && !cache))
-    {
+      (force && !cache)) {
     this->SetError("given invalid arguments for CACHE mode.");
     return false;
-    }
+  }
 
-  if(cache)
-    {
+  if (cache) {
     std::string::size_type cacheStart = args.size() - 3 - (force ? 1 : 0);
-    type = cmState::StringToCacheEntryType(args[cacheStart+1].c_str());
-    docstring = args[cacheStart+2].c_str();
-    }
+    type = cmState::StringToCacheEntryType(args[cacheStart + 1].c_str());
+    docstring = args[cacheStart + 2].c_str();
+  }
 
   // see if this is already in the cache
   cmState* state = this->Makefile->GetState();
   const char* existingValue = state->GetCacheEntryValue(variable);
-  if(existingValue &&
-      (state->GetCacheEntryType(variable) != cmState::UNINITIALIZED))
-    {
+  if (existingValue &&
+      (state->GetCacheEntryType(variable) != cmState::UNINITIALIZED)) {
     // if the set is trying to CACHE the value but the value
     // is already in the cache and the type is not internal
     // then leave now without setting any definitions in the cache
     // or the makefile
-    if(cache && type != cmState::INTERNAL && !force)
-      {
+    if (cache && type != cmState::INTERNAL && !force) {
       return true;
-      }
     }
+  }
 
   // if it is meant to be in the cache then define it in the cache
-  if(cache)
-    {
-    this->Makefile->AddCacheDefinition(variable,
-                                   value.c_str(),
-                                   docstring,
-                                   type, force);
-    }
-  else
-    {
+  if (cache) {
+    this->Makefile->AddCacheDefinition(variable, value.c_str(), docstring,
+                                       type, force);
+  } else {
     // add the definition
     this->Makefile->AddDefinition(variable, value.c_str());
-    }
+  }
   return true;
 }
-
diff --git a/Source/cmSetCommand.h b/Source/cmSetCommand.h
index 4adc2d9..65af8ac 100644
--- a/Source/cmSetCommand.h
+++ b/Source/cmSetCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmSetCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSetCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "set";}
+  virtual std::string GetName() const { return "set"; }
 
   cmTypeMacro(cmSetCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmSetDirectoryPropertiesCommand.cxx b/Source/cmSetDirectoryPropertiesCommand.cxx
index 3d4b7a9..ca758da 100644
--- a/Source/cmSetDirectoryPropertiesCommand.cxx
+++ b/Source/cmSetDirectoryPropertiesCommand.cxx
@@ -14,57 +14,43 @@
 #include "cmake.h"
 
 // cmSetDirectoryPropertiesCommand
-bool cmSetDirectoryPropertiesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSetDirectoryPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string errors;
-  bool ret =
-    cmSetDirectoryPropertiesCommand::RunCommand(this->Makefile,
-                                                args.begin() + 1,
-                                                args.end(), errors);
-  if (!ret)
-    {
+  bool ret = cmSetDirectoryPropertiesCommand::RunCommand(
+    this->Makefile, args.begin() + 1, args.end(), errors);
+  if (!ret) {
     this->SetError(errors);
-    }
+  }
   return ret;
 }
 
-bool cmSetDirectoryPropertiesCommand
-::RunCommand(cmMakefile *mf,
-             std::vector<std::string>::const_iterator ait,
-             std::vector<std::string>::const_iterator aitend,
-             std::string &errors)
+bool cmSetDirectoryPropertiesCommand::RunCommand(
+  cmMakefile* mf, std::vector<std::string>::const_iterator ait,
+  std::vector<std::string>::const_iterator aitend, std::string& errors)
 {
-  for (; ait != aitend; ait += 2 )
-    {
-    if ( ait +1 == aitend)
-      {
+  for (; ait != aitend; ait += 2) {
+    if (ait + 1 == aitend) {
       errors = "Wrong number of arguments";
       return false;
-      }
+    }
     const std::string& prop = *ait;
-    const std::string& value = *(ait+1);
-    if ( prop == "VARIABLES" )
-      {
-      errors =
-        "Variables and cache variables should be set using SET command";
+    const std::string& value = *(ait + 1);
+    if (prop == "VARIABLES") {
+      errors = "Variables and cache variables should be set using SET command";
       return false;
-      }
-    else if ( prop == "MACROS" )
-      {
-      errors =
-        "Commands and macros cannot be set using SET_CMAKE_PROPERTIES";
+    } else if (prop == "MACROS") {
+      errors = "Commands and macros cannot be set using SET_CMAKE_PROPERTIES";
       return false;
-      }
-    mf->SetProperty(prop, value.c_str());
     }
+    mf->SetProperty(prop, value.c_str());
+  }
 
   return true;
 }
-
diff --git a/Source/cmSetDirectoryPropertiesCommand.h b/Source/cmSetDirectoryPropertiesCommand.h
index f444a1b..a393eee 100644
--- a/Source/cmSetDirectoryPropertiesCommand.h
+++ b/Source/cmSetDirectoryPropertiesCommand.h
@@ -17,17 +17,14 @@
 class cmSetDirectoryPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmSetDirectoryPropertiesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSetDirectoryPropertiesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -37,19 +34,17 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_directory_properties";}
+  virtual std::string GetName() const { return "set_directory_properties"; }
 
   /**
    * Static entry point for use by other commands
    */
-  static bool RunCommand(cmMakefile *mf,
+  static bool RunCommand(cmMakefile* mf,
                          std::vector<std::string>::const_iterator ait,
                          std::vector<std::string>::const_iterator aitend,
-                         std::string &errors);
+                         std::string& errors);
 
   cmTypeMacro(cmSetDirectoryPropertiesCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index a03f608..73f7437 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -15,7 +15,6 @@
 #include "cmSetTargetPropertiesCommand.h"
 #include "cmSetTestsPropertiesCommand.h"
 
-
 cmSetPropertyCommand::cmSetPropertyCommand()
 {
   this->AppendMode = false;
@@ -23,243 +22,205 @@ cmSetPropertyCommand::cmSetPropertyCommand()
   this->Remove = true;
 }
 
-bool cmSetPropertyCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSetPropertyCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Get the scope on which to set the property.
   std::vector<std::string>::const_iterator arg = args.begin();
   cmProperty::ScopeType scope;
-  if(*arg == "GLOBAL")
-    {
+  if (*arg == "GLOBAL") {
     scope = cmProperty::GLOBAL;
-    }
-  else if(*arg == "DIRECTORY")
-    {
+  } else if (*arg == "DIRECTORY") {
     scope = cmProperty::DIRECTORY;
-    }
-  else if(*arg == "TARGET")
-    {
+  } else if (*arg == "TARGET") {
     scope = cmProperty::TARGET;
-    }
-  else if(*arg == "SOURCE")
-    {
+  } else if (*arg == "SOURCE") {
     scope = cmProperty::SOURCE_FILE;
-    }
-  else if(*arg == "TEST")
-    {
+  } else if (*arg == "TEST") {
     scope = cmProperty::TEST;
-    }
-  else if(*arg == "CACHE")
-    {
+  } else if (*arg == "CACHE") {
     scope = cmProperty::CACHE;
-    }
-  else if(*arg == "INSTALL")
-    {
+  } else if (*arg == "INSTALL") {
     scope = cmProperty::INSTALL;
-    }
-  else
-    {
+  } else {
     std::ostringstream e;
     e << "given invalid scope " << *arg << ".  "
       << "Valid scopes are GLOBAL, DIRECTORY, "
-        "TARGET, SOURCE, TEST, CACHE, INSTALL.";
+         "TARGET, SOURCE, TEST, CACHE, INSTALL.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   // Parse the rest of the arguments up to the values.
-  enum Doing { DoingNone, DoingNames, DoingProperty, DoingValues };
+  enum Doing
+  {
+    DoingNone,
+    DoingNames,
+    DoingProperty,
+    DoingValues
+  };
   Doing doing = DoingNames;
   const char* sep = "";
-  for(++arg; arg != args.end(); ++arg)
-    {
-    if(*arg == "PROPERTY")
-      {
+  for (++arg; arg != args.end(); ++arg) {
+    if (*arg == "PROPERTY") {
       doing = DoingProperty;
-      }
-    else if(*arg == "APPEND")
-      {
+    } else if (*arg == "APPEND") {
       doing = DoingNone;
       this->AppendMode = true;
       this->Remove = false;
       this->AppendAsString = false;
-      }
-    else if(*arg == "APPEND_STRING")
-      {
+    } else if (*arg == "APPEND_STRING") {
       doing = DoingNone;
       this->AppendMode = true;
       this->Remove = false;
       this->AppendAsString = true;
-      }
-    else if(doing == DoingNames)
-      {
+    } else if (doing == DoingNames) {
       this->Names.insert(*arg);
-      }
-    else if(doing == DoingProperty)
-      {
+    } else if (doing == DoingProperty) {
       this->PropertyName = *arg;
       doing = DoingValues;
-      }
-    else if(doing == DoingValues)
-      {
+    } else if (doing == DoingValues) {
       this->PropertyValue += sep;
       sep = ";";
       this->PropertyValue += *arg;
       this->Remove = false;
-      }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "given invalid argument \"" << *arg << "\".";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
 
   // Make sure a property name was found.
-  if(this->PropertyName.empty())
-    {
+  if (this->PropertyName.empty()) {
     this->SetError("not given a PROPERTY <name> argument.");
     return false;
-    }
+  }
 
   // Dispatch property setting.
-  switch(scope)
-    {
-    case cmProperty::GLOBAL:      return this->HandleGlobalMode();
-    case cmProperty::DIRECTORY:   return this->HandleDirectoryMode();
-    case cmProperty::TARGET:      return this->HandleTargetMode();
-    case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
-    case cmProperty::TEST:        return this->HandleTestMode();
-    case cmProperty::CACHE:       return this->HandleCacheMode();
-    case cmProperty::INSTALL:     return this->HandleInstallMode();
+  switch (scope) {
+    case cmProperty::GLOBAL:
+      return this->HandleGlobalMode();
+    case cmProperty::DIRECTORY:
+      return this->HandleDirectoryMode();
+    case cmProperty::TARGET:
+      return this->HandleTargetMode();
+    case cmProperty::SOURCE_FILE:
+      return this->HandleSourceMode();
+    case cmProperty::TEST:
+      return this->HandleTestMode();
+    case cmProperty::CACHE:
+      return this->HandleCacheMode();
+    case cmProperty::INSTALL:
+      return this->HandleInstallMode();
 
     case cmProperty::VARIABLE:
     case cmProperty::CACHED_VARIABLE:
       break; // should never happen
-    }
+  }
   return true;
 }
 
 bool cmSetPropertyCommand::HandleGlobalMode()
 {
-  if(!this->Names.empty())
-    {
+  if (!this->Names.empty()) {
     this->SetError("given names for GLOBAL scope.");
     return false;
-    }
+  }
 
   // Set or append the property.
   cmake* cm = this->Makefile->GetCMakeInstance();
   const char* name = this->PropertyName.c_str();
-  const char *value = this->PropertyValue.c_str();
-  if (this->Remove)
-    {
+  const char* value = this->PropertyValue.c_str();
+  if (this->Remove) {
     value = 0;
-    }
-  if(this->AppendMode)
-    {
+  }
+  if (this->AppendMode) {
     cm->AppendProperty(name, value ? value : "", this->AppendAsString);
-    }
-  else
-    {
+  } else {
     cm->SetProperty(name, value);
-    }
+  }
 
   return true;
 }
 
 bool cmSetPropertyCommand::HandleDirectoryMode()
 {
-  if(this->Names.size() > 1)
-    {
+  if (this->Names.size() > 1) {
     this->SetError("allows at most one name for DIRECTORY scope.");
     return false;
-    }
+  }
 
   // Default to the current directory.
   cmMakefile* mf = this->Makefile;
 
   // Lookup the directory if given.
-  if(!this->Names.empty())
-    {
+  if (!this->Names.empty()) {
     // Construct the directory name.  Interpret relative paths with
     // respect to the current directory.
     std::string dir = *this->Names.begin();
-    if(!cmSystemTools::FileIsFullPath(dir.c_str()))
-      {
+    if (!cmSystemTools::FileIsFullPath(dir.c_str())) {
       dir = this->Makefile->GetCurrentSourceDirectory();
       dir += "/";
       dir += *this->Names.begin();
-      }
+    }
 
     // The local generators are associated with collapsed paths.
     dir = cmSystemTools::CollapseFullPath(dir);
 
     mf = this->Makefile->GetGlobalGenerator()->FindMakefile(dir);
-    if (!mf)
-      {
+    if (!mf) {
       // Could not find the directory.
-      this->SetError
-        ("DIRECTORY scope provided but requested directory was not found. "
-         "This could be because the directory argument was invalid or, "
-         "it is valid but has not been processed yet.");
+      this->SetError(
+        "DIRECTORY scope provided but requested directory was not found. "
+        "This could be because the directory argument was invalid or, "
+        "it is valid but has not been processed yet.");
       return false;
-      }
     }
+  }
 
   // Set or append the property.
   const char* name = this->PropertyName.c_str();
-  const char *value = this->PropertyValue.c_str();
-  if (this->Remove)
-    {
+  const char* value = this->PropertyValue.c_str();
+  if (this->Remove) {
     value = 0;
-    }
-  if(this->AppendMode)
-    {
+  }
+  if (this->AppendMode) {
     mf->AppendProperty(name, value ? value : "", this->AppendAsString);
-    }
-  else
-    {
+  } else {
     mf->SetProperty(name, value);
-    }
+  }
 
   return true;
 }
 
 bool cmSetPropertyCommand::HandleTargetMode()
 {
-  for(std::set<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end(); ++ni)
-    {
-    if (this->Makefile->IsAlias(*ni))
-      {
+  for (std::set<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
+    if (this->Makefile->IsAlias(*ni)) {
       this->SetError("can not be used on an ALIAS target.");
       return false;
-      }
-    if(cmTarget* target = this->Makefile->FindTargetToUse(*ni))
-      {
+    }
+    if (cmTarget* target = this->Makefile->FindTargetToUse(*ni)) {
       // Handle the current target.
-      if(!this->HandleTarget(target))
-        {
+      if (!this->HandleTarget(target)) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "could not find TARGET " << *ni
         << ".  Perhaps it has not yet been created.";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -267,19 +228,15 @@ bool cmSetPropertyCommand::HandleTarget(cmTarget* target)
 {
   // Set or append the property.
   const char* name = this->PropertyName.c_str();
-  const char *value = this->PropertyValue.c_str();
-  if (this->Remove)
-    {
+  const char* value = this->PropertyValue.c_str();
+  if (this->Remove) {
     value = 0;
-    }
-  if(this->AppendMode)
-    {
+  }
+  if (this->AppendMode) {
     target->AppendProperty(name, value, this->AppendAsString);
-    }
-  else
-    {
+  } else {
     target->SetProperty(name, value);
-    }
+  }
 
   // Check the resulting value.
   target->CheckProperty(name, this->Makefile);
@@ -289,25 +246,20 @@ bool cmSetPropertyCommand::HandleTarget(cmTarget* target)
 
 bool cmSetPropertyCommand::HandleSourceMode()
 {
-  for(std::set<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end(); ++ni)
-    {
+  for (std::set<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
     // Get the source file.
-    if(cmSourceFile* sf = this->Makefile->GetOrCreateSource(*ni))
-      {
-      if(!this->HandleSource(sf))
-        {
+    if (cmSourceFile* sf = this->Makefile->GetOrCreateSource(*ni)) {
+      if (!this->HandleSource(sf)) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "given SOURCE name that could not be found or created: " << *ni;
       this->SetError(e.str());
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -315,20 +267,16 @@ bool cmSetPropertyCommand::HandleSource(cmSourceFile* sf)
 {
   // Set or append the property.
   const char* name = this->PropertyName.c_str();
-  const char *value = this->PropertyValue.c_str();
-  if (this->Remove)
-    {
+  const char* value = this->PropertyValue.c_str();
+  if (this->Remove) {
     value = 0;
-    }
+  }
 
-  if(this->AppendMode)
-    {
+  if (this->AppendMode) {
     sf->AppendProperty(name, value, this->AppendAsString);
-    }
-  else
-    {
+  } else {
     sf->SetProperty(name, value);
-    }
+  }
   return true;
 }
 
@@ -336,37 +284,30 @@ bool cmSetPropertyCommand::HandleTestMode()
 {
   // Look for tests with all names given.
   std::set<std::string>::iterator next;
-  for(std::set<std::string>::iterator ni = this->Names.begin();
-      ni != this->Names.end(); ni = next)
-    {
+  for (std::set<std::string>::iterator ni = this->Names.begin();
+       ni != this->Names.end(); ni = next) {
     next = ni;
     ++next;
-    if(cmTest* test = this->Makefile->GetTest(*ni))
-      {
-      if(this->HandleTest(test))
-        {
+    if (cmTest* test = this->Makefile->GetTest(*ni)) {
+      if (this->HandleTest(test)) {
         this->Names.erase(ni);
-        }
-      else
-        {
+      } else {
         return false;
-        }
       }
     }
+  }
 
   // Names that are still left were not found.
-  if(!this->Names.empty())
-    {
+  if (!this->Names.empty()) {
     std::ostringstream e;
     e << "given TEST names that do not exist:\n";
-    for(std::set<std::string>::const_iterator ni = this->Names.begin();
-        ni != this->Names.end(); ++ni)
-      {
+    for (std::set<std::string>::const_iterator ni = this->Names.begin();
+         ni != this->Names.end(); ++ni) {
       e << "  " << *ni << "\n";
-      }
+    }
     this->SetError(e.str());
     return false;
-    }
+  }
   return true;
 }
 
@@ -374,84 +315,66 @@ bool cmSetPropertyCommand::HandleTest(cmTest* test)
 {
   // Set or append the property.
   const char* name = this->PropertyName.c_str();
-  const char *value = this->PropertyValue.c_str();
-  if (this->Remove)
-    {
+  const char* value = this->PropertyValue.c_str();
+  if (this->Remove) {
     value = 0;
-    }
-  if(this->AppendMode)
-    {
+  }
+  if (this->AppendMode) {
     test->AppendProperty(name, value, this->AppendAsString);
-    }
-  else
-    {
+  } else {
     test->SetProperty(name, value);
-    }
+  }
 
   return true;
 }
 
 bool cmSetPropertyCommand::HandleCacheMode()
 {
-  if(this->PropertyName == "ADVANCED")
-    {
-    if(!this->Remove &&
-       !cmSystemTools::IsOn(this->PropertyValue.c_str()) &&
-       !cmSystemTools::IsOff(this->PropertyValue.c_str()))
-      {
+  if (this->PropertyName == "ADVANCED") {
+    if (!this->Remove && !cmSystemTools::IsOn(this->PropertyValue.c_str()) &&
+        !cmSystemTools::IsOff(this->PropertyValue.c_str())) {
       std::ostringstream e;
       e << "given non-boolean value \"" << this->PropertyValue
         << "\" for CACHE property \"ADVANCED\".  ";
       this->SetError(e.str());
       return false;
-      }
     }
-  else if(this->PropertyName == "TYPE")
-    {
-    if(!cmState::IsCacheEntryType(this->PropertyValue.c_str()))
-      {
+  } else if (this->PropertyName == "TYPE") {
+    if (!cmState::IsCacheEntryType(this->PropertyValue.c_str())) {
       std::ostringstream e;
       e << "given invalid CACHE entry TYPE \"" << this->PropertyValue << "\"";
       this->SetError(e.str());
       return false;
-      }
     }
-  else if(this->PropertyName != "HELPSTRING" &&
-          this->PropertyName != "STRINGS" &&
-          this->PropertyName != "VALUE")
-    {
+  } else if (this->PropertyName != "HELPSTRING" &&
+             this->PropertyName != "STRINGS" &&
+             this->PropertyName != "VALUE") {
     std::ostringstream e;
     e << "given invalid CACHE property " << this->PropertyName << ".  "
       << "Settable CACHE properties are: "
       << "ADVANCED, HELPSTRING, STRINGS, TYPE, and VALUE.";
     this->SetError(e.str());
     return false;
-    }
+  }
 
-  for(std::set<std::string>::const_iterator ni = this->Names.begin();
-      ni != this->Names.end(); ++ni)
-    {
+  for (std::set<std::string>::const_iterator ni = this->Names.begin();
+       ni != this->Names.end(); ++ni) {
     // Get the source file.
     cmMakefile* mf = this->GetMakefile();
     cmake* cm = mf->GetCMakeInstance();
-    const char* existingValue
-                          = cm->GetState()->GetCacheEntryValue(*ni);
-    if(existingValue)
-      {
-      if(!this->HandleCacheEntry(*ni))
-        {
+    const char* existingValue = cm->GetState()->GetCacheEntryValue(*ni);
+    if (existingValue) {
+      if (!this->HandleCacheEntry(*ni)) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "could not find CACHE variable " << *ni
         << ".  Perhaps it has not yet been created.";
       this->SetError(e.str());
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -461,19 +384,15 @@ bool cmSetPropertyCommand::HandleCacheEntry(std::string const& cacheKey)
   const char* name = this->PropertyName.c_str();
   const char* value = this->PropertyValue.c_str();
   cmState* state = this->Makefile->GetState();
-  if (this->Remove)
-    {
+  if (this->Remove) {
     state->RemoveCacheEntryProperty(cacheKey, name);
-    }
-  if(this->AppendMode)
-    {
+  }
+  if (this->AppendMode) {
     state->AppendCacheEntryProperty(cacheKey, name, value,
-                                     this->AppendAsString);
-    }
-  else
-    {
+                                    this->AppendAsString);
+  } else {
     state->SetCacheEntryProperty(cacheKey, name, value);
-    }
+  }
 
   return true;
 }
@@ -482,25 +401,20 @@ bool cmSetPropertyCommand::HandleInstallMode()
 {
   cmake* cm = this->Makefile->GetCMakeInstance();
 
-  for(std::set<std::string>::const_iterator i = this->Names.begin();
-      i != this->Names.end(); ++i)
-    {
-    if(cmInstalledFile* file = cm->GetOrCreateInstalledFile(
-      this->Makefile, *i))
-      {
-      if(!this->HandleInstall(file))
-        {
+  for (std::set<std::string>::const_iterator i = this->Names.begin();
+       i != this->Names.end(); ++i) {
+    if (cmInstalledFile* file =
+          cm->GetOrCreateInstalledFile(this->Makefile, *i)) {
+      if (!this->HandleInstall(file)) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       std::ostringstream e;
       e << "given INSTALL name that could not be found or created: " << *i;
       this->SetError(e.str());
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -511,18 +425,13 @@ bool cmSetPropertyCommand::HandleInstall(cmInstalledFile* file)
 
   cmMakefile* mf = this->Makefile;
 
-  const char *value = this->PropertyValue.c_str();
-  if (this->Remove)
-    {
+  const char* value = this->PropertyValue.c_str();
+  if (this->Remove) {
     file->RemoveProperty(name);
-    }
-  else if(this->AppendMode)
-    {
+  } else if (this->AppendMode) {
     file->AppendProperty(mf, name, value, this->AppendAsString);
-    }
-  else
-    {
+  } else {
     file->SetProperty(mf, name, value);
-    }
+  }
   return true;
 }
diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h
index 3285e60..a85d652 100644
--- a/Source/cmSetPropertyCommand.h
+++ b/Source/cmSetPropertyCommand.h
@@ -19,22 +19,19 @@ class cmSetPropertyCommand : public cmCommand
 public:
   cmSetPropertyCommand();
 
-  virtual cmCommand* Clone()
-    {
-      return new cmSetPropertyCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSetPropertyCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_property";}
+  virtual std::string GetName() const { return "set_property"; }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -66,6 +63,4 @@ private:
   bool HandleInstall(cmInstalledFile* file);
 };
 
-
-
 #endif
diff --git a/Source/cmSetSourceFilesPropertiesCommand.cxx b/Source/cmSetSourceFilesPropertiesCommand.cxx
index 19c6819..976f3c8 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.cxx
+++ b/Source/cmSetSourceFilesPropertiesCommand.cxx
@@ -14,157 +14,117 @@
 #include "cmSourceFile.h"
 
 // cmSetSourceFilesPropertiesCommand
-bool cmSetSourceFilesPropertiesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSetSourceFilesPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // break the arguments into source file names and properties
   int numFiles = 0;
   std::vector<std::string>::const_iterator j;
   j = args.begin();
   // old style allows for specifier before PROPERTIES keyword
-  while (j != args.end() &&
-         *j != "ABSTRACT" &&
-         *j != "WRAP_EXCLUDE" &&
-         *j != "GENERATED" &&
-         *j != "COMPILE_FLAGS" &&
-         *j != "OBJECT_DEPENDS" &&
-         *j != "PROPERTIES")
-    {
+  while (j != args.end() && *j != "ABSTRACT" && *j != "WRAP_EXCLUDE" &&
+         *j != "GENERATED" && *j != "COMPILE_FLAGS" &&
+         *j != "OBJECT_DEPENDS" && *j != "PROPERTIES") {
     numFiles++;
     ++j;
-    }
+  }
 
   // now call the worker function
   std::string errors;
-  bool ret =
-    cmSetSourceFilesPropertiesCommand
-    ::RunCommand(this->Makefile,
-                 args.begin(),
-                 args.begin() + numFiles,
-                 args.begin() + numFiles,
-                 args.end(), errors);
-  if (!ret)
-    {
+  bool ret = cmSetSourceFilesPropertiesCommand::RunCommand(
+    this->Makefile, args.begin(), args.begin() + numFiles,
+    args.begin() + numFiles, args.end(), errors);
+  if (!ret) {
     this->SetError(errors);
-    }
+  }
   return ret;
 }
 
-bool cmSetSourceFilesPropertiesCommand
-::RunCommand(cmMakefile *mf,
-             std::vector<std::string>::const_iterator filebeg,
-             std::vector<std::string>::const_iterator fileend,
-             std::vector<std::string>::const_iterator propbeg,
-             std::vector<std::string>::const_iterator propend,
-             std::string &errors)
+bool cmSetSourceFilesPropertiesCommand::RunCommand(
+  cmMakefile* mf, std::vector<std::string>::const_iterator filebeg,
+  std::vector<std::string>::const_iterator fileend,
+  std::vector<std::string>::const_iterator propbeg,
+  std::vector<std::string>::const_iterator propend, std::string& errors)
 {
   std::vector<std::string> propertyPairs;
   bool generated = false;
   std::vector<std::string>::const_iterator j;
   // build the property pairs
-  for(j= propbeg; j != propend;++j)
-    {
+  for (j = propbeg; j != propend; ++j) {
     // old style allows for specifier before PROPERTIES keyword
-    if(*j == "ABSTRACT")
-      {
+    if (*j == "ABSTRACT") {
       propertyPairs.push_back("ABSTRACT");
       propertyPairs.push_back("1");
-      }
-    else if(*j == "WRAP_EXCLUDE")
-      {
+    } else if (*j == "WRAP_EXCLUDE") {
       propertyPairs.push_back("WRAP_EXCLUDE");
       propertyPairs.push_back("1");
-      }
-    else if(*j == "GENERATED")
-      {
+    } else if (*j == "GENERATED") {
       generated = true;
       propertyPairs.push_back("GENERATED");
       propertyPairs.push_back("1");
-      }
-    else if(*j == "COMPILE_FLAGS")
-      {
+    } else if (*j == "COMPILE_FLAGS") {
       propertyPairs.push_back("COMPILE_FLAGS");
       ++j;
-      if(j == propend)
-        {
+      if (j == propend) {
         errors = "called with incorrect number of arguments "
-          "COMPILE_FLAGS with no flags";
+                 "COMPILE_FLAGS with no flags";
         return false;
-        }
-      propertyPairs.push_back(*j);
       }
-    else if(*j == "OBJECT_DEPENDS")
-      {
+      propertyPairs.push_back(*j);
+    } else if (*j == "OBJECT_DEPENDS") {
       propertyPairs.push_back("OBJECT_DEPENDS");
       ++j;
-      if(j == propend)
-        {
+      if (j == propend) {
         errors = "called with incorrect number of arguments "
-          "OBJECT_DEPENDS with no dependencies";
+                 "OBJECT_DEPENDS with no dependencies";
         return false;
-        }
-      propertyPairs.push_back(*j);
       }
-    else if(*j == "PROPERTIES")
-      {
+      propertyPairs.push_back(*j);
+    } else if (*j == "PROPERTIES") {
       // now loop through the rest of the arguments, new style
       ++j;
-      while (j != propend)
-        {
+      while (j != propend) {
         propertyPairs.push_back(*j);
-        if(*j == "GENERATED")
-          {
+        if (*j == "GENERATED") {
           ++j;
-          if(j != propend && cmSystemTools::IsOn(j->c_str()))
-            {
+          if (j != propend && cmSystemTools::IsOn(j->c_str())) {
             generated = true;
-            }
           }
-        else
-          {
+        } else {
           ++j;
-          }
-        if(j == propend)
-          {
+        }
+        if (j == propend) {
           errors = "called with incorrect number of arguments.";
           return false;
-          }
+        }
         propertyPairs.push_back(*j);
         ++j;
-        }
+      }
       // break out of the loop because j is already == end
       break;
-      }
-    else
-      {
+    } else {
       errors = "called with illegal arguments, maybe missing a "
-        "PROPERTIES specifier?";
+               "PROPERTIES specifier?";
       return false;
-      }
     }
+  }
 
   // now loop over all the files
-  for(j= filebeg; j != fileend;++j)
-    {
+  for (j = filebeg; j != fileend; ++j) {
     // get the source file
-    cmSourceFile* sf =
-      mf->GetOrCreateSource(*j, generated);
-    if(sf)
-      {
+    cmSourceFile* sf = mf->GetOrCreateSource(*j, generated);
+    if (sf) {
       // now loop through all the props and set them
       unsigned int k;
-      for (k = 0; k < propertyPairs.size(); k = k + 2)
-        {
-        sf->SetProperty(propertyPairs[k],propertyPairs[k+1].c_str());
-        }
+      for (k = 0; k < propertyPairs.size(); k = k + 2) {
+        sf->SetProperty(propertyPairs[k], propertyPairs[k + 1].c_str());
       }
     }
+  }
   return true;
 }
-
diff --git a/Source/cmSetSourceFilesPropertiesCommand.h b/Source/cmSetSourceFilesPropertiesCommand.h
index 5fa5a3a..20e6b93 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.h
+++ b/Source/cmSetSourceFilesPropertiesCommand.h
@@ -17,33 +17,28 @@
 class cmSetSourceFilesPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmSetSourceFilesPropertiesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSetSourceFilesPropertiesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_source_files_properties";}
+  virtual std::string GetName() const { return "set_source_files_properties"; }
 
   cmTypeMacro(cmSetSourceFilesPropertiesCommand, cmCommand);
 
-  static bool RunCommand(cmMakefile *mf,
+  static bool RunCommand(cmMakefile* mf,
                          std::vector<std::string>::const_iterator filebeg,
                          std::vector<std::string>::const_iterator fileend,
                          std::vector<std::string>::const_iterator propbeg,
                          std::vector<std::string>::const_iterator propend,
-                         std::string &errors);
+                         std::string& errors);
 };
 
-
-
 #endif
diff --git a/Source/cmSetTargetPropertiesCommand.cxx b/Source/cmSetTargetPropertiesCommand.cxx
index b4c58d4..86c8016 100644
--- a/Source/cmSetTargetPropertiesCommand.cxx
+++ b/Source/cmSetTargetPropertiesCommand.cxx
@@ -14,87 +14,72 @@
 #include "cmGlobalGenerator.h"
 
 // cmSetTargetPropertiesCommand
-bool cmSetTargetPropertiesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSetTargetPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // first collect up the list of files
   std::vector<std::string> propertyPairs;
   int numFiles = 0;
   std::vector<std::string>::const_iterator j;
-  for(j= args.begin(); j != args.end();++j)
-    {
-    if(*j == "PROPERTIES")
-      {
+  for (j = args.begin(); j != args.end(); ++j) {
+    if (*j == "PROPERTIES") {
       // now loop through the rest of the arguments, new style
       ++j;
-      if (std::distance(j, args.end()) % 2 != 0)
-        {
+      if (std::distance(j, args.end()) % 2 != 0) {
         this->SetError("called with incorrect number of arguments.");
         return false;
-        }
+      }
       propertyPairs.insert(propertyPairs.end(), j, args.end());
       break;
-      }
-    else
-      {
+    } else {
       numFiles++;
-      }
-    }
-  if(propertyPairs.empty())
-    {
-     this->SetError("called with illegal arguments, maybe missing "
-                    "a PROPERTIES specifier?");
-     return false;
     }
+  }
+  if (propertyPairs.empty()) {
+    this->SetError("called with illegal arguments, maybe missing "
+                   "a PROPERTIES specifier?");
+    return false;
+  }
 
   // now loop over all the targets
   int i;
-  for(i = 0; i < numFiles; ++i)
-    {
-    if (this->Makefile->IsAlias(args[i]))
-      {
+  for (i = 0; i < numFiles; ++i) {
+    if (this->Makefile->IsAlias(args[i])) {
       this->SetError("can not be used on an ALIAS target.");
       return false;
-      }
-    bool ret = cmSetTargetPropertiesCommand::SetOneTarget
-      (args[i],propertyPairs,this->Makefile);
-    if (!ret)
-      {
+    }
+    bool ret = cmSetTargetPropertiesCommand::SetOneTarget(
+      args[i], propertyPairs, this->Makefile);
+    if (!ret) {
       std::string message = "Can not find target to add properties to: ";
       message += args[i];
       this->SetError(message);
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool cmSetTargetPropertiesCommand
-::SetOneTarget(const std::string& tname,
-               std::vector<std::string> &propertyPairs,
-               cmMakefile *mf)
+bool cmSetTargetPropertiesCommand::SetOneTarget(
+  const std::string& tname, std::vector<std::string>& propertyPairs,
+  cmMakefile* mf)
 {
-  if(cmTarget* target = mf->FindTargetToUse(tname))
-    {
+  if (cmTarget* target = mf->FindTargetToUse(tname)) {
     // now loop through all the props and set them
     unsigned int k;
-    for (k = 0; k < propertyPairs.size(); k = k + 2)
-      {
-      target->SetProperty(propertyPairs[k],
-                          propertyPairs[k+1].c_str());
+    for (k = 0; k < propertyPairs.size(); k = k + 2) {
+      target->SetProperty(propertyPairs[k], propertyPairs[k + 1].c_str());
       target->CheckProperty(propertyPairs[k], mf);
-      }
     }
+  }
   // if file is not already in the makefile, then add it
-  else
-    {
+  else {
     return false;
-    }
+  }
   return true;
 }
diff --git a/Source/cmSetTargetPropertiesCommand.h b/Source/cmSetTargetPropertiesCommand.h
index 3981ef3..122c15e 100644
--- a/Source/cmSetTargetPropertiesCommand.h
+++ b/Source/cmSetTargetPropertiesCommand.h
@@ -17,33 +17,28 @@
 class cmSetTargetPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-      return new cmSetTargetPropertiesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSetTargetPropertiesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_target_properties";}
+  virtual std::string GetName() const { return "set_target_properties"; }
 
   /**
    *  Used by this command and cmSetPropertiesCommand
    */
   static bool SetOneTarget(const std::string& tname,
-                           std::vector<std::string> &propertyPairs,
-                           cmMakefile *mf);
+                           std::vector<std::string>& propertyPairs,
+                           cmMakefile* mf);
 
   cmTypeMacro(cmSetTargetPropertiesCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmSetTestsPropertiesCommand.cxx b/Source/cmSetTestsPropertiesCommand.cxx
index 70c34c4..2fb137f 100644
--- a/Source/cmSetTestsPropertiesCommand.cxx
+++ b/Source/cmSetTestsPropertiesCommand.cxx
@@ -15,89 +15,70 @@
 #include "cmake.h"
 
 // cmSetTestsPropertiesCommand
-bool cmSetTestsPropertiesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSetTestsPropertiesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // first collect up the list of files
   std::vector<std::string> propertyPairs;
   int numFiles = 0;
   std::vector<std::string>::const_iterator j;
-  for(j= args.begin(); j != args.end();++j)
-    {
-    if(*j == "PROPERTIES")
-      {
+  for (j = args.begin(); j != args.end(); ++j) {
+    if (*j == "PROPERTIES") {
       // now loop through the rest of the arguments, new style
       ++j;
-      if (std::distance(j, args.end()) % 2 != 0)
-        {
+      if (std::distance(j, args.end()) % 2 != 0) {
         this->SetError("called with incorrect number of arguments.");
         return false;
-        }
+      }
       propertyPairs.insert(propertyPairs.end(), j, args.end());
       break;
-      }
-    else
-      {
+    } else {
       numFiles++;
-      }
     }
-  if(propertyPairs.empty())
-    {
+  }
+  if (propertyPairs.empty()) {
     this->SetError("called with illegal arguments, maybe "
                    "missing a PROPERTIES specifier?");
     return false;
-    }
+  }
 
   // now loop over all the targets
   int i;
-  for(i = 0; i < numFiles; ++i)
-    {
+  for (i = 0; i < numFiles; ++i) {
     std::string errors;
-    bool ret =
-      cmSetTestsPropertiesCommand::SetOneTest(args[i],
-                                              propertyPairs,
-                                              this->Makefile, errors);
-    if (!ret)
-      {
+    bool ret = cmSetTestsPropertiesCommand::SetOneTest(args[i], propertyPairs,
+                                                       this->Makefile, errors);
+    if (!ret) {
       this->SetError(errors);
       return ret;
-      }
     }
+  }
 
   return true;
 }
 
-
-bool cmSetTestsPropertiesCommand
-::SetOneTest(const std::string& tname,
-             std::vector<std::string> &propertyPairs,
-             cmMakefile *mf, std::string &errors)
+bool cmSetTestsPropertiesCommand::SetOneTest(
+  const std::string& tname, std::vector<std::string>& propertyPairs,
+  cmMakefile* mf, std::string& errors)
 {
-  if(cmTest* test = mf->GetTest(tname))
-    {
+  if (cmTest* test = mf->GetTest(tname)) {
     // now loop through all the props and set them
     unsigned int k;
-    for (k = 0; k < propertyPairs.size(); k = k + 2)
-      {
-      if (!propertyPairs[k].empty())
-        {
-        test->SetProperty(propertyPairs[k], propertyPairs[k+1].c_str());
-        }
+    for (k = 0; k < propertyPairs.size(); k = k + 2) {
+      if (!propertyPairs[k].empty()) {
+        test->SetProperty(propertyPairs[k], propertyPairs[k + 1].c_str());
       }
     }
-  else
-    {
+  } else {
     errors = "Can not find test to add properties to: ";
     errors += tname;
     return false;
-    }
+  }
 
   return true;
 }
-
diff --git a/Source/cmSetTestsPropertiesCommand.h b/Source/cmSetTestsPropertiesCommand.h
index dabe944..e469b2a 100644
--- a/Source/cmSetTestsPropertiesCommand.h
+++ b/Source/cmSetTestsPropertiesCommand.h
@@ -17,31 +17,25 @@
 class cmSetTestsPropertiesCommand : public cmCommand
 {
 public:
-  virtual cmCommand* Clone()
-    {
-    return new cmSetTestsPropertiesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSetTestsPropertiesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the input file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "set_tests_properties";}
+  virtual std::string GetName() const { return "set_tests_properties"; }
 
   cmTypeMacro(cmSetTestsPropertiesCommand, cmCommand);
 
   static bool SetOneTest(const std::string& tname,
-                         std::vector<std::string> &propertyPairs,
-                         cmMakefile *mf,
-                         std::string &errors);
+                         std::vector<std::string>& propertyPairs,
+                         cmMakefile* mf, std::string& errors);
 };
 
-
-
 #endif
diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx
index e2970e5..702af4d 100644
--- a/Source/cmSiteNameCommand.cxx
+++ b/Source/cmSiteNameCommand.cxx
@@ -14,14 +14,13 @@
 #include <cmsys/RegularExpression.hxx>
 
 // cmSiteNameCommand
-bool cmSiteNameCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args,
+                                    cmExecutionStatus&)
 {
-  if(args.size() != 1 )
-    {
+  if (args.size() != 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::vector<std::string> paths;
   paths.push_back("/usr/bsd");
   paths.push_back("/usr/sbin");
@@ -30,66 +29,54 @@ bool cmSiteNameCommand
   paths.push_back("/sbin");
   paths.push_back("/usr/local/bin");
 
-  const char* cacheValue
-    = this->Makefile->GetDefinition(args[0]);
-  if(cacheValue)
-    {
+  const char* cacheValue = this->Makefile->GetDefinition(args[0]);
+  if (cacheValue) {
     return true;
-    }
+  }
 
-  const char *temp = this->Makefile->GetDefinition("HOSTNAME");
+  const char* temp = this->Makefile->GetDefinition("HOSTNAME");
   std::string hostname_cmd;
-  if(temp)
-    {
+  if (temp) {
     hostname_cmd = temp;
-    }
-  else
-    {
+  } else {
     hostname_cmd = cmSystemTools::FindProgram("hostname", paths);
-    }
+  }
 
   std::string siteName = "unknown";
 #if defined(_WIN32) && !defined(__CYGWIN__)
   std::string host;
-  if(cmSystemTools::ReadRegistryValue
-     ("HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\"
-      "Control\\ComputerName\\ComputerName;ComputerName", host))
-    {
+  if (cmSystemTools::ReadRegistryValue(
+        "HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\"
+        "Control\\ComputerName\\ComputerName;ComputerName",
+        host)) {
     siteName = host;
-    }
+  }
 #else
   // try to find the hostname for this computer
-  if (!cmSystemTools::IsOff(hostname_cmd.c_str()))
-    {
+  if (!cmSystemTools::IsOff(hostname_cmd.c_str())) {
     std::string host;
-    cmSystemTools::RunSingleCommand(hostname_cmd.c_str(),
-      &host, 0, 0, 0, cmSystemTools::OUTPUT_NONE);
+    cmSystemTools::RunSingleCommand(hostname_cmd.c_str(), &host, 0, 0, 0,
+                                    cmSystemTools::OUTPUT_NONE);
 
     // got the hostname
-    if (!host.empty())
-      {
+    if (!host.empty()) {
       // remove any white space from the host name
       std::string hostRegExp = "[ \t\n\r]*([^\t\n\r ]*)[ \t\n\r]*";
-      cmsys::RegularExpression hostReg (hostRegExp.c_str());
-      if (hostReg.find(host.c_str()))
-        {
+      cmsys::RegularExpression hostReg(hostRegExp.c_str());
+      if (hostReg.find(host.c_str())) {
         // strip whitespace
         host = hostReg.match(1);
-        }
+      }
 
-      if(!host.empty())
-        {
+      if (!host.empty()) {
         siteName = host;
-        }
       }
     }
+  }
 #endif
-  this->Makefile->
-    AddCacheDefinition(args[0],
-                       siteName.c_str(),
-                       "Name of the computer/site where compile is being run",
-                       cmState::STRING);
+  this->Makefile->AddCacheDefinition(
+    args[0], siteName.c_str(),
+    "Name of the computer/site where compile is being run", cmState::STRING);
 
   return true;
 }
-
diff --git a/Source/cmSiteNameCommand.h b/Source/cmSiteNameCommand.h
index ec63ef8..a4812f7 100644
--- a/Source/cmSiteNameCommand.h
+++ b/Source/cmSiteNameCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmSiteNameCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSiteNameCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "site_name";}
+  virtual std::string GetName() const { return "site_name"; }
 
   cmTypeMacro(cmSiteNameCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx
index b31bc74..5b0acee 100644
--- a/Source/cmSourceFile.cxx
+++ b/Source/cmSourceFile.cxx
@@ -16,13 +16,13 @@
 #include "cmSystemTools.h"
 #include "cmake.h"
 
-cmSourceFile::cmSourceFile(cmMakefile* mf, const std::string& name):
-  Location(mf, name)
+cmSourceFile::cmSourceFile(cmMakefile* mf, const std::string& name)
+  : Location(mf, name)
 {
   this->CustomCommand = 0;
   this->FindFullPathFailed = false;
-  this->IsUiFile = (".ui" ==
-          cmSystemTools::GetFilenameLastExtension(this->Location.GetName()));
+  this->IsUiFile = (".ui" == cmSystemTools::GetFilenameLastExtension(
+                               this->Location.GetName()));
 }
 
 cmSourceFile::~cmSourceFile()
@@ -50,34 +50,29 @@ std::string cmSourceFile::GetObjectLibrary() const
 std::string cmSourceFile::GetLanguage()
 {
   // If the language was set explicitly by the user then use it.
-  if(const char* lang = this->GetProperty(propLANGUAGE))
-    {
+  if (const char* lang = this->GetProperty(propLANGUAGE)) {
     return lang;
-    }
+  }
 
   // Perform computation needed to get the language if necessary.
-  if(this->FullPath.empty() && this->Language.empty())
-    {
+  if (this->FullPath.empty() && this->Language.empty()) {
     // If a known extension is given or a known full path is given
     // then trust that the current extension is sufficient to
     // determine the language.  This will fail only if the user
     // specifies a full path to the source but leaves off the
     // extension, which is kind of weird.
-    if(this->Location.ExtensionIsAmbiguous() &&
-       this->Location.DirectoryIsAmbiguous())
-      {
+    if (this->Location.ExtensionIsAmbiguous() &&
+        this->Location.DirectoryIsAmbiguous()) {
       // Finalize the file location to get the extension and set the
       // language.
       this->GetFullPath();
-      }
-    else
-      {
+    } else {
       // Use the known extension to get the language if possible.
       std::string ext =
         cmSystemTools::GetFilenameLastExtension(this->Location.GetName());
       this->CheckLanguage(ext);
-      }
     }
+  }
 
   // Now try to determine the language.
   return static_cast<cmSourceFile const*>(this)->GetLanguage();
@@ -86,16 +81,14 @@ std::string cmSourceFile::GetLanguage()
 std::string cmSourceFile::GetLanguage() const
 {
   // If the language was set explicitly by the user then use it.
-  if(const char* lang = this->GetProperty(propLANGUAGE))
-    {
+  if (const char* lang = this->GetProperty(propLANGUAGE)) {
     return lang;
-    }
+  }
 
   // If the language was determined from the source file extension use it.
-  if(!this->Language.empty())
-    {
+  if (!this->Language.empty()) {
     return this->Language;
-    }
+  }
 
   // The language is not known.
   return "";
@@ -103,18 +96,16 @@ std::string cmSourceFile::GetLanguage() const
 
 cmSourceFileLocation const& cmSourceFile::GetLocation() const
 {
-    return this->Location;
+  return this->Location;
 }
 
 std::string const& cmSourceFile::GetFullPath(std::string* error)
 {
-  if(this->FullPath.empty())
-    {
-    if(this->FindFullPath(error))
-      {
+  if (this->FullPath.empty()) {
+    if (this->FindFullPath(error)) {
       this->CheckExtension();
-      }
     }
+  }
   return this->FullPath;
 }
 
@@ -126,15 +117,13 @@ std::string const& cmSourceFile::GetFullPath() const
 bool cmSourceFile::FindFullPath(std::string* error)
 {
   // If thie method has already failed once do not try again.
-  if(this->FindFullPathFailed)
-    {
+  if (this->FindFullPathFailed) {
     return false;
-    }
+  }
 
   // If the file is generated compute the location without checking on
   // disk.
-  if(this->GetPropertyAsBool("GENERATED"))
-    {
+  if (this->GetPropertyAsBool("GENERATED")) {
     // The file is either already a full path or is relative to the
     // build directory for the target.
     this->Location.DirectoryUseBinary();
@@ -142,99 +131,80 @@ bool cmSourceFile::FindFullPath(std::string* error)
     this->FullPath += "/";
     this->FullPath += this->Location.GetName();
     return true;
-    }
+  }
 
   // The file is not generated.  It must exist on disk.
   cmMakefile const* mf = this->Location.GetMakefile();
-  const char* tryDirs[3] = {0, 0, 0};
-  if(this->Location.DirectoryIsAmbiguous())
-    {
+  const char* tryDirs[3] = { 0, 0, 0 };
+  if (this->Location.DirectoryIsAmbiguous()) {
     tryDirs[0] = mf->GetCurrentSourceDirectory();
     tryDirs[1] = mf->GetCurrentBinaryDirectory();
-    }
-  else
-    {
+  } else {
     tryDirs[0] = "";
-    }
+  }
   const std::vector<std::string>& srcExts =
-      mf->GetCMakeInstance()->GetSourceExtensions();
+    mf->GetCMakeInstance()->GetSourceExtensions();
   std::vector<std::string> hdrExts =
-      mf->GetCMakeInstance()->GetHeaderExtensions();
-  for(const char* const* di = tryDirs; *di; ++di)
-    {
+    mf->GetCMakeInstance()->GetHeaderExtensions();
+  for (const char* const* di = tryDirs; *di; ++di) {
     std::string tryPath = this->Location.GetDirectory();
-    if(!tryPath.empty())
-      {
+    if (!tryPath.empty()) {
       tryPath += "/";
-      }
+    }
     tryPath += this->Location.GetName();
     tryPath = cmSystemTools::CollapseFullPath(tryPath, *di);
-    if(this->TryFullPath(tryPath, ""))
-      {
+    if (this->TryFullPath(tryPath, "")) {
       return true;
-      }
-    for(std::vector<std::string>::const_iterator ei = srcExts.begin();
-        ei != srcExts.end(); ++ei)
-      {
-      if(this->TryFullPath(tryPath, *ei))
-        {
+    }
+    for (std::vector<std::string>::const_iterator ei = srcExts.begin();
+         ei != srcExts.end(); ++ei) {
+      if (this->TryFullPath(tryPath, *ei)) {
         return true;
-        }
       }
-    for(std::vector<std::string>::const_iterator ei = hdrExts.begin();
-        ei != hdrExts.end(); ++ei)
-      {
-      if(this->TryFullPath(tryPath, *ei))
-        {
+    }
+    for (std::vector<std::string>::const_iterator ei = hdrExts.begin();
+         ei != hdrExts.end(); ++ei) {
+      if (this->TryFullPath(tryPath, *ei)) {
         return true;
-        }
       }
     }
+  }
 
   std::ostringstream e;
   std::string missing = this->Location.GetDirectory();
-  if(!missing.empty())
-    {
+  if (!missing.empty()) {
     missing += "/";
-    }
+  }
   missing += this->Location.GetName();
   e << "Cannot find source file:\n  " << missing << "\nTried extensions";
-  for(std::vector<std::string>::const_iterator ext = srcExts.begin();
-      ext != srcExts.end(); ++ext)
-    {
+  for (std::vector<std::string>::const_iterator ext = srcExts.begin();
+       ext != srcExts.end(); ++ext) {
     e << " ." << *ext;
-    }
-  for(std::vector<std::string>::const_iterator ext = hdrExts.begin();
-      ext != hdrExts.end(); ++ext)
-    {
+  }
+  for (std::vector<std::string>::const_iterator ext = hdrExts.begin();
+       ext != hdrExts.end(); ++ext) {
     e << " ." << *ext;
-    }
-  if(error)
-    {
+  }
+  if (error) {
     *error = e.str();
-    }
-  else
-    {
+  } else {
     this->Location.GetMakefile()->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
+  }
   this->FindFullPathFailed = true;
   return false;
 }
 
-bool cmSourceFile::TryFullPath(const std::string& path,
-                               const std::string& ext)
+bool cmSourceFile::TryFullPath(const std::string& path, const std::string& ext)
 {
   std::string tryPath = path;
-  if(!ext.empty())
-    {
+  if (!ext.empty()) {
     tryPath += ".";
     tryPath += ext;
-    }
-  if(cmSystemTools::FileExists(tryPath.c_str()))
-    {
+  }
+  if (cmSystemTools::FileExists(tryPath.c_str())) {
     this->FullPath = tryPath;
     return true;
-    }
+  }
   return false;
 }
 
@@ -243,25 +213,21 @@ void cmSourceFile::CheckExtension()
   // Compute the extension.
   std::string realExt =
     cmSystemTools::GetFilenameLastExtension(this->FullPath);
-  if(!realExt.empty())
-    {
+  if (!realExt.empty()) {
     // Store the extension without the leading '.'.
     this->Extension = realExt.substr(1);
-    }
+  }
 
   // Look for object files.
-  if(this->Extension == "obj" ||
-     this->Extension == "o" ||
-     this->Extension == "lo")
-    {
+  if (this->Extension == "obj" || this->Extension == "o" ||
+      this->Extension == "lo") {
     this->SetProperty("EXTERNAL_OBJECT", "1");
-    }
+  }
 
   // Try to identify the source file language from the extension.
-  if(this->Language.empty())
-    {
+  if (this->Language.empty()) {
     this->CheckLanguage(this->Extension);
-    }
+  }
 }
 
 void cmSourceFile::CheckLanguage(std::string const& ext)
@@ -270,10 +236,9 @@ void cmSourceFile::CheckLanguage(std::string const& ext)
   cmMakefile const* mf = this->Location.GetMakefile();
   cmGlobalGenerator* gg = mf->GetGlobalGenerator();
   std::string l = gg->GetLanguageFromExtension(ext.c_str());
-  if(!l.empty())
-    {
+  if (!l.empty()) {
     this->Language = l;
-    }
+  }
 }
 
 bool cmSourceFile::Matches(cmSourceFileLocation const& loc)
@@ -285,14 +250,12 @@ void cmSourceFile::SetProperty(const std::string& prop, const char* value)
 {
   this->Properties.SetProperty(prop, value);
 
-  if (this->IsUiFile)
-    {
+  if (this->IsUiFile) {
     cmMakefile const* mf = this->Location.GetMakefile();
-    if (prop == "AUTOUIC_OPTIONS")
-      {
+    if (prop == "AUTOUIC_OPTIONS") {
       const_cast<cmMakefile*>(mf)->AddQtUiFileWithOptions(this);
-      }
     }
+  }
 }
 
 void cmSourceFile::AppendProperty(const std::string& prop, const char* value,
@@ -317,11 +280,10 @@ const char* cmSourceFile::GetPropertyForUser(const std::string& prop)
   // cmSourceFileLocation class to commit to a particular full path to
   // the source file as late as possible.  If the users requests the
   // LOCATION property we must commit now.
-  if(prop == "LOCATION")
-    {
+  if (prop == "LOCATION") {
     // Commit to a location.
     this->GetFullPath();
-    }
+  }
 
   // Perform the normal property lookup.
   return this->GetProperty(prop);
@@ -330,29 +292,23 @@ const char* cmSourceFile::GetPropertyForUser(const std::string& prop)
 const char* cmSourceFile::GetProperty(const std::string& prop) const
 {
   // Check for computed properties.
-  if(prop == "LOCATION")
-    {
-    if(this->FullPath.empty())
-      {
+  if (prop == "LOCATION") {
+    if (this->FullPath.empty()) {
       return 0;
-      }
-    else
-      {
+    } else {
       return this->FullPath.c_str();
-      }
     }
+  }
 
-  const char *retVal = this->Properties.GetPropertyValue(prop);
-  if (!retVal)
-    {
+  const char* retVal = this->Properties.GetPropertyValue(prop);
+  if (!retVal) {
     cmMakefile const* mf = this->Location.GetMakefile();
-    const bool chain = mf->GetState()->
-                      IsPropertyChained(prop, cmProperty::SOURCE_FILE);
-    if (chain)
-      {
+    const bool chain =
+      mf->GetState()->IsPropertyChained(prop, cmProperty::SOURCE_FILE);
+    if (chain) {
       return mf->GetProperty(prop, chain);
-      }
     }
+  }
 
   return retVal;
 }
diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h
index e5e2ab9..b1623bd 100644
--- a/Source/cmSourceFile.h
+++ b/Source/cmSourceFile.h
@@ -41,13 +41,13 @@ public:
    */
   cmCustomCommand* GetCustomCommand();
   cmCustomCommand const* GetCustomCommand() const;
-  void SetCustomCommand(cmCustomCommand *cc);
+  void SetCustomCommand(cmCustomCommand* cc);
 
   ///! Set/Get a property of this source file
-  void SetProperty(const std::string& prop, const char *value);
-  void AppendProperty(const std::string& prop,
-                      const char* value,bool asString=false);
-  const char *GetProperty(const std::string& prop) const;
+  void SetProperty(const std::string& prop, const char* value);
+  void AppendProperty(const std::string& prop, const char* value,
+                      bool asString = false);
+  const char* GetProperty(const std::string& prop) const;
   bool GetPropertyAsBool(const std::string& prop) const;
 
   /** Implement getting a property when called from a CMake language
@@ -86,11 +86,11 @@ public:
   /**
    * Return the vector that holds the list of dependencies
    */
-  const std::vector<std::string> &GetDepends() const {return this->Depends;}
+  const std::vector<std::string>& GetDepends() const { return this->Depends; }
   void AddDepend(const std::string& d) { this->Depends.push_back(d); }
 
   // Get the properties
-  cmPropertyMap &GetProperties() { return this->Properties; }
+  cmPropertyMap& GetProperties() { return this->Properties; }
 
   /**
    * Check whether the given source file location could refer to this
@@ -118,7 +118,6 @@ private:
   void CheckExtension();
   void CheckLanguage(std::string const& ext);
 
-
   static const std::string propLANGUAGE;
 };
 
diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx
index 6e47402..3219f36 100644
--- a/Source/cmSourceFileLocation.cxx
+++ b/Source/cmSourceFileLocation.cxx
@@ -19,9 +19,10 @@
 #include "assert.h"
 
 cmSourceFileLocation::cmSourceFileLocation()
-  : Makefile(0), AmbiguousDirectory(true), AmbiguousExtension(true)
+  : Makefile(0)
+  , AmbiguousDirectory(true)
+  , AmbiguousExtension(true)
 {
-
 }
 
 cmSourceFileLocation::cmSourceFileLocation(const cmSourceFileLocation& loc)
@@ -33,13 +34,12 @@ cmSourceFileLocation::cmSourceFileLocation(const cmSourceFileLocation& loc)
   this->Name = loc.Name;
 }
 
-cmSourceFileLocation&
-cmSourceFileLocation::operator=(const cmSourceFileLocation& loc)
+cmSourceFileLocation& cmSourceFileLocation::operator=(
+  const cmSourceFileLocation& loc)
 {
-  if(this == &loc)
-    {
+  if (this == &loc) {
     return *this;
-    }
+  }
   this->Makefile = loc.Makefile;
   this->AmbiguousDirectory = loc.AmbiguousDirectory;
   this->AmbiguousExtension = loc.AmbiguousExtension;
@@ -49,58 +49,50 @@ cmSourceFileLocation::operator=(const cmSourceFileLocation& loc)
   return *this;
 }
 
-cmSourceFileLocation
-::cmSourceFileLocation(cmMakefile const* mf, const std::string& name)
+cmSourceFileLocation::cmSourceFileLocation(cmMakefile const* mf,
+                                           const std::string& name)
   : Makefile(mf)
 {
   this->AmbiguousDirectory = !cmSystemTools::FileIsFullPath(name.c_str());
   this->AmbiguousExtension = true;
   this->Directory = cmSystemTools::GetFilenamePath(name);
-  if (cmSystemTools::FileIsFullPath(this->Directory.c_str()))
-    {
-    this->Directory
-                  = cmSystemTools::CollapseFullPath(this->Directory);
-    }
+  if (cmSystemTools::FileIsFullPath(this->Directory.c_str())) {
+    this->Directory = cmSystemTools::CollapseFullPath(this->Directory);
+  }
   this->Name = cmSystemTools::GetFilenameName(name);
   this->UpdateExtension(name);
 }
 
 void cmSourceFileLocation::Update(cmSourceFileLocation const& loc)
 {
-  if(this->AmbiguousDirectory && !loc.AmbiguousDirectory)
-    {
+  if (this->AmbiguousDirectory && !loc.AmbiguousDirectory) {
     this->Directory = loc.Directory;
     this->AmbiguousDirectory = false;
-    }
-  if(this->AmbiguousExtension && !loc.AmbiguousExtension)
-    {
+  }
+  if (this->AmbiguousExtension && !loc.AmbiguousExtension) {
     this->Name = loc.Name;
     this->AmbiguousExtension = false;
-    }
+  }
 }
 
 void cmSourceFileLocation::DirectoryUseSource()
 {
   assert(this->Makefile);
-  if(this->AmbiguousDirectory)
-    {
-    this->Directory =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentSourceDirectory());
+  if (this->AmbiguousDirectory) {
+    this->Directory = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentSourceDirectory());
     this->AmbiguousDirectory = false;
-    }
+  }
 }
 
 void cmSourceFileLocation::DirectoryUseBinary()
 {
   assert(this->Makefile);
-  if(this->AmbiguousDirectory)
-    {
-    this->Directory =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentBinaryDirectory());
+  if (this->AmbiguousDirectory) {
+    this->Directory = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentBinaryDirectory());
     this->AmbiguousDirectory = false;
-    }
+  }
 }
 
 void cmSourceFileLocation::UpdateExtension(const std::string& name)
@@ -108,155 +100,129 @@ void cmSourceFileLocation::UpdateExtension(const std::string& name)
   assert(this->Makefile);
   // Check the extension.
   std::string ext = cmSystemTools::GetFilenameLastExtension(name);
-  if(!ext.empty()) { ext = ext.substr(1); }
+  if (!ext.empty()) {
+    ext = ext.substr(1);
+  }
 
   // The global generator checks extensions of enabled languages.
   cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
   cmMakefile const* mf = this->Makefile;
   const std::vector<std::string>& srcExts =
-      mf->GetCMakeInstance()->GetSourceExtensions();
+    mf->GetCMakeInstance()->GetSourceExtensions();
   const std::vector<std::string>& hdrExts =
-      mf->GetCMakeInstance()->GetHeaderExtensions();
-  if(!gg->GetLanguageFromExtension(ext.c_str()).empty() ||
-     std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
-     std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
-    {
+    mf->GetCMakeInstance()->GetHeaderExtensions();
+  if (!gg->GetLanguageFromExtension(ext.c_str()).empty() ||
+      std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
+      std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) {
     // This is a known extension.  Use the given filename with extension.
     this->Name = cmSystemTools::GetFilenameName(name);
     this->AmbiguousExtension = false;
-    }
-  else
-    {
+  } else {
     // This is not a known extension.  See if the file exists on disk as
     // named.
     std::string tryPath;
-    if(this->AmbiguousDirectory)
-      {
+    if (this->AmbiguousDirectory) {
       // Check the source tree only because a file in the build tree should
       // be specified by full path at least once.  We do not want this
       // detection to depend on whether the project has already been built.
       tryPath = this->Makefile->GetCurrentSourceDirectory();
       tryPath += "/";
-      }
-    if(!this->Directory.empty())
-      {
+    }
+    if (!this->Directory.empty()) {
       tryPath += this->Directory;
       tryPath += "/";
-      }
+    }
     tryPath += this->Name;
-    if(cmSystemTools::FileExists(tryPath.c_str(), true))
-      {
+    if (cmSystemTools::FileExists(tryPath.c_str(), true)) {
       // We found a source file named by the user on disk.  Trust it's
       // extension.
       this->Name = cmSystemTools::GetFilenameName(name);
       this->AmbiguousExtension = false;
 
       // If the directory was ambiguous, it isn't anymore.
-      if(this->AmbiguousDirectory)
-        {
+      if (this->AmbiguousDirectory) {
         this->DirectoryUseSource();
-        }
       }
     }
+  }
 }
 
-bool
-cmSourceFileLocation
-::MatchesAmbiguousExtension(cmSourceFileLocation const& loc) const
+bool cmSourceFileLocation::MatchesAmbiguousExtension(
+  cmSourceFileLocation const& loc) const
 {
   assert(this->Makefile);
   // This location's extension is not ambiguous but loc's extension
   // is.  See if the names match as-is.
-  if(this->Name == loc.Name)
-    {
+  if (this->Name == loc.Name) {
     return true;
-    }
+  }
 
   // Check if loc's name could possibly be extended to our name by
   // adding an extension.
-  if(!(this->Name.size() > loc.Name.size() &&
-       this->Name[loc.Name.size()] == '.' &&
-       cmHasLiteralPrefixImpl(this->Name.c_str(),
-                              loc.Name.c_str(), loc.Name.size())))
-    {
+  if (!(this->Name.size() > loc.Name.size() &&
+        this->Name[loc.Name.size()] == '.' &&
+        cmHasLiteralPrefixImpl(this->Name.c_str(), loc.Name.c_str(),
+                               loc.Name.size()))) {
     return false;
-    }
+  }
 
   // Only a fixed set of extensions will be tried to match a file on
   // disk.  One of these must match if loc refers to this source file.
-  std::string const& ext = this->Name.substr(loc.Name.size()+1);
+  std::string const& ext = this->Name.substr(loc.Name.size() + 1);
   cmMakefile const* mf = this->Makefile;
   const std::vector<std::string>& srcExts =
-      mf->GetCMakeInstance()->GetSourceExtensions();
-  if(std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end())
-    {
+    mf->GetCMakeInstance()->GetSourceExtensions();
+  if (std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end()) {
     return true;
-    }
+  }
   std::vector<std::string> hdrExts =
-      mf->GetCMakeInstance()->GetHeaderExtensions();
-  if(std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
-    {
+    mf->GetCMakeInstance()->GetHeaderExtensions();
+  if (std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end()) {
     return true;
-    }
+  }
   return false;
 }
 
 bool cmSourceFileLocation::Matches(cmSourceFileLocation const& loc)
 {
   assert(this->Makefile);
-  if(this->AmbiguousExtension == loc.AmbiguousExtension)
-    {
+  if (this->AmbiguousExtension == loc.AmbiguousExtension) {
     // Both extensions are similarly ambiguous.  Since only the old fixed set
     // of extensions will be tried, the names must match at this point to be
     // the same file.
-    if(this->Name.size() != loc.Name.size() ||
-      !cmSystemTools::ComparePath(this->Name, loc.Name))
-      {
+    if (this->Name.size() != loc.Name.size() ||
+        !cmSystemTools::ComparePath(this->Name, loc.Name)) {
       return false;
-      }
     }
-  else
-    {
+  } else {
     const cmSourceFileLocation* loc1;
     const cmSourceFileLocation* loc2;
-    if(this->AmbiguousExtension)
-      {
+    if (this->AmbiguousExtension) {
       // Only "this" extension is ambiguous.
       loc1 = &loc;
       loc2 = this;
-      }
-    else
-      {
+    } else {
       // Only "loc" extension is ambiguous.
       loc1 = this;
       loc2 = &loc;
-      }
-    if(!loc1->MatchesAmbiguousExtension(*loc2))
-      {
+    }
+    if (!loc1->MatchesAmbiguousExtension(*loc2)) {
       return false;
-      }
     }
+  }
 
-  if(!this->AmbiguousDirectory && !loc.AmbiguousDirectory)
-    {
+  if (!this->AmbiguousDirectory && !loc.AmbiguousDirectory) {
     // Both sides have absolute directories.
-    if(this->Directory != loc.Directory)
-      {
+    if (this->Directory != loc.Directory) {
       return false;
-      }
     }
-  else if(this->AmbiguousDirectory && loc.AmbiguousDirectory)
-    {
-    if (this->Makefile == loc.Makefile)
-      {
+  } else if (this->AmbiguousDirectory && loc.AmbiguousDirectory) {
+    if (this->Makefile == loc.Makefile) {
       // Both sides have directories relative to the same location.
-      if(this->Directory != loc.Directory)
-        {
+      if (this->Directory != loc.Directory) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       // Each side has a directory relative to a different location.
       // This can occur when referencing a source file from a different
       // directory.  This is not yet allowed.
@@ -264,41 +230,28 @@ bool cmSourceFileLocation::Matches(cmSourceFileLocation const& loc)
         cmake::INTERNAL_ERROR,
         "Matches error: Each side has a directory relative to a different "
         "location. This can occur when referencing a source file from a "
-        "different directory.  This is not yet allowed."
-        );
+        "different directory.  This is not yet allowed.");
       return false;
-      }
     }
-  else if(this->AmbiguousDirectory)
-    {
+  } else if (this->AmbiguousDirectory) {
     // Compare possible directory combinations.
-    std::string const& srcDir =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentSourceDirectory());
-    std::string const& binDir =
-      cmSystemTools::CollapseFullPath(
-        this->Directory, this->Makefile->GetCurrentBinaryDirectory());
-    if(srcDir != loc.Directory &&
-       binDir != loc.Directory)
-      {
+    std::string const& srcDir = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentSourceDirectory());
+    std::string const& binDir = cmSystemTools::CollapseFullPath(
+      this->Directory, this->Makefile->GetCurrentBinaryDirectory());
+    if (srcDir != loc.Directory && binDir != loc.Directory) {
       return false;
-      }
     }
-  else if(loc.AmbiguousDirectory)
-    {
+  } else if (loc.AmbiguousDirectory) {
     // Compare possible directory combinations.
-    std::string const& srcDir =
-      cmSystemTools::CollapseFullPath(
-        loc.Directory, loc.Makefile->GetCurrentSourceDirectory());
-    std::string const& binDir =
-      cmSystemTools::CollapseFullPath(
-        loc.Directory, loc.Makefile->GetCurrentBinaryDirectory());
-    if(srcDir != this->Directory &&
-       binDir != this->Directory)
-      {
+    std::string const& srcDir = cmSystemTools::CollapseFullPath(
+      loc.Directory, loc.Makefile->GetCurrentSourceDirectory());
+    std::string const& binDir = cmSystemTools::CollapseFullPath(
+      loc.Directory, loc.Makefile->GetCurrentBinaryDirectory());
+    if (srcDir != this->Directory && binDir != this->Directory) {
       return false;
-      }
     }
+  }
 
   // File locations match.
   this->Update(loc);
diff --git a/Source/cmSourceGroup.cxx b/Source/cmSourceGroup.cxx
index 34b4315..c09d596 100644
--- a/Source/cmSourceGroup.cxx
+++ b/Source/cmSourceGroup.cxx
@@ -18,15 +18,15 @@ public:
 };
 
 cmSourceGroup::cmSourceGroup(const char* name, const char* regex,
-                             const char* parentName): Name(name)
+                             const char* parentName)
+  : Name(name)
 {
   this->Internal = new cmSourceGroupInternals;
   this->SetGroupRegex(regex);
-  if(parentName)
-    {
+  if (parentName) {
     this->FullName = parentName;
     this->FullName += "\\";
-    }
+  }
   this->FullName += this->Name;
 }
 
@@ -57,14 +57,11 @@ cmSourceGroup& cmSourceGroup::operator=(cmSourceGroup const& r)
 
 void cmSourceGroup::SetGroupRegex(const char* regex)
 {
-  if(regex)
-    {
+  if (regex) {
     this->GroupRegex.compile(regex);
-    }
-  else
-    {
+  } else {
     this->GroupRegex.compile("^$");
-    }
+  }
 }
 
 void cmSourceGroup::AddGroupFile(const std::string& name)
@@ -90,10 +87,9 @@ bool cmSourceGroup::MatchesRegex(const char* name)
 bool cmSourceGroup::MatchesFiles(const char* name)
 {
   std::set<std::string>::const_iterator i = this->GroupFiles.find(name);
-  if(i != this->GroupFiles.end())
-    {
+  if (i != this->GroupFiles.end()) {
     return true;
-    }
+  }
   return false;
 }
 
@@ -112,7 +108,7 @@ void cmSourceGroup::AddChild(cmSourceGroup child)
   this->Internal->GroupChildren.push_back(child);
 }
 
-cmSourceGroup *cmSourceGroup::LookupChild(const char* name) const
+cmSourceGroup* cmSourceGroup::LookupChild(const char* name) const
 {
   // initializing iterators
   std::vector<cmSourceGroup>::const_iterator iter =
@@ -121,22 +117,20 @@ cmSourceGroup *cmSourceGroup::LookupChild(const char* name) const
     this->Internal->GroupChildren.end();
 
   // st
-  for(;iter!=end; ++iter)
-    {
+  for (; iter != end; ++iter) {
     std::string sgName = iter->GetName();
 
     // look if descenened is the one were looking for
-    if(sgName == name)
-      {
+    if (sgName == name) {
       return const_cast<cmSourceGroup*>(&(*iter)); // if it so return it
-      }
     }
+  }
 
   // if no child with this name was found return NULL
   return NULL;
 }
 
-cmSourceGroup *cmSourceGroup::MatchChildrenFiles(const char *name)
+cmSourceGroup* cmSourceGroup::MatchChildrenFiles(const char* name)
 {
   // initializing iterators
   std::vector<cmSourceGroup>::iterator iter =
@@ -144,23 +138,19 @@ cmSourceGroup *cmSourceGroup::MatchChildrenFiles(const char *name)
   std::vector<cmSourceGroup>::iterator end =
     this->Internal->GroupChildren.end();
 
-  if(this->MatchesFiles(name))
-    {
+  if (this->MatchesFiles(name)) {
     return this;
-    }
-  for(;iter!=end;++iter)
-    {
-    cmSourceGroup *result = iter->MatchChildrenFiles(name);
-    if(result)
-      {
+  }
+  for (; iter != end; ++iter) {
+    cmSourceGroup* result = iter->MatchChildrenFiles(name);
+    if (result) {
       return result;
-      }
     }
+  }
   return 0;
 }
 
-
-cmSourceGroup *cmSourceGroup::MatchChildrenRegex(const char *name)
+cmSourceGroup* cmSourceGroup::MatchChildrenRegex(const char* name)
 {
   // initializing iterators
   std::vector<cmSourceGroup>::iterator iter =
@@ -168,24 +158,20 @@ cmSourceGroup *cmSourceGroup::MatchChildrenRegex(const char *name)
   std::vector<cmSourceGroup>::iterator end =
     this->Internal->GroupChildren.end();
 
-  for(;iter!=end; ++iter)
-    {
-    cmSourceGroup *result = iter->MatchChildrenRegex(name);
-    if(result)
-      {
+  for (; iter != end; ++iter) {
+    cmSourceGroup* result = iter->MatchChildrenRegex(name);
+    if (result) {
       return result;
-      }
     }
-  if(this->MatchesRegex(name))
-    {
+  }
+  if (this->MatchesRegex(name)) {
     return this;
-    }
+  }
 
   return 0;
 }
 
-std::vector<cmSourceGroup> const&
-cmSourceGroup::GetGroupChildren() const
+std::vector<cmSourceGroup> const& cmSourceGroup::GetGroupChildren() const
 {
   return this->Internal->GroupChildren;
 }
diff --git a/Source/cmSourceGroup.h b/Source/cmSourceGroup.h
index 316d725..5a551f8 100644
--- a/Source/cmSourceGroup.h
+++ b/Source/cmSourceGroup.h
@@ -34,7 +34,7 @@ class cmSourceGroup
 {
 public:
   cmSourceGroup(const char* name, const char* regex,
-                const char* parentName=0);
+                const char* parentName = 0);
   cmSourceGroup(cmSourceGroup const& r);
   ~cmSourceGroup();
   cmSourceGroup& operator=(cmSourceGroup const&);
@@ -57,7 +57,7 @@ public:
   /**
    * Looks up child and returns it
    */
-  cmSourceGroup *LookupChild(const char *name) const;
+  cmSourceGroup* LookupChild(const char* name) const;
 
   /**
    * Get the name of this group.
@@ -83,12 +83,12 @@ public:
    * Check if the given name matches this group's explicit file list
    * in children.
    */
-  cmSourceGroup *MatchChildrenFiles(const char *name);
+  cmSourceGroup* MatchChildrenFiles(const char* name);
 
   /**
    * Check if the given name matches this group's regex in children.
    */
-  cmSourceGroup *MatchChildrenRegex(const char *name);
+  cmSourceGroup* MatchChildrenRegex(const char* name);
 
   /**
    * Assign the given source file to this group.  Used only by
@@ -103,6 +103,7 @@ public:
   const std::vector<const cmSourceFile*>& GetSourceFiles() const;
 
   std::vector<cmSourceGroup> const& GetGroupChildren() const;
+
 private:
   /**
    * The name of the source group.
diff --git a/Source/cmSourceGroupCommand.cxx b/Source/cmSourceGroupCommand.cxx
index fadb172..252819c 100644
--- a/Source/cmSourceGroupCommand.cxx
+++ b/Source/cmSourceGroupCommand.cxx
@@ -12,91 +12,74 @@
 #include "cmSourceGroupCommand.h"
 
 // cmSourceGroupCommand
-bool cmSourceGroupCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSourceGroupCommand::InitialPass(std::vector<std::string> const& args,
+                                       cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string delimiter = "\\";
-  if(this->Makefile->GetDefinition("SOURCE_GROUP_DELIMITER"))
-    {
+  if (this->Makefile->GetDefinition("SOURCE_GROUP_DELIMITER")) {
     delimiter = this->Makefile->GetDefinition("SOURCE_GROUP_DELIMITER");
-    }
+  }
 
   std::vector<std::string> folders =
     cmSystemTools::tokenize(args[0], delimiter);
 
   cmSourceGroup* sg = 0;
   sg = this->Makefile->GetSourceGroup(folders);
-  if(!sg)
-    {
+  if (!sg) {
     this->Makefile->AddSourceGroup(folders);
     sg = this->Makefile->GetSourceGroup(folders);
-    }
+  }
 
-  if(!sg)
-    {
+  if (!sg) {
     this->SetError("Could not create or find source group");
     return false;
-    }
+  }
   // If only two arguments are given, the pre-1.8 version of the
   // command is being invoked.
-  if(args.size() == 2  && args[1] != "FILES")
-    {
+  if (args.size() == 2 && args[1] != "FILES") {
     sg->SetGroupRegex(args[1].c_str());
     return true;
-    }
+  }
 
   // Process arguments.
   bool doingFiles = false;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "REGULAR_EXPRESSION")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "REGULAR_EXPRESSION") {
       // Next argument must specify the regex.
-      if(i+1 < args.size())
-        {
+      if (i + 1 < args.size()) {
         ++i;
         sg->SetGroupRegex(args[i].c_str());
-        }
-      else
-        {
+      } else {
         this->SetError("REGULAR_EXPRESSION argument given without a regex.");
         return false;
-        }
-      doingFiles = false;
       }
-    else if(args[i] == "FILES")
-      {
+      doingFiles = false;
+    } else if (args[i] == "FILES") {
       // Next arguments will specify files.
       doingFiles = true;
-      }
-    else if(doingFiles)
-      {
+    } else if (doingFiles) {
       // Convert name to full path and add to the group's list.
       std::string src = args[i];
-      if(!cmSystemTools::FileIsFullPath(src.c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(src.c_str())) {
         src = this->Makefile->GetCurrentSourceDirectory();
         src += "/";
         src += args[i];
-        }
+      }
       src = cmSystemTools::CollapseFullPath(src.c_str());
       sg->AddGroupFile(src);
-      }
-    else
-      {
+    } else {
       std::ostringstream err;
       err << "Unknown argument \"" << args[i] << "\".  "
           << "Perhaps the FILES keyword is missing.\n";
       this->SetError(err.str());
       return false;
-      }
     }
+  }
 
   return true;
 }
diff --git a/Source/cmSourceGroupCommand.h b/Source/cmSourceGroupCommand.h
index 410411b..0458656 100644
--- a/Source/cmSourceGroupCommand.h
+++ b/Source/cmSourceGroupCommand.h
@@ -26,26 +26,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmSourceGroupCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSourceGroupCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "source_group";}
+  virtual std::string GetName() const { return "source_group"; }
 
   cmTypeMacro(cmSourceGroupCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmStandardIncludes.h b/Source/cmStandardIncludes.h
index f80586e..6669e5c 100644
--- a/Source/cmStandardIncludes.h
+++ b/Source/cmStandardIncludes.h
@@ -21,14 +21,13 @@
 #include <cmsys/Configure.hxx>
 
 #ifdef _MSC_VER
-#pragma warning ( disable : 4786 )
-#pragma warning ( disable : 4503 )
+#pragma warning(disable : 4786)
+#pragma warning(disable : 4503)
 #endif
 
-
 #ifdef __ICL
-#pragma warning ( disable : 985 )
-#pragma warning ( disable : 1572 ) /* floating-point equality test */
+#pragma warning(disable : 985)
+#pragma warning(disable : 1572) /* floating-point equality test */
 #endif
 
 // Provide fixed-size integer types.
@@ -53,36 +52,45 @@
 #include <stdlib.h>
 #include <string.h>
 
-#if defined( _MSC_VER )
+#if defined(_MSC_VER)
 typedef unsigned short mode_t;
 #else
-# include <sys/types.h>
+#include <sys/types.h>
 #endif
 
 // use this class to shrink the size of symbols in .o files
 // std::string is really basic_string<....lots of stuff....>
 // when combined with a map or set, the symbols can be > 2000 chars!
 #include <cmsys/String.hxx>
-//typedef cmsys::String std::string;
+// typedef cmsys::String std::string;
 
 /* Poison this operator to avoid common mistakes.  */
-extern void operator << (std::ostream&, const std::ostringstream&);
+extern void operator<<(std::ostream&, const std::ostringstream&);
 
 /** Standard documentation entry for cmDocumentation's formatting.  */
 struct cmDocumentationEntry
 {
   std::string Name;
   std::string Brief;
-  cmDocumentationEntry(){}
-  cmDocumentationEntry(const char *doc[2])
-  { if (doc[0]) this->Name = doc[0];
-  if (doc[1]) this->Brief = doc[1];}
-  cmDocumentationEntry(const char *n, const char *b)
-  { if (n) this->Name = n; if (b) this->Brief = b; }
+  cmDocumentationEntry() {}
+  cmDocumentationEntry(const char* doc[2])
+  {
+    if (doc[0])
+      this->Name = doc[0];
+    if (doc[1])
+      this->Brief = doc[1];
+  }
+  cmDocumentationEntry(const char* n, const char* b)
+  {
+    if (n)
+      this->Name = n;
+    if (b)
+      this->Brief = b;
+  }
 };
 
 /** Data structure to represent a single command line.  */
-class cmCustomCommandLine: public std::vector<std::string>
+class cmCustomCommandLine : public std::vector<std::string>
 {
 public:
   typedef std::vector<std::string> Superclass;
@@ -91,7 +99,7 @@ public:
 };
 
 /** Data structure to represent a list of command lines.  */
-class cmCustomCommandLines: public std::vector<cmCustomCommandLine>
+class cmCustomCommandLines : public std::vector<cmCustomCommandLine>
 {
 public:
   typedef std::vector<cmCustomCommandLine> Superclass;
@@ -101,32 +109,28 @@ public:
 
 // All subclasses of cmCommand or cmCTestGenericHandler should
 // invoke this macro.
-#define cmTypeMacro(thisClass,superclass) \
-virtual const char* GetNameOfClass() { return #thisClass; } \
-typedef superclass Superclass; \
-static bool IsTypeOf(const char *type) \
-{ \
-  if ( !strcmp(#thisClass,type) ) \
-    { \
-    return true; \
-    } \
-  return Superclass::IsTypeOf(type); \
-} \
-virtual bool IsA(const char *type) \
-{ \
-  return thisClass::IsTypeOf(type); \
-} \
-static thisClass* SafeDownCast(cmObject *c) \
-{ \
-  if ( c && c->IsA(#thisClass) ) \
-    { \
-    return static_cast<thisClass *>(c); \
-    } \
-  return 0;\
-} \
-class cmTypeMacro_UseTrailingSemicolon
-
-enum cmTargetLinkLibraryType {
+#define cmTypeMacro(thisClass, superclass)                                    \
+  virtual const char* GetNameOfClass() { return #thisClass; }                 \
+  typedef superclass Superclass;                                              \
+  static bool IsTypeOf(const char* type)                                      \
+  {                                                                           \
+    if (!strcmp(#thisClass, type)) {                                          \
+      return true;                                                            \
+    }                                                                         \
+    return Superclass::IsTypeOf(type);                                        \
+  }                                                                           \
+  virtual bool IsA(const char* type) { return thisClass::IsTypeOf(type); }    \
+  static thisClass* SafeDownCast(cmObject* c)                                 \
+  {                                                                           \
+    if (c && c->IsA(#thisClass)) {                                            \
+      return static_cast<thisClass*>(c);                                      \
+    }                                                                         \
+    return 0;                                                                 \
+  }                                                                           \
+  class cmTypeMacro_UseTrailingSemicolon
+
+enum cmTargetLinkLibraryType
+{
   GENERAL_LibraryType,
   DEBUG_LibraryType,
   OPTIMIZED_LibraryType
diff --git a/Source/cmStandardLexer.h b/Source/cmStandardLexer.h
index bd08ac7..94ed276 100644
--- a/Source/cmStandardLexer.h
+++ b/Source/cmStandardLexer.h
@@ -14,29 +14,29 @@
 
 /* Disable some warnings.  */
 #if defined(_MSC_VER)
-# pragma warning ( disable : 4127 )
-# pragma warning ( disable : 4131 )
-# pragma warning ( disable : 4244 )
-# pragma warning ( disable : 4251 )
-# pragma warning ( disable : 4267 )
-# pragma warning ( disable : 4305 )
-# pragma warning ( disable : 4309 )
-# pragma warning ( disable : 4706 )
-# pragma warning ( disable : 4786 )
+#pragma warning(disable : 4127)
+#pragma warning(disable : 4131)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4251)
+#pragma warning(disable : 4267)
+#pragma warning(disable : 4305)
+#pragma warning(disable : 4309)
+#pragma warning(disable : 4706)
+#pragma warning(disable : 4786)
 #endif
 
 /* Define isatty on windows.  */
 #if defined(_WIN32) && !defined(__CYGWIN__)
-# include <io.h>
-# if defined( _MSC_VER )
-#  define isatty _isatty
-# endif
-# define YY_NO_UNISTD_H 1
+#include <io.h>
+#if defined(_MSC_VER)
+#define isatty _isatty
+#endif
+#define YY_NO_UNISTD_H 1
 #endif
 
 /* Make sure malloc and free are available on QNX.  */
 #ifdef __QNX__
-# include <malloc.h>
+#include <malloc.h>
 #endif
 
 /* Disable features we do not need. */
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index a400def..b674b4e 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -31,7 +31,7 @@ struct cmState::SnapshotDataType
   bool Keep;
   cmLinkedTree<std::string>::iterator ExecutionListFile;
   cmLinkedTree<cmState::BuildsystemDirectoryStateType>::iterator
-                                                          BuildSystemDirectory;
+    BuildSystemDirectory;
   cmLinkedTree<cmDefinitions>::iterator Vars;
   cmLinkedTree<cmDefinitions>::iterator Root;
   cmLinkedTree<cmDefinitions>::iterator Parent;
@@ -40,12 +40,24 @@ struct cmState::SnapshotDataType
   std::vector<std::string>::size_type CompileOptionsPosition;
 };
 
-struct cmState::PolicyStackEntry: public cmPolicies::PolicyMap
+struct cmState::PolicyStackEntry : public cmPolicies::PolicyMap
 {
   typedef cmPolicies::PolicyMap derived;
-  PolicyStackEntry(bool w = false): derived(), Weak(w) {}
-  PolicyStackEntry(derived const& d, bool w): derived(d), Weak(w) {}
-  PolicyStackEntry(PolicyStackEntry const& r): derived(r), Weak(r.Weak) {}
+  PolicyStackEntry(bool w = false)
+    : derived()
+    , Weak(w)
+  {
+  }
+  PolicyStackEntry(derived const& d, bool w)
+    : derived(d)
+    , Weak(w)
+  {
+  }
+  PolicyStackEntry(PolicyStackEntry const& r)
+    : derived(r)
+    , Weak(r.Weak)
+  {
+  }
   bool Weak;
 };
 
@@ -83,13 +95,13 @@ struct cmState::BuildsystemDirectoryStateType
 };
 
 cmState::cmState()
-  : IsInTryCompile(false),
-    WindowsShell(false),
-    WindowsVSIDE(false),
-    WatcomWMake(false),
-    MinGWMake(false),
-    NMake(false),
-    MSYSShell(false)
+  : IsInTryCompile(false)
+  , WindowsShell(false)
+  , WindowsVSIDE(false)
+  , WatcomWMake(false)
+  , MinGWMake(false)
+  , NMake(false)
+  , MSYSShell(false)
 {
   this->CacheManager = new cmCacheManager;
 }
@@ -102,76 +114,61 @@ cmState::~cmState()
 
 const char* cmState::GetTargetTypeName(cmState::TargetType targetType)
 {
-  switch( targetType )
-    {
-      case cmState::STATIC_LIBRARY:
-        return "STATIC_LIBRARY";
-      case cmState::MODULE_LIBRARY:
-        return "MODULE_LIBRARY";
-      case cmState::SHARED_LIBRARY:
-        return "SHARED_LIBRARY";
-      case cmState::OBJECT_LIBRARY:
-        return "OBJECT_LIBRARY";
-      case cmState::EXECUTABLE:
-        return "EXECUTABLE";
-      case cmState::UTILITY:
-        return "UTILITY";
-      case cmState::GLOBAL_TARGET:
-        return "GLOBAL_TARGET";
-      case cmState::INTERFACE_LIBRARY:
-        return "INTERFACE_LIBRARY";
-      case cmState::UNKNOWN_LIBRARY:
-        return "UNKNOWN_LIBRARY";
-    }
+  switch (targetType) {
+    case cmState::STATIC_LIBRARY:
+      return "STATIC_LIBRARY";
+    case cmState::MODULE_LIBRARY:
+      return "MODULE_LIBRARY";
+    case cmState::SHARED_LIBRARY:
+      return "SHARED_LIBRARY";
+    case cmState::OBJECT_LIBRARY:
+      return "OBJECT_LIBRARY";
+    case cmState::EXECUTABLE:
+      return "EXECUTABLE";
+    case cmState::UTILITY:
+      return "UTILITY";
+    case cmState::GLOBAL_TARGET:
+      return "GLOBAL_TARGET";
+    case cmState::INTERFACE_LIBRARY:
+      return "INTERFACE_LIBRARY";
+    case cmState::UNKNOWN_LIBRARY:
+      return "UNKNOWN_LIBRARY";
+  }
   assert(0 && "Unexpected target type");
   return 0;
 }
 
-const char* cmCacheEntryTypes[] =
-{ "BOOL",
-  "PATH",
-  "FILEPATH",
-  "STRING",
-  "INTERNAL",
-  "STATIC",
-  "UNINITIALIZED",
-  0
-};
+const char* cmCacheEntryTypes[] = { "BOOL",          "PATH",     "FILEPATH",
+                                    "STRING",        "INTERNAL", "STATIC",
+                                    "UNINITIALIZED", 0 };
 
-const char*
-cmState::CacheEntryTypeToString(cmState::CacheEntryType type)
+const char* cmState::CacheEntryTypeToString(cmState::CacheEntryType type)
 {
-  if ( type > 6 )
-    {
+  if (type > 6) {
     return cmCacheEntryTypes[6];
-    }
+  }
   return cmCacheEntryTypes[type];
 }
 
-cmState::CacheEntryType
-cmState::StringToCacheEntryType(const char* s)
+cmState::CacheEntryType cmState::StringToCacheEntryType(const char* s)
 {
   int i = 0;
-  while(cmCacheEntryTypes[i])
-    {
-    if(strcmp(s, cmCacheEntryTypes[i]) == 0)
-      {
+  while (cmCacheEntryTypes[i]) {
+    if (strcmp(s, cmCacheEntryTypes[i]) == 0) {
       return static_cast<cmState::CacheEntryType>(i);
-      }
-    ++i;
     }
+    ++i;
+  }
   return STRING;
 }
 
 bool cmState::IsCacheEntryType(std::string const& key)
 {
-  for(int i=0; cmCacheEntryTypes[i]; ++i)
-    {
-    if(strcmp(key.c_str(), cmCacheEntryTypes[i]) == 0)
-      {
+  for (int i = 0; cmCacheEntryTypes[i]; ++i) {
+    if (strcmp(key.c_str(), cmCacheEntryTypes[i]) == 0) {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -179,8 +176,7 @@ bool cmState::LoadCache(const std::string& path, bool internal,
                         std::set<std::string>& excludes,
                         std::set<std::string>& includes)
 {
-  return this->CacheManager->LoadCache(path, internal,
-                                       excludes, includes);
+  return this->CacheManager->LoadCache(path, internal, excludes, includes);
 }
 
 bool cmState::SaveCache(const std::string& path)
@@ -197,89 +193,82 @@ std::vector<std::string> cmState::GetCacheEntryKeys() const
 {
   std::vector<std::string> definitions;
   definitions.reserve(this->CacheManager->GetSize());
-  cmCacheManager::CacheIterator cit =
-    this->CacheManager->GetCacheIterator();
-  for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
-    {
+  cmCacheManager::CacheIterator cit = this->CacheManager->GetCacheIterator();
+  for (cit.Begin(); !cit.IsAtEnd(); cit.Next()) {
     definitions.push_back(cit.GetName());
-    }
+  }
   return definitions;
 }
 
 const char* cmState::GetCacheEntryValue(std::string const& key) const
 {
-  cmCacheManager::CacheEntry* e = this->CacheManager
-             ->GetCacheEntry(key);
-  if (!e)
-    {
+  cmCacheManager::CacheEntry* e = this->CacheManager->GetCacheEntry(key);
+  if (!e) {
     return 0;
-    }
+  }
   return e->Value.c_str();
 }
 
-const char*
-cmState::GetInitializedCacheValue(std::string const& key) const
+const char* cmState::GetInitializedCacheValue(std::string const& key) const
 {
   return this->CacheManager->GetInitializedCacheValue(key);
 }
 
-cmState::CacheEntryType
-cmState::GetCacheEntryType(std::string const& key) const
+cmState::CacheEntryType cmState::GetCacheEntryType(
+  std::string const& key) const
 {
   cmCacheManager::CacheIterator it =
-      this->CacheManager->GetCacheIterator(key.c_str());
+    this->CacheManager->GetCacheIterator(key.c_str());
   return it.GetType();
 }
 
 void cmState::SetCacheEntryValue(std::string const& key,
-                                         std::string const& value)
+                                 std::string const& value)
 {
   this->CacheManager->SetCacheEntryValue(key, value);
 }
 
 void cmState::SetCacheEntryProperty(std::string const& key,
-                            std::string const& propertyName,
-                            std::string const& value)
+                                    std::string const& propertyName,
+                                    std::string const& value)
 {
   cmCacheManager::CacheIterator it =
-      this->CacheManager->GetCacheIterator(key.c_str());
+    this->CacheManager->GetCacheIterator(key.c_str());
   it.SetProperty(propertyName, value.c_str());
 }
 
 void cmState::SetCacheEntryBoolProperty(std::string const& key,
-                            std::string const& propertyName,
-                            bool value)
+                                        std::string const& propertyName,
+                                        bool value)
 {
   cmCacheManager::CacheIterator it =
-      this->CacheManager->GetCacheIterator(key.c_str());
+    this->CacheManager->GetCacheIterator(key.c_str());
   it.SetProperty(propertyName, value);
 }
 
 const char* cmState::GetCacheEntryProperty(std::string const& key,
-                                              std::string const& propertyName)
+                                           std::string const& propertyName)
 {
-  cmCacheManager::CacheIterator it = this->CacheManager
-             ->GetCacheIterator(key.c_str());
-  if (!it.PropertyExists(propertyName))
-    {
+  cmCacheManager::CacheIterator it =
+    this->CacheManager->GetCacheIterator(key.c_str());
+  if (!it.PropertyExists(propertyName)) {
     return 0;
-    }
+  }
   return it.GetProperty(propertyName);
 }
 
 bool cmState::GetCacheEntryPropertyAsBool(std::string const& key,
-                                              std::string const& propertyName)
+                                          std::string const& propertyName)
 {
-  return this->CacheManager
-             ->GetCacheIterator(key.c_str()).GetPropertyAsBool(propertyName);
+  return this->CacheManager->GetCacheIterator(key.c_str())
+    .GetPropertyAsBool(propertyName);
 }
 
 void cmState::AddCacheEntry(const std::string& key, const char* value,
-                                    const char* helpString,
-                                    cmState::CacheEntryType type)
+                            const char* helpString,
+                            cmState::CacheEntryType type)
 {
-  this->CacheManager->AddCacheEntry(key, value,
-                                                        helpString, type);
+  this->CacheManager->AddCacheEntry(key, value, helpString, type);
 }
 
 void cmState::RemoveCacheEntry(std::string const& key)
@@ -288,21 +277,18 @@ void cmState::RemoveCacheEntry(std::string const& key)
 }
 
 void cmState::AppendCacheEntryProperty(const std::string& key,
-                                               const std::string& property,
-                                               const std::string& value,
-                                               bool asString)
+                                       const std::string& property,
+                                       const std::string& value, bool asString)
 {
-  this->CacheManager
-       ->GetCacheIterator(key.c_str()).AppendProperty(property,
-                                                       value.c_str(),
-                                                       asString);
+  this->CacheManager->GetCacheIterator(key.c_str())
+    .AppendProperty(property, value.c_str(), asString);
 }
 
 void cmState::RemoveCacheEntryProperty(std::string const& key,
-                                              std::string const& propertyName)
+                                       std::string const& propertyName)
 {
-  this->CacheManager
-       ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0);
+  this->CacheManager->GetCacheIterator(key.c_str())
+    .SetProperty(propertyName, (void*)0);
 }
 
 cmState::Snapshot cmState::Reset()
@@ -314,17 +300,17 @@ cmState::Snapshot cmState::Reset()
   this->ExecutionListFiles.Truncate();
 
   {
-  cmLinkedTree<BuildsystemDirectoryStateType>::iterator it =
+    cmLinkedTree<BuildsystemDirectoryStateType>::iterator it =
       this->BuildsystemDirectory.Truncate();
-  it->IncludeDirectories.clear();
-  it->IncludeDirectoryBacktraces.clear();
-  it->CompileDefinitions.clear();
-  it->CompileDefinitionsBacktraces.clear();
-  it->CompileOptions.clear();
-  it->CompileOptionsBacktraces.clear();
-  it->DirectoryEnd = pos;
-  it->Properties.clear();
-  it->Children.clear();
+    it->IncludeDirectories.clear();
+    it->IncludeDirectoryBacktraces.clear();
+    it->CompileDefinitions.clear();
+    it->CompileDefinitionsBacktraces.clear();
+    it->CompileOptions.clear();
+    it->CompileOptionsBacktraces.clear();
+    it->DirectoryEnd = pos;
+    it->Properties.clear();
+    it->Children.clear();
   }
 
   this->PolicyStack.Clear();
@@ -335,99 +321,83 @@ cmState::Snapshot cmState::Reset()
   assert(pos->PolicyRoot.IsValid());
 
   {
-  std::string srcDir =
+    std::string srcDir =
       cmDefinitions::Get("CMAKE_SOURCE_DIR", pos->Vars, pos->Root);
-  std::string binDir =
+    std::string binDir =
       cmDefinitions::Get("CMAKE_BINARY_DIR", pos->Vars, pos->Root);
-  this->VarTree.Clear();
-  pos->Vars = this->VarTree.Push(this->VarTree.Root());
-  pos->Parent = this->VarTree.Root();
-  pos->Root = this->VarTree.Root();
+    this->VarTree.Clear();
+    pos->Vars = this->VarTree.Push(this->VarTree.Root());
+    pos->Parent = this->VarTree.Root();
+    pos->Root = this->VarTree.Root();
 
-  pos->Vars->Set("CMAKE_SOURCE_DIR", srcDir.c_str());
-  pos->Vars->Set("CMAKE_BINARY_DIR", binDir.c_str());
+    pos->Vars->Set("CMAKE_SOURCE_DIR", srcDir.c_str());
+    pos->Vars->Set("CMAKE_BINARY_DIR", binDir.c_str());
   }
 
-  this->DefineProperty
-    ("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY,
-     "", "", true);
-  this->DefineProperty
-    ("RULE_LAUNCH_LINK", cmProperty::DIRECTORY,
-     "", "", true);
-  this->DefineProperty
-    ("RULE_LAUNCH_CUSTOM", cmProperty::DIRECTORY,
-     "", "", true);
-
-  this->DefineProperty
-    ("RULE_LAUNCH_COMPILE", cmProperty::TARGET,
-     "", "", true);
-  this->DefineProperty
-    ("RULE_LAUNCH_LINK", cmProperty::TARGET,
-     "", "", true);
-  this->DefineProperty
-    ("RULE_LAUNCH_CUSTOM", cmProperty::TARGET,
-     "", "", true);
+  this->DefineProperty("RULE_LAUNCH_COMPILE", cmProperty::DIRECTORY, "", "",
+                       true);
+  this->DefineProperty("RULE_LAUNCH_LINK", cmProperty::DIRECTORY, "", "",
+                       true);
+  this->DefineProperty("RULE_LAUNCH_CUSTOM", cmProperty::DIRECTORY, "", "",
+                       true);
+
+  this->DefineProperty("RULE_LAUNCH_COMPILE", cmProperty::TARGET, "", "",
+                       true);
+  this->DefineProperty("RULE_LAUNCH_LINK", cmProperty::TARGET, "", "", true);
+  this->DefineProperty("RULE_LAUNCH_CUSTOM", cmProperty::TARGET, "", "", true);
 
   return Snapshot(this, pos);
 }
 
 void cmState::DefineProperty(const std::string& name,
-                           cmProperty::ScopeType scope,
-                           const char *ShortDescription,
-                           const char *FullDescription,
-                           bool chained)
+                             cmProperty::ScopeType scope,
+                             const char* ShortDescription,
+                             const char* FullDescription, bool chained)
 {
-  this->PropertyDefinitions[scope].DefineProperty(name,scope,ShortDescription,
-                                                  FullDescription,
-                                                  chained);
+  this->PropertyDefinitions[scope].DefineProperty(
+    name, scope, ShortDescription, FullDescription, chained);
 }
 
-cmPropertyDefinition const* cmState
-::GetPropertyDefinition(const std::string& name,
-                        cmProperty::ScopeType scope) const
+cmPropertyDefinition const* cmState::GetPropertyDefinition(
+  const std::string& name, cmProperty::ScopeType scope) const
 {
-  if (this->IsPropertyDefined(name,scope))
-    {
+  if (this->IsPropertyDefined(name, scope)) {
     cmPropertyDefinitionMap const& defs =
-        this->PropertyDefinitions.find(scope)->second;
+      this->PropertyDefinitions.find(scope)->second;
     return &defs.find(name)->second;
-    }
+  }
   return 0;
 }
 
 bool cmState::IsPropertyDefined(const std::string& name,
                                 cmProperty::ScopeType scope) const
 {
-  std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>::const_iterator it
-      = this->PropertyDefinitions.find(scope);
-  if (it == this->PropertyDefinitions.end())
-    {
+  std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>::const_iterator it =
+    this->PropertyDefinitions.find(scope);
+  if (it == this->PropertyDefinitions.end()) {
     return false;
-    }
+  }
   return it->second.IsPropertyDefined(name);
 }
 
 bool cmState::IsPropertyChained(const std::string& name,
                                 cmProperty::ScopeType scope) const
 {
-  std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>::const_iterator it
-      = this->PropertyDefinitions.find(scope);
-  if (it == this->PropertyDefinitions.end())
-    {
+  std::map<cmProperty::ScopeType, cmPropertyDefinitionMap>::const_iterator it =
+    this->PropertyDefinitions.find(scope);
+  if (it == this->PropertyDefinitions.end()) {
     return false;
-    }
+  }
   return it->second.IsPropertyChained(name);
 }
 
 void cmState::SetLanguageEnabled(std::string const& l)
 {
-  std::vector<std::string>::iterator it =
-      std::lower_bound(this->EnabledLanguages.begin(),
-                       this->EnabledLanguages.end(), l);
-  if (it == this->EnabledLanguages.end() || *it != l)
-    {
+  std::vector<std::string>::iterator it = std::lower_bound(
+    this->EnabledLanguages.begin(), this->EnabledLanguages.end(), l);
+  if (it == this->EnabledLanguages.end() || *it != l) {
     this->EnabledLanguages.insert(it, l);
-    }
+  }
 }
 
 bool cmState::GetLanguageEnabled(std::string const& l) const
@@ -468,19 +438,17 @@ void cmState::RenameCommand(std::string const& oldName,
   std::string sOldName = cmSystemTools::LowerCase(oldName);
   std::string sNewName = cmSystemTools::LowerCase(newName);
   std::map<std::string, cmCommand*>::iterator pos =
-      this->Commands.find(sOldName);
-  if ( pos == this->Commands.end() )
-    {
+    this->Commands.find(sOldName);
+  if (pos == this->Commands.end()) {
     return;
-    }
+  }
   cmCommand* cmd = pos->second;
 
   pos = this->Commands.find(sNewName);
-  if (pos != this->Commands.end())
-    {
+  if (pos != this->Commands.end()) {
     delete pos->second;
     this->Commands.erase(pos);
-    }
+  }
   this->Commands.insert(std::make_pair(sNewName, cmd));
   pos = this->Commands.find(sOldName);
   this->Commands.erase(pos);
@@ -491,31 +459,26 @@ void cmState::AddCommand(cmCommand* command)
   std::string name = cmSystemTools::LowerCase(command->GetName());
   // if the command already exists, free the old one
   std::map<std::string, cmCommand*>::iterator pos = this->Commands.find(name);
-  if (pos != this->Commands.end())
-    {
+  if (pos != this->Commands.end()) {
     delete pos->second;
     this->Commands.erase(pos);
-    }
+  }
   this->Commands.insert(std::make_pair(name, command));
 }
 
 void cmState::RemoveUnscriptableCommands()
 {
   std::vector<std::string> unscriptableCommands;
-  for (std::map<std::string, cmCommand*>::iterator
-       pos = this->Commands.begin();
-       pos != this->Commands.end(); )
-    {
-    if (!pos->second->IsScriptable())
-      {
+  for (std::map<std::string, cmCommand*>::iterator pos =
+         this->Commands.begin();
+       pos != this->Commands.end();) {
+    if (!pos->second->IsScriptable()) {
       delete pos->second;
       this->Commands.erase(pos++);
-      }
-    else
-      {
+    } else {
       ++pos;
-      }
     }
+  }
 }
 
 cmCommand* cmState::GetCommand(std::string const& name) const
@@ -523,11 +486,10 @@ cmCommand* cmState::GetCommand(std::string const& name) const
   cmCommand* command = 0;
   std::string sName = cmSystemTools::LowerCase(name);
   std::map<std::string, cmCommand*>::const_iterator pos =
-      this->Commands.find(sName);
-  if (pos != this->Commands.end())
-    {
+    this->Commands.find(sName);
+  if (pos != this->Commands.end()) {
     command = (*pos).second;
-    }
+  }
   return command;
 }
 
@@ -535,42 +497,34 @@ std::vector<std::string> cmState::GetCommandNames() const
 {
   std::vector<std::string> commandNames;
   commandNames.reserve(this->Commands.size());
-  std::map<std::string, cmCommand*>::const_iterator cmds
-      = this->Commands.begin();
-  for ( ; cmds != this->Commands.end(); ++ cmds )
-    {
+  std::map<std::string, cmCommand*>::const_iterator cmds =
+    this->Commands.begin();
+  for (; cmds != this->Commands.end(); ++cmds) {
     commandNames.push_back(cmds->first);
-    }
+  }
   return commandNames;
 }
 
 void cmState::RemoveUserDefinedCommands()
 {
   std::vector<cmCommand*> renamedCommands;
-  for(std::map<std::string, cmCommand*>::iterator j = this->Commands.begin();
-      j != this->Commands.end(); )
-    {
+  for (std::map<std::string, cmCommand*>::iterator j = this->Commands.begin();
+       j != this->Commands.end();) {
     if (j->second->IsA("cmMacroHelperCommand") ||
-        j->second->IsA("cmFunctionHelperCommand"))
-      {
+        j->second->IsA("cmFunctionHelperCommand")) {
       delete j->second;
       this->Commands.erase(j++);
-      }
-    else if (j->first != j->second->GetName())
-      {
+    } else if (j->first != j->second->GetName()) {
       renamedCommands.push_back(j->second);
       this->Commands.erase(j++);
-      }
-    else
-      {
+    } else {
       ++j;
-      }
     }
+  }
   for (std::vector<cmCommand*>::const_iterator it = renamedCommands.begin();
-       it != renamedCommands.end(); ++it)
-    {
+       it != renamedCommands.end(); ++it) {
     this->Commands[cmSystemTools::LowerCase((*it)->GetName())] = *it;
-    }
+  }
 }
 
 void cmState::SetGlobalProperty(const std::string& prop, const char* value)
@@ -578,44 +532,35 @@ void cmState::SetGlobalProperty(const std::string& prop, const char* value)
   this->GlobalProperties.SetProperty(prop, value);
 }
 
-void cmState::AppendGlobalProperty(const std::string& prop,
-                                   const char* value, bool asString)
+void cmState::AppendGlobalProperty(const std::string& prop, const char* value,
+                                   bool asString)
 {
   this->GlobalProperties.AppendProperty(prop, value, asString);
 }
 
-const char *cmState::GetGlobalProperty(const std::string& prop)
+const char* cmState::GetGlobalProperty(const std::string& prop)
 {
-  if ( prop == "CACHE_VARIABLES" )
-    {
+  if (prop == "CACHE_VARIABLES") {
     std::vector<std::string> cacheKeys = this->GetCacheEntryKeys();
     this->SetGlobalProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str());
-    }
-  else if ( prop == "COMMANDS" )
-    {
+  } else if (prop == "COMMANDS") {
     std::vector<std::string> commands = this->GetCommandNames();
     this->SetGlobalProperty("COMMANDS", cmJoin(commands, ";").c_str());
-    }
-  else if ( prop == "IN_TRY_COMPILE" )
-    {
+  } else if (prop == "IN_TRY_COMPILE") {
     this->SetGlobalProperty("IN_TRY_COMPILE",
-                      this->IsInTryCompile ? "1" : "0");
-    }
-  else if ( prop == "ENABLED_LANGUAGES" )
-    {
+                            this->IsInTryCompile ? "1" : "0");
+  } else if (prop == "ENABLED_LANGUAGES") {
     std::string langs;
     langs = cmJoin(this->EnabledLanguages, ";");
     this->SetGlobalProperty("ENABLED_LANGUAGES", langs.c_str());
-    }
+  }
 #define STRING_LIST_ELEMENT(F) ";" #F
-  if (prop == "CMAKE_C_KNOWN_FEATURES")
-    {
+  if (prop == "CMAKE_C_KNOWN_FEATURES") {
     return FOR_EACH_C_FEATURE(STRING_LIST_ELEMENT) + 1;
-    }
-  if (prop == "CMAKE_CXX_KNOWN_FEATURES")
-    {
+  }
+  if (prop == "CMAKE_CXX_KNOWN_FEATURES") {
     return FOR_EACH_CXX_FEATURE(STRING_LIST_ELEMENT) + 1;
-    }
+  }
 #undef STRING_LIST_ELEMENT
   return this->GlobalProperties.GetPropertyValue(prop);
 }
@@ -631,8 +576,8 @@ void cmState::SetSourceDirectory(std::string const& sourceDirectory)
   cmSystemTools::ConvertToUnixSlashes(this->SourceDirectory);
 
   cmSystemTools::SplitPath(
-      cmSystemTools::CollapseFullPath(this->SourceDirectory),
-        this->SourceDirectoryComponents);
+    cmSystemTools::CollapseFullPath(this->SourceDirectory),
+    this->SourceDirectoryComponents);
 }
 
 const char* cmState::GetSourceDirectory() const
@@ -651,8 +596,8 @@ void cmState::SetBinaryDirectory(std::string const& binaryDirectory)
   cmSystemTools::ConvertToUnixSlashes(this->BinaryDirectory);
 
   cmSystemTools::SplitPath(
-      cmSystemTools::CollapseFullPath(this->BinaryDirectory),
-        this->BinaryDirectoryComponents);
+    cmSystemTools::CollapseFullPath(this->BinaryDirectory),
+    this->BinaryDirectoryComponents);
 }
 
 void cmState::SetWindowsShell(bool windowsShell)
@@ -744,30 +689,25 @@ void cmState::Directory::ComputeRelativePathTopSource()
   cmState::Snapshot snapshot = this->Snapshot_;
   std::vector<cmState::Snapshot> snapshots;
   snapshots.push_back(snapshot);
-  while (true)
-    {
+  while (true) {
     snapshot = snapshot.GetBuildsystemDirectoryParent();
-    if (snapshot.IsValid())
-      {
+    if (snapshot.IsValid()) {
       snapshots.push_back(snapshot);
-      }
-    else
-      {
+    } else {
       break;
-      }
     }
+  }
 
   std::string result = snapshots.front().GetDirectory().GetCurrentSource();
 
   for (std::vector<cmState::Snapshot>::const_iterator it =
-       snapshots.begin() + 1; it != snapshots.end(); ++it)
-    {
+         snapshots.begin() + 1;
+       it != snapshots.end(); ++it) {
     std::string currentSource = it->GetDirectory().GetCurrentSource();
-    if(cmSystemTools::IsSubDirectory(result, currentSource))
-      {
+    if (cmSystemTools::IsSubDirectory(result, currentSource)) {
       result = currentSource;
-      }
     }
+  }
   this->DirectoryState->RelativePathTopSource = result;
 }
 
@@ -776,43 +716,34 @@ void cmState::Directory::ComputeRelativePathTopBinary()
   cmState::Snapshot snapshot = this->Snapshot_;
   std::vector<cmState::Snapshot> snapshots;
   snapshots.push_back(snapshot);
-  while (true)
-    {
+  while (true) {
     snapshot = snapshot.GetBuildsystemDirectoryParent();
-    if (snapshot.IsValid())
-      {
+    if (snapshot.IsValid()) {
       snapshots.push_back(snapshot);
-      }
-    else
-      {
+    } else {
       break;
-      }
     }
+  }
 
-  std::string result =
-      snapshots.front().GetDirectory().GetCurrentBinary();
+  std::string result = snapshots.front().GetDirectory().GetCurrentBinary();
 
   for (std::vector<cmState::Snapshot>::const_iterator it =
-       snapshots.begin() + 1; it != snapshots.end(); ++it)
-    {
+         snapshots.begin() + 1;
+       it != snapshots.end(); ++it) {
     std::string currentBinary = it->GetDirectory().GetCurrentBinary();
-    if(cmSystemTools::IsSubDirectory(result, currentBinary))
-      {
+    if (cmSystemTools::IsSubDirectory(result, currentBinary)) {
       result = currentBinary;
-      }
     }
+  }
 
   // The current working directory on Windows cannot be a network
   // path.  Therefore relative paths cannot work when the binary tree
   // is a network path.
-  if(result.size() < 2 || result.substr(0, 2) != "//")
-    {
+  if (result.size() < 2 || result.substr(0, 2) != "//") {
     this->DirectoryState->RelativePathTopBinary = result;
-    }
-  else
-    {
+  } else {
     this->DirectoryState->RelativePathTopBinary = "";
-    }
+  }
 }
 
 cmState::Snapshot cmState::CreateBaseSnapshot()
@@ -823,9 +754,9 @@ cmState::Snapshot cmState::CreateBaseSnapshot()
   pos->SnapshotType = BaseType;
   pos->Keep = true;
   pos->BuildSystemDirectory =
-      this->BuildsystemDirectory.Push(this->BuildsystemDirectory.Root());
+    this->BuildsystemDirectory.Push(this->BuildsystemDirectory.Root());
   pos->ExecutionListFile =
-      this->ExecutionListFiles.Push(this->ExecutionListFiles.Root());
+    this->ExecutionListFiles.Push(this->ExecutionListFiles.Root());
   pos->IncludeDirectoryPosition = 0;
   pos->CompileDefinitionsPosition = 0;
   pos->CompileOptionsPosition = 0;
@@ -842,8 +773,8 @@ cmState::Snapshot cmState::CreateBaseSnapshot()
   return cmState::Snapshot(this, pos);
 }
 
-cmState::Snapshot
-cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot)
+cmState::Snapshot cmState::CreateBuildsystemDirectorySnapshot(
+  Snapshot originSnapshot)
 {
   assert(originSnapshot.IsValid());
   PositionType pos = this->SnapshotData.Push(originSnapshot.Position);
@@ -851,12 +782,10 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot)
   pos->ScopeParent = originSnapshot.Position;
   pos->SnapshotType = BuildsystemDirectoryType;
   pos->Keep = true;
-  pos->BuildSystemDirectory =
-      this->BuildsystemDirectory.Push(
-        originSnapshot.Position->BuildSystemDirectory);
+  pos->BuildSystemDirectory = this->BuildsystemDirectory.Push(
+    originSnapshot.Position->BuildSystemDirectory);
   pos->ExecutionListFile =
-      this->ExecutionListFiles.Push(
-        originSnapshot.Position->ExecutionListFile);
+    this->ExecutionListFiles.Push(originSnapshot.Position->ExecutionListFile);
   pos->BuildSystemDirectory->DirectoryEnd = pos;
   pos->Policies = originSnapshot.Position->Policies;
   pos->PolicyRoot = originSnapshot.Position->Policies;
@@ -864,8 +793,7 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot)
   assert(pos->Policies.IsValid());
   assert(pos->PolicyRoot.IsValid());
 
-  cmLinkedTree<cmDefinitions>::iterator origin =
-      originSnapshot.Position->Vars;
+  cmLinkedTree<cmDefinitions>::iterator origin = originSnapshot.Position->Vars;
   pos->Parent = origin;
   pos->Root = origin;
   pos->Vars = this->VarTree.Push(origin);
@@ -878,99 +806,92 @@ cmState::CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot)
   return snapshot;
 }
 
-cmState::Snapshot
-cmState::CreateFunctionCallSnapshot(cmState::Snapshot originSnapshot,
-                                    std::string const& fileName)
+cmState::Snapshot cmState::CreateFunctionCallSnapshot(
+  cmState::Snapshot originSnapshot, std::string const& fileName)
 {
-  PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
-                                             *originSnapshot.Position);
+  PositionType pos =
+    this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
   pos->ScopeParent = originSnapshot.Position;
   pos->SnapshotType = FunctionCallType;
   pos->Keep = false;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
-        originSnapshot.Position->ExecutionListFile, fileName);
+    originSnapshot.Position->ExecutionListFile, fileName);
   pos->BuildSystemDirectory->DirectoryEnd = pos;
   pos->PolicyScope = originSnapshot.Position->Policies;
   assert(originSnapshot.Position->Vars.IsValid());
-  cmLinkedTree<cmDefinitions>::iterator origin =
-      originSnapshot.Position->Vars;
+  cmLinkedTree<cmDefinitions>::iterator origin = originSnapshot.Position->Vars;
   pos->Parent = origin;
   pos->Vars = this->VarTree.Push(origin);
   return cmState::Snapshot(this, pos);
 }
 
-
-cmState::Snapshot
-cmState::CreateMacroCallSnapshot(cmState::Snapshot originSnapshot,
-                                    std::string const& fileName)
+cmState::Snapshot cmState::CreateMacroCallSnapshot(
+  cmState::Snapshot originSnapshot, std::string const& fileName)
 {
-  PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
-                                             *originSnapshot.Position);
+  PositionType pos =
+    this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
   pos->SnapshotType = MacroCallType;
   pos->Keep = false;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
-        originSnapshot.Position->ExecutionListFile, fileName);
+    originSnapshot.Position->ExecutionListFile, fileName);
   assert(originSnapshot.Position->Vars.IsValid());
   pos->BuildSystemDirectory->DirectoryEnd = pos;
   pos->PolicyScope = originSnapshot.Position->Policies;
   return cmState::Snapshot(this, pos);
 }
 
-cmState::Snapshot
-cmState::CreateIncludeFileSnapshot(cmState::Snapshot originSnapshot,
-                                   const std::string& fileName)
+cmState::Snapshot cmState::CreateIncludeFileSnapshot(
+  cmState::Snapshot originSnapshot, const std::string& fileName)
 {
-  PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
-                                             *originSnapshot.Position);
+  PositionType pos =
+    this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
   pos->SnapshotType = IncludeFileType;
   pos->Keep = true;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
-        originSnapshot.Position->ExecutionListFile, fileName);
+    originSnapshot.Position->ExecutionListFile, fileName);
   assert(originSnapshot.Position->Vars.IsValid());
   pos->BuildSystemDirectory->DirectoryEnd = pos;
   pos->PolicyScope = originSnapshot.Position->Policies;
   return cmState::Snapshot(this, pos);
 }
 
-cmState::Snapshot
-cmState::CreateVariableScopeSnapshot(cmState::Snapshot originSnapshot)
+cmState::Snapshot cmState::CreateVariableScopeSnapshot(
+  cmState::Snapshot originSnapshot)
 {
-  PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
-                                             *originSnapshot.Position);
+  PositionType pos =
+    this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
   pos->ScopeParent = originSnapshot.Position;
   pos->SnapshotType = VariableScopeType;
   pos->Keep = false;
   pos->PolicyScope = originSnapshot.Position->Policies;
   assert(originSnapshot.Position->Vars.IsValid());
 
-  cmLinkedTree<cmDefinitions>::iterator origin =
-      originSnapshot.Position->Vars;
+  cmLinkedTree<cmDefinitions>::iterator origin = originSnapshot.Position->Vars;
   pos->Parent = origin;
   pos->Vars = this->VarTree.Push(origin);
   assert(pos->Vars.IsValid());
   return cmState::Snapshot(this, pos);
 }
 
-cmState::Snapshot
-cmState::CreateInlineListFileSnapshot(cmState::Snapshot originSnapshot,
-                                      const std::string& fileName)
+cmState::Snapshot cmState::CreateInlineListFileSnapshot(
+  cmState::Snapshot originSnapshot, const std::string& fileName)
 {
-  PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
-                                             *originSnapshot.Position);
+  PositionType pos =
+    this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
   pos->SnapshotType = InlineListFileType;
   pos->Keep = true;
   pos->ExecutionListFile = this->ExecutionListFiles.Push(
-        originSnapshot.Position->ExecutionListFile, fileName);
+    originSnapshot.Position->ExecutionListFile, fileName);
   pos->BuildSystemDirectory->DirectoryEnd = pos;
   pos->PolicyScope = originSnapshot.Position->Policies;
   return cmState::Snapshot(this, pos);
 }
 
-cmState::Snapshot
-cmState::CreatePolicyScopeSnapshot(cmState::Snapshot originSnapshot)
+cmState::Snapshot cmState::CreatePolicyScopeSnapshot(
+  cmState::Snapshot originSnapshot)
 {
-  PositionType pos = this->SnapshotData.Push(originSnapshot.Position,
-                                             *originSnapshot.Position);
+  PositionType pos =
+    this->SnapshotData.Push(originSnapshot.Position, *originSnapshot.Position);
   pos->SnapshotType = PolicyScopeType;
   pos->Keep = false;
   pos->BuildSystemDirectory->DirectoryEnd = pos;
@@ -984,27 +905,24 @@ cmState::Snapshot cmState::Pop(cmState::Snapshot originSnapshot)
   PositionType prevPos = pos;
   ++prevPos;
   prevPos->IncludeDirectoryPosition =
-      prevPos->BuildSystemDirectory->IncludeDirectories.size();
+    prevPos->BuildSystemDirectory->IncludeDirectories.size();
   prevPos->CompileDefinitionsPosition =
-      prevPos->BuildSystemDirectory->CompileDefinitions.size();
+    prevPos->BuildSystemDirectory->CompileDefinitions.size();
   prevPos->CompileOptionsPosition =
-      prevPos->BuildSystemDirectory->CompileOptions.size();
+    prevPos->BuildSystemDirectory->CompileOptions.size();
   prevPos->BuildSystemDirectory->DirectoryEnd = prevPos;
 
-  if (!pos->Keep && this->SnapshotData.IsLast(pos))
-    {
-    if (pos->Vars != prevPos->Vars)
-      {
+  if (!pos->Keep && this->SnapshotData.IsLast(pos)) {
+    if (pos->Vars != prevPos->Vars) {
       assert(this->VarTree.IsLast(pos->Vars));
       this->VarTree.Pop(pos->Vars);
-      }
-    if (pos->ExecutionListFile != prevPos->ExecutionListFile)
-      {
+    }
+    if (pos->ExecutionListFile != prevPos->ExecutionListFile) {
       assert(this->ExecutionListFiles.IsLast(pos->ExecutionListFile));
       this->ExecutionListFiles.Pop(pos->ExecutionListFile);
-      }
-    this->SnapshotData.Pop(pos);
     }
+    this->SnapshotData.Pop(pos);
+  }
 
   return Snapshot(this, prevPos);
 }
@@ -1021,10 +939,9 @@ std::vector<cmState::Snapshot> cmState::Snapshot::GetChildren()
 }
 
 cmState::Snapshot::Snapshot(cmState* state, PositionType position)
-  : State(state),
-  Position(position)
+  : State(state)
+  , Position(position)
 {
-
 }
 
 cmState::SnapshotType cmState::Snapshot::GetType() const
@@ -1045,8 +962,7 @@ void cmState::Directory::SetCurrentSource(std::string const& dir)
   loc = cmSystemTools::CollapseFullPath(loc);
 
   cmSystemTools::SplitPath(
-      loc,
-      this->DirectoryState->CurrentSourceDirectoryComponents);
+    loc, this->DirectoryState->CurrentSourceDirectoryComponents);
   this->ComputeRelativePathTopSource();
 
   this->Snapshot_.SetDefinition("CMAKE_CURRENT_SOURCE_DIR", loc.c_str());
@@ -1065,8 +981,7 @@ void cmState::Directory::SetCurrentBinary(std::string const& dir)
   loc = cmSystemTools::CollapseFullPath(loc);
 
   cmSystemTools::SplitPath(
-      loc,
-      this->DirectoryState->CurrentBinaryDirectoryComponents);
+    loc, this->DirectoryState->CurrentBinaryDirectoryComponents);
   this->ComputeRelativePathTopBinary();
 
   this->Snapshot_.SetDefinition("CMAKE_CURRENT_BINARY_DIR", loc.c_str());
@@ -1117,23 +1032,21 @@ std::string cmState::Snapshot::GetExecutionListFile() const
 bool cmState::Snapshot::IsValid() const
 {
   return this->State && this->Position.IsValid()
-      ? this->Position != this->State->SnapshotData.Root()
-      : false;
+    ? this->Position != this->State->SnapshotData.Root()
+    : false;
 }
 
 cmState::Snapshot cmState::Snapshot::GetBuildsystemDirectoryParent() const
 {
   Snapshot snapshot;
-  if (!this->State || this->Position == this->State->SnapshotData.Root())
-    {
+  if (!this->State || this->Position == this->State->SnapshotData.Root()) {
     return snapshot;
-    }
+  }
   PositionType parentPos = this->Position->DirectoryParent;
-  if (parentPos != this->State->SnapshotData.Root())
-    {
-    snapshot = Snapshot(this->State,
-                        parentPos->BuildSystemDirectory->DirectoryEnd);
-    }
+  if (parentPos != this->State->SnapshotData.Root()) {
+    snapshot =
+      Snapshot(this->State, parentPos->BuildSystemDirectory->DirectoryEnd);
+  }
 
   return snapshot;
 }
@@ -1146,27 +1059,23 @@ cmState::Snapshot cmState::Snapshot::GetCallStackParent() const
   Snapshot snapshot;
   PositionType parentPos = this->Position;
   while (parentPos->SnapshotType == cmState::PolicyScopeType ||
-         parentPos->SnapshotType == cmState::VariableScopeType)
-    {
+         parentPos->SnapshotType == cmState::VariableScopeType) {
     ++parentPos;
-    }
-  if (parentPos->SnapshotType == cmState::BuildsystemDirectoryType
-      || parentPos->SnapshotType == cmState::BaseType)
-    {
+  }
+  if (parentPos->SnapshotType == cmState::BuildsystemDirectoryType ||
+      parentPos->SnapshotType == cmState::BaseType) {
     return snapshot;
-    }
+  }
 
   ++parentPos;
   while (parentPos->SnapshotType == cmState::PolicyScopeType ||
-         parentPos->SnapshotType == cmState::VariableScopeType)
-    {
+         parentPos->SnapshotType == cmState::VariableScopeType) {
     ++parentPos;
-    }
+  }
 
-  if (parentPos == this->State->SnapshotData.Root())
-    {
+  if (parentPos == this->State->SnapshotData.Root()) {
     return snapshot;
-    }
+  }
 
   snapshot = Snapshot(this->State, parentPos);
   return snapshot;
@@ -1180,28 +1089,25 @@ cmState::Snapshot cmState::Snapshot::GetCallStackBottom() const
   PositionType pos = this->Position;
   while (pos->SnapshotType != cmState::BaseType &&
          pos->SnapshotType != cmState::BuildsystemDirectoryType &&
-         pos != this->State->SnapshotData.Root())
-    {
+         pos != this->State->SnapshotData.Root()) {
     ++pos;
-    }
+  }
   return Snapshot(this->State, pos);
 }
 
 void cmState::Snapshot::PushPolicy(cmPolicies::PolicyMap entry, bool weak)
 {
   PositionType pos = this->Position;
-  pos->Policies =
-    this->State->PolicyStack.Push(pos->Policies,
-                                  PolicyStackEntry(entry, weak));
+  pos->Policies = this->State->PolicyStack.Push(pos->Policies,
+                                                PolicyStackEntry(entry, weak));
 }
 
 bool cmState::Snapshot::PopPolicy()
 {
   PositionType pos = this->Position;
-  if (pos->Policies == pos->PolicyScope)
-    {
+  if (pos->Policies == pos->PolicyScope) {
     return false;
-    }
+  }
   pos->Policies = this->State->PolicyStack.Pop(pos->Policies);
   return true;
 }
@@ -1216,51 +1122,45 @@ void cmState::Snapshot::SetPolicy(cmPolicies::PolicyID id,
 {
   // Update the policy stack from the top to the top-most strong entry.
   bool previous_was_weak = true;
-  for(cmLinkedTree<PolicyStackEntry>::iterator psi = this->Position->Policies;
-      previous_was_weak && psi != this->Position->PolicyRoot; ++psi)
-    {
+  for (cmLinkedTree<PolicyStackEntry>::iterator psi = this->Position->Policies;
+       previous_was_weak && psi != this->Position->PolicyRoot; ++psi) {
     psi->Set(id, status);
     previous_was_weak = psi->Weak;
-    }
+  }
 }
 
-cmPolicies::PolicyStatus
-cmState::Snapshot::GetPolicy(cmPolicies::PolicyID id) const
+cmPolicies::PolicyStatus cmState::Snapshot::GetPolicy(
+  cmPolicies::PolicyID id) const
 {
   cmPolicies::PolicyStatus status = cmPolicies::GetPolicyStatus(id);
 
-  if(status == cmPolicies::REQUIRED_ALWAYS ||
-     status == cmPolicies::REQUIRED_IF_USED)
-    {
+  if (status == cmPolicies::REQUIRED_ALWAYS ||
+      status == cmPolicies::REQUIRED_IF_USED) {
     return status;
-    }
+  }
 
   cmLinkedTree<BuildsystemDirectoryStateType>::iterator dir =
-      this->Position->BuildSystemDirectory;
+    this->Position->BuildSystemDirectory;
 
-  while (true)
-    {
+  while (true) {
     assert(dir.IsValid());
     cmLinkedTree<PolicyStackEntry>::iterator leaf =
-        dir->DirectoryEnd->Policies;
+      dir->DirectoryEnd->Policies;
     cmLinkedTree<PolicyStackEntry>::iterator root =
-        dir->DirectoryEnd->PolicyRoot;
-    for( ; leaf != root; ++leaf)
-      {
-      if(leaf->IsDefined(id))
-        {
+      dir->DirectoryEnd->PolicyRoot;
+    for (; leaf != root; ++leaf) {
+      if (leaf->IsDefined(id)) {
         status = leaf->Get(id);
         return status;
-        }
       }
+    }
     cmState::PositionType e = dir->DirectoryEnd;
     cmState::PositionType p = e->DirectoryParent;
-    if (p == this->State->SnapshotData.Root())
-      {
+    if (p == this->State->SnapshotData.Root()) {
       break;
-      }
-    dir = p->BuildSystemDirectory;
     }
+    dir = p->BuildSystemDirectory;
+  }
   return status;
 }
 
@@ -1272,8 +1172,7 @@ bool cmState::Snapshot::HasDefinedPolicyCMP0011()
 const char* cmState::Snapshot::GetDefinition(std::string const& name) const
 {
   assert(this->Position->Vars.IsValid());
-  return cmDefinitions::Get(name, this->Position->Vars,
-                    this->Position->Root);
+  return cmDefinitions::Get(name, this->Position->Vars, this->Position->Root);
 }
 
 bool cmState::Snapshot::IsInitialized(std::string const& name) const
@@ -1306,29 +1205,23 @@ std::vector<std::string> cmState::Snapshot::ClosureKeys() const
 
 bool cmState::Snapshot::RaiseScope(std::string const& var, const char* varDef)
 {
-  if(this->Position->ScopeParent == this->Position->DirectoryParent)
-    {
+  if (this->Position->ScopeParent == this->Position->DirectoryParent) {
     Snapshot parentDir = this->GetBuildsystemDirectoryParent();
-    if(!parentDir.IsValid())
-      {
+    if (!parentDir.IsValid()) {
       return false;
-      }
+    }
     // Update the definition in the parent directory top scope.  This
     // directory's scope was initialized by the closure of the parent
     // scope, so we do not need to localize the definition first.
-    if (varDef)
-      {
+    if (varDef) {
       parentDir.SetDefinition(var, varDef);
-      }
-    else
-      {
+    } else {
       parentDir.RemoveDefinition(var);
-      }
-    return true;
     }
+    return true;
+  }
   // First localize the definition in the current scope.
-  cmDefinitions::Raise(var, this->Position->Vars,
-                       this->Position->Root);
+  cmDefinitions::Raise(var, this->Position->Vars, this->Position->Root);
 
   // Now update the definition in the parent scope.
   this->Position->Parent->Set(var, varDef);
@@ -1337,31 +1230,27 @@ bool cmState::Snapshot::RaiseScope(std::string const& var, const char* varDef)
 
 static const std::string cmPropertySentinal = std::string();
 
-template<typename T, typename U, typename V>
-void InitializeContentFromParent(T& parentContent,
-                          T& thisContent,
-                          U& parentBacktraces,
-                          U& thisBacktraces,
-                          V& contentEndPosition)
+template <typename T, typename U, typename V>
+void InitializeContentFromParent(T& parentContent, T& thisContent,
+                                 U& parentBacktraces, U& thisBacktraces,
+                                 V& contentEndPosition)
 {
-  std::vector<std::string>::const_iterator parentBegin =
-      parentContent.begin();
-  std::vector<std::string>::const_iterator parentEnd =
-      parentContent.end();
+  std::vector<std::string>::const_iterator parentBegin = parentContent.begin();
+  std::vector<std::string>::const_iterator parentEnd = parentContent.end();
 
   std::vector<std::string>::const_reverse_iterator parentRbegin =
-      cmMakeReverseIterator(parentEnd);
+    cmMakeReverseIterator(parentEnd);
   std::vector<std::string>::const_reverse_iterator parentRend =
-      parentContent.rend();
+    parentContent.rend();
   parentRbegin = std::find(parentRbegin, parentRend, cmPropertySentinal);
   std::vector<std::string>::const_iterator parentIt = parentRbegin.base();
 
   thisContent = std::vector<std::string>(parentIt, parentEnd);
 
   std::vector<cmListFileBacktrace>::const_iterator btIt =
-      parentBacktraces.begin() + std::distance(parentBegin, parentIt);
+    parentBacktraces.begin() + std::distance(parentBegin, parentIt);
   std::vector<cmListFileBacktrace>::const_iterator btEnd =
-      parentBacktraces.end();
+    parentBacktraces.end();
 
   thisBacktraces = std::vector<cmListFileBacktrace>(btIt, btEnd);
 
@@ -1370,67 +1259,64 @@ void InitializeContentFromParent(T& parentContent,
 
 void cmState::Snapshot::SetDefaultDefinitions()
 {
-  /* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set.
-    With CMake must separate between target and host platform. In most cases
-    the tests for WIN32, UNIX and APPLE will be for the target system, so an
-    additional set of variables for the host system is required ->
-    CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE.
-    WIN32, UNIX and APPLE are now set in the platform files in
-    Modules/Platforms/.
-    To keep cmake scripts (-P) and custom language and compiler modules
-    working, these variables are still also set here in this place, but they
-    will be reset in CMakeSystemSpecificInformation.cmake before the platform
-    files are executed. */
-  #if defined(_WIN32)
+/* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set.
+  With CMake must separate between target and host platform. In most cases
+  the tests for WIN32, UNIX and APPLE will be for the target system, so an
+  additional set of variables for the host system is required ->
+  CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE.
+  WIN32, UNIX and APPLE are now set in the platform files in
+  Modules/Platforms/.
+  To keep cmake scripts (-P) and custom language and compiler modules
+  working, these variables are still also set here in this place, but they
+  will be reset in CMakeSystemSpecificInformation.cmake before the platform
+  files are executed. */
+#if defined(_WIN32)
+  this->SetDefinition("WIN32", "1");
+  this->SetDefinition("CMAKE_HOST_WIN32", "1");
+#else
+  this->SetDefinition("UNIX", "1");
+  this->SetDefinition("CMAKE_HOST_UNIX", "1");
+#endif
+#if defined(__CYGWIN__)
+  if (cmSystemTools::IsOn(
+        cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32"))) {
     this->SetDefinition("WIN32", "1");
     this->SetDefinition("CMAKE_HOST_WIN32", "1");
-  #else
-    this->SetDefinition("UNIX", "1");
-    this->SetDefinition("CMAKE_HOST_UNIX", "1");
-  #endif
-  #if defined(__CYGWIN__)
-    if(cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32")))
-      {
-      this->SetDefinition("WIN32", "1");
-      this->SetDefinition("CMAKE_HOST_WIN32", "1");
-      }
-  #endif
-  #if defined(__APPLE__)
-    this->SetDefinition("APPLE", "1");
-    this->SetDefinition("CMAKE_HOST_APPLE", "1");
-  #endif
-  #if defined(__sun__)
-    this->SetDefinition("CMAKE_HOST_SOLARIS", "1");
-  #endif
-
-    char temp[1024];
-    sprintf(temp, "%d", cmVersion::GetMinorVersion());
-    this->SetDefinition("CMAKE_MINOR_VERSION", temp);
-    sprintf(temp, "%d", cmVersion::GetMajorVersion());
-    this->SetDefinition("CMAKE_MAJOR_VERSION", temp);
-    sprintf(temp, "%d", cmVersion::GetPatchVersion());
-    this->SetDefinition("CMAKE_PATCH_VERSION", temp);
-    sprintf(temp, "%d", cmVersion::GetTweakVersion());
-    this->SetDefinition("CMAKE_TWEAK_VERSION", temp);
-    this->SetDefinition("CMAKE_VERSION",
-                                      cmVersion::GetCMakeVersion());
-
-    this->SetDefinition("CMAKE_FILES_DIRECTORY",
-                        cmake::GetCMakeFilesDirectory());
+  }
+#endif
+#if defined(__APPLE__)
+  this->SetDefinition("APPLE", "1");
+  this->SetDefinition("CMAKE_HOST_APPLE", "1");
+#endif
+#if defined(__sun__)
+  this->SetDefinition("CMAKE_HOST_SOLARIS", "1");
+#endif
+
+  char temp[1024];
+  sprintf(temp, "%d", cmVersion::GetMinorVersion());
+  this->SetDefinition("CMAKE_MINOR_VERSION", temp);
+  sprintf(temp, "%d", cmVersion::GetMajorVersion());
+  this->SetDefinition("CMAKE_MAJOR_VERSION", temp);
+  sprintf(temp, "%d", cmVersion::GetPatchVersion());
+  this->SetDefinition("CMAKE_PATCH_VERSION", temp);
+  sprintf(temp, "%d", cmVersion::GetTweakVersion());
+  this->SetDefinition("CMAKE_TWEAK_VERSION", temp);
+  this->SetDefinition("CMAKE_VERSION", cmVersion::GetCMakeVersion());
+
+  this->SetDefinition("CMAKE_FILES_DIRECTORY",
+                      cmake::GetCMakeFilesDirectory());
 
   // Setup the default include file regular expression (match everything).
-  this->Position->BuildSystemDirectory
-      ->Properties.SetProperty("INCLUDE_REGULAR_EXPRESSION", "^.*$");
+  this->Position->BuildSystemDirectory->Properties.SetProperty(
+    "INCLUDE_REGULAR_EXPRESSION", "^.*$");
 }
 
 void cmState::Snapshot::SetDirectoryDefinitions()
 {
-  this->SetDefinition("CMAKE_SOURCE_DIR",
-                      this->State->GetSourceDirectory());
+  this->SetDefinition("CMAKE_SOURCE_DIR", this->State->GetSourceDirectory());
   this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR",
                       this->State->GetSourceDirectory());
-  this->SetDefinition("CMAKE_BINARY_DIR",
-                      this->State->GetBinaryDirectory());
+  this->SetDefinition("CMAKE_BINARY_DIR", this->State->GetBinaryDirectory());
   this->SetDefinition("CMAKE_CURRENT_BINARY_DIR",
                       this->State->GetBinaryDirectory());
 }
@@ -1442,25 +1328,28 @@ void cmState::Snapshot::InitializeFromParent()
   assert(parent->Vars.IsValid());
 
   *this->Position->Vars =
-      cmDefinitions::MakeClosure(parent->Vars, parent->Root);
-
-  InitializeContentFromParent(parent->BuildSystemDirectory->IncludeDirectories,
-              this->Position->BuildSystemDirectory->IncludeDirectories,
-              parent->BuildSystemDirectory->IncludeDirectoryBacktraces,
-              this->Position->BuildSystemDirectory->IncludeDirectoryBacktraces,
-              this->Position->IncludeDirectoryPosition);
-
-  InitializeContentFromParent(parent->BuildSystemDirectory->CompileDefinitions,
-            this->Position->BuildSystemDirectory->CompileDefinitions,
-            parent->BuildSystemDirectory->CompileDefinitionsBacktraces,
-            this->Position->BuildSystemDirectory->CompileDefinitionsBacktraces,
-            this->Position->CompileDefinitionsPosition);
-
-  InitializeContentFromParent(parent->BuildSystemDirectory->CompileOptions,
-                this->Position->BuildSystemDirectory->CompileOptions,
-                parent->BuildSystemDirectory->CompileOptionsBacktraces,
-                this->Position->BuildSystemDirectory->CompileOptionsBacktraces,
-                this->Position->CompileOptionsPosition);
+    cmDefinitions::MakeClosure(parent->Vars, parent->Root);
+
+  InitializeContentFromParent(
+    parent->BuildSystemDirectory->IncludeDirectories,
+    this->Position->BuildSystemDirectory->IncludeDirectories,
+    parent->BuildSystemDirectory->IncludeDirectoryBacktraces,
+    this->Position->BuildSystemDirectory->IncludeDirectoryBacktraces,
+    this->Position->IncludeDirectoryPosition);
+
+  InitializeContentFromParent(
+    parent->BuildSystemDirectory->CompileDefinitions,
+    this->Position->BuildSystemDirectory->CompileDefinitions,
+    parent->BuildSystemDirectory->CompileDefinitionsBacktraces,
+    this->Position->BuildSystemDirectory->CompileDefinitionsBacktraces,
+    this->Position->CompileDefinitionsPosition);
+
+  InitializeContentFromParent(
+    parent->BuildSystemDirectory->CompileOptions,
+    this->Position->BuildSystemDirectory->CompileOptions,
+    parent->BuildSystemDirectory->CompileOptionsBacktraces,
+    this->Position->BuildSystemDirectory->CompileOptionsBacktraces,
+    this->Position->CompileOptionsPosition);
 }
 
 cmState* cmState::Snapshot::GetState() const
@@ -1488,50 +1377,47 @@ void cmState::Snapshot::InitializeFromParent_ForSubdirsCommand()
   std::string currentSrcDir = this->GetDefinition("CMAKE_CURRENT_SOURCE_DIR");
   std::string currentBinDir = this->GetDefinition("CMAKE_CURRENT_BINARY_DIR");
   this->InitializeFromParent();
-  this->SetDefinition("CMAKE_SOURCE_DIR",
-                      this->State->GetSourceDirectory());
-  this->SetDefinition("CMAKE_BINARY_DIR",
-                      this->State->GetBinaryDirectory());
+  this->SetDefinition("CMAKE_SOURCE_DIR", this->State->GetSourceDirectory());
+  this->SetDefinition("CMAKE_BINARY_DIR", this->State->GetBinaryDirectory());
 
   this->SetDefinition("CMAKE_CURRENT_SOURCE_DIR", currentSrcDir.c_str());
   this->SetDefinition("CMAKE_CURRENT_BINARY_DIR", currentBinDir.c_str());
 }
 
 cmState::Directory::Directory(
-    cmLinkedTree<BuildsystemDirectoryStateType>::iterator iter,
-    const cmState::Snapshot& snapshot)
-  : DirectoryState(iter), Snapshot_(snapshot)
+  cmLinkedTree<BuildsystemDirectoryStateType>::iterator iter,
+  const cmState::Snapshot& snapshot)
+  : DirectoryState(iter)
+  , Snapshot_(snapshot)
 {
-
 }
 
 template <typename T, typename U>
 cmStringRange GetPropertyContent(T const& content, U contentEndPosition)
 {
   std::vector<std::string>::const_iterator end =
-      content.begin() + contentEndPosition;
+    content.begin() + contentEndPosition;
 
   std::vector<std::string>::const_reverse_iterator rbegin =
-      cmMakeReverseIterator(end);
+    cmMakeReverseIterator(end);
   rbegin = std::find(rbegin, content.rend(), cmPropertySentinal);
 
   return cmMakeRange(rbegin.base(), end);
 }
 
 template <typename T, typename U, typename V>
-cmBacktraceRange GetPropertyBacktraces(T const& content,
-                                    U const& backtraces,
-                                    V contentEndPosition)
+cmBacktraceRange GetPropertyBacktraces(T const& content, U const& backtraces,
+                                       V contentEndPosition)
 {
   std::vector<std::string>::const_iterator entryEnd =
-      content.begin() + contentEndPosition;
+    content.begin() + contentEndPosition;
 
   std::vector<std::string>::const_reverse_iterator rbegin =
-      cmMakeReverseIterator(entryEnd);
+    cmMakeReverseIterator(entryEnd);
   rbegin = std::find(rbegin, content.rend(), cmPropertySentinal);
 
   std::vector<cmListFileBacktrace>::const_iterator it =
-      backtraces.begin() + std::distance(content.begin(), rbegin.base());
+    backtraces.begin() + std::distance(content.begin(), rbegin.base());
 
   std::vector<cmListFileBacktrace>::const_iterator end = backtraces.end();
   return cmMakeRange(it, end);
@@ -1539,12 +1425,11 @@ cmBacktraceRange GetPropertyBacktraces(T const& content,
 
 template <typename T, typename U, typename V>
 void AppendEntry(T& content, U& backtraces, V& endContentPosition,
-    const std::string& value, const cmListFileBacktrace& lfbt)
+                 const std::string& value, const cmListFileBacktrace& lfbt)
 {
-  if (value.empty())
-    {
+  if (value.empty()) {
     return;
-    }
+  }
 
   assert(endContentPosition == content.size());
 
@@ -1580,65 +1465,64 @@ void ClearContent(T& content, U& backtraces, V& endContentPosition)
   endContentPosition = content.size();
 }
 
-cmStringRange
-cmState::Directory::GetIncludeDirectoriesEntries() const
+cmStringRange cmState::Directory::GetIncludeDirectoriesEntries() const
 {
-  return GetPropertyContent(this->DirectoryState->IncludeDirectories,
-                       this->Snapshot_.Position->IncludeDirectoryPosition);
+  return GetPropertyContent(
+    this->DirectoryState->IncludeDirectories,
+    this->Snapshot_.Position->IncludeDirectoryPosition);
 }
 
-cmBacktraceRange
-cmState::Directory::GetIncludeDirectoriesEntryBacktraces() const
+cmBacktraceRange cmState::Directory::GetIncludeDirectoriesEntryBacktraces()
+  const
 {
-  return GetPropertyBacktraces(this->DirectoryState->IncludeDirectories,
-                       this->DirectoryState->IncludeDirectoryBacktraces,
-                       this->Snapshot_.Position->IncludeDirectoryPosition);
+  return GetPropertyBacktraces(
+    this->DirectoryState->IncludeDirectories,
+    this->DirectoryState->IncludeDirectoryBacktraces,
+    this->Snapshot_.Position->IncludeDirectoryPosition);
 }
 
 void cmState::Directory::AppendIncludeDirectoriesEntry(
-    const std::string& vec, const cmListFileBacktrace& lfbt)
+  const std::string& vec, const cmListFileBacktrace& lfbt)
 {
   AppendEntry(this->DirectoryState->IncludeDirectories,
               this->DirectoryState->IncludeDirectoryBacktraces,
-              this->Snapshot_.Position->IncludeDirectoryPosition,
-              vec, lfbt);
+              this->Snapshot_.Position->IncludeDirectoryPosition, vec, lfbt);
 }
 
 void cmState::Directory::PrependIncludeDirectoriesEntry(
-    const std::string& vec, const cmListFileBacktrace& lfbt)
+  const std::string& vec, const cmListFileBacktrace& lfbt)
 {
   std::vector<std::string>::iterator entryEnd =
-      this->DirectoryState->IncludeDirectories.begin()
-      + this->Snapshot_.Position->IncludeDirectoryPosition;
+    this->DirectoryState->IncludeDirectories.begin() +
+    this->Snapshot_.Position->IncludeDirectoryPosition;
 
   std::vector<std::string>::reverse_iterator rend =
-      this->DirectoryState->IncludeDirectories.rend();
+    this->DirectoryState->IncludeDirectories.rend();
   std::vector<std::string>::reverse_iterator rbegin =
-      cmMakeReverseIterator(entryEnd);
+    cmMakeReverseIterator(entryEnd);
   rbegin = std::find(rbegin, rend, cmPropertySentinal);
 
   std::vector<std::string>::iterator entryIt = rbegin.base();
   std::vector<std::string>::iterator entryBegin =
-      this->DirectoryState->IncludeDirectories.begin();
+    this->DirectoryState->IncludeDirectories.begin();
 
   std::vector<cmListFileBacktrace>::iterator btIt =
-      this->DirectoryState->IncludeDirectoryBacktraces.begin()
-      + std::distance(entryBegin, entryIt);
+    this->DirectoryState->IncludeDirectoryBacktraces.begin() +
+    std::distance(entryBegin, entryIt);
 
   this->DirectoryState->IncludeDirectories.insert(entryIt, vec);
   this->DirectoryState->IncludeDirectoryBacktraces.insert(btIt, lfbt);
 
   this->Snapshot_.Position->IncludeDirectoryPosition =
-      this->DirectoryState->IncludeDirectories.size();
+    this->DirectoryState->IncludeDirectories.size();
 }
 
-void cmState::Directory::SetIncludeDirectories(
-    const std::string& vec, const cmListFileBacktrace& lfbt)
+void cmState::Directory::SetIncludeDirectories(const std::string& vec,
+                                               const cmListFileBacktrace& lfbt)
 {
   SetContent(this->DirectoryState->IncludeDirectories,
              this->DirectoryState->IncludeDirectoryBacktraces,
-             this->Snapshot_.Position->IncludeDirectoryPosition,
-             vec, lfbt);
+             this->Snapshot_.Position->IncludeDirectoryPosition, vec, lfbt);
 }
 
 void cmState::Directory::ClearIncludeDirectories()
@@ -1650,25 +1534,26 @@ void cmState::Directory::ClearIncludeDirectories()
 
 cmStringRange cmState::Directory::GetCompileDefinitionsEntries() const
 {
-  return GetPropertyContent(this->DirectoryState->CompileDefinitions,
-                     this->Snapshot_.Position->CompileDefinitionsPosition);
+  return GetPropertyContent(
+    this->DirectoryState->CompileDefinitions,
+    this->Snapshot_.Position->CompileDefinitionsPosition);
 }
 
-cmBacktraceRange
-cmState::Directory::GetCompileDefinitionsEntryBacktraces() const
+cmBacktraceRange cmState::Directory::GetCompileDefinitionsEntryBacktraces()
+  const
 {
-  return GetPropertyBacktraces(this->DirectoryState->CompileDefinitions,
-                     this->DirectoryState->CompileDefinitionsBacktraces,
-                     this->Snapshot_.Position->CompileDefinitionsPosition);
+  return GetPropertyBacktraces(
+    this->DirectoryState->CompileDefinitions,
+    this->DirectoryState->CompileDefinitionsBacktraces,
+    this->Snapshot_.Position->CompileDefinitionsPosition);
 }
 
-void cmState::Directory::AppendCompileDefinitionsEntry(const std::string& vec,
-                                               const cmListFileBacktrace& lfbt)
+void cmState::Directory::AppendCompileDefinitionsEntry(
+  const std::string& vec, const cmListFileBacktrace& lfbt)
 {
   AppendEntry(this->DirectoryState->CompileDefinitions,
               this->DirectoryState->CompileDefinitionsBacktraces,
-              this->Snapshot_.Position->CompileDefinitionsPosition,
-              vec, lfbt);
+              this->Snapshot_.Position->CompileDefinitionsPosition, vec, lfbt);
 }
 
 void cmState::Directory::SetCompileDefinitions(const std::string& vec,
@@ -1676,8 +1561,7 @@ void cmState::Directory::SetCompileDefinitions(const std::string& vec,
 {
   SetContent(this->DirectoryState->CompileDefinitions,
              this->DirectoryState->CompileDefinitionsBacktraces,
-             this->Snapshot_.Position->CompileDefinitionsPosition,
-             vec, lfbt);
+             this->Snapshot_.Position->CompileDefinitionsPosition, vec, lfbt);
 }
 
 void cmState::Directory::ClearCompileDefinitions()
@@ -1690,24 +1574,23 @@ void cmState::Directory::ClearCompileDefinitions()
 cmStringRange cmState::Directory::GetCompileOptionsEntries() const
 {
   return GetPropertyContent(this->DirectoryState->CompileOptions,
-                         this->Snapshot_.Position->CompileOptionsPosition);
+                            this->Snapshot_.Position->CompileOptionsPosition);
 }
 
 cmBacktraceRange cmState::Directory::GetCompileOptionsEntryBacktraces() const
 {
-  return GetPropertyBacktraces(this->DirectoryState->CompileOptions,
-                         this->DirectoryState->CompileOptionsBacktraces,
-                         this->Snapshot_.Position->CompileOptionsPosition);
+  return GetPropertyBacktraces(
+    this->DirectoryState->CompileOptions,
+    this->DirectoryState->CompileOptionsBacktraces,
+    this->Snapshot_.Position->CompileOptionsPosition);
 }
 
-void
-cmState::Directory::AppendCompileOptionsEntry(const std::string& vec,
-                                              const cmListFileBacktrace& lfbt)
+void cmState::Directory::AppendCompileOptionsEntry(
+  const std::string& vec, const cmListFileBacktrace& lfbt)
 {
   AppendEntry(this->DirectoryState->CompileOptions,
               this->DirectoryState->CompileOptionsBacktraces,
-              this->Snapshot_.Position->CompileOptionsPosition,
-              vec, lfbt);
+              this->Snapshot_.Position->CompileOptionsPosition, vec, lfbt);
 }
 
 void cmState::Directory::SetCompileOptions(const std::string& vec,
@@ -1715,8 +1598,7 @@ void cmState::Directory::SetCompileOptions(const std::string& vec,
 {
   SetContent(this->DirectoryState->CompileOptions,
              this->DirectoryState->CompileOptionsBacktraces,
-             this->Snapshot_.Position->CompileOptionsPosition,
-             vec, lfbt);
+             this->Snapshot_.Position->CompileOptionsPosition, vec, lfbt);
 }
 
 void cmState::Directory::ClearCompileOptions()
@@ -1727,7 +1609,7 @@ void cmState::Directory::ClearCompileOptions()
 }
 
 bool cmState::Snapshot::StrictWeakOrder::operator()(
-    const cmState::Snapshot& lhs, const cmState::Snapshot& rhs) const
+  const cmState::Snapshot& lhs, const cmState::Snapshot& rhs) const
 {
   return lhs.Position.StrictWeakOrdered(rhs.Position);
 }
@@ -1736,140 +1618,112 @@ void cmState::Directory::SetProperty(const std::string& prop,
                                      const char* value,
                                      cmListFileBacktrace lfbt)
 {
-  if (prop == "INCLUDE_DIRECTORIES")
-    {
-    if (!value)
-      {
+  if (prop == "INCLUDE_DIRECTORIES") {
+    if (!value) {
       this->ClearIncludeDirectories();
       return;
-      }
+    }
     this->SetIncludeDirectories(value, lfbt);
     return;
-    }
-  if (prop == "COMPILE_OPTIONS")
-    {
-    if (!value)
-      {
+  }
+  if (prop == "COMPILE_OPTIONS") {
+    if (!value) {
       this->ClearCompileOptions();
       return;
-      }
+    }
     this->SetCompileOptions(value, lfbt);
     return;
-    }
-  if (prop == "COMPILE_DEFINITIONS")
-    {
-    if (!value)
-      {
+  }
+  if (prop == "COMPILE_DEFINITIONS") {
+    if (!value) {
       this->ClearCompileDefinitions();
       return;
-      }
+    }
     this->SetCompileDefinitions(value, lfbt);
     return;
-    }
+  }
 
   this->DirectoryState->Properties.SetProperty(prop, value);
 }
 
 void cmState::Directory::AppendProperty(const std::string& prop,
-                                        const char* value,
-                                        bool asString,
+                                        const char* value, bool asString,
                                         cmListFileBacktrace lfbt)
 {
-  if (prop == "INCLUDE_DIRECTORIES")
-    {
+  if (prop == "INCLUDE_DIRECTORIES") {
     this->AppendIncludeDirectoriesEntry(value, lfbt);
     return;
-    }
-  if (prop == "COMPILE_OPTIONS")
-    {
+  }
+  if (prop == "COMPILE_OPTIONS") {
     this->AppendCompileOptionsEntry(value, lfbt);
     return;
-    }
-  if (prop == "COMPILE_DEFINITIONS")
-    {
+  }
+  if (prop == "COMPILE_DEFINITIONS") {
     this->AppendCompileDefinitionsEntry(value, lfbt);
     return;
-    }
+  }
 
   this->DirectoryState->Properties.AppendProperty(prop, value, asString);
 }
 
-const char*cmState::Directory::GetProperty(const std::string& prop) const
+const char* cmState::Directory::GetProperty(const std::string& prop) const
 {
-  const bool chain = this->Snapshot_.State->
-      IsPropertyChained(prop, cmProperty::DIRECTORY);
+  const bool chain =
+    this->Snapshot_.State->IsPropertyChained(prop, cmProperty::DIRECTORY);
   return this->GetProperty(prop, chain);
 }
 
-const char*
-cmState::Directory::GetProperty(const std::string& prop, bool chain) const
+const char* cmState::Directory::GetProperty(const std::string& prop,
+                                            bool chain) const
 {
   static std::string output;
   output = "";
-  if (prop == "PARENT_DIRECTORY")
-    {
-    cmState::Snapshot parent =
-        this->Snapshot_.GetBuildsystemDirectoryParent();
-    if(parent.IsValid())
-      {
+  if (prop == "PARENT_DIRECTORY") {
+    cmState::Snapshot parent = this->Snapshot_.GetBuildsystemDirectoryParent();
+    if (parent.IsValid()) {
       return parent.GetDirectory().GetCurrentSource();
-      }
-    return "";
     }
-  else if (prop == "LISTFILE_STACK")
-    {
+    return "";
+  } else if (prop == "LISTFILE_STACK") {
     std::vector<std::string> listFiles;
     cmState::Snapshot snp = this->Snapshot_;
-    while (snp.IsValid())
-      {
+    while (snp.IsValid()) {
       listFiles.push_back(snp.GetExecutionListFile());
       snp = snp.GetCallStackParent();
-      }
+    }
     std::reverse(listFiles.begin(), listFiles.end());
     output = cmJoin(listFiles, ";");
     return output.c_str();
-    }
-  else if ( prop == "CACHE_VARIABLES" )
-    {
+  } else if (prop == "CACHE_VARIABLES") {
     output = cmJoin(this->Snapshot_.State->GetCacheEntryKeys(), ";");
     return output.c_str();
-    }
-  else if (prop == "VARIABLES")
-    {
+  } else if (prop == "VARIABLES") {
     std::vector<std::string> res = this->Snapshot_.ClosureKeys();
     std::vector<std::string> cacheKeys =
-        this->Snapshot_.State->GetCacheEntryKeys();
+      this->Snapshot_.State->GetCacheEntryKeys();
     res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
     std::sort(res.begin(), res.end());
     output = cmJoin(res, ";");
     return output.c_str();
-    }
-  else if (prop == "INCLUDE_DIRECTORIES")
-    {
+  } else if (prop == "INCLUDE_DIRECTORIES") {
     output = cmJoin(this->GetIncludeDirectoriesEntries(), ";");
     return output.c_str();
-    }
-  else if (prop == "COMPILE_OPTIONS")
-    {
+  } else if (prop == "COMPILE_OPTIONS") {
     output = cmJoin(this->GetCompileOptionsEntries(), ";");
     return output.c_str();
-    }
-  else if (prop == "COMPILE_DEFINITIONS")
-    {
+  } else if (prop == "COMPILE_DEFINITIONS") {
     output = cmJoin(this->GetCompileDefinitionsEntries(), ";");
     return output.c_str();
-    }
+  }
 
-  const char *retVal = this->DirectoryState->Properties.GetPropertyValue(prop);
-  if (!retVal && chain)
-    {
+  const char* retVal = this->DirectoryState->Properties.GetPropertyValue(prop);
+  if (!retVal && chain) {
     Snapshot parentSnapshot = this->Snapshot_.GetBuildsystemDirectoryParent();
-    if (parentSnapshot.IsValid())
-      {
+    if (parentSnapshot.IsValid()) {
       return parentSnapshot.GetDirectory().GetProperty(prop, chain);
-      }
-    return this->Snapshot_.State->GetGlobalProperty(prop);
     }
+    return this->Snapshot_.State->GetGlobalProperty(prop);
+  }
 
   return retVal;
 }
@@ -1883,12 +1737,11 @@ std::vector<std::string> cmState::Directory::GetPropertyKeys() const
 {
   std::vector<std::string> keys;
   keys.reserve(this->DirectoryState->Properties.size());
-  for(cmPropertyMap::const_iterator it =
-      this->DirectoryState->Properties.begin();
-      it != this->DirectoryState->Properties.end(); ++it)
-    {
+  for (cmPropertyMap::const_iterator it =
+         this->DirectoryState->Properties.begin();
+       it != this->DirectoryState->Properties.end(); ++it) {
     keys.push_back(it->first);
-    }
+  }
   return keys;
 }
 
@@ -1902,8 +1755,7 @@ bool operator!=(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs)
   return lhs.Position != rhs.Position;
 }
 
-static bool ParseEntryWithoutType(const std::string& entry,
-                                  std::string& var,
+static bool ParseEntryWithoutType(const std::string& entry, std::string& var,
                                   std::string& value)
 {
   // input line is:         key=value
@@ -1913,37 +1765,28 @@ static bool ParseEntryWithoutType(const std::string& entry,
   static cmsys::RegularExpression regQuoted(
     "^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
   bool flag = false;
-  if(regQuoted.find(entry))
-    {
+  if (regQuoted.find(entry)) {
     var = regQuoted.match(1);
     value = regQuoted.match(2);
     flag = true;
-    }
-  else if (reg.find(entry))
-    {
+  } else if (reg.find(entry)) {
     var = reg.match(1);
     value = reg.match(2);
     flag = true;
-    }
+  }
 
   // if value is enclosed in single quotes ('foo') then remove them
   // it is used to enclose trailing space or tab
-  if (flag &&
-      value.size() >= 2 &&
-      value[0] == '\'' &&
-      value[value.size() - 1] == '\'')
-    {
-    value = value.substr(1,
-                         value.size() - 2);
-    }
+  if (flag && value.size() >= 2 && value[0] == '\'' &&
+      value[value.size() - 1] == '\'') {
+    value = value.substr(1, value.size() - 2);
+  }
 
   return flag;
 }
 
-bool cmState::ParseCacheEntry(const std::string& entry,
-                                std::string& var,
-                                std::string& value,
-                                CacheEntryType& type)
+bool cmState::ParseCacheEntry(const std::string& entry, std::string& var,
+                              std::string& value, CacheEntryType& type)
 {
   // input line is:         key:type=value
   static cmsys::RegularExpression reg(
@@ -1952,36 +1795,28 @@ bool cmState::ParseCacheEntry(const std::string& entry,
   static cmsys::RegularExpression regQuoted(
     "^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
   bool flag = false;
-  if(regQuoted.find(entry))
-    {
+  if (regQuoted.find(entry)) {
     var = regQuoted.match(1);
     type = cmState::StringToCacheEntryType(regQuoted.match(2).c_str());
     value = regQuoted.match(3);
     flag = true;
-    }
-  else if (reg.find(entry))
-    {
+  } else if (reg.find(entry)) {
     var = reg.match(1);
     type = cmState::StringToCacheEntryType(reg.match(2).c_str());
     value = reg.match(3);
     flag = true;
-    }
+  }
 
   // if value is enclosed in single quotes ('foo') then remove them
   // it is used to enclose trailing space or tab
-  if (flag &&
-      value.size() >= 2 &&
-      value[0] == '\'' &&
-      value[value.size() - 1] == '\'')
-    {
-    value = value.substr(1,
-                         value.size() - 2);
-    }
+  if (flag && value.size() >= 2 && value[0] == '\'' &&
+      value[value.size() - 1] == '\'') {
+    value = value.substr(1, value.size() - 2);
+  }
 
-  if (!flag)
-    {
+  if (!flag) {
     return ParseEntryWithoutType(entry, var, value);
-    }
+  }
 
   return flag;
 }
diff --git a/Source/cmState.h b/Source/cmState.h
index 705c1a8..7ecac56 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -33,6 +33,7 @@ class cmState
   struct BuildsystemDirectoryStateType;
   typedef cmLinkedTree<SnapshotDataType>::iterator PositionType;
   friend class Snapshot;
+
 public:
   cmState();
   ~cmState();
@@ -51,7 +52,8 @@ public:
 
   class Directory;
 
-  class Snapshot {
+  class Snapshot
+  {
   public:
     Snapshot(cmState* state = 0);
     Snapshot(cmState* state, PositionType position);
@@ -120,16 +122,15 @@ public:
   {
     Directory(cmLinkedTree<BuildsystemDirectoryStateType>::iterator iter,
               Snapshot const& snapshot);
+
   public:
     const char* GetCurrentSource() const;
     void SetCurrentSource(std::string const& dir);
     const char* GetCurrentBinary() const;
     void SetCurrentBinary(std::string const& dir);
 
-    std::vector<std::string> const&
-    GetCurrentSourceComponents() const;
-    std::vector<std::string> const&
-    GetCurrentBinaryComponents() const;
+    std::vector<std::string> const& GetCurrentSourceComponents() const;
+    std::vector<std::string> const& GetCurrentBinaryComponents() const;
 
     const char* GetRelativePathTopSource() const;
     const char* GetRelativePathTopBinary() const;
@@ -157,17 +158,17 @@ public:
     cmStringRange GetCompileOptionsEntries() const;
     cmBacktraceRange GetCompileOptionsEntryBacktraces() const;
     void AppendCompileOptionsEntry(std::string const& vec,
-                                       cmListFileBacktrace const& lfbt);
+                                   cmListFileBacktrace const& lfbt);
     void SetCompileOptions(std::string const& vec,
-                               cmListFileBacktrace const& lfbt);
+                           cmListFileBacktrace const& lfbt);
     void ClearCompileOptions();
 
-    void SetProperty(const std::string& prop, const char *value,
+    void SetProperty(const std::string& prop, const char* value,
                      cmListFileBacktrace lfbt);
-    void AppendProperty(const std::string& prop, const char *value,
+    void AppendProperty(const std::string& prop, const char* value,
                         bool asString, cmListFileBacktrace lfbt);
-    const char *GetProperty(const std::string& prop) const;
-    const char *GetProperty(const std::string& prop, bool chain) const;
+    const char* GetProperty(const std::string& prop) const;
+    const char* GetProperty(const std::string& prop, bool chain) const;
     bool GetPropertyAsBool(const std::string& prop) const;
     std::vector<std::string> GetPropertyKeys() const;
 
@@ -181,17 +182,23 @@ public:
     friend class Snapshot;
   };
 
-  enum TargetType { EXECUTABLE, STATIC_LIBRARY,
-                    SHARED_LIBRARY, MODULE_LIBRARY,
-                    OBJECT_LIBRARY, UTILITY, GLOBAL_TARGET,
-                    INTERFACE_LIBRARY,
-                    UNKNOWN_LIBRARY};
+  enum TargetType
+  {
+    EXECUTABLE,
+    STATIC_LIBRARY,
+    SHARED_LIBRARY,
+    MODULE_LIBRARY,
+    OBJECT_LIBRARY,
+    UTILITY,
+    GLOBAL_TARGET,
+    INTERFACE_LIBRARY,
+    UNKNOWN_LIBRARY
+  };
 
   static const char* GetTargetTypeName(cmState::TargetType targetType);
 
   Snapshot CreateBaseSnapshot();
-  Snapshot
-  CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot);
+  Snapshot CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot);
   Snapshot CreateFunctionCallSnapshot(Snapshot originSnapshot,
                                       std::string const& fileName);
   Snapshot CreateMacroCallSnapshot(Snapshot originSnapshot,
@@ -204,8 +211,16 @@ public:
   Snapshot CreatePolicyScopeSnapshot(Snapshot originSnapshot);
   Snapshot Pop(Snapshot originSnapshot);
 
-  enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
-                       UNINITIALIZED };
+  enum CacheEntryType
+  {
+    BOOL = 0,
+    PATH,
+    FILEPATH,
+    STRING,
+    INTERNAL,
+    STATIC,
+    UNINITIALIZED
+  };
   static CacheEntryType StringToCacheEntryType(const char*);
   static const char* CacheEntryTypeToString(CacheEntryType);
   static bool IsCacheEntryType(std::string const& key);
@@ -214,7 +229,7 @@ public:
                  std::set<std::string>& excludes,
                  std::set<std::string>& includes);
 
-  bool SaveCache(const std::string& path) ;
+  bool SaveCache(const std::string& path);
 
   bool DeleteCache(const std::string& path);
 
@@ -231,8 +246,7 @@ public:
                              std::string const& propertyName,
                              std::string const& value);
   void SetCacheEntryBoolProperty(std::string const& key,
-                                 std::string const& propertyName,
-                                 bool value);
+                                 std::string const& propertyName, bool value);
   const char* GetCacheEntryProperty(std::string const& key,
                                     std::string const& propertyName);
   bool GetCacheEntryPropertyAsBool(std::string const& key,
@@ -245,21 +259,18 @@ public:
                                 std::string const& propertyName);
 
   ///! Break up a line like VAR:type="value" into var, type and value
-  static bool ParseCacheEntry(const std::string& entry,
-                              std::string& var,
-                              std::string& value,
-                              CacheEntryType& type);
+  static bool ParseCacheEntry(const std::string& entry, std::string& var,
+                              std::string& value, CacheEntryType& type);
 
   Snapshot Reset();
   // Define a property
   void DefineProperty(const std::string& name, cmProperty::ScopeType scope,
-                      const char *ShortDescription,
-                      const char *FullDescription,
-                      bool chain = false);
+                      const char* ShortDescription,
+                      const char* FullDescription, bool chain = false);
 
   // get property definition
-  cmPropertyDefinition const* GetPropertyDefinition
-  (const std::string& name, cmProperty::ScopeType scope) const;
+  cmPropertyDefinition const* GetPropertyDefinition(
+    const std::string& name, cmProperty::ScopeType scope) const;
 
   // Is a property defined?
   bool IsPropertyDefined(const std::string& name,
@@ -283,10 +294,10 @@ public:
   void RemoveUserDefinedCommands();
   std::vector<std::string> GetCommandNames() const;
 
-  void SetGlobalProperty(const std::string& prop, const char *value);
-  void AppendGlobalProperty(const std::string& prop,
-                      const char *value,bool asString=false);
-  const char *GetGlobalProperty(const std::string& prop);
+  void SetGlobalProperty(const std::string& prop, const char* value);
+  void AppendGlobalProperty(const std::string& prop, const char* value,
+                            bool asString = false);
+  const char* GetGlobalProperty(const std::string& prop);
   bool GetGlobalPropertyAsBool(const std::string& prop);
 
   const char* GetSourceDirectory() const;
diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx
index 757425f..a348aef 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -23,99 +23,58 @@
 #include <cmTimestamp.h>
 #include <cmUuid.h>
 
-bool cmStringCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmStringCommand::InitialPass(std::vector<std::string> const& args,
+                                  cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("must be called with at least one argument.");
     return false;
-    }
+  }
 
-  const std::string &subCommand = args[0];
-  if(subCommand == "REGEX")
-    {
+  const std::string& subCommand = args[0];
+  if (subCommand == "REGEX") {
     return this->HandleRegexCommand(args);
-    }
-  else if(subCommand == "REPLACE")
-    {
+  } else if (subCommand == "REPLACE") {
     return this->HandleReplaceCommand(args);
-    }
-  else if ( subCommand == "MD5" ||
-            subCommand == "SHA1" ||
-            subCommand == "SHA224" ||
-            subCommand == "SHA256" ||
-            subCommand == "SHA384" ||
-            subCommand == "SHA512" )
-    {
+  } else if (subCommand == "MD5" || subCommand == "SHA1" ||
+             subCommand == "SHA224" || subCommand == "SHA256" ||
+             subCommand == "SHA384" || subCommand == "SHA512") {
     return this->HandleHashCommand(args);
-    }
-  else if(subCommand == "TOLOWER")
-    {
+  } else if (subCommand == "TOLOWER") {
     return this->HandleToUpperLowerCommand(args, false);
-    }
-  else if(subCommand == "TOUPPER")
-    {
+  } else if (subCommand == "TOUPPER") {
     return this->HandleToUpperLowerCommand(args, true);
-    }
-  else if(subCommand == "COMPARE")
-    {
+  } else if (subCommand == "COMPARE") {
     return this->HandleCompareCommand(args);
-    }
-  else if(subCommand == "ASCII")
-    {
+  } else if (subCommand == "ASCII") {
     return this->HandleAsciiCommand(args);
-    }
-  else if(subCommand == "CONFIGURE")
-    {
+  } else if (subCommand == "CONFIGURE") {
     return this->HandleConfigureCommand(args);
-    }
-  else if(subCommand == "LENGTH")
-    {
+  } else if (subCommand == "LENGTH") {
     return this->HandleLengthCommand(args);
-    }
-  else if(subCommand == "APPEND")
-    {
+  } else if (subCommand == "APPEND") {
     return this->HandleAppendCommand(args);
-    }
-  else if(subCommand == "CONCAT")
-    {
+  } else if (subCommand == "CONCAT") {
     return this->HandleConcatCommand(args);
-    }
-  else if(subCommand == "SUBSTRING")
-    {
+  } else if (subCommand == "SUBSTRING") {
     return this->HandleSubstringCommand(args);
-    }
-  else if(subCommand == "STRIP")
-    {
+  } else if (subCommand == "STRIP") {
     return this->HandleStripCommand(args);
-    }
-  else if(subCommand == "RANDOM")
-    {
+  } else if (subCommand == "RANDOM") {
     return this->HandleRandomCommand(args);
-    }
-  else if(subCommand == "FIND")
-    {
+  } else if (subCommand == "FIND") {
     return this->HandleFindCommand(args);
-    }
-  else if(subCommand == "TIMESTAMP")
-    {
+  } else if (subCommand == "TIMESTAMP") {
     return this->HandleTimestampCommand(args);
-    }
-  else if(subCommand == "MAKE_C_IDENTIFIER")
-    {
+  } else if (subCommand == "MAKE_C_IDENTIFIER") {
     return this->HandleMakeCIdentifierCommand(args);
-    }
-  else if(subCommand == "GENEX_STRIP")
-    {
+  } else if (subCommand == "GENEX_STRIP") {
     return this->HandleGenexStripCommand(args);
-    }
-  else if(subCommand == "UUID")
-    {
+  } else if (subCommand == "UUID") {
     return this->HandleUuidCommand(args);
-    }
+  }
 
-  std::string e = "does not recognize sub-command "+subCommand;
+  std::string e = "does not recognize sub-command " + subCommand;
   this->SetError(e);
   return false;
 }
@@ -123,21 +82,19 @@ bool cmStringCommand
 bool cmStringCommand::HandleHashCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     std::ostringstream e;
     e << args[0] << " requires an output variable and an input string";
     this->SetError(e.str());
     return false;
-    }
+  }
 
   cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
-  if(hash.get())
-    {
+  if (hash.get()) {
     std::string out = hash->HashString(args[2]);
     this->Makefile->AddDefinition(args[1], out.c_str());
     return true;
-    }
+  }
   return false;
 #else
   std::ostringstream e;
@@ -150,23 +107,19 @@ bool cmStringCommand::HandleHashCommand(std::vector<std::string> const& args)
 bool cmStringCommand::HandleToUpperLowerCommand(
   std::vector<std::string> const& args, bool toUpper)
 {
-  if ( args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("no output variable specified");
     return false;
-    }
+  }
 
   std::string outvar = args[2];
   std::string output;
 
-  if (toUpper)
-    {
+  if (toUpper) {
     output = cmSystemTools::UpperCase(args[1]);
-    }
-  else
-    {
+  } else {
     output = cmSystemTools::LowerCase(args[1]);
-    }
+  }
 
   // Store the output in the provided variable.
   this->Makefile->AddDefinition(outvar, output.c_str());
@@ -175,30 +128,25 @@ bool cmStringCommand::HandleToUpperLowerCommand(
 
 bool cmStringCommand::HandleAsciiCommand(std::vector<std::string> const& args)
 {
-  if ( args.size() < 3 )
-    {
+  if (args.size() < 3) {
     this->SetError("No output variable specified");
     return false;
-    }
+  }
   std::string::size_type cc;
-  std::string outvar = args[args.size()-1];
+  std::string outvar = args[args.size() - 1];
   std::string output = "";
-  for ( cc = 1; cc < args.size()-1; cc ++ )
-    {
+  for (cc = 1; cc < args.size() - 1; cc++) {
     int ch = atoi(args[cc].c_str());
-    if ( ch > 0 && ch < 256 )
-      {
+    if (ch > 0 && ch < 256) {
       output += static_cast<char>(ch);
-      }
-    else
-      {
+    } else {
       std::string error = "Character with code ";
       error += args[cc];
       error += " does not exist.";
       this->SetError(error);
       return false;
-      }
     }
+  }
   // Store the output in the provided variable.
   this->Makefile->AddDefinition(outvar, output.c_str());
   return true;
@@ -207,38 +155,29 @@ bool cmStringCommand::HandleAsciiCommand(std::vector<std::string> const& args)
 bool cmStringCommand::HandleConfigureCommand(
   std::vector<std::string> const& args)
 {
-  if ( args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("No input string specified.");
     return false;
-    }
-  else if ( args.size() < 3 )
-    {
+  } else if (args.size() < 3) {
     this->SetError("No output variable specified.");
     return false;
-    }
+  }
 
   // Parse options.
   bool escapeQuotes = false;
   bool atOnly = false;
-  for(unsigned int i = 3; i < args.size(); ++i)
-    {
-    if(args[i] == "@ONLY")
-      {
+  for (unsigned int i = 3; i < args.size(); ++i) {
+    if (args[i] == "@ONLY") {
       atOnly = true;
-      }
-    else if(args[i] == "ESCAPE_QUOTES")
-      {
+    } else if (args[i] == "ESCAPE_QUOTES") {
       escapeQuotes = true;
-      }
-    else
-      {
+    } else {
       std::ostringstream err;
       err << "Unrecognized argument \"" << args[i] << "\"";
       this->SetError(err.str());
       return false;
-      }
     }
+  }
 
   // Configure the string.
   std::string output;
@@ -252,44 +191,35 @@ bool cmStringCommand::HandleConfigureCommand(
 
 bool cmStringCommand::HandleRegexCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command REGEX requires a mode to be specified.");
     return false;
-    }
+  }
   std::string mode = args[1];
-  if(mode == "MATCH")
-    {
-    if(args.size() < 5)
-      {
+  if (mode == "MATCH") {
+    if (args.size() < 5) {
       this->SetError("sub-command REGEX, mode MATCH needs "
                      "at least 5 arguments total to command.");
       return false;
-      }
-    return this->RegexMatch(args);
     }
-  else if(mode == "MATCHALL")
-    {
-    if(args.size() < 5)
-      {
+    return this->RegexMatch(args);
+  } else if (mode == "MATCHALL") {
+    if (args.size() < 5) {
       this->SetError("sub-command REGEX, mode MATCHALL needs "
                      "at least 5 arguments total to command.");
       return false;
-      }
-    return this->RegexMatchAll(args);
     }
-  else if(mode == "REPLACE")
-    {
-    if(args.size() < 6)
-      {
+    return this->RegexMatchAll(args);
+  } else if (mode == "REPLACE") {
+    if (args.size() < 6) {
       this->SetError("sub-command REGEX, mode REPLACE needs "
                      "at least 6 arguments total to command.");
       return false;
-      }
-    return this->RegexReplace(args);
     }
+    return this->RegexReplace(args);
+  }
 
-  std::string e = "sub-command REGEX does not recognize mode "+mode;
+  std::string e = "sub-command REGEX does not recognize mode " + mode;
   this->SetError(e);
   return false;
 }
@@ -304,34 +234,31 @@ bool cmStringCommand::RegexMatch(std::vector<std::string> const& args)
   this->Makefile->ClearMatches();
   // Compile the regular expression.
   cmsys::RegularExpression re;
-  if(!re.compile(regex.c_str()))
-    {
+  if (!re.compile(regex.c_str())) {
     std::string e =
-      "sub-command REGEX, mode MATCH failed to compile regex \""+regex+"\".";
+      "sub-command REGEX, mode MATCH failed to compile regex \"" + regex +
+      "\".";
     this->SetError(e);
     return false;
-    }
+  }
 
   // Concatenate all the last arguments together.
   std::string input = cmJoin(cmMakeRange(args).advance(4), std::string());
 
   // Scan through the input for all matches.
   std::string output;
-  if(re.find(input.c_str()))
-    {
+  if (re.find(input.c_str())) {
     this->Makefile->StoreMatches(re);
     std::string::size_type l = re.start();
     std::string::size_type r = re.end();
-    if(r-l == 0)
-      {
-      std::string e =
-        "sub-command REGEX, mode MATCH regex \""+regex+
+    if (r - l == 0) {
+      std::string e = "sub-command REGEX, mode MATCH regex \"" + regex +
         "\" matched an empty string.";
       this->SetError(e);
       return false;
-      }
-    output = input.substr(l, r-l);
     }
+    output = input.substr(l, r - l);
+  }
 
   // Store the output in the provided variable.
   this->Makefile->AddDefinition(outvar, output.c_str());
@@ -348,14 +275,13 @@ bool cmStringCommand::RegexMatchAll(std::vector<std::string> const& args)
   this->Makefile->ClearMatches();
   // Compile the regular expression.
   cmsys::RegularExpression re;
-  if(!re.compile(regex.c_str()))
-    {
+  if (!re.compile(regex.c_str())) {
     std::string e =
-      "sub-command REGEX, mode MATCHALL failed to compile regex \""+
-      regex+"\".";
+      "sub-command REGEX, mode MATCHALL failed to compile regex \"" + regex +
+      "\".";
     this->SetError(e);
     return false;
-    }
+  }
 
   // Concatenate all the last arguments together.
   std::string input = cmJoin(cmMakeRange(args).advance(4), std::string());
@@ -363,25 +289,22 @@ bool cmStringCommand::RegexMatchAll(std::vector<std::string> const& args)
   // Scan through the input for all matches.
   std::string output;
   const char* p = input.c_str();
-  while(re.find(p))
-    {
+  while (re.find(p)) {
     this->Makefile->StoreMatches(re);
     std::string::size_type l = re.start();
     std::string::size_type r = re.end();
-    if(r-l == 0)
-      {
-      std::string e = "sub-command REGEX, mode MATCHALL regex \""+
-        regex+"\" matched an empty string.";
+    if (r - l == 0) {
+      std::string e = "sub-command REGEX, mode MATCHALL regex \"" + regex +
+        "\" matched an empty string.";
       this->SetError(e);
       return false;
-      }
-    if(!output.empty())
-      {
+    }
+    if (!output.empty()) {
       output += ";";
-      }
-    output += std::string(p+l, r-l);
-    p += r;
     }
+    output += std::string(p + l, r - l);
+    p += r;
+  }
 
   // Store the output in the provided variable.
   this->Makefile->AddDefinition(outvar, output.c_str());
@@ -399,62 +322,48 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
   // Pull apart the replace expression to find the escaped [0-9] values.
   std::vector<RegexReplacement> replacement;
   std::string::size_type l = 0;
-  while(l < replace.length())
-    {
+  while (l < replace.length()) {
     std::string::size_type r = replace.find("\\", l);
-    if(r == std::string::npos)
-      {
+    if (r == std::string::npos) {
       r = replace.length();
-      replacement.push_back(replace.substr(l, r-l));
+      replacement.push_back(replace.substr(l, r - l));
+    } else {
+      if (r - l > 0) {
+        replacement.push_back(replace.substr(l, r - l));
       }
-    else
-      {
-      if(r-l > 0)
-        {
-        replacement.push_back(replace.substr(l, r-l));
-        }
-      if(r == (replace.length()-1))
-        {
+      if (r == (replace.length() - 1)) {
         this->SetError("sub-command REGEX, mode REPLACE: "
                        "replace-expression ends in a backslash.");
         return false;
-        }
-      if((replace[r+1] >= '0') && (replace[r+1] <= '9'))
-        {
-        replacement.push_back(replace[r+1]-'0');
-        }
-      else if(replace[r+1] == 'n')
-        {
+      }
+      if ((replace[r + 1] >= '0') && (replace[r + 1] <= '9')) {
+        replacement.push_back(replace[r + 1] - '0');
+      } else if (replace[r + 1] == 'n') {
         replacement.push_back("\n");
-        }
-      else if(replace[r+1] == '\\')
-        {
+      } else if (replace[r + 1] == '\\') {
         replacement.push_back("\\");
-        }
-      else
-        {
+      } else {
         std::string e = "sub-command REGEX, mode REPLACE: Unknown escape \"";
         e += replace.substr(r, 2);
         e += "\" in replace-expression.";
         this->SetError(e);
         return false;
-        }
-      r += 2;
       }
-    l = r;
+      r += 2;
     }
+    l = r;
+  }
 
   this->Makefile->ClearMatches();
   // Compile the regular expression.
   cmsys::RegularExpression re;
-  if(!re.compile(regex.c_str()))
-    {
+  if (!re.compile(regex.c_str())) {
     std::string e =
-      "sub-command REGEX, mode REPLACE failed to compile regex \""+
-      regex+"\".";
+      "sub-command REGEX, mode REPLACE failed to compile regex \"" + regex +
+      "\".";
     this->SetError(e);
     return false;
-    }
+  }
 
   // Concatenate all the last arguments together.
   std::string input = cmJoin(cmMakeRange(args).advance(5), std::string());
@@ -462,8 +371,7 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
   // Scan through the input for all matches.
   std::string output;
   std::string::size_type base = 0;
-  while(re.find(input.c_str()+base))
-    {
+  while (re.find(input.c_str() + base)) {
     this->Makefile->StoreMatches(re);
     std::string::size_type l2 = re.start();
     std::string::size_type r = re.end();
@@ -472,81 +380,69 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
     output += input.substr(base, l2);
 
     // Make sure the match had some text.
-    if(r-l2 == 0)
-      {
-      std::string e = "sub-command REGEX, mode REPLACE regex \""+
-        regex+"\" matched an empty string.";
+    if (r - l2 == 0) {
+      std::string e = "sub-command REGEX, mode REPLACE regex \"" + regex +
+        "\" matched an empty string.";
       this->SetError(e);
       return false;
-      }
+    }
 
     // Concatenate the replacement for the match.
-    for(unsigned int i=0; i < replacement.size(); ++i)
-      {
-      if(replacement[i].number < 0)
-        {
+    for (unsigned int i = 0; i < replacement.size(); ++i) {
+      if (replacement[i].number < 0) {
         // This is just a plain-text part of the replacement.
         output += replacement[i].value;
-        }
-      else
-        {
+      } else {
         // Replace with part of the match.
         int n = replacement[i].number;
         std::string::size_type start = re.start(n);
         std::string::size_type end = re.end(n);
-        std::string::size_type len = input.length()-base;
-        if((start != std::string::npos) && (end != std::string::npos) &&
-           (start <= len) && (end <= len))
-          {
-          output += input.substr(base+start, end-start);
-          }
-        else
-          {
+        std::string::size_type len = input.length() - base;
+        if ((start != std::string::npos) && (end != std::string::npos) &&
+            (start <= len) && (end <= len)) {
+          output += input.substr(base + start, end - start);
+        } else {
           std::string e =
-            "sub-command REGEX, mode REPLACE: replace expression \""+
-            replace+"\" contains an out-of-range escape for regex \""+
-            regex+"\".";
+            "sub-command REGEX, mode REPLACE: replace expression \"" +
+            replace + "\" contains an out-of-range escape for regex \"" +
+            regex + "\".";
           this->SetError(e);
           return false;
-          }
         }
       }
+    }
 
     // Move past the match.
     base += r;
-    }
+  }
 
   // Concatenate the text after the last match.
-  output += input.substr(base, input.length()-base);
+  output += input.substr(base, input.length() - base);
 
   // Store the output in the provided variable.
   this->Makefile->AddDefinition(outvar, output.c_str());
   return true;
 }
 
-bool cmStringCommand::HandleFindCommand(std::vector<std::string> const&
-                                           args)
+bool cmStringCommand::HandleFindCommand(std::vector<std::string> const& args)
 {
   // check if all required parameters were passed
-  if(args.size() < 4 || args.size() > 5)
-    {
+  if (args.size() < 4 || args.size() > 5) {
     this->SetError("sub-command FIND requires 3 or 4 parameters.");
     return false;
-    }
+  }
 
   // check if the reverse flag was set or not
   bool reverseMode = false;
-  if(args.size() == 5 && args[4] == "REVERSE")
-    {
+  if (args.size() == 5 && args[4] == "REVERSE") {
     reverseMode = true;
-    }
+  }
 
   // if we have 5 arguments the last one must be REVERSE
-  if(args.size() == 5 && args[4] != "REVERSE")
-    {
+  if (args.size() == 5 && args[4] != "REVERSE") {
     this->SetError("sub-command FIND: unknown last parameter");
     return false;
-    }
+  }
 
   // local parameter names.
   const std::string& sstring = args[1];
@@ -554,101 +450,83 @@ bool cmStringCommand::HandleFindCommand(std::vector<std::string> const&
   const std::string& outvar = args[3];
 
   // ensure that the user cannot accidentally specify REVERSE as a variable
-  if(outvar == "REVERSE")
-    {
+  if (outvar == "REVERSE") {
     this->SetError("sub-command FIND does not allow one to select REVERSE as "
                    "the output variable.  "
                    "Maybe you missed the actual output variable?");
     return false;
-    }
+  }
 
   // try to find the character and return its position
   size_t pos;
-  if(!reverseMode)
-    {
+  if (!reverseMode) {
     pos = sstring.find(schar);
-    }
-  else
-    {
+  } else {
     pos = sstring.rfind(schar);
-    }
-  if(std::string::npos != pos)
-    {
+  }
+  if (std::string::npos != pos) {
     std::ostringstream s;
     s << pos;
     this->Makefile->AddDefinition(outvar, s.str().c_str());
     return true;
-    }
+  }
 
   // the character was not found, but this is not really an error
   this->Makefile->AddDefinition(outvar, "-1");
   return true;
 }
 
-bool cmStringCommand::HandleCompareCommand(std::vector<std::string> const&
-                                           args)
+bool cmStringCommand::HandleCompareCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command COMPARE requires a mode to be specified.");
     return false;
-    }
+  }
   std::string mode = args[1];
-  if((mode == "EQUAL") || (mode == "NOTEQUAL") ||
-     (mode == "LESS") || (mode == "GREATER"))
-    {
-    if(args.size() < 5)
-      {
+  if ((mode == "EQUAL") || (mode == "NOTEQUAL") || (mode == "LESS") ||
+      (mode == "GREATER")) {
+    if (args.size() < 5) {
       std::string e = "sub-command COMPARE, mode ";
       e += mode;
       e += " needs at least 5 arguments total to command.";
       this->SetError(e);
       return false;
-      }
+    }
 
     const std::string& left = args[2];
     const std::string& right = args[3];
     const std::string& outvar = args[4];
     bool result;
-    if(mode == "LESS")
-      {
+    if (mode == "LESS") {
       result = (left < right);
-      }
-    else if(mode == "GREATER")
-      {
+    } else if (mode == "GREATER") {
       result = (left > right);
-      }
-    else if(mode == "EQUAL")
-      {
+    } else if (mode == "EQUAL") {
       result = (left == right);
-      }
-    else // if(mode == "NOTEQUAL")
-      {
+    } else // if(mode == "NOTEQUAL")
+    {
       result = !(left == right);
-      }
-    if(result)
-      {
+    }
+    if (result) {
       this->Makefile->AddDefinition(outvar, "1");
-      }
-    else
-      {
+    } else {
       this->Makefile->AddDefinition(outvar, "0");
-      }
-    return true;
     }
-  std::string e = "sub-command COMPARE does not recognize mode "+mode;
+    return true;
+  }
+  std::string e = "sub-command COMPARE does not recognize mode " + mode;
   this->SetError(e);
   return false;
 }
 
-bool cmStringCommand::HandleReplaceCommand(std::vector<std::string> const&
-                                           args)
+bool cmStringCommand::HandleReplaceCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() < 5)
-    {
+  if (args.size() < 5) {
     this->SetError("sub-command REPLACE requires at least four arguments.");
     return false;
-    }
+  }
 
   const std::string& matchExpression = args[1];
   const std::string& replaceExpression = args[2];
@@ -663,14 +541,13 @@ bool cmStringCommand::HandleReplaceCommand(std::vector<std::string> const&
   return true;
 }
 
-bool cmStringCommand::HandleSubstringCommand(std::vector<std::string> const&
-                                             args)
+bool cmStringCommand::HandleSubstringCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() != 5)
-    {
+  if (args.size() != 5) {
     this->SetError("sub-command SUBSTRING requires four arguments.");
     return false;
-    }
+  }
 
   const std::string& stringValue = args[1];
   int begin = atoi(args[2].c_str());
@@ -679,35 +556,31 @@ bool cmStringCommand::HandleSubstringCommand(std::vector<std::string> const&
 
   size_t stringLength = stringValue.size();
   int intStringLength = static_cast<int>(stringLength);
-  if ( begin < 0 || begin > intStringLength )
-    {
+  if (begin < 0 || begin > intStringLength) {
     std::ostringstream ostr;
     ostr << "begin index: " << begin << " is out of range 0 - "
          << stringLength;
     this->SetError(ostr.str());
     return false;
-    }
-  if ( end < -1 )
-    {
+  }
+  if (end < -1) {
     std::ostringstream ostr;
     ostr << "end index: " << end << " should be -1 or greater";
     this->SetError(ostr.str());
     return false;
-    }
+  }
 
   this->Makefile->AddDefinition(variableName,
                                 stringValue.substr(begin, end).c_str());
   return true;
 }
 
-bool cmStringCommand
-::HandleLengthCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleLengthCommand(std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("sub-command LENGTH requires two arguments.");
     return false;
-    }
+  }
 
   const std::string& stringValue = args[1];
   const std::string& variableName = args[2];
@@ -722,39 +595,34 @@ bool cmStringCommand
 
 bool cmStringCommand::HandleAppendCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command APPEND requires at least one argument.");
     return false;
-    }
+  }
 
   // Skip if nothing to append.
-  if(args.size() < 3)
-    {
+  if (args.size() < 3) {
     return true;
-    }
+  }
 
   const std::string& variable = args[1];
 
   std::string value;
   const char* oldValue = this->Makefile->GetDefinition(variable);
-  if(oldValue)
-    {
+  if (oldValue) {
     value = oldValue;
-    }
+  }
   value += cmJoin(cmMakeRange(args).advance(2), std::string());
   this->Makefile->AddDefinition(variable, value.c_str());
   return true;
 }
 
-bool cmStringCommand
-::HandleConcatCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleConcatCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command CONCAT requires at least one argument.");
     return false;
-    }
+  }
 
   std::string const& variableName = args[1];
   std::string value = cmJoin(cmMakeRange(args).advance(2), std::string());
@@ -763,36 +631,34 @@ bool cmStringCommand
   return true;
 }
 
-bool cmStringCommand
-::HandleMakeCIdentifierCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleMakeCIdentifierCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("sub-command MAKE_C_IDENTIFIER requires two arguments.");
     return false;
-    }
+  }
 
   const std::string& input = args[1];
   const std::string& variableName = args[2];
 
   this->Makefile->AddDefinition(variableName,
-                      cmSystemTools::MakeCidentifier(input).c_str());
+                                cmSystemTools::MakeCidentifier(input).c_str());
   return true;
 }
 
-bool cmStringCommand
-::HandleGenexStripCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleGenexStripCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("sub-command GENEX_STRIP requires two arguments.");
     return false;
-    }
+  }
 
   const std::string& input = args[1];
 
-  std::string result = cmGeneratorExpression::Preprocess(input,
-                        cmGeneratorExpression::StripAllGeneratorExpressions);
+  std::string result = cmGeneratorExpression::Preprocess(
+    input, cmGeneratorExpression::StripAllGeneratorExpressions);
 
   const std::string& variableName = args[2];
 
@@ -800,14 +666,12 @@ bool cmStringCommand
   return true;
 }
 
-bool cmStringCommand::HandleStripCommand(
-  std::vector<std::string> const& args)
+bool cmStringCommand::HandleStripCommand(std::vector<std::string> const& args)
 {
- if(args.size() != 3)
-    {
+  if (args.size() != 3) {
     this->SetError("sub-command STRIP requires two arguments.");
     return false;
-    }
+  }
 
   const std::string& stringValue = args[1];
   const std::string& variableName = args[2];
@@ -816,159 +680,131 @@ bool cmStringCommand::HandleStripCommand(
   size_t endPos = 0;
   const char* ptr = stringValue.c_str();
   size_t cc;
-  for ( cc = 0; cc < inStringLength; ++ cc )
-    {
-    if ( !isspace(*ptr) )
-      {
-      if ( startPos > inStringLength )
-        {
+  for (cc = 0; cc < inStringLength; ++cc) {
+    if (!isspace(*ptr)) {
+      if (startPos > inStringLength) {
         startPos = cc;
-        }
-      endPos = cc;
       }
-    ++ ptr;
+      endPos = cc;
     }
+    ++ptr;
+  }
 
   size_t outLength = 0;
 
   // if the input string didn't contain any non-space characters, return
   // an empty string
-  if (startPos > inStringLength)
-    {
+  if (startPos > inStringLength) {
     outLength = 0;
     startPos = 0;
-    }
-  else
-    {
-    outLength=endPos - startPos + 1;
-    }
+  } else {
+    outLength = endPos - startPos + 1;
+  }
 
-  this->Makefile->AddDefinition(variableName,
-    stringValue.substr(startPos, outLength).c_str());
+  this->Makefile->AddDefinition(
+    variableName, stringValue.substr(startPos, outLength).c_str());
   return true;
 }
 
-bool cmStringCommand
-::HandleRandomCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleRandomCommand(std::vector<std::string> const& args)
 {
-  if(args.size() < 2 || args.size() == 3 || args.size() == 5)
-    {
+  if (args.size() < 2 || args.size() == 3 || args.size() == 5) {
     this->SetError("sub-command RANDOM requires at least one argument.");
     return false;
-    }
+  }
 
   static bool seeded = false;
   bool force_seed = false;
   unsigned int seed = 0;
   int length = 5;
   const char cmStringCommandDefaultAlphabet[] = "qwertyuiopasdfghjklzxcvbnm"
-    "QWERTYUIOPASDFGHJKLZXCVBNM"
-    "0123456789";
+                                                "QWERTYUIOPASDFGHJKLZXCVBNM"
+                                                "0123456789";
   std::string alphabet;
 
-  if ( args.size() > 3 )
-    {
+  if (args.size() > 3) {
     size_t i = 1;
     size_t stopAt = args.size() - 2;
 
-    for ( ; i < stopAt; ++i )
-      {
-      if ( args[i] == "LENGTH" )
-        {
+    for (; i < stopAt; ++i) {
+      if (args[i] == "LENGTH") {
         ++i;
         length = atoi(args[i].c_str());
-        }
-      else if ( args[i] == "ALPHABET" )
-        {
+      } else if (args[i] == "ALPHABET") {
         ++i;
         alphabet = args[i];
-        }
-      else if ( args[i] == "RANDOM_SEED" )
-        {
+      } else if (args[i] == "RANDOM_SEED") {
         ++i;
         seed = static_cast<unsigned int>(atoi(args[i].c_str()));
         force_seed = true;
-        }
       }
     }
-  if (alphabet.empty())
-    {
+  }
+  if (alphabet.empty()) {
     alphabet = cmStringCommandDefaultAlphabet;
-    }
+  }
 
   double sizeofAlphabet = static_cast<double>(alphabet.size());
-  if ( sizeofAlphabet < 1 )
-    {
+  if (sizeofAlphabet < 1) {
     this->SetError("sub-command RANDOM invoked with bad alphabet.");
     return false;
-    }
-  if ( length < 1 )
-    {
+  }
+  if (length < 1) {
     this->SetError("sub-command RANDOM invoked with bad length.");
     return false;
-    }
-  const std::string& variableName = args[args.size()-1];
+  }
+  const std::string& variableName = args[args.size() - 1];
 
   std::vector<char> result;
 
-  if (!seeded || force_seed)
-    {
+  if (!seeded || force_seed) {
     seeded = true;
-    srand(force_seed? seed : cmSystemTools::RandomSeed());
-    }
+    srand(force_seed ? seed : cmSystemTools::RandomSeed());
+  }
 
   const char* alphaPtr = alphabet.c_str();
   int cc;
-  for ( cc = 0; cc < length; cc ++ )
-    {
-    int idx=(int) (sizeofAlphabet* rand()/(RAND_MAX+1.0));
+  for (cc = 0; cc < length; cc++) {
+    int idx = (int)(sizeofAlphabet * rand() / (RAND_MAX + 1.0));
     result.push_back(*(alphaPtr + idx));
-    }
+  }
   result.push_back(0);
 
   this->Makefile->AddDefinition(variableName, &*result.begin());
   return true;
 }
 
-bool cmStringCommand
-::HandleTimestampCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleTimestampCommand(
+  std::vector<std::string> const& args)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("sub-command TIMESTAMP requires at least one argument.");
     return false;
-    }
-  else if(args.size() > 4)
-    {
+  } else if (args.size() > 4) {
     this->SetError("sub-command TIMESTAMP takes at most three arguments.");
     return false;
-    }
+  }
 
   unsigned int argsIndex = 1;
 
-  const std::string &outputVariable = args[argsIndex++];
+  const std::string& outputVariable = args[argsIndex++];
 
   std::string formatString;
-  if(args.size() > argsIndex && args[argsIndex] != "UTC")
-    {
+  if (args.size() > argsIndex && args[argsIndex] != "UTC") {
     formatString = args[argsIndex++];
-    }
+  }
 
   bool utcFlag = false;
-  if(args.size() > argsIndex)
-    {
-    if(args[argsIndex] == "UTC")
-      {
+  if (args.size() > argsIndex) {
+    if (args[argsIndex] == "UTC") {
       utcFlag = true;
-      }
-    else
-      {
+    } else {
       std::string e = " TIMESTAMP sub-command does not recognize option " +
-          args[argsIndex] + ".";
+        args[argsIndex] + ".";
       this->SetError(e);
       return false;
-      }
     }
+  }
 
   cmTimestamp timestamp;
   std::string result = timestamp.CurrentTime(formatString, utcFlag);
@@ -977,106 +813,83 @@ bool cmStringCommand
   return true;
 }
 
-bool cmStringCommand
-::HandleUuidCommand(std::vector<std::string> const& args)
+bool cmStringCommand::HandleUuidCommand(std::vector<std::string> const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   unsigned int argsIndex = 1;
 
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("UUID sub-command requires an output variable.");
     return false;
-    }
+  }
 
-  const std::string &outputVariable = args[argsIndex++];
+  const std::string& outputVariable = args[argsIndex++];
 
   std::string uuidNamespaceString;
   std::string uuidName;
   std::string uuidType;
   bool uuidUpperCase = false;
 
-  while(args.size() > argsIndex)
-    {
-    if(args[argsIndex] == "NAMESPACE")
-      {
+  while (args.size() > argsIndex) {
+    if (args[argsIndex] == "NAMESPACE") {
       ++argsIndex;
-      if(argsIndex >= args.size())
-        {
+      if (argsIndex >= args.size()) {
         this->SetError("UUID sub-command, NAMESPACE requires a value.");
         return false;
-        }
-      uuidNamespaceString = args[argsIndex++];
       }
-    else if(args[argsIndex] == "NAME")
-      {
+      uuidNamespaceString = args[argsIndex++];
+    } else if (args[argsIndex] == "NAME") {
       ++argsIndex;
-      if(argsIndex >= args.size())
-        {
+      if (argsIndex >= args.size()) {
         this->SetError("UUID sub-command, NAME requires a value.");
         return false;
-        }
-      uuidName = args[argsIndex++];
       }
-    else if(args[argsIndex] == "TYPE")
-      {
+      uuidName = args[argsIndex++];
+    } else if (args[argsIndex] == "TYPE") {
       ++argsIndex;
-      if(argsIndex >= args.size())
-        {
+      if (argsIndex >= args.size()) {
         this->SetError("UUID sub-command, TYPE requires a value.");
         return false;
-        }
-      uuidType = args[argsIndex++];
       }
-    else if(args[argsIndex] == "UPPER")
-      {
+      uuidType = args[argsIndex++];
+    } else if (args[argsIndex] == "UPPER") {
       ++argsIndex;
       uuidUpperCase = true;
-      }
-    else
-      {
-      std::string e = "UUID sub-command does not recognize option " +
-          args[argsIndex] + ".";
+    } else {
+      std::string e =
+        "UUID sub-command does not recognize option " + args[argsIndex] + ".";
       this->SetError(e);
       return false;
-      }
     }
+  }
 
   std::string uuid;
   cmUuid uuidGenerator;
 
   std::vector<unsigned char> uuidNamespace;
-  if(!uuidGenerator.StringToBinary(uuidNamespaceString, uuidNamespace))
-    {
+  if (!uuidGenerator.StringToBinary(uuidNamespaceString, uuidNamespace)) {
     this->SetError("UUID sub-command, malformed NAMESPACE UUID.");
     return false;
-    }
+  }
 
-  if(uuidType == "MD5")
-    {
+  if (uuidType == "MD5") {
     uuid = uuidGenerator.FromMd5(uuidNamespace, uuidName);
-    }
-  else if(uuidType == "SHA1")
-    {
+  } else if (uuidType == "SHA1") {
     uuid = uuidGenerator.FromSha1(uuidNamespace, uuidName);
-    }
-  else
-    {
+  } else {
     std::string e = "UUID sub-command, unknown TYPE '" + uuidType + "'.";
     this->SetError(e);
     return false;
-    }
+  }
 
-  if(uuid.empty())
-    {
+  if (uuid.empty()) {
     this->SetError("UUID sub-command, generation failed.");
     return false;
-    }
+  }
 
-  if(uuidUpperCase)
-    {
+  if (uuidUpperCase) {
     uuid = cmSystemTools::UpperCase(uuid);
-    }
+  }
 
   this->Makefile->AddDefinition(outputVariable, uuid.c_str());
   return true;
diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h
index 3ed17eb..23d482c 100644
--- a/Source/cmStringCommand.h
+++ b/Source/cmStringCommand.h
@@ -15,9 +15,8 @@
 #include "cmCommand.h"
 
 class cmMakefile;
-namespace cmsys
-{
-  class RegularExpression;
+namespace cmsys {
+class RegularExpression;
 }
 
 /** \class cmStringCommand
@@ -30,17 +29,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmStringCommand;
-    }
+  virtual cmCommand* Clone() { return new cmStringCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -50,9 +46,10 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "string";}
+  virtual std::string GetName() const { return "string"; }
 
   cmTypeMacro(cmStringCommand, cmCommand);
+
 protected:
   bool HandleConfigureCommand(std::vector<std::string> const& args);
   bool HandleAsciiCommand(std::vector<std::string> const& args);
@@ -80,14 +77,25 @@ protected:
   class RegexReplacement
   {
   public:
-    RegexReplacement(const char* s): number(-1), value(s) {}
-    RegexReplacement(const std::string& s): number(-1), value(s) {}
-    RegexReplacement(int n): number(n), value() {}
+    RegexReplacement(const char* s)
+      : number(-1)
+      , value(s)
+    {
+    }
+    RegexReplacement(const std::string& s)
+      : number(-1)
+      , value(s)
+    {
+    }
+    RegexReplacement(int n)
+      : number(n)
+      , value()
+    {
+    }
     RegexReplacement() {}
     int number;
     std::string value;
   };
 };
 
-
 #endif
diff --git a/Source/cmSubdirCommand.cxx b/Source/cmSubdirCommand.cxx
index 6a4a835..401f588 100644
--- a/Source/cmSubdirCommand.cxx
+++ b/Source/cmSubdirCommand.cxx
@@ -12,62 +12,51 @@
 #include "cmSubdirCommand.h"
 
 // cmSubdirCommand
-bool cmSubdirCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmSubdirCommand::InitialPass(std::vector<std::string> const& args,
+                                  cmExecutionStatus&)
 {
-  if(args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   bool res = true;
   bool excludeFromAll = false;
 
-  for(std::vector<std::string>::const_iterator i = args.begin();
-      i != args.end(); ++i)
-    {
-    if(*i == "EXCLUDE_FROM_ALL")
-      {
+  for (std::vector<std::string>::const_iterator i = args.begin();
+       i != args.end(); ++i) {
+    if (*i == "EXCLUDE_FROM_ALL") {
       excludeFromAll = true;
       continue;
-      }
-    if(*i == "PREORDER")
-      {
+    }
+    if (*i == "PREORDER") {
       // Ignored
       continue;
-      }
+    }
 
     // if they specified a relative path then compute the full
     std::string srcPath =
-      std::string(this->Makefile->GetCurrentSourceDirectory()) +
-        "/" + i->c_str();
-    if (cmSystemTools::FileIsDirectory(srcPath))
-      {
+      std::string(this->Makefile->GetCurrentSourceDirectory()) + "/" +
+      i->c_str();
+    if (cmSystemTools::FileIsDirectory(srcPath)) {
       std::string binPath =
-        std::string(this->Makefile->GetCurrentBinaryDirectory()) +
-        "/" + i->c_str();
-      this->Makefile->AddSubDirectory(srcPath, binPath,
-                                  excludeFromAll, false);
-      }
+        std::string(this->Makefile->GetCurrentBinaryDirectory()) + "/" +
+        i->c_str();
+      this->Makefile->AddSubDirectory(srcPath, binPath, excludeFromAll, false);
+    }
     // otherwise it is a full path
-    else if ( cmSystemTools::FileIsDirectory(*i) )
-      {
+    else if (cmSystemTools::FileIsDirectory(*i)) {
       // we must compute the binPath from the srcPath, we just take the last
       // element from the source path and use that
       std::string binPath =
-        std::string(this->Makefile->GetCurrentBinaryDirectory()) +
-        "/" + cmSystemTools::GetFilenameName(*i);
-      this->Makefile->AddSubDirectory(*i, binPath,
-                                  excludeFromAll, false);
-      }
-    else
-      {
+        std::string(this->Makefile->GetCurrentBinaryDirectory()) + "/" +
+        cmSystemTools::GetFilenameName(*i);
+      this->Makefile->AddSubDirectory(*i, binPath, excludeFromAll, false);
+    } else {
       std::string error = "Incorrect SUBDIRS command. Directory: ";
       error += *i + " does not exist.";
       this->SetError(error);
       res = false;
-      }
     }
+  }
   return res;
 }
-
diff --git a/Source/cmSubdirCommand.h b/Source/cmSubdirCommand.h
index bcefd2c..9da91c4 100644
--- a/Source/cmSubdirCommand.h
+++ b/Source/cmSubdirCommand.h
@@ -27,26 +27,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmSubdirCommand;
-    }
+  virtual cmCommand* Clone() { return new cmSubdirCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "subdirs";}
+  virtual std::string GetName() const { return "subdirs"; }
 
   cmTypeMacro(cmSubdirCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmSubdirDependsCommand.cxx b/Source/cmSubdirDependsCommand.cxx
index 9381983..c80fb94 100644
--- a/Source/cmSubdirDependsCommand.cxx
+++ b/Source/cmSubdirDependsCommand.cxx
@@ -11,10 +11,11 @@
 ============================================================================*/
 #include "cmSubdirDependsCommand.h"
 
-bool cmSubdirDependsCommand::InitialPass(std::vector<std::string> const& ,
-                                         cmExecutionStatus &)
+bool cmSubdirDependsCommand::InitialPass(std::vector<std::string> const&,
+                                         cmExecutionStatus&)
 {
-  this->Disallowed(cmPolicies::CMP0029,
+  this->Disallowed(
+    cmPolicies::CMP0029,
     "The subdir_depends command should not be called; see CMP0029.");
   return true;
 }
diff --git a/Source/cmSubdirDependsCommand.h b/Source/cmSubdirDependsCommand.h
index 3f3507e..a15ee3e 100644
--- a/Source/cmSubdirDependsCommand.h
+++ b/Source/cmSubdirDependsCommand.h
@@ -19,8 +19,8 @@ class cmSubdirDependsCommand : public cmCommand
 public:
   virtual cmCommand* Clone() { return new cmSubdirDependsCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const { return "subdir_depends";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "subdir_depends"; }
   cmTypeMacro(cmSubdirDependsCommand, cmCommand);
 };
 
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index 08dda81..bb52441 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -19,7 +19,7 @@
 #include <string.h>
 #include <time.h>
 #ifdef __QNX__
-# include <malloc.h> /* for malloc/free on QNX */
+#include <malloc.h> /* for malloc/free on QNX */
 #endif
 #include <cmsys/Directory.hxx>
 #include <cmsys/Encoding.hxx>
@@ -27,49 +27,49 @@
 #include <cmsys/RegularExpression.hxx>
 #include <cmsys/System.h>
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cmArchiveWrite.h"
-# include "cmLocale.h"
-# include <cm_libarchive.h>
-# ifndef __LA_INT64_T
-#  define __LA_INT64_T la_int64_t
-# endif
+#include "cmArchiveWrite.h"
+#include "cmLocale.h"
+#include <cm_libarchive.h>
+#ifndef __LA_INT64_T
+#define __LA_INT64_T la_int64_t
+#endif
 #endif
 #include <cmsys/FStream.hxx>
 #include <cmsys/Terminal.h>
 
 #if defined(_WIN32)
-# include <windows.h>
-  // include wincrypt.h after windows.h
-# include <wincrypt.h>
+#include <windows.h>
+// include wincrypt.h after windows.h
+#include <wincrypt.h>
 #else
-# include <sys/time.h>
-# include <sys/types.h>
-# include <sys/wait.h>
-# include <unistd.h>
-# include <utime.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <utime.h>
 #endif
 
 #if defined(__APPLE__)
-# include <mach-o/dyld.h>
+#include <mach-o/dyld.h>
 #endif
 
 #include <sys/stat.h>
 
-#if defined(_WIN32) && \
-   (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__MINGW32__))
-# include <io.h>
+#if defined(_WIN32) &&                                                        \
+  (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__MINGW32__))
+#include <io.h>
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cmCryptoHash.h"
+#include "cmCryptoHash.h"
 #endif
 
 #if defined(CMAKE_USE_ELF_PARSER)
-# include "cmELF.h"
+#include "cmELF.h"
 #endif
 
 #if defined(CMAKE_USE_MACH_PARSER)
-# include "cmMachO.h"
+#include "cmMachO.h"
 #endif
 
 static bool cm_isspace(char c)
@@ -91,27 +91,24 @@ public:
 
 #if !defined(HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE)
 // For GetEnvironmentVariables
-# if defined(_WIN32)
-extern __declspec( dllimport ) char** environ;
-# else
+#if defined(_WIN32)
+extern __declspec(dllimport) char** environ;
+#else
 extern char** environ;
-# endif
+#endif
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-static std::string
-cm_archive_entry_pathname(struct archive_entry *entry)
+static std::string cm_archive_entry_pathname(struct archive_entry* entry)
 {
 #if cmsys_STL_HAS_WSTRING
-  return cmsys::Encoding::ToNarrow(
-    archive_entry_pathname_w(entry));
+  return cmsys::Encoding::ToNarrow(archive_entry_pathname_w(entry));
 #else
   return archive_entry_pathname(entry);
 #endif
 }
 
-static int cm_archive_read_open_file(struct archive* a,
-                                     const char* file,
+static int cm_archive_read_open_file(struct archive* a, const char* file,
                                      int block_size)
 {
 #if cmsys_STL_HAS_WSTRING
@@ -127,16 +124,18 @@ static int cm_archive_read_open_file(struct archive* a,
 class cmSystemToolsWindowsHandle
 {
 public:
-  cmSystemToolsWindowsHandle(HANDLE h): handle_(h) {}
+  cmSystemToolsWindowsHandle(HANDLE h)
+    : handle_(h)
+  {
+  }
   ~cmSystemToolsWindowsHandle()
-    {
-    if(this->handle_ != INVALID_HANDLE_VALUE)
-      {
+  {
+    if (this->handle_ != INVALID_HANDLE_VALUE) {
       CloseHandle(this->handle_);
-      }
     }
+  }
   operator bool() const { return this->handle_ != INVALID_HANDLE_VALUE; }
-  bool operator !() const { return this->handle_ == INVALID_HANDLE_VALUE; }
+  bool operator!() const { return this->handle_ == INVALID_HANDLE_VALUE; }
   operator HANDLE() const { return this->handle_; }
 private:
   HANDLE handle_;
@@ -176,39 +175,33 @@ void cmSystemTools::ExpandRegistryValues(std::string& source, KeyWOW64 view)
   cmsys::RegularExpression regEntry("\\[(HKEY[^]]*)\\]");
 
   // check for black line or comment
-  while (regEntry.find(source))
-    {
+  while (regEntry.find(source)) {
     // the arguments are the second match
     std::string key = regEntry.match(1);
     std::string val;
-    if (ReadRegistryValue(key.c_str(), val, view))
-      {
+    if (ReadRegistryValue(key.c_str(), val, view)) {
       std::string reg = "[";
       reg += key + "]";
       cmSystemTools::ReplaceString(source, reg.c_str(), val.c_str());
-      }
-    else
-      {
+    } else {
       std::string reg = "[";
       reg += key + "]";
       cmSystemTools::ReplaceString(source, reg.c_str(), "/registry");
-      }
     }
+  }
 }
 #else
 void cmSystemTools::ExpandRegistryValues(std::string& source, KeyWOW64)
 {
   cmsys::RegularExpression regEntry("\\[(HKEY[^]]*)\\]");
-  while (regEntry.find(source))
-    {
+  while (regEntry.find(source)) {
     // the arguments are the second match
     std::string key = regEntry.match(1);
     std::string val;
     std::string reg = "[";
     reg += key + "]";
     cmSystemTools::ReplaceString(source, reg.c_str(), "/registry");
-    }
-
+  }
 }
 #endif
 
@@ -216,14 +209,12 @@ std::string cmSystemTools::EscapeQuotes(const std::string& str)
 {
   std::string result;
   result.reserve(str.size());
-  for(const char* ch = str.c_str(); *ch != '\0'; ++ch)
-    {
-    if(*ch == '"')
-      {
+  for (const char* ch = str.c_str(); *ch != '\0'; ++ch) {
+    if (*ch == '"') {
       result += '\\';
-      }
-    result += *ch;
     }
+    result += *ch;
+  }
   return result;
 }
 
@@ -242,34 +233,30 @@ std::string cmSystemTools::TrimWhitespace(const std::string& s)
   if (start == s.end())
     return "";
 
-  std::string::const_iterator stop = s.end()-1;
+  std::string::const_iterator stop = s.end() - 1;
   while (cm_isspace(*stop))
     --stop;
-  return std::string(start, stop+1);
+  return std::string(start, stop + 1);
 }
 
-void cmSystemTools::Error(const char* m1, const char* m2,
-                          const char* m3, const char* m4)
+void cmSystemTools::Error(const char* m1, const char* m2, const char* m3,
+                          const char* m4)
 {
   std::string message = "CMake Error: ";
-  if(m1)
-    {
+  if (m1) {
     message += m1;
-    }
-  if(m2)
-    {
+  }
+  if (m2) {
     message += m2;
-    }
-  if(m3)
-    {
+  }
+  if (m3) {
     message += m3;
-    }
-  if(m4)
-    {
+  }
+  if (m4) {
     message += m4;
-    }
+  }
   cmSystemTools::s_ErrorOccured = true;
-  cmSystemTools::Message(message.c_str(),"Error");
+  cmSystemTools::Message(message.c_str(), "Error");
 }
 
 void cmSystemTools::SetInterruptCallback(InterruptCallback f, void* clientData)
@@ -280,10 +267,9 @@ void cmSystemTools::SetInterruptCallback(InterruptCallback f, void* clientData)
 
 bool cmSystemTools::GetInterruptFlag()
 {
-  if(s_InterruptCallback)
-    {
+  if (s_InterruptCallback) {
     return (*s_InterruptCallback)(s_InterruptCallbackClientData);
-    }
+  }
   return false;
 }
 
@@ -317,50 +303,38 @@ void cmSystemTools::Stderr(const char* s)
 
 void cmSystemTools::Stderr(const char* s, size_t length)
 {
-  if(s_StderrCallback)
-    {
+  if (s_StderrCallback) {
     (*s_StderrCallback)(s, length, s_StderrCallbackClientData);
-    }
-  else
-    {
+  } else {
     std::cerr.write(s, length);
     std::cerr.flush();
-    }
+  }
 }
 
 void cmSystemTools::Stdout(const char* s, size_t length)
 {
-  if(s_StdoutCallback)
-    {
+  if (s_StdoutCallback) {
     (*s_StdoutCallback)(s, length, s_StdoutCallbackClientData);
-    }
-  else
-    {
+  } else {
     std::cout.write(s, length);
     std::cout.flush();
-    }
+  }
 }
 
-void cmSystemTools::Message(const char* m1, const char *title)
+void cmSystemTools::Message(const char* m1, const char* title)
 {
-  if(s_DisableMessages)
-    {
+  if (s_DisableMessages) {
     return;
-    }
-  if(s_MessageCallback)
-    {
+  }
+  if (s_MessageCallback) {
     (*s_MessageCallback)(m1, title, s_DisableMessages,
                          s_MessageCallbackClientData);
     return;
-    }
-  else
-    {
+  } else {
     std::cerr << m1 << std::endl << std::flush;
-    }
-
+  }
 }
 
-
 void cmSystemTools::ReportLastSystemError(const char* msg)
 {
   std::string m = msg;
@@ -371,94 +345,78 @@ void cmSystemTools::ReportLastSystemError(const char* msg)
 
 bool cmSystemTools::IsInternallyOn(const char* val)
 {
-  if (!val)
-    {
+  if (!val) {
     return false;
-    }
+  }
   std::basic_string<char> v = val;
-  if (v.size() > 4)
-    {
+  if (v.size() > 4) {
     return false;
-    }
+  }
 
-  for(std::basic_string<char>::iterator c = v.begin();
-      c != v.end(); c++)
-    {
+  for (std::basic_string<char>::iterator c = v.begin(); c != v.end(); c++) {
     *c = static_cast<char>(toupper(*c));
-    }
+  }
   return v == "I_ON";
 }
 
 bool cmSystemTools::IsOn(const char* val)
 {
-  if (!val)
-    {
+  if (!val) {
     return false;
-    }
+  }
   size_t len = strlen(val);
-  if (len > 4)
-    {
+  if (len > 4) {
     return false;
-    }
+  }
   std::basic_string<char> v(val, len);
 
   static std::set<std::string> onValues;
-  if(onValues.empty())
-    {
+  if (onValues.empty()) {
     onValues.insert("ON");
     onValues.insert("1");
     onValues.insert("YES");
     onValues.insert("TRUE");
     onValues.insert("Y");
-    }
-  for(std::basic_string<char>::iterator c = v.begin();
-      c != v.end(); c++)
-    {
+  }
+  for (std::basic_string<char>::iterator c = v.begin(); c != v.end(); c++) {
     *c = static_cast<char>(toupper(*c));
-    }
+  }
   return (onValues.count(v) > 0);
 }
 
 bool cmSystemTools::IsNOTFOUND(const char* val)
 {
-  if(strcmp(val, "NOTFOUND") == 0)
-    {
+  if (strcmp(val, "NOTFOUND") == 0) {
     return true;
-    }
+  }
   return cmHasLiteralSuffix(val, "-NOTFOUND");
 }
 
-
 bool cmSystemTools::IsOff(const char* val)
 {
-  if (!val || !*val)
-    {
+  if (!val || !*val) {
     return true;
-    }
+  }
   size_t len = strlen(val);
   // Try and avoid toupper() for large strings.
-  if (len > 6)
-    {
+  if (len > 6) {
     return cmSystemTools::IsNOTFOUND(val);
-    }
+  }
 
   static std::set<std::string> offValues;
-  if(offValues.empty())
-    {
+  if (offValues.empty()) {
     offValues.insert("OFF");
     offValues.insert("0");
     offValues.insert("NO");
     offValues.insert("FALSE");
     offValues.insert("N");
     offValues.insert("IGNORE");
-    }
+  }
   // Try and avoid toupper().
   std::basic_string<char> v(val, len);
-  for(std::basic_string<char>::iterator c = v.begin();
-      c != v.end(); c++)
-    {
+  for (std::basic_string<char>::iterator c = v.begin(); c != v.end(); c++) {
     *c = static_cast<char>(toupper(*c));
-    }
+  }
   return (offValues.count(v) > 0);
 }
 
@@ -473,84 +431,70 @@ void cmSystemTools::ParseWindowsCommandLine(const char* command,
   bool in_quotes = false;
   int backslashes = 0;
   std::string arg;
-  for(const char* c = command;*c; ++c)
-    {
-    if(*c == '\\')
-      {
+  for (const char* c = command; *c; ++c) {
+    if (*c == '\\') {
       ++backslashes;
       in_argument = true;
-      }
-    else if(*c == '"')
-      {
-      int backslash_pairs  = backslashes >> 1;
+    } else if (*c == '"') {
+      int backslash_pairs = backslashes >> 1;
       int backslash_escaped = backslashes & 1;
       arg.append(backslash_pairs, '\\');
       backslashes = 0;
-      if(backslash_escaped)
-        {
+      if (backslash_escaped) {
         /* An odd number of backslashes precede this quote.
            It is escaped.  */
         arg.append(1, '"');
-        }
-      else
-        {
+      } else {
         /* An even number of backslashes precede this quote.
            It is not escaped.  */
         in_quotes = !in_quotes;
-        }
-      in_argument = true;
       }
-    else
-      {
+      in_argument = true;
+    } else {
       arg.append(backslashes, '\\');
       backslashes = 0;
-      if (cm_isspace(*c))
-        {
-        if(in_quotes)
-          {
+      if (cm_isspace(*c)) {
+        if (in_quotes) {
           arg.append(1, *c);
-          }
-        else if(in_argument)
-          {
+        } else if (in_argument) {
           args.push_back(arg);
           arg = "";
           in_argument = false;
-          }
         }
-      else
-        {
+      } else {
         in_argument = true;
         arg.append(1, *c);
-        }
       }
     }
+  }
   arg.append(backslashes, '\\');
-  if(in_argument)
-    {
+  if (in_argument) {
     args.push_back(arg);
-    }
+  }
 }
 
 class cmSystemToolsArgV
 {
   char** ArgV;
+
 public:
-  cmSystemToolsArgV(char** argv): ArgV(argv) {}
+  cmSystemToolsArgV(char** argv)
+    : ArgV(argv)
+  {
+  }
   ~cmSystemToolsArgV()
-    {
-    for(char** arg = this->ArgV; arg && *arg; ++arg)
-      {
+  {
+    for (char** arg = this->ArgV; arg && *arg; ++arg) {
       free(*arg);
-      }
-    free(this->ArgV);
     }
+    free(this->ArgV);
+  }
   void Store(std::vector<std::string>& args) const
-    {
-    for(char** arg = this->ArgV; arg && *arg; ++arg)
-      {
+  {
+    for (char** arg = this->ArgV; arg && *arg; ++arg) {
       args.push_back(*arg);
-      }
     }
+  }
 };
 
 void cmSystemTools::ParseUnixCommandLine(const char* command,
@@ -569,117 +513,93 @@ std::vector<std::string> cmSystemTools::ParseArguments(const char* command)
   bool win_path = false;
 
   if ((command[0] != '/' && command[1] == ':' && command[2] == '\\') ||
-      (command[0] == '\"' && command[1] != '/' && command[2] == ':'
-       && command[3] == '\\') ||
-      (command[0] == '\'' && command[1] != '/' && command[2] == ':'
-       && command[3] == '\\') ||
-      (command[0] == '\\' && command[1] == '\\'))
-    {
+      (command[0] == '\"' && command[1] != '/' && command[2] == ':' &&
+       command[3] == '\\') ||
+      (command[0] == '\'' && command[1] != '/' && command[2] == ':' &&
+       command[3] == '\\') ||
+      (command[0] == '\\' && command[1] == '\\')) {
     win_path = true;
-    }
+  }
   // Split the command into an argv array.
-  for(const char* c = command; *c;)
-    {
+  for (const char* c = command; *c;) {
     // Skip over whitespace.
-    while(*c == ' ' || *c == '\t')
-      {
+    while (*c == ' ' || *c == '\t') {
       ++c;
-      }
+    }
     arg = "";
-    if(*c == '"')
-      {
+    if (*c == '"') {
       // Parse a quoted argument.
       ++c;
-      while(*c && *c != '"')
-        {
+      while (*c && *c != '"') {
         arg.append(1, *c);
         ++c;
-        }
-      if(*c)
-        {
+      }
+      if (*c) {
         ++c;
-        }
-      args.push_back(arg);
       }
-    else if(*c == '\'')
-      {
+      args.push_back(arg);
+    } else if (*c == '\'') {
       // Parse a quoted argument.
       ++c;
-      while(*c && *c != '\'')
-        {
+      while (*c && *c != '\'') {
         arg.append(1, *c);
         ++c;
-        }
-      if(*c)
-        {
+      }
+      if (*c) {
         ++c;
-        }
-      args.push_back(arg);
       }
-    else if(*c)
-      {
+      args.push_back(arg);
+    } else if (*c) {
       // Parse an unquoted argument.
-      while(*c && *c != ' ' && *c != '\t')
-        {
-        if(*c == '\\' && !win_path)
-          {
+      while (*c && *c != ' ' && *c != '\t') {
+        if (*c == '\\' && !win_path) {
           ++c;
-          if(*c)
-            {
+          if (*c) {
             arg.append(1, *c);
             ++c;
-            }
           }
-        else
-          {
+        } else {
           arg.append(1, *c);
           ++c;
-          }
         }
-      args.push_back(arg);
       }
+      args.push_back(arg);
     }
+  }
 
   return args;
 }
 
-
-bool cmSystemTools::RunSingleCommand(std::vector<std::string>const& command,
+bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command,
                                      std::string* captureStdOut,
-                                     std::string* captureStdErr,
-                                     int* retVal , const char* dir ,
-                                     OutputOption outputflag ,
-                                     double timeout )
+                                     std::string* captureStdErr, int* retVal,
+                                     const char* dir, OutputOption outputflag,
+                                     double timeout)
 {
   std::vector<const char*> argv;
-  for(std::vector<std::string>::const_iterator a = command.begin();
-      a != command.end(); ++a)
-    {
+  for (std::vector<std::string>::const_iterator a = command.begin();
+       a != command.end(); ++a) {
     argv.push_back(a->c_str());
-    }
+  }
   argv.push_back(0);
 
   cmsysProcess* cp = cmsysProcess_New();
   cmsysProcess_SetCommand(cp, &*argv.begin());
   cmsysProcess_SetWorkingDirectory(cp, dir);
-  if(cmSystemTools::GetRunCommandHideConsole())
-    {
+  if (cmSystemTools::GetRunCommandHideConsole()) {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
-    }
+  }
 
-  if (outputflag == OUTPUT_PASSTHROUGH)
-    {
+  if (outputflag == OUTPUT_PASSTHROUGH) {
     cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDOUT, 1);
     cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDERR, 1);
     captureStdOut = 0;
     captureStdErr = 0;
-    }
-  else if (outputflag == OUTPUT_MERGE ||
-           (captureStdErr && captureStdErr == captureStdOut))
-    {
+  } else if (outputflag == OUTPUT_MERGE ||
+             (captureStdErr && captureStdErr == captureStdOut)) {
     cmsysProcess_SetOption(cp, cmsysProcess_Option_MergeOutput, 1);
     captureStdErr = 0;
-    }
+  }
   assert(!captureStdErr || captureStdErr != captureStdOut);
 
   cmsysProcess_SetTimeout(cp, timeout);
@@ -690,193 +610,152 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string>const& command,
   char* data;
   int length;
   int pipe;
-  if(outputflag != OUTPUT_PASSTHROUGH &&
-     (captureStdOut || captureStdErr || outputflag != OUTPUT_NONE))
-    {
-    while((pipe = cmsysProcess_WaitForData(cp, &data, &length, 0)) > 0)
-      {
+  if (outputflag != OUTPUT_PASSTHROUGH &&
+      (captureStdOut || captureStdErr || outputflag != OUTPUT_NONE)) {
+    while ((pipe = cmsysProcess_WaitForData(cp, &data, &length, 0)) > 0) {
       // Translate NULL characters in the output into valid text.
       // Visual Studio 7 puts these characters in the output of its
       // build process.
-      for(int i=0; i < length; ++i)
-        {
-        if(data[i] == '\0')
-          {
+      for (int i = 0; i < length; ++i) {
+        if (data[i] == '\0') {
           data[i] = ' ';
-          }
         }
+      }
 
-      if (pipe == cmsysProcess_Pipe_STDOUT)
-        {
-        if (outputflag != OUTPUT_NONE)
-          {
+      if (pipe == cmsysProcess_Pipe_STDOUT) {
+        if (outputflag != OUTPUT_NONE) {
           cmSystemTools::Stdout(data, length);
-          }
-        if (captureStdOut)
-          {
-          tempStdOut.insert(tempStdOut.end(), data, data+length);
-          }
         }
-      else if (pipe == cmsysProcess_Pipe_STDERR)
-        {
-        if (outputflag != OUTPUT_NONE)
-          {
+        if (captureStdOut) {
+          tempStdOut.insert(tempStdOut.end(), data, data + length);
+        }
+      } else if (pipe == cmsysProcess_Pipe_STDERR) {
+        if (outputflag != OUTPUT_NONE) {
           cmSystemTools::Stderr(data, length);
-          }
-        if (captureStdErr)
-          {
-          tempStdErr.insert(tempStdErr.end(), data, data+length);
-          }
+        }
+        if (captureStdErr) {
+          tempStdErr.insert(tempStdErr.end(), data, data + length);
         }
       }
     }
+  }
 
   cmsysProcess_WaitForExit(cp, 0);
-  if (captureStdOut)
-    {
+  if (captureStdOut) {
     captureStdOut->assign(tempStdOut.begin(), tempStdOut.end());
-    }
-  if (captureStdErr)
-    {
+  }
+  if (captureStdErr) {
     captureStdErr->assign(tempStdErr.begin(), tempStdErr.end());
-    }
+  }
 
   bool result = true;
-  if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exited)
-    {
-    if ( retVal )
-      {
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
+    if (retVal) {
       *retVal = cmsysProcess_GetExitValue(cp);
-      }
-    else
-      {
-      if ( cmsysProcess_GetExitValue(cp) !=  0 )
-        {
+    } else {
+      if (cmsysProcess_GetExitValue(cp) != 0) {
         result = false;
-        }
       }
     }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exception)
-    {
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exception) {
     const char* exception_str = cmsysProcess_GetExceptionString(cp);
-    if ( outputflag != OUTPUT_NONE )
-      {
+    if (outputflag != OUTPUT_NONE) {
       std::cerr << exception_str << std::endl;
-      }
-    if ( captureStdErr )
-      {
+    }
+    if (captureStdErr) {
       captureStdErr->append(exception_str, strlen(exception_str));
-      }
-    result = false;
     }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Error)
-    {
+    result = false;
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
     const char* error_str = cmsysProcess_GetErrorString(cp);
-    if ( outputflag != OUTPUT_NONE )
-      {
+    if (outputflag != OUTPUT_NONE) {
       std::cerr << error_str << std::endl;
-      }
-    if ( captureStdErr )
-      {
+    }
+    if (captureStdErr) {
       captureStdErr->append(error_str, strlen(error_str));
-      }
-    result = false;
     }
-  else if(cmsysProcess_GetState(cp) == cmsysProcess_State_Expired)
-    {
+    result = false;
+  } else if (cmsysProcess_GetState(cp) == cmsysProcess_State_Expired) {
     const char* error_str = "Process terminated due to timeout\n";
-    if ( outputflag != OUTPUT_NONE )
-      {
+    if (outputflag != OUTPUT_NONE) {
       std::cerr << error_str << std::endl;
-      }
-    if ( captureStdErr )
-      {
+    }
+    if (captureStdErr) {
       captureStdErr->append(error_str, strlen(error_str));
-      }
-    result = false;
     }
+    result = false;
+  }
 
   cmsysProcess_Delete(cp);
   return result;
 }
 
-bool cmSystemTools::RunSingleCommand(
-  const char* command,
-  std::string* captureStdOut,
-  std::string* captureStdErr,
-  int *retVal,
-  const char* dir,
-  OutputOption outputflag,
-  double timeout)
+bool cmSystemTools::RunSingleCommand(const char* command,
+                                     std::string* captureStdOut,
+                                     std::string* captureStdErr, int* retVal,
+                                     const char* dir, OutputOption outputflag,
+                                     double timeout)
 {
-  if(s_DisableRunCommandOutput)
-    {
+  if (s_DisableRunCommandOutput) {
     outputflag = OUTPUT_NONE;
-    }
+  }
 
   std::vector<std::string> args = cmSystemTools::ParseArguments(command);
 
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     return false;
-    }
+  }
   return cmSystemTools::RunSingleCommand(args, captureStdOut, captureStdErr,
                                          retVal, dir, outputflag, timeout);
 }
 
-std::string
-cmSystemTools::PrintSingleCommand(std::vector<std::string> const& command)
+std::string cmSystemTools::PrintSingleCommand(
+  std::vector<std::string> const& command)
 {
-  if (command.empty())
-    {
+  if (command.empty()) {
     return std::string();
-    }
+  }
 
   return cmWrap('"', command, '"', " ");
 }
 
 bool cmSystemTools::DoesFileExistWithExtensions(
-  const char* name,
-  const std::vector<std::string>& headerExts)
+  const char* name, const std::vector<std::string>& headerExts)
 {
   std::string hname;
 
-  for( std::vector<std::string>::const_iterator ext = headerExts.begin();
-       ext != headerExts.end(); ++ext )
-    {
+  for (std::vector<std::string>::const_iterator ext = headerExts.begin();
+       ext != headerExts.end(); ++ext) {
     hname = name;
     hname += ".";
     hname += *ext;
-    if(cmSystemTools::FileExists(hname.c_str()))
-      {
+    if (cmSystemTools::FileExists(hname.c_str())) {
       return true;
-      }
     }
+  }
   return false;
 }
 
 std::string cmSystemTools::FileExistsInParentDirectories(const char* fname,
-  const char* directory, const char* toplevel)
+                                                         const char* directory,
+                                                         const char* toplevel)
 {
   std::string file = fname;
   cmSystemTools::ConvertToUnixSlashes(file);
   std::string dir = directory;
   cmSystemTools::ConvertToUnixSlashes(dir);
   std::string prevDir;
-  while(dir != prevDir)
-    {
+  while (dir != prevDir) {
     std::string path = dir + "/" + file;
-    if ( cmSystemTools::FileExists(path.c_str()) )
-      {
+    if (cmSystemTools::FileExists(path.c_str())) {
       return path;
-      }
-    if ( dir.size() < strlen(toplevel) )
-      {
+    }
+    if (dir.size() < strlen(toplevel)) {
       break;
-      }
+    }
     prevDir = dir;
     dir = cmSystemTools::GetParentDirectory(dir);
-    }
+  }
   return "";
 }
 
@@ -886,7 +765,7 @@ bool cmSystemTools::cmCopyFile(const char* source, const char* destination)
 }
 
 bool cmSystemTools::CopyFileIfDifferent(const char* source,
-  const char* destination)
+                                        const char* destination)
 {
   return Superclass::CopyFileIfDifferent(source, destination);
 }
@@ -894,36 +773,31 @@ bool cmSystemTools::CopyFileIfDifferent(const char* source,
 #ifdef _WIN32
 cmSystemTools::WindowsFileRetry cmSystemTools::GetWindowsFileRetry()
 {
-  static WindowsFileRetry retry = {0,0};
-  if(!retry.Count)
-    {
-    unsigned int data[2] = {0,0};
-    HKEY const keys[2] = {HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE};
-    wchar_t const* const values[2] = {L"FilesystemRetryCount",
-                                      L"FilesystemRetryDelay"};
-    for(int k=0; k < 2; ++k)
-      {
+  static WindowsFileRetry retry = { 0, 0 };
+  if (!retry.Count) {
+    unsigned int data[2] = { 0, 0 };
+    HKEY const keys[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
+    wchar_t const* const values[2] = { L"FilesystemRetryCount",
+                                       L"FilesystemRetryDelay" };
+    for (int k = 0; k < 2; ++k) {
       HKEY hKey;
-      if(RegOpenKeyExW(keys[k], L"Software\\Kitware\\CMake\\Config",
-                       0, KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS)
-        {
-        for(int v=0; v < 2; ++v)
-          {
+      if (RegOpenKeyExW(keys[k], L"Software\\Kitware\\CMake\\Config", 0,
+                        KEY_QUERY_VALUE, &hKey) == ERROR_SUCCESS) {
+        for (int v = 0; v < 2; ++v) {
           DWORD dwData, dwType, dwSize = 4;
-          if(!data[v] &&
-             RegQueryValueExW(hKey, values[v], 0, &dwType, (BYTE *)&dwData,
-                              &dwSize) == ERROR_SUCCESS &&
-             dwType == REG_DWORD && dwSize == 4)
-            {
+          if (!data[v] &&
+              RegQueryValueExW(hKey, values[v], 0, &dwType, (BYTE*)&dwData,
+                               &dwSize) == ERROR_SUCCESS &&
+              dwType == REG_DWORD && dwSize == 4) {
             data[v] = static_cast<unsigned int>(dwData);
-            }
           }
-        RegCloseKey(hKey);
         }
+        RegCloseKey(hKey);
       }
-    retry.Count = data[0]? data[0] : 5;
-    retry.Delay = data[1]? data[1] : 500;
     }
+    retry.Count = data[0] ? data[0] : 5;
+    retry.Delay = data[1] ? data[1] : 500;
+  }
   return retry;
 }
 #endif
@@ -931,43 +805,38 @@ cmSystemTools::WindowsFileRetry cmSystemTools::GetWindowsFileRetry()
 bool cmSystemTools::RenameFile(const char* oldname, const char* newname)
 {
 #ifdef _WIN32
-# ifndef INVALID_FILE_ATTRIBUTES
-#  define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
-# endif
+#ifndef INVALID_FILE_ATTRIBUTES
+#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+#endif
   /* Windows MoveFileEx may not replace read-only or in-use files.  If it
      fails then remove the read-only attribute from any existing destination.
      Try multiple times since we may be racing against another process
      creating/opening the destination file just before our MoveFileEx.  */
   WindowsFileRetry retry = cmSystemTools::GetWindowsFileRetry();
-  while(!MoveFileExW(
-      SystemTools::ConvertToWindowsExtendedPath(oldname).c_str(),
-      SystemTools::ConvertToWindowsExtendedPath(newname).c_str(),
-                     MOVEFILE_REPLACE_EXISTING) && --retry.Count)
-    {
+  while (
+    !MoveFileExW(SystemTools::ConvertToWindowsExtendedPath(oldname).c_str(),
+                 SystemTools::ConvertToWindowsExtendedPath(newname).c_str(),
+                 MOVEFILE_REPLACE_EXISTING) &&
+    --retry.Count) {
     DWORD last_error = GetLastError();
     // Try again only if failure was due to access/sharing permissions.
-    if(last_error != ERROR_ACCESS_DENIED &&
-       last_error != ERROR_SHARING_VIOLATION)
-      {
+    if (last_error != ERROR_ACCESS_DENIED &&
+        last_error != ERROR_SHARING_VIOLATION) {
       return false;
-      }
-    DWORD attrs =
-      GetFileAttributesW(
-        SystemTools::ConvertToWindowsExtendedPath(newname).c_str());
-    if((attrs != INVALID_FILE_ATTRIBUTES) &&
-       (attrs & FILE_ATTRIBUTE_READONLY))
-      {
+    }
+    DWORD attrs = GetFileAttributesW(
+      SystemTools::ConvertToWindowsExtendedPath(newname).c_str());
+    if ((attrs != INVALID_FILE_ATTRIBUTES) &&
+        (attrs & FILE_ATTRIBUTE_READONLY)) {
       // Remove the read-only attribute from the destination file.
       SetFileAttributesW(
         SystemTools::ConvertToWindowsExtendedPath(newname).c_str(),
-                         attrs & ~FILE_ATTRIBUTE_READONLY);
-      }
-    else
-      {
+        attrs & ~FILE_ATTRIBUTE_READONLY);
+    } else {
       // The file may be temporarily in use so wait a bit.
       cmSystemTools::Delay(retry.Delay);
-      }
     }
+  }
   return retry.Count > 0;
 #else
   /* On UNIX we have an OS-provided call to do this atomically.  */
@@ -985,7 +854,8 @@ bool cmSystemTools::ComputeFileMD5(const std::string& source, char* md5out)
 #else
   (void)source;
   (void)md5out;
-  cmSystemTools::Message("md5sum not supported in bootstrapping mode","Error");
+  cmSystemTools::Message("md5sum not supported in bootstrapping mode",
+                         "Error");
   return false;
 #endif
 }
@@ -997,7 +867,8 @@ std::string cmSystemTools::ComputeStringMD5(const std::string& input)
   return md5.HashString(input);
 #else
   (void)input;
-  cmSystemTools::Message("md5sum not supported in bootstrapping mode","Error");
+  cmSystemTools::Message("md5sum not supported in bootstrapping mode",
+                         "Error");
   return "";
 #endif
 }
@@ -1013,42 +884,29 @@ std::string cmSystemTools::ComputeCertificateThumbprint(
   HCERTSTORE certStore = NULL;
   PCCERT_CONTEXT certContext = NULL;
 
-  HANDLE certFile =
-    CreateFileW(cmsys::Encoding::ToWide(source.c_str()).c_str(),
-                GENERIC_READ,
-                FILE_SHARE_READ,
-                NULL,
-                OPEN_EXISTING,
-                FILE_ATTRIBUTE_NORMAL,
-                NULL);
-
-  if (certFile != INVALID_HANDLE_VALUE && certFile != NULL)
-    {
+  HANDLE certFile = CreateFileW(
+    cmsys::Encoding::ToWide(source.c_str()).c_str(), GENERIC_READ,
+    FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+  if (certFile != INVALID_HANDLE_VALUE && certFile != NULL) {
     DWORD fileSize = GetFileSize(certFile, NULL);
-    if (fileSize != INVALID_FILE_SIZE)
-      {
+    if (fileSize != INVALID_FILE_SIZE) {
       certData = new BYTE[fileSize];
-      if (certData != NULL)
-        {
+      if (certData != NULL) {
         DWORD dwRead = 0;
-        if (ReadFile(certFile, certData, fileSize, &dwRead, NULL))
-          {
+        if (ReadFile(certFile, certData, fileSize, &dwRead, NULL)) {
           cryptBlob.cbData = fileSize;
           cryptBlob.pbData = certData;
 
           // Verify that this is a valid cert
-          if (PFXIsPFXBlob(&cryptBlob))
-            {
+          if (PFXIsPFXBlob(&cryptBlob)) {
             // Open the certificate as a store
-            certStore = PFXImportCertStore(
-              &cryptBlob, NULL, CRYPT_EXPORTABLE);
-            if (certStore != NULL)
-              {
+            certStore = PFXImportCertStore(&cryptBlob, NULL, CRYPT_EXPORTABLE);
+            if (certStore != NULL) {
               // There should only be 1 cert.
-              certContext = CertEnumCertificatesInStore(certStore,
-                certContext);
-              if (certContext != NULL)
-                {
+              certContext =
+                CertEnumCertificatesInStore(certStore, certContext);
+              if (certContext != NULL) {
                 // The hash is 20 bytes
                 BYTE hashData[20];
                 DWORD hashLength = 20;
@@ -1056,35 +914,33 @@ std::string cmSystemTools::ComputeCertificateThumbprint(
                 // Buffer to print the hash. Each byte takes 2 chars +
                 // terminating character
                 char hashPrint[41];
-                char *pHashPrint = hashPrint;
+                char* pHashPrint = hashPrint;
                 // Get the hash property from the certificate
-                if (CertGetCertificateContextProperty(certContext,
-                  CERT_HASH_PROP_ID, hashData, &hashLength))
-                  {
-                  for (DWORD i = 0; i < hashLength; i++)
-                    {
+                if (CertGetCertificateContextProperty(
+                      certContext, CERT_HASH_PROP_ID, hashData, &hashLength)) {
+                  for (DWORD i = 0; i < hashLength; i++) {
                     // Convert each byte to hexadecimal
                     sprintf(pHashPrint, "%02X", hashData[i]);
                     pHashPrint += 2;
-                    }
+                  }
                   *pHashPrint = '\0';
                   thumbprint = hashPrint;
-                  }
-                CertFreeCertificateContext(certContext);
                 }
-              CertCloseStore(certStore, 0);
+                CertFreeCertificateContext(certContext);
               }
+              CertCloseStore(certStore, 0);
             }
           }
-        delete[] certData;
         }
+        delete[] certData;
       }
-    CloseHandle(certFile);
     }
+    CloseHandle(certFile);
+  }
 #else
   (void)source;
   cmSystemTools::Message("ComputeCertificateThumbprint is not implemented",
-    "Error");
+                         "Error");
 #endif
 
   return thumbprint;
@@ -1097,65 +953,54 @@ void cmSystemTools::Glob(const std::string& directory,
   cmsys::Directory d;
   cmsys::RegularExpression reg(regexp.c_str());
 
-  if (d.Load(directory))
-    {
+  if (d.Load(directory)) {
     size_t numf;
-        unsigned int i;
+    unsigned int i;
     numf = d.GetNumberOfFiles();
-    for (i = 0; i < numf; i++)
-      {
+    for (i = 0; i < numf; i++) {
       std::string fname = d.GetFile(i);
-      if (reg.find(fname))
-        {
+      if (reg.find(fname)) {
         files.push_back(fname);
-        }
       }
     }
+  }
 }
 
-
 void cmSystemTools::GlobDirs(const std::string& path,
                              std::vector<std::string>& files)
 {
   std::string::size_type pos = path.find("/*");
-  if(pos == std::string::npos)
-    {
+  if (pos == std::string::npos) {
     files.push_back(path);
     return;
-    }
+  }
   std::string startPath = path.substr(0, pos);
-  std::string finishPath = path.substr(pos+2);
+  std::string finishPath = path.substr(pos + 2);
 
   cmsys::Directory d;
-  if (d.Load(startPath))
-    {
-    for (unsigned int i = 0; i < d.GetNumberOfFiles(); ++i)
-      {
-      if((std::string(d.GetFile(i)) != ".")
-         && (std::string(d.GetFile(i)) != ".."))
-        {
+  if (d.Load(startPath)) {
+    for (unsigned int i = 0; i < d.GetNumberOfFiles(); ++i) {
+      if ((std::string(d.GetFile(i)) != ".") &&
+          (std::string(d.GetFile(i)) != "..")) {
         std::string fname = startPath;
-        fname +="/";
+        fname += "/";
         fname += d.GetFile(i);
-        if(cmSystemTools::FileIsDirectory(fname))
-          {
+        if (cmSystemTools::FileIsDirectory(fname)) {
           fname += finishPath;
           cmSystemTools::GlobDirs(fname, files);
-          }
         }
       }
     }
+  }
 }
 
-
 void cmSystemTools::ExpandList(std::vector<std::string> const& arguments,
                                std::vector<std::string>& newargs)
 {
   std::vector<std::string>::const_iterator i;
-  for(i = arguments.begin();i != arguments.end(); ++i)
-    {
+  for (i = arguments.begin(); i != arguments.end(); ++i) {
     cmSystemTools::ExpandListArgument(*i, newargs);
-    }
+  }
 }
 
 void cmSystemTools::ExpandListArgument(const std::string& arg,
@@ -1163,73 +1008,60 @@ void cmSystemTools::ExpandListArgument(const std::string& arg,
                                        bool emptyArgs)
 {
   // If argument is empty, it is an empty list.
-  if(!emptyArgs && arg.empty())
-    {
+  if (!emptyArgs && arg.empty()) {
     return;
-    }
+  }
   // if there are no ; in the name then just copy the current string
-  if(arg.find(';') == std::string::npos)
-    {
+  if (arg.find(';') == std::string::npos) {
     newargs.push_back(arg);
     return;
-    }
+  }
   std::string newArg;
-  const char *last = arg.c_str();
+  const char* last = arg.c_str();
   // Break the string at non-escaped semicolons not nested in [].
   int squareNesting = 0;
-  for(const char* c = last; *c; ++c)
-    {
-    switch(*c)
-      {
-      case '\\':
-        {
+  for (const char* c = last; *c; ++c) {
+    switch (*c) {
+      case '\\': {
         // We only want to allow escaping of semicolons.  Other
         // escapes should not be processed here.
         const char* next = c + 1;
-        if(*next == ';')
-          {
+        if (*next == ';') {
           newArg.append(last, c - last);
           // Skip over the escape character
           last = c = next;
-          }
-        } break;
-      case '[':
-        {
+        }
+      } break;
+      case '[': {
         ++squareNesting;
-        } break;
-      case ']':
-        {
+      } break;
+      case ']': {
         --squareNesting;
-        } break;
-      case ';':
-        {
+      } break;
+      case ';': {
         // Break the string here if we are not nested inside square
         // brackets.
-        if(squareNesting == 0)
-          {
+        if (squareNesting == 0) {
           newArg.append(last, c - last);
           // Skip over the semicolon
           last = c + 1;
-          if ( !newArg.empty() || emptyArgs )
-            {
+          if (!newArg.empty() || emptyArgs) {
             // Add the last argument if the string is not empty.
             newargs.push_back(newArg);
             newArg = "";
-            }
           }
-        } break;
-      default:
-        {
+        }
+      } break;
+      default: {
         // Just append this character.
-        } break;
-      }
+      } break;
     }
+  }
   newArg.append(last);
-  if ( !newArg.empty() || emptyArgs )
-    {
+  if (!newArg.empty() || emptyArgs) {
     // Add the last argument if the string is not empty.
     newargs.push_back(newArg);
-    }
+  }
 }
 
 bool cmSystemTools::SimpleGlob(const std::string& glob,
@@ -1237,116 +1069,99 @@ bool cmSystemTools::SimpleGlob(const std::string& glob,
                                int type /* = 0 */)
 {
   files.clear();
-  if ( glob[glob.size()-1] != '*' )
-    {
+  if (glob[glob.size() - 1] != '*') {
     return false;
-    }
+  }
   std::string path = cmSystemTools::GetFilenamePath(glob);
   std::string ppath = cmSystemTools::GetFilenameName(glob);
-  ppath = ppath.substr(0, ppath.size()-1);
-  if (path.empty())
-    {
+  ppath = ppath.substr(0, ppath.size() - 1);
+  if (path.empty()) {
     path = "/";
-    }
+  }
 
   bool res = false;
   cmsys::Directory d;
-  if (d.Load(path))
-    {
-    for (unsigned int i = 0; i < d.GetNumberOfFiles(); ++i)
-      {
-      if((std::string(d.GetFile(i)) != ".")
-         && (std::string(d.GetFile(i)) != ".."))
-        {
+  if (d.Load(path)) {
+    for (unsigned int i = 0; i < d.GetNumberOfFiles(); ++i) {
+      if ((std::string(d.GetFile(i)) != ".") &&
+          (std::string(d.GetFile(i)) != "..")) {
         std::string fname = path;
-        if ( path[path.size()-1] != '/' )
-          {
-          fname +="/";
-          }
+        if (path[path.size() - 1] != '/') {
+          fname += "/";
+        }
         fname += d.GetFile(i);
         std::string sfname = d.GetFile(i);
-        if ( type > 0 && cmSystemTools::FileIsDirectory(fname) )
-          {
+        if (type > 0 && cmSystemTools::FileIsDirectory(fname)) {
           continue;
-          }
-        if ( type < 0 && !cmSystemTools::FileIsDirectory(fname) )
-          {
+        }
+        if (type < 0 && !cmSystemTools::FileIsDirectory(fname)) {
           continue;
-          }
-        if ( sfname.size() >= ppath.size() &&
-             sfname.substr(0, ppath.size()) ==
-             ppath )
-          {
+        }
+        if (sfname.size() >= ppath.size() &&
+            sfname.substr(0, ppath.size()) == ppath) {
           files.push_back(fname);
           res = true;
-          }
         }
       }
     }
+  }
   return res;
 }
 
 cmSystemTools::FileFormat cmSystemTools::GetFileFormat(const char* cext)
 {
-  if ( ! cext || *cext == 0 )
-    {
+  if (!cext || *cext == 0) {
     return cmSystemTools::NO_FILE_FORMAT;
-    }
-  //std::string ext = cmSystemTools::LowerCase(cext);
+  }
+  // std::string ext = cmSystemTools::LowerCase(cext);
   std::string ext = cext;
-  if ( ext == "c" || ext == ".c" ||
-       ext == "m" || ext == ".m"
-    ) { return cmSystemTools::C_FILE_FORMAT; }
-  if (
-    ext == "C" || ext == ".C" ||
-    ext == "M" || ext == ".M" ||
-    ext == "c++" || ext == ".c++" ||
-    ext == "cc" || ext == ".cc" ||
-    ext == "cpp" || ext == ".cpp" ||
-    ext == "cxx" || ext == ".cxx" ||
-    ext == "mm" || ext == ".mm"
-    ) { return cmSystemTools::CXX_FILE_FORMAT; }
-  if (
-    ext == "f" || ext == ".f" ||
-    ext == "F" || ext == ".F" ||
-    ext == "f77" || ext == ".f77" ||
-    ext == "f90" || ext == ".f90" ||
-    ext == "for" || ext == ".for" ||
-    ext == "f95" || ext == ".f95"
-    ) { return cmSystemTools::FORTRAN_FILE_FORMAT; }
-  if ( ext == "java" || ext == ".java" )
-    { return cmSystemTools::JAVA_FILE_FORMAT; }
-  if (
-    ext == "H" || ext == ".H" ||
-    ext == "h" || ext == ".h" ||
-    ext == "h++" || ext == ".h++" ||
-    ext == "hm" || ext == ".hm" ||
-    ext == "hpp" || ext == ".hpp" ||
-    ext == "hxx" || ext == ".hxx" ||
-    ext == "in" || ext == ".in" ||
-    ext == "txx" || ext == ".txx"
-    ) { return cmSystemTools::HEADER_FILE_FORMAT; }
-  if ( ext == "rc" || ext == ".rc" )
-    { return cmSystemTools::RESOURCE_FILE_FORMAT; }
-  if ( ext == "def" || ext == ".def" )
-    { return cmSystemTools::DEFINITION_FILE_FORMAT; }
-  if ( ext == "lib" || ext == ".lib" ||
-       ext == "a" || ext == ".a")
-    { return cmSystemTools::STATIC_LIBRARY_FILE_FORMAT; }
-  if ( ext == "o" || ext == ".o" ||
-       ext == "obj" || ext == ".obj")
-    { return cmSystemTools::OBJECT_FILE_FORMAT; }
+  if (ext == "c" || ext == ".c" || ext == "m" || ext == ".m") {
+    return cmSystemTools::C_FILE_FORMAT;
+  }
+  if (ext == "C" || ext == ".C" || ext == "M" || ext == ".M" || ext == "c++" ||
+      ext == ".c++" || ext == "cc" || ext == ".cc" || ext == "cpp" ||
+      ext == ".cpp" || ext == "cxx" || ext == ".cxx" || ext == "mm" ||
+      ext == ".mm") {
+    return cmSystemTools::CXX_FILE_FORMAT;
+  }
+  if (ext == "f" || ext == ".f" || ext == "F" || ext == ".F" || ext == "f77" ||
+      ext == ".f77" || ext == "f90" || ext == ".f90" || ext == "for" ||
+      ext == ".for" || ext == "f95" || ext == ".f95") {
+    return cmSystemTools::FORTRAN_FILE_FORMAT;
+  }
+  if (ext == "java" || ext == ".java") {
+    return cmSystemTools::JAVA_FILE_FORMAT;
+  }
+  if (ext == "H" || ext == ".H" || ext == "h" || ext == ".h" || ext == "h++" ||
+      ext == ".h++" || ext == "hm" || ext == ".hm" || ext == "hpp" ||
+      ext == ".hpp" || ext == "hxx" || ext == ".hxx" || ext == "in" ||
+      ext == ".in" || ext == "txx" || ext == ".txx") {
+    return cmSystemTools::HEADER_FILE_FORMAT;
+  }
+  if (ext == "rc" || ext == ".rc") {
+    return cmSystemTools::RESOURCE_FILE_FORMAT;
+  }
+  if (ext == "def" || ext == ".def") {
+    return cmSystemTools::DEFINITION_FILE_FORMAT;
+  }
+  if (ext == "lib" || ext == ".lib" || ext == "a" || ext == ".a") {
+    return cmSystemTools::STATIC_LIBRARY_FILE_FORMAT;
+  }
+  if (ext == "o" || ext == ".o" || ext == "obj" || ext == ".obj") {
+    return cmSystemTools::OBJECT_FILE_FORMAT;
+  }
 #ifdef __APPLE__
-  if ( ext == "dylib" || ext == ".dylib" )
-    { return cmSystemTools::SHARED_LIBRARY_FILE_FORMAT; }
-  if ( ext == "so" || ext == ".so" ||
-       ext == "bundle" || ext == ".bundle" )
-    { return cmSystemTools::MODULE_FILE_FORMAT; }
-#else // __APPLE__
-  if ( ext == "so" || ext == ".so" ||
-       ext == "sl" || ext == ".sl" ||
-       ext == "dll" || ext == ".dll" )
-    { return cmSystemTools::SHARED_LIBRARY_FILE_FORMAT; }
+  if (ext == "dylib" || ext == ".dylib") {
+    return cmSystemTools::SHARED_LIBRARY_FILE_FORMAT;
+  }
+  if (ext == "so" || ext == ".so" || ext == "bundle" || ext == ".bundle") {
+    return cmSystemTools::MODULE_FILE_FORMAT;
+  }
+#else  // __APPLE__
+  if (ext == "so" || ext == ".so" || ext == "sl" || ext == ".sl" ||
+      ext == "dll" || ext == ".dll") {
+    return cmSystemTools::SHARED_LIBRARY_FILE_FORMAT;
+  }
 #endif // __APPLE__
   return cmSystemTools::UNKNOWN_FILE_FORMAT;
 }
@@ -1362,10 +1177,9 @@ bool cmSystemTools::Split(const char* s, std::vector<std::string>& l)
 std::string cmSystemTools::ConvertToOutputPath(const char* path)
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  if(s_ForceUnixPaths)
-    {
+  if (s_ForceUnixPaths) {
     return cmSystemTools::ConvertToUnixOutputPath(path);
-    }
+  }
   return cmSystemTools::ConvertToWindowsOutputPath(path);
 #else
   return cmSystemTools::ConvertToUnixOutputPath(path);
@@ -1375,15 +1189,13 @@ std::string cmSystemTools::ConvertToOutputPath(const char* path)
 void cmSystemTools::ConvertToOutputSlashes(std::string& path)
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  if(!s_ForceUnixPaths)
-    {
+  if (!s_ForceUnixPaths) {
     // Convert to windows slashes.
     std::string::size_type pos = 0;
-    while((pos = path.find('/', pos)) != std::string::npos)
-      {
+    while ((pos = path.find('/', pos)) != std::string::npos) {
       path[pos++] = '\\';
-      }
     }
+  }
 #else
   static_cast<void>(path);
 #endif
@@ -1401,48 +1213,42 @@ std::string cmSystemTools::ConvertToRunCommandPath(const char* path)
 // compute the relative path from here to there
 std::string cmSystemTools::RelativePath(const char* local, const char* remote)
 {
-  if(!cmSystemTools::FileIsFullPath(local))
-    {
+  if (!cmSystemTools::FileIsFullPath(local)) {
     cmSystemTools::Error("RelativePath must be passed a full path to local: ",
                          local);
-    }
-  if(!cmSystemTools::FileIsFullPath(remote))
-    {
-    cmSystemTools::Error
-      ("RelativePath must be passed a full path to remote: ", remote);
-    }
+  }
+  if (!cmSystemTools::FileIsFullPath(remote)) {
+    cmSystemTools::Error("RelativePath must be passed a full path to remote: ",
+                         remote);
+  }
   return cmsys::SystemTools::RelativePath(local, remote);
 }
 
 std::string cmSystemTools::CollapseCombinedPath(std::string const& dir,
                                                 std::string const& file)
 {
-  if(dir.empty() || dir == ".")
-    {
+  if (dir.empty() || dir == ".") {
     return file;
-    }
+  }
 
   std::vector<std::string> dirComponents;
   std::vector<std::string> fileComponents;
   cmSystemTools::SplitPath(dir, dirComponents);
   cmSystemTools::SplitPath(file, fileComponents);
 
-  if(fileComponents.empty())
-    {
+  if (fileComponents.empty()) {
     return dir;
-    }
-  if(fileComponents[0] != "")
-    {
+  }
+  if (fileComponents[0] != "") {
     // File is not a relative path.
     return file;
-    }
+  }
 
-  std::vector<std::string>::iterator i = fileComponents.begin()+1;
-  while(i != fileComponents.end() && *i == ".." && dirComponents.size() > 1)
-    {
-    ++i; // Remove ".." file component.
+  std::vector<std::string>::iterator i = fileComponents.begin() + 1;
+  while (i != fileComponents.end() && *i == ".." && dirComponents.size() > 1) {
+    ++i;                      // Remove ".." file component.
     dirComponents.pop_back(); // Remove last dir component.
-    }
+  }
 
   dirComponents.insert(dirComponents.end(), i, fileComponents.end());
   return cmSystemTools::JoinPath(dirComponents);
@@ -1465,20 +1271,18 @@ std::vector<std::string> cmSystemTools::GetEnvironmentVariables()
 {
   std::vector<std::string> env;
   int cc;
-  for ( cc = 0; environ[cc]; ++ cc )
-    {
+  for (cc = 0; environ[cc]; ++cc) {
     env.push_back(environ[cc]);
-    }
+  }
   return env;
 }
 
 void cmSystemTools::AppendEnv(std::vector<std::string> const& env)
 {
-  for(std::vector<std::string>::const_iterator eit = env.begin();
-      eit != env.end(); ++eit)
-    {
+  for (std::vector<std::string>::const_iterator eit = env.begin();
+       eit != env.end(); ++eit) {
     cmSystemTools::PutEnv(*eit);
-    }
+  }
 }
 
 cmSystemTools::SaveRestoreEnvironment::SaveRestoreEnvironment()
@@ -1490,19 +1294,17 @@ cmSystemTools::SaveRestoreEnvironment::~SaveRestoreEnvironment()
 {
   // First clear everything in the current environment:
   std::vector<std::string> currentEnv = GetEnvironmentVariables();
-  for(std::vector<std::string>::const_iterator
-        eit = currentEnv.begin(); eit != currentEnv.end(); ++eit)
-    {
+  for (std::vector<std::string>::const_iterator eit = currentEnv.begin();
+       eit != currentEnv.end(); ++eit) {
     std::string var(*eit);
 
     std::string::size_type pos = var.find("=");
-    if (pos != std::string::npos)
-      {
+    if (pos != std::string::npos) {
       var = var.substr(0, pos);
-      }
+    }
 
     cmSystemTools::UnsetEnv(var.c_str());
-    }
+  }
 
   // Then put back each entry from the original environment:
   cmSystemTools::AppendEnv(this->Env);
@@ -1521,13 +1323,13 @@ void cmSystemTools::EnableVSConsoleOutput()
   // output and allow it to be captured on the fly.
   cmSystemTools::PutEnv("vsconsoleoutput=1");
 
-# ifdef CMAKE_BUILD_WITH_CMAKE
+#ifdef CMAKE_BUILD_WITH_CMAKE
   // VS sets an environment variable to tell MS tools like "cl" to report
   // output through a backdoor pipe instead of stdout/stderr.  Unset the
   // environment variable to close this backdoor for any path of process
   // invocations that passes through CMake so we can capture the output.
   cmSystemTools::UnsetEnv("VS_UNICODE_OUTPUT");
-# endif
+#endif
 #endif
 }
 
@@ -1539,25 +1341,23 @@ bool cmSystemTools::IsPathToFramework(const char* path)
 
 bool cmSystemTools::CreateTar(const char* outFileName,
                               const std::vector<std::string>& files,
-                              cmTarCompression compressType,
-                              bool verbose, std::string const& mtime,
+                              cmTarCompression compressType, bool verbose,
+                              std::string const& mtime,
                               std::string const& format)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
   cmsys::ofstream fout(outFileName, std::ios::out | std::ios::binary);
-  if(!fout)
-    {
+  if (!fout) {
     std::string e = "Cannot open output file \"";
     e += outFileName;
     e += "\": ";
     e += cmSystemTools::GetLastSystemError();
     cmSystemTools::Error(e.c_str());
     return false;
-    }
+  }
   cmArchiveWrite::Compress compress = cmArchiveWrite::CompressNone;
-  switch (compressType)
-    {
+  switch (compressType) {
     case TarCompressGZip:
       compress = cmArchiveWrite::CompressGZip;
       break;
@@ -1570,32 +1370,27 @@ bool cmSystemTools::CreateTar(const char* outFileName,
     case TarCompressNone:
       compress = cmArchiveWrite::CompressNone;
       break;
-    }
+  }
 
-  cmArchiveWrite a(fout, compress,
-    format.empty() ? "paxr" : format);
+  cmArchiveWrite a(fout, compress, format.empty() ? "paxr" : format);
 
   a.SetMTime(mtime);
   a.SetVerbose(verbose);
-  for(std::vector<std::string>::const_iterator i = files.begin();
-      i != files.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = files.begin();
+       i != files.end(); ++i) {
     std::string path = *i;
-    if(cmSystemTools::FileIsFullPath(path.c_str()))
-      {
+    if (cmSystemTools::FileIsFullPath(path.c_str())) {
       // Get the relative path to the file.
       path = cmSystemTools::RelativePath(cwd.c_str(), path.c_str());
-      }
-    if(!a.Add(path))
-      {
+    }
+    if (!a.Add(path)) {
       break;
-      }
     }
-  if(!a)
-    {
+  }
+  if (!a) {
     cmSystemTools::Error(a.GetError().c_str());
     return false;
-    }
+  }
   return true;
 #else
   (void)outFileName;
@@ -1606,18 +1401,17 @@ bool cmSystemTools::CreateTar(const char* outFileName,
 }
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-namespace{
-#define BSDTAR_FILESIZE_PRINTF  "%lu"
-#define BSDTAR_FILESIZE_TYPE    unsigned long
-  void
-    list_item_verbose(FILE *out, struct archive_entry *entry)
-{
-  char                   tmp[100];
-  size_t                         w;
-  const char            *p;
-  const char            *fmt;
-  time_t                         tim;
-  static time_t          now;
+namespace {
+#define BSDTAR_FILESIZE_PRINTF "%lu"
+#define BSDTAR_FILESIZE_TYPE unsigned long
+void list_item_verbose(FILE* out, struct archive_entry* entry)
+{
+  char tmp[100];
+  size_t w;
+  const char* p;
+  const char* fmt;
+  time_t tim;
+  static time_t now;
   size_t u_width = 6;
   size_t gs_width = 13;
 
@@ -1628,57 +1422,44 @@ namespace{
    * and just widen them as necessary.  These numbers are completely
    * arbitrary.
    */
-  if (!now)
-    {
+  if (!now) {
     time(&now);
-    }
-  fprintf(out, "%s %d ",
-          archive_entry_strmode(entry),
+  }
+  fprintf(out, "%s %d ", archive_entry_strmode(entry),
           archive_entry_nlink(entry));
 
   /* Use uname if it's present, else uid. */
   p = archive_entry_uname(entry);
-  if ((p == NULL) || (*p == '\0'))
-    {
-    sprintf(tmp, "%lu ",
-            (unsigned long)archive_entry_uid(entry));
+  if ((p == NULL) || (*p == '\0')) {
+    sprintf(tmp, "%lu ", (unsigned long)archive_entry_uid(entry));
     p = tmp;
-    }
+  }
   w = strlen(p);
-  if (w > u_width)
-    {
+  if (w > u_width) {
     u_width = w;
-    }
+  }
   fprintf(out, "%-*s ", (int)u_width, p);
   /* Use gname if it's present, else gid. */
   p = archive_entry_gname(entry);
-  if (p != NULL && p[0] != '\0')
-    {
+  if (p != NULL && p[0] != '\0') {
     fprintf(out, "%s", p);
     w = strlen(p);
-    }
-  else
-    {
-    sprintf(tmp, "%lu",
-            (unsigned long)archive_entry_gid(entry));
+  } else {
+    sprintf(tmp, "%lu", (unsigned long)archive_entry_gid(entry));
     w = strlen(tmp);
     fprintf(out, "%s", tmp);
-    }
+  }
 
   /*
    * Print device number or file size, right-aligned so as to make
    * total width of group and devnum/filesize fields be gs_width.
    * If gs_width is too small, grow it.
    */
-  if (archive_entry_filetype(entry) == AE_IFCHR
-      || archive_entry_filetype(entry) == AE_IFBLK)
-    {
-    sprintf(tmp, "%lu,%lu",
-            (unsigned long)archive_entry_rdevmajor(entry),
+  if (archive_entry_filetype(entry) == AE_IFCHR ||
+      archive_entry_filetype(entry) == AE_IFBLK) {
+    sprintf(tmp, "%lu,%lu", (unsigned long)archive_entry_rdevmajor(entry),
             (unsigned long)archive_entry_rdevminor(entry));
-    }
-  else
-    {
+  } else {
     /*
      * Note the use of platform-dependent macros to format
      * the filesize here.  We need the format string and the
@@ -1686,50 +1467,44 @@ namespace{
      */
     sprintf(tmp, BSDTAR_FILESIZE_PRINTF,
             (BSDTAR_FILESIZE_TYPE)archive_entry_size(entry));
-    }
-  if (w + strlen(tmp) >= gs_width)
-    {
-    gs_width = w+strlen(tmp)+1;
-    }
+  }
+  if (w + strlen(tmp) >= gs_width) {
+    gs_width = w + strlen(tmp) + 1;
+  }
   fprintf(out, "%*s", (int)(gs_width - w), tmp);
 
   /* Format the time using 'ls -l' conventions. */
   tim = archive_entry_mtime(entry);
 #define HALF_YEAR (time_t)365 * 86400 / 2
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  /* Windows' strftime function does not support %e format. */
-#define DAY_FMT  "%d"
+/* Windows' strftime function does not support %e format. */
+#define DAY_FMT "%d"
 #else
-#define DAY_FMT  "%e"  /* Day number without leading zeros */
+#define DAY_FMT "%e" /* Day number without leading zeros */
 #endif
-  if (tim < now - HALF_YEAR || tim > now + HALF_YEAR)
-    {
+  if (tim < now - HALF_YEAR || tim > now + HALF_YEAR) {
     fmt = DAY_FMT " %b  %Y";
-    }
-  else
-    {
+  } else {
     fmt = DAY_FMT " %b %H:%M";
-    }
+  }
   strftime(tmp, sizeof(tmp), fmt, localtime(&tim));
   fprintf(out, " %s ", tmp);
   fprintf(out, "%s", cm_archive_entry_pathname(entry).c_str());
 
   /* Extra information for links. */
   if (archive_entry_hardlink(entry)) /* Hard link */
-    {
-    fprintf(out, " link to %s",
-            archive_entry_hardlink(entry));
-    }
-  else if (archive_entry_symlink(entry)) /* Symbolic link */
-    {
+  {
+    fprintf(out, " link to %s", archive_entry_hardlink(entry));
+  } else if (archive_entry_symlink(entry)) /* Symbolic link */
+  {
     fprintf(out, " -> %s", archive_entry_symlink(entry));
-    }
+  }
 }
 
-long copy_data(struct archive *ar, struct archive *aw)
+long copy_data(struct archive* ar, struct archive* aw)
 {
   long r;
-  const void *buff;
+  const void* buff;
   size_t size;
 #if defined(ARCHIVE_VERSION_NUMBER) && ARCHIVE_VERSION_NUMBER >= 3000000
   __LA_INT64_T offset;
@@ -1737,122 +1512,99 @@ long copy_data(struct archive *ar, struct archive *aw)
   off_t offset;
 #endif
 
-  for (;;)
-    {
+  for (;;) {
     r = archive_read_data_block(ar, &buff, &size, &offset);
-    if (r == ARCHIVE_EOF)
-      {
+    if (r == ARCHIVE_EOF) {
       return (ARCHIVE_OK);
-      }
-    if (r != ARCHIVE_OK)
-      {
+    }
+    if (r != ARCHIVE_OK) {
       return (r);
-      }
+    }
     r = archive_write_data_block(aw, buff, size, offset);
-    if (r != ARCHIVE_OK)
-      {
+    if (r != ARCHIVE_OK) {
       cmSystemTools::Message("archive_write_data_block()",
                              archive_error_string(aw));
       return (r);
-      }
     }
+  }
 #if !defined(__clang__) && !defined(__HP_aCC)
   return r; /* this should not happen but it quiets some compilers */
 #endif
 }
 
-bool extract_tar(const char* outFileName, bool verbose,
-                 bool extract)
+bool extract_tar(const char* outFileName, bool verbose, bool extract)
 {
   cmLocaleRAII localeRAII;
   static_cast<void>(localeRAII);
   struct archive* a = archive_read_new();
-  struct archive *ext = archive_write_disk_new();
+  struct archive* ext = archive_write_disk_new();
   archive_read_support_filter_all(a);
   archive_read_support_format_all(a);
-  struct archive_entry *entry;
+  struct archive_entry* entry;
   int r = cm_archive_read_open_file(a, outFileName, 10240);
-  if(r)
-    {
+  if (r) {
     cmSystemTools::Error("Problem with archive_read_open_file(): ",
                          archive_error_string(a));
     archive_write_free(ext);
     archive_read_close(a);
     return false;
-    }
-  for (;;)
-    {
+  }
+  for (;;) {
     r = archive_read_next_header(a, &entry);
-    if (r == ARCHIVE_EOF)
-      {
+    if (r == ARCHIVE_EOF) {
       break;
-      }
-    if (r != ARCHIVE_OK)
-      {
+    }
+    if (r != ARCHIVE_OK) {
       cmSystemTools::Error("Problem with archive_read_next_header(): ",
                            archive_error_string(a));
       break;
-      }
-    if(verbose)
-      {
-      if(extract)
-        {
+    }
+    if (verbose) {
+      if (extract) {
         cmSystemTools::Stdout("x ");
         cmSystemTools::Stdout(cm_archive_entry_pathname(entry).c_str());
-        }
-      else
-        {
+      } else {
         list_item_verbose(stdout, entry);
-        }
-      cmSystemTools::Stdout("\n");
       }
-    else if(!extract)
-      {
+      cmSystemTools::Stdout("\n");
+    } else if (!extract) {
       cmSystemTools::Stdout(cm_archive_entry_pathname(entry).c_str());
       cmSystemTools::Stdout("\n");
-      }
-    if(extract)
-      {
+    }
+    if (extract) {
       r = archive_write_disk_set_options(ext, ARCHIVE_EXTRACT_TIME);
-      if (r != ARCHIVE_OK)
-        {
-        cmSystemTools::Error(
-          "Problem with archive_write_disk_set_options(): ",
-          archive_error_string(ext));
+      if (r != ARCHIVE_OK) {
+        cmSystemTools::Error("Problem with archive_write_disk_set_options(): ",
+                             archive_error_string(ext));
         break;
-        }
+      }
 
       r = archive_write_header(ext, entry);
-      if (r == ARCHIVE_OK)
-        {
+      if (r == ARCHIVE_OK) {
         copy_data(a, ext);
         r = archive_write_finish_entry(ext);
-        if (r != ARCHIVE_OK)
-          {
+        if (r != ARCHIVE_OK) {
           cmSystemTools::Error("Problem with archive_write_finish_entry(): ",
                                archive_error_string(ext));
           break;
-          }
         }
+      }
 #ifdef _WIN32
-      else if(const char* linktext = archive_entry_symlink(entry))
-        {
+      else if (const char* linktext = archive_entry_symlink(entry)) {
         std::cerr << "cmake -E tar: warning: skipping symbolic link \""
-                  << cm_archive_entry_pathname(entry)
-                  << "\" -> \""
-                  << linktext << "\"." << std::endl;
-        }
+                  << cm_archive_entry_pathname(entry) << "\" -> \"" << linktext
+                  << "\"." << std::endl;
+      }
 #endif
-      else
-        {
+      else {
         cmSystemTools::Error("Problem with archive_write_header(): ",
                              archive_error_string(ext));
         cmSystemTools::Error("Current file: ",
                              cm_archive_entry_pathname(entry).c_str());
         break;
-        }
       }
     }
+  }
   archive_write_free(ext);
   archive_read_close(a);
   archive_read_free(a);
@@ -1861,8 +1613,7 @@ bool extract_tar(const char* outFileName, bool verbose,
 }
 #endif
 
-bool cmSystemTools::ExtractTar(const char* outFileName,
-                               bool verbose)
+bool cmSystemTools::ExtractTar(const char* outFileName, bool verbose)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   return extract_tar(outFileName, verbose, true);
@@ -1873,8 +1624,7 @@ bool cmSystemTools::ExtractTar(const char* outFileName,
 #endif
 }
 
-bool cmSystemTools::ListTar(const char* outFileName,
-                            bool verbose)
+bool cmSystemTools::ListTar(const char* outFileName, bool verbose)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   return extract_tar(outFileName, verbose, false);
@@ -1886,105 +1636,79 @@ bool cmSystemTools::ListTar(const char* outFileName,
 }
 
 int cmSystemTools::WaitForLine(cmsysProcess* process, std::string& line,
-                               double timeout,
-                               std::vector<char>& out,
+                               double timeout, std::vector<char>& out,
                                std::vector<char>& err)
 {
   line = "";
   std::vector<char>::iterator outiter = out.begin();
   std::vector<char>::iterator erriter = err.begin();
-  while(1)
-    {
+  while (1) {
     // Check for a newline in stdout.
-    for(;outiter != out.end(); ++outiter)
-      {
-      if((*outiter == '\r') && ((outiter+1) == out.end()))
-        {
+    for (; outiter != out.end(); ++outiter) {
+      if ((*outiter == '\r') && ((outiter + 1) == out.end())) {
         break;
-        }
-      else if(*outiter == '\n' || *outiter == '\0')
-        {
-        std::vector<char>::size_type length = outiter-out.begin();
-        if(length > 1 && *(outiter-1) == '\r')
-          {
+      } else if (*outiter == '\n' || *outiter == '\0') {
+        std::vector<char>::size_type length = outiter - out.begin();
+        if (length > 1 && *(outiter - 1) == '\r') {
           --length;
-          }
-        if(length > 0)
-          {
+        }
+        if (length > 0) {
           line.append(&out[0], length);
-          }
-        out.erase(out.begin(), outiter+1);
-        return cmsysProcess_Pipe_STDOUT;
         }
+        out.erase(out.begin(), outiter + 1);
+        return cmsysProcess_Pipe_STDOUT;
       }
+    }
 
     // Check for a newline in stderr.
-    for(;erriter != err.end(); ++erriter)
-      {
-      if((*erriter == '\r') && ((erriter+1) == err.end()))
-        {
+    for (; erriter != err.end(); ++erriter) {
+      if ((*erriter == '\r') && ((erriter + 1) == err.end())) {
         break;
-        }
-      else if(*erriter == '\n' || *erriter == '\0')
-        {
-        std::vector<char>::size_type length = erriter-err.begin();
-        if(length > 1 && *(erriter-1) == '\r')
-          {
+      } else if (*erriter == '\n' || *erriter == '\0') {
+        std::vector<char>::size_type length = erriter - err.begin();
+        if (length > 1 && *(erriter - 1) == '\r') {
           --length;
-          }
-        if(length > 0)
-          {
+        }
+        if (length > 0) {
           line.append(&err[0], length);
-          }
-        err.erase(err.begin(), erriter+1);
-        return cmsysProcess_Pipe_STDERR;
         }
+        err.erase(err.begin(), erriter + 1);
+        return cmsysProcess_Pipe_STDERR;
       }
+    }
 
     // No newlines found.  Wait for more data from the process.
     int length;
     char* data;
     int pipe = cmsysProcess_WaitForData(process, &data, &length, &timeout);
-    if(pipe == cmsysProcess_Pipe_Timeout)
-      {
+    if (pipe == cmsysProcess_Pipe_Timeout) {
       // Timeout has been exceeded.
       return pipe;
-      }
-    else if(pipe == cmsysProcess_Pipe_STDOUT)
-      {
+    } else if (pipe == cmsysProcess_Pipe_STDOUT) {
       // Append to the stdout buffer.
       std::vector<char>::size_type size = out.size();
-      out.insert(out.end(), data, data+length);
-      outiter = out.begin()+size;
-      }
-    else if(pipe == cmsysProcess_Pipe_STDERR)
-      {
+      out.insert(out.end(), data, data + length);
+      outiter = out.begin() + size;
+    } else if (pipe == cmsysProcess_Pipe_STDERR) {
       // Append to the stderr buffer.
       std::vector<char>::size_type size = err.size();
-      err.insert(err.end(), data, data+length);
-      erriter = err.begin()+size;
-      }
-    else if(pipe == cmsysProcess_Pipe_None)
-      {
+      err.insert(err.end(), data, data + length);
+      erriter = err.begin() + size;
+    } else if (pipe == cmsysProcess_Pipe_None) {
       // Both stdout and stderr pipes have broken.  Return leftover data.
-      if(!out.empty())
-        {
-        line.append(&out[0], outiter-out.begin());
+      if (!out.empty()) {
+        line.append(&out[0], outiter - out.begin());
         out.erase(out.begin(), out.end());
         return cmsysProcess_Pipe_STDOUT;
-        }
-      else if(!err.empty())
-        {
-        line.append(&err[0], erriter-err.begin());
+      } else if (!err.empty()) {
+        line.append(&err[0], erriter - err.begin());
         err.erase(err.begin(), err.end());
         return cmsysProcess_Pipe_STDERR;
-        }
-      else
-        {
+      } else {
         return cmsysProcess_Pipe_None;
-        }
       }
     }
+  }
 }
 
 void cmSystemTools::DoNotInheritStdPipes()
@@ -1996,23 +1720,20 @@ void cmSystemTools::DoNotInheritStdPipes()
   // shell windows
   CONSOLE_SCREEN_BUFFER_INFO hOutInfo;
   HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
-  if(GetConsoleScreenBufferInfo(hOut, &hOutInfo))
-    {
+  if (GetConsoleScreenBufferInfo(hOut, &hOutInfo)) {
     return;
-    }
+  }
   {
-  HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
-  DuplicateHandle(GetCurrentProcess(), out,
-                  GetCurrentProcess(), &out, 0, FALSE,
-                  DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
-  SetStdHandle(STD_OUTPUT_HANDLE, out);
+    HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
+    DuplicateHandle(GetCurrentProcess(), out, GetCurrentProcess(), &out, 0,
+                    FALSE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
+    SetStdHandle(STD_OUTPUT_HANDLE, out);
   }
   {
-  HANDLE out = GetStdHandle(STD_ERROR_HANDLE);
-  DuplicateHandle(GetCurrentProcess(), out,
-                  GetCurrentProcess(), &out, 0, FALSE,
-                  DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
-  SetStdHandle(STD_ERROR_HANDLE, out);
+    HANDLE out = GetStdHandle(STD_ERROR_HANDLE);
+    DuplicateHandle(GetCurrentProcess(), out, GetCurrentProcess(), &out, 0,
+                    FALSE, DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE);
+    SetStdHandle(STD_ERROR_HANDLE, out);
   }
 #endif
 }
@@ -2020,43 +1741,36 @@ void cmSystemTools::DoNotInheritStdPipes()
 bool cmSystemTools::CopyFileTime(const char* fromFile, const char* toFile)
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  cmSystemToolsWindowsHandle hFrom =
-    CreateFileW(SystemTools::ConvertToWindowsExtendedPath(fromFile).c_str(),
-                GENERIC_READ, FILE_SHARE_READ, 0,
-                OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
-  cmSystemToolsWindowsHandle hTo =
-    CreateFileW(SystemTools::ConvertToWindowsExtendedPath(toFile).c_str(),
-                FILE_WRITE_ATTRIBUTES, 0, 0, OPEN_EXISTING,
-                FILE_FLAG_BACKUP_SEMANTICS, 0);
-  if(!hFrom || !hTo)
-    {
+  cmSystemToolsWindowsHandle hFrom = CreateFileW(
+    SystemTools::ConvertToWindowsExtendedPath(fromFile).c_str(), GENERIC_READ,
+    FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+  cmSystemToolsWindowsHandle hTo = CreateFileW(
+    SystemTools::ConvertToWindowsExtendedPath(toFile).c_str(),
+    FILE_WRITE_ATTRIBUTES, 0, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+  if (!hFrom || !hTo) {
     return false;
-    }
+  }
   FILETIME timeCreation;
   FILETIME timeLastAccess;
   FILETIME timeLastWrite;
-  if(!GetFileTime(hFrom, &timeCreation, &timeLastAccess, &timeLastWrite))
-    {
+  if (!GetFileTime(hFrom, &timeCreation, &timeLastAccess, &timeLastWrite)) {
     return false;
-    }
-  if(!SetFileTime(hTo, &timeCreation, &timeLastAccess, &timeLastWrite))
-    {
+  }
+  if (!SetFileTime(hTo, &timeCreation, &timeLastAccess, &timeLastWrite)) {
     return false;
-    }
+  }
 #else
   struct stat fromStat;
-  if(stat(fromFile, &fromStat) < 0)
-    {
+  if (stat(fromFile, &fromStat) < 0) {
     return false;
-    }
+  }
 
   struct utimbuf buf;
   buf.actime = fromStat.st_atime;
   buf.modtime = fromStat.st_mtime;
-  if(utime(toFile, &buf) < 0)
-    {
+  if (utime(toFile, &buf) < 0) {
     return false;
-    }
+  }
 #endif
   return true;
 }
@@ -2074,24 +1788,21 @@ void cmSystemTools::FileTimeDelete(cmSystemToolsFileTime* t)
 bool cmSystemTools::FileTimeGet(const char* fname, cmSystemToolsFileTime* t)
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  cmSystemToolsWindowsHandle h =
-    CreateFileW(SystemTools::ConvertToWindowsExtendedPath(fname).c_str(),
-                GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING,
-                FILE_FLAG_BACKUP_SEMANTICS, 0);
-  if(!h)
-    {
+  cmSystemToolsWindowsHandle h = CreateFileW(
+    SystemTools::ConvertToWindowsExtendedPath(fname).c_str(), GENERIC_READ,
+    FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+  if (!h) {
     return false;
-    }
-  if(!GetFileTime(h, &t->timeCreation, &t->timeLastAccess, &t->timeLastWrite))
-    {
+  }
+  if (!GetFileTime(h, &t->timeCreation, &t->timeLastAccess,
+                   &t->timeLastWrite)) {
     return false;
-    }
+  }
 #else
   struct stat st;
-  if(stat(fname, &st) < 0)
-    {
+  if (stat(fname, &st) < 0) {
     return false;
-    }
+  }
   t->timeBuf.actime = st.st_atime;
   t->timeBuf.modtime = st.st_mtime;
 #endif
@@ -2101,41 +1812,37 @@ bool cmSystemTools::FileTimeGet(const char* fname, cmSystemToolsFileTime* t)
 bool cmSystemTools::FileTimeSet(const char* fname, cmSystemToolsFileTime* t)
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  cmSystemToolsWindowsHandle h =
-    CreateFileW(SystemTools::ConvertToWindowsExtendedPath(fname).c_str(),
-                FILE_WRITE_ATTRIBUTES, 0, 0, OPEN_EXISTING,
-                FILE_FLAG_BACKUP_SEMANTICS, 0);
-  if(!h)
-    {
+  cmSystemToolsWindowsHandle h = CreateFileW(
+    SystemTools::ConvertToWindowsExtendedPath(fname).c_str(),
+    FILE_WRITE_ATTRIBUTES, 0, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
+  if (!h) {
     return false;
-    }
-  if(!SetFileTime(h, &t->timeCreation, &t->timeLastAccess, &t->timeLastWrite))
-    {
+  }
+  if (!SetFileTime(h, &t->timeCreation, &t->timeLastAccess,
+                   &t->timeLastWrite)) {
     return false;
-    }
+  }
 #else
-  if(utime(fname, &t->timeBuf) < 0)
-    {
+  if (utime(fname, &t->timeBuf) < 0) {
     return false;
-    }
+  }
 #endif
   return true;
 }
 
 #ifdef _WIN32
-# ifndef CRYPT_SILENT
-#  define CRYPT_SILENT 0x40 /* Not defined by VS 6 version of header.  */
-# endif
+#ifndef CRYPT_SILENT
+#define CRYPT_SILENT 0x40 /* Not defined by VS 6 version of header.  */
+#endif
 static int WinCryptRandom(void* data, size_t size)
 {
   int result = 0;
   HCRYPTPROV hProvider = 0;
-  if(CryptAcquireContextW(&hProvider, 0, 0, PROV_RSA_FULL,
-                          CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
-    {
-    result = CryptGenRandom(hProvider, (DWORD)size, (BYTE*)data)? 1:0;
+  if (CryptAcquireContextW(&hProvider, 0, 0, PROV_RSA_FULL,
+                           CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+    result = CryptGenRandom(hProvider, (DWORD)size, (BYTE*)data) ? 1 : 0;
     CryptReleaseContext(hProvider, 0);
-    }
+  }
   return result;
 }
 #endif
@@ -2146,10 +1853,9 @@ unsigned int cmSystemTools::RandomSeed()
   unsigned int seed = 0;
 
   // Try using a real random source.
-  if(WinCryptRandom(&seed, sizeof(seed)))
-    {
+  if (WinCryptRandom(&seed, sizeof(seed))) {
     return seed;
-    }
+  }
 
   // Fall back to the time and pid.
   FILETIME ft;
@@ -2169,11 +1875,10 @@ unsigned int cmSystemTools::RandomSeed()
   cmsys::ifstream fin;
   fin.rdbuf()->pubsetbuf(0, 0); // Unbuffered read.
   fin.open("/dev/urandom");
-  if(fin.good() && fin.read(seed.bytes, sizeof(seed)) &&
-     fin.gcount() == sizeof(seed))
-    {
+  if (fin.good() && fin.read(seed.bytes, sizeof(seed)) &&
+      fin.gcount() == sizeof(seed)) {
     return seed.integer;
-    }
+  }
 
   // Fall back to the time and pid.
   struct timeval t;
@@ -2205,57 +1910,46 @@ void cmSystemTools::FindCMakeResources(const char* argv0)
     cmSystemTools::GetFilenamePath(cmsys::Encoding::ToNarrow(modulepath));
 #elif defined(__APPLE__)
   (void)argv0; // ignore this on OS X
-# define CM_EXE_PATH_LOCAL_SIZE 16384
+#define CM_EXE_PATH_LOCAL_SIZE 16384
   char exe_path_local[CM_EXE_PATH_LOCAL_SIZE];
-# if defined(MAC_OS_X_VERSION_10_3) && !defined(MAC_OS_X_VERSION_10_4)
+#if defined(MAC_OS_X_VERSION_10_3) && !defined(MAC_OS_X_VERSION_10_4)
   unsigned long exe_path_size = CM_EXE_PATH_LOCAL_SIZE;
-# else
+#else
   uint32_t exe_path_size = CM_EXE_PATH_LOCAL_SIZE;
-# endif
-# undef CM_EXE_PATH_LOCAL_SIZE
+#endif
+#undef CM_EXE_PATH_LOCAL_SIZE
   char* exe_path = exe_path_local;
-  if(_NSGetExecutablePath(exe_path, &exe_path_size) < 0)
-    {
+  if (_NSGetExecutablePath(exe_path, &exe_path_size) < 0) {
     exe_path = (char*)malloc(exe_path_size);
     _NSGetExecutablePath(exe_path, &exe_path_size);
-    }
+  }
   exe_dir =
-    cmSystemTools::GetFilenamePath(
-      cmSystemTools::GetRealPath(exe_path));
-  if(exe_path != exe_path_local)
-    {
+    cmSystemTools::GetFilenamePath(cmSystemTools::GetRealPath(exe_path));
+  if (exe_path != exe_path_local) {
     free(exe_path);
-    }
-  if(cmSystemTools::GetFilenameName(exe_dir) == "MacOS")
-    {
+  }
+  if (cmSystemTools::GetFilenameName(exe_dir) == "MacOS") {
     // The executable is inside an application bundle.
     // Look for ../bin (install tree) and then fall back to
     // ../../../bin (build tree).
     exe_dir = cmSystemTools::GetFilenamePath(exe_dir);
-    if(cmSystemTools::FileExists((exe_dir+"/bin/cmake").c_str()))
-      {
+    if (cmSystemTools::FileExists((exe_dir + "/bin/cmake").c_str())) {
       exe_dir += "/bin";
-      }
-    else
-      {
+    } else {
       exe_dir = cmSystemTools::GetFilenamePath(exe_dir);
       exe_dir = cmSystemTools::GetFilenamePath(exe_dir);
-      }
     }
+  }
 #else
   std::string errorMsg;
   std::string exe;
-  if(cmSystemTools::FindProgramPath(argv0, exe, errorMsg))
-    {
+  if (cmSystemTools::FindProgramPath(argv0, exe, errorMsg)) {
     // remove symlinks
     exe = cmSystemTools::GetRealPath(exe);
-    exe_dir =
-      cmSystemTools::GetFilenamePath(exe);
-    }
-  else
-    {
+    exe_dir = cmSystemTools::GetFilenamePath(exe);
+  } else {
     // ???
-    }
+  }
 #endif
   cmSystemToolsCMakeCommand = exe_dir;
   cmSystemToolsCMakeCommand += "/cmake";
@@ -2274,54 +1968,46 @@ void cmSystemTools::FindCMakeResources(const char* argv0)
   cmSystemToolsCMakeGUICommand = exe_dir;
   cmSystemToolsCMakeGUICommand += "/cmake-gui";
   cmSystemToolsCMakeGUICommand += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(cmSystemToolsCMakeGUICommand.c_str()))
-    {
+  if (!cmSystemTools::FileExists(cmSystemToolsCMakeGUICommand.c_str())) {
     cmSystemToolsCMakeGUICommand = "";
-    }
+  }
   cmSystemToolsCMakeCursesCommand = exe_dir;
   cmSystemToolsCMakeCursesCommand += "/ccmake";
   cmSystemToolsCMakeCursesCommand += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(cmSystemToolsCMakeCursesCommand.c_str()))
-    {
+  if (!cmSystemTools::FileExists(cmSystemToolsCMakeCursesCommand.c_str())) {
     cmSystemToolsCMakeCursesCommand = "";
-    }
+  }
   cmSystemToolsCMClDepsCommand = exe_dir;
   cmSystemToolsCMClDepsCommand += "/cmcldeps";
   cmSystemToolsCMClDepsCommand += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(cmSystemToolsCMClDepsCommand.c_str()))
-    {
+  if (!cmSystemTools::FileExists(cmSystemToolsCMClDepsCommand.c_str())) {
     cmSystemToolsCMClDepsCommand = "";
-    }
+  }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   // Install tree has "<prefix>/bin/cmake" and "<prefix><CMAKE_DATA_DIR>".
   std::string dir = cmSystemTools::GetFilenamePath(exe_dir);
   cmSystemToolsCMakeRoot = dir + CMAKE_DATA_DIR;
-  if(!cmSystemTools::FileExists(
-       (cmSystemToolsCMakeRoot+"/Modules/CMake.cmake").c_str()))
-    {
+  if (!cmSystemTools::FileExists(
+        (cmSystemToolsCMakeRoot + "/Modules/CMake.cmake").c_str())) {
     // Build tree has "<build>/bin[/<config>]/cmake" and
     // "<build>/CMakeFiles/CMakeSourceDir.txt".
     std::string src_dir_txt = dir + "/CMakeFiles/CMakeSourceDir.txt";
     cmsys::ifstream fin(src_dir_txt.c_str());
     std::string src_dir;
-    if(fin && cmSystemTools::GetLineFromStream(fin, src_dir) &&
-       cmSystemTools::FileIsDirectory(src_dir))
-      {
+    if (fin && cmSystemTools::GetLineFromStream(fin, src_dir) &&
+        cmSystemTools::FileIsDirectory(src_dir)) {
       cmSystemToolsCMakeRoot = src_dir;
-      }
-    else
-      {
+    } else {
       dir = cmSystemTools::GetFilenamePath(dir);
       src_dir_txt = dir + "/CMakeFiles/CMakeSourceDir.txt";
       cmsys::ifstream fin2(src_dir_txt.c_str());
-      if(fin2 && cmSystemTools::GetLineFromStream(fin2, src_dir) &&
-         cmSystemTools::FileIsDirectory(src_dir))
-        {
+      if (fin2 && cmSystemTools::GetLineFromStream(fin2, src_dir) &&
+          cmSystemTools::FileIsDirectory(src_dir)) {
         cmSystemToolsCMakeRoot = src_dir;
-        }
       }
     }
+  }
 #else
   // Bootstrap build knows its source.
   cmSystemToolsCMakeRoot = CMAKE_BOOTSTRAP_SOURCE_DIR;
@@ -2373,81 +2059,70 @@ void cmSystemTools::MakefileColorEcho(int color, const char* message,
   // However, we can test for some situations when the answer is most
   // likely no.
   int assumeTTY = cmsysTerminal_Color_AssumeTTY;
-  if(cmSystemTools::GetEnv("DART_TEST_FROM_DART") ||
-     cmSystemTools::GetEnv("DASHBOARD_TEST_FROM_CTEST") ||
-     cmSystemTools::GetEnv("CTEST_INTERACTIVE_DEBUG_MODE"))
-    {
+  if (cmSystemTools::GetEnv("DART_TEST_FROM_DART") ||
+      cmSystemTools::GetEnv("DASHBOARD_TEST_FROM_CTEST") ||
+      cmSystemTools::GetEnv("CTEST_INTERACTIVE_DEBUG_MODE")) {
     // Avoid printing color escapes during dashboard builds.
     assumeTTY = 0;
-    }
+  }
 
-  if(enabled && color != cmsysTerminal_Color_Normal)
-    {
+  if (enabled && color != cmsysTerminal_Color_Normal) {
     // Print with color.  Delay the newline until later so that
     // all color restore sequences appear before it.
     cmsysTerminal_cfprintf(color | assumeTTY, stdout, "%s", message);
-    }
-  else
-    {
+  } else {
     // Color is disabled.  Print without color.
     fprintf(stdout, "%s", message);
-    }
+  }
 
-  if(newline)
-    {
+  if (newline) {
     fprintf(stdout, "\n");
-    }
+  }
 }
 
 bool cmSystemTools::GuessLibrarySOName(std::string const& fullPath,
                                        std::string& soname)
 {
-  // For ELF shared libraries use a real parser to get the correct
-  // soname.
+// For ELF shared libraries use a real parser to get the correct
+// soname.
 #if defined(CMAKE_USE_ELF_PARSER)
   cmELF elf(fullPath.c_str());
-  if(elf)
-    {
+  if (elf) {
     return elf.GetSOName(soname);
-    }
+  }
 #endif
 
   // If the file is not a symlink we have no guess for its soname.
-  if(!cmSystemTools::FileIsSymlink(fullPath))
-    {
+  if (!cmSystemTools::FileIsSymlink(fullPath)) {
     return false;
-    }
-  if(!cmSystemTools::ReadSymlink(fullPath, soname))
-    {
+  }
+  if (!cmSystemTools::ReadSymlink(fullPath, soname)) {
     return false;
-    }
+  }
 
   // If the symlink has a path component we have no guess for the soname.
-  if(!cmSystemTools::GetFilenamePath(soname).empty())
-    {
+  if (!cmSystemTools::GetFilenamePath(soname).empty()) {
     return false;
-    }
+  }
 
   // If the symlink points at an extended version of the same name
   // assume it is the soname.
   std::string name = cmSystemTools::GetFilenameName(fullPath);
-  if(soname.length() > name.length() &&
-     soname.substr(0, name.length()) == name)
-    {
+  if (soname.length() > name.length() &&
+      soname.substr(0, name.length()) == name) {
     return true;
-    }
+  }
   return false;
 }
 
 bool cmSystemTools::GuessLibraryInstallName(std::string const& fullPath,
-                                       std::string& soname)
+                                            std::string& soname)
 {
 #if defined(CMAKE_USE_MACH_PARSER)
   cmMachO macho(fullPath.c_str());
-  if(macho)
-    {
+  if (macho) {
     return macho.GetInstallName(soname);
-    }
+  }
 #else
   (void)fullPath;
   (void)soname;
@@ -2464,40 +2139,33 @@ std::string::size_type cmSystemToolsFindRPath(std::string const& have,
   std::string::size_type pos = have.find(want);
 
   // If the path is not present we are done.
-  if(pos == std::string::npos)
-    {
+  if (pos == std::string::npos) {
     return pos;
-    }
+  }
 
   // Build a regex to match a properly separated path instance.
   std::string regex_str = "(^|:)(";
-  for(std::string::const_iterator i = want.begin(); i != want.end(); ++i)
-    {
+  for (std::string::const_iterator i = want.begin(); i != want.end(); ++i) {
     int ch = *i;
-    if(!(('a' <= ch && ch <= 'z') ||
-         ('A' <= ch && ch <= 'Z') ||
-         ('0' <= ch && ch <= '9')))
-      {
+    if (!(('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
+          ('0' <= ch && ch <= '9'))) {
       // Escape the non-alphanumeric character.
       regex_str += "\\";
-      }
+    }
     // Store the character.
     regex_str.append(1, static_cast<char>(ch));
-    }
+  }
   regex_str += ")(:|$)";
 
   // Look for the separated path.
   cmsys::RegularExpression regex(regex_str.c_str());
-  if(regex.find(have))
-    {
+  if (regex.find(have)) {
     // Return the position of the path portion.
     return regex.start(2);
-    }
-  else
-    {
+  } else {
     // The desired rpath was not found.
     return std::string::npos;
-    }
+  }
 }
 #endif
 
@@ -2513,206 +2181,176 @@ struct cmSystemToolsRPathInfo
 
 bool cmSystemTools::ChangeRPath(std::string const& file,
                                 std::string const& oldRPath,
-                                std::string const& newRPath,
-                                std::string* emsg,
+                                std::string const& newRPath, std::string* emsg,
                                 bool* changed)
 {
 #if defined(CMAKE_USE_ELF_PARSER)
-  if(changed)
-    {
+  if (changed) {
     *changed = false;
-    }
+  }
   int rp_count = 0;
   bool remove_rpath = true;
   cmSystemToolsRPathInfo rp[2];
   {
-  // Parse the ELF binary.
-  cmELF elf(file.c_str());
-
-  // Get the RPATH and RUNPATH entries from it.
-  int se_count = 0;
-  cmELF::StringEntry const* se[2] = {0, 0};
-  const char* se_name[2] = {0, 0};
-  if(cmELF::StringEntry const* se_rpath = elf.GetRPath())
-    {
-    se[se_count] = se_rpath;
-    se_name[se_count] = "RPATH";
-    ++se_count;
-    }
-  if(cmELF::StringEntry const* se_runpath = elf.GetRunPath())
-    {
-    se[se_count] = se_runpath;
-    se_name[se_count] = "RUNPATH";
-    ++se_count;
-    }
-  if(se_count == 0)
-    {
-    if(newRPath.empty())
-      {
-      // The new rpath is empty and there is no rpath anyway so it is
-      // okay.
-      return true;
-      }
-    else
-      {
-      if(emsg)
-        {
-        *emsg = "No valid ELF RPATH or RUNPATH entry exists in the file; ";
-        *emsg += elf.GetErrorMessage();
+    // Parse the ELF binary.
+    cmELF elf(file.c_str());
+
+    // Get the RPATH and RUNPATH entries from it.
+    int se_count = 0;
+    cmELF::StringEntry const* se[2] = { 0, 0 };
+    const char* se_name[2] = { 0, 0 };
+    if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) {
+      se[se_count] = se_rpath;
+      se_name[se_count] = "RPATH";
+      ++se_count;
+    }
+    if (cmELF::StringEntry const* se_runpath = elf.GetRunPath()) {
+      se[se_count] = se_runpath;
+      se_name[se_count] = "RUNPATH";
+      ++se_count;
+    }
+    if (se_count == 0) {
+      if (newRPath.empty()) {
+        // The new rpath is empty and there is no rpath anyway so it is
+        // okay.
+        return true;
+      } else {
+        if (emsg) {
+          *emsg = "No valid ELF RPATH or RUNPATH entry exists in the file; ";
+          *emsg += elf.GetErrorMessage();
         }
-      return false;
+        return false;
       }
     }
 
-  for(int i=0; i < se_count; ++i)
-    {
-    // If both RPATH and RUNPATH refer to the same string literal it
-    // needs to be changed only once.
-    if(rp_count && rp[0].Position == se[i]->Position)
-      {
-      continue;
+    for (int i = 0; i < se_count; ++i) {
+      // If both RPATH and RUNPATH refer to the same string literal it
+      // needs to be changed only once.
+      if (rp_count && rp[0].Position == se[i]->Position) {
+        continue;
       }
 
-    // Make sure the current rpath contains the old rpath.
-    std::string::size_type pos =
-      cmSystemToolsFindRPath(se[i]->Value, oldRPath);
-    if(pos == std::string::npos)
-      {
-      // If it contains the new rpath instead then it is okay.
-      if(cmSystemToolsFindRPath(se[i]->Value, newRPath) != std::string::npos)
-        {
-        remove_rpath = false;
-        continue;
+      // Make sure the current rpath contains the old rpath.
+      std::string::size_type pos =
+        cmSystemToolsFindRPath(se[i]->Value, oldRPath);
+      if (pos == std::string::npos) {
+        // If it contains the new rpath instead then it is okay.
+        if (cmSystemToolsFindRPath(se[i]->Value, newRPath) !=
+            std::string::npos) {
+          remove_rpath = false;
+          continue;
         }
-      if(emsg)
-        {
-        std::ostringstream e;
-        /* clang-format off */
+        if (emsg) {
+          std::ostringstream e;
+          /* clang-format off */
         e << "The current " << se_name[i] << " is:\n"
           << "  " << se[i]->Value << "\n"
           << "which does not contain:\n"
           << "  " << oldRPath << "\n"
           << "as was expected.";
-        /* clang-format on */
-        *emsg = e.str();
+          /* clang-format on */
+          *emsg = e.str();
         }
-      return false;
+        return false;
       }
 
-    // Store information about the entry in the file.
-    rp[rp_count].Position = se[i]->Position;
-    rp[rp_count].Size = se[i]->Size;
-    rp[rp_count].Name = se_name[i];
-
-    std::string::size_type prefix_len = pos;
-
-    // If oldRPath was at the end of the file's RPath, and newRPath is empty,
-    // we should remove the unnecessary ':' at the end.
-    if (newRPath.empty() &&
-        pos > 0 &&
-        se[i]->Value[pos - 1] == ':' &&
-        pos + oldRPath.length() == se[i]->Value.length())
-      {
-      prefix_len--;
+      // Store information about the entry in the file.
+      rp[rp_count].Position = se[i]->Position;
+      rp[rp_count].Size = se[i]->Size;
+      rp[rp_count].Name = se_name[i];
+
+      std::string::size_type prefix_len = pos;
+
+      // If oldRPath was at the end of the file's RPath, and newRPath is empty,
+      // we should remove the unnecessary ':' at the end.
+      if (newRPath.empty() && pos > 0 && se[i]->Value[pos - 1] == ':' &&
+          pos + oldRPath.length() == se[i]->Value.length()) {
+        prefix_len--;
       }
 
-    // Construct the new value which preserves the part of the path
-    // not being changed.
-    rp[rp_count].Value = se[i]->Value.substr(0, prefix_len);
-    rp[rp_count].Value += newRPath;
-    rp[rp_count].Value += se[i]->Value.substr(pos+oldRPath.length(),
-                                              oldRPath.npos);
+      // Construct the new value which preserves the part of the path
+      // not being changed.
+      rp[rp_count].Value = se[i]->Value.substr(0, prefix_len);
+      rp[rp_count].Value += newRPath;
+      rp[rp_count].Value +=
+        se[i]->Value.substr(pos + oldRPath.length(), oldRPath.npos);
 
-    if (!rp[rp_count].Value.empty())
-      {
-      remove_rpath = false;
+      if (!rp[rp_count].Value.empty()) {
+        remove_rpath = false;
       }
 
-    // Make sure there is enough room to store the new rpath and at
-    // least one null terminator.
-    if(rp[rp_count].Size < rp[rp_count].Value.length()+1)
-      {
-      if(emsg)
-        {
-        *emsg = "The replacement path is too long for the ";
-        *emsg += se_name[i];
-        *emsg += " entry.";
+      // Make sure there is enough room to store the new rpath and at
+      // least one null terminator.
+      if (rp[rp_count].Size < rp[rp_count].Value.length() + 1) {
+        if (emsg) {
+          *emsg = "The replacement path is too long for the ";
+          *emsg += se_name[i];
+          *emsg += " entry.";
         }
-      return false;
+        return false;
       }
 
-    // This entry is ready for update.
-    ++rp_count;
+      // This entry is ready for update.
+      ++rp_count;
     }
   }
 
   // If no runtime path needs to be changed, we are done.
-  if(rp_count == 0)
-    {
+  if (rp_count == 0) {
     return true;
-    }
+  }
 
   // If the resulting rpath is empty, just remove the entire entry instead.
-  if (remove_rpath)
-    {
+  if (remove_rpath) {
     return cmSystemTools::RemoveRPath(file, emsg, changed);
-    }
+  }
 
   {
-  // Open the file for update.
-  cmsys::ofstream f(file.c_str(),
-                  std::ios::in | std::ios::out | std::ios::binary);
-  if(!f)
-    {
-    if(emsg)
-      {
-      *emsg = "Error opening file for update.";
+    // Open the file for update.
+    cmsys::ofstream f(file.c_str(),
+                      std::ios::in | std::ios::out | std::ios::binary);
+    if (!f) {
+      if (emsg) {
+        *emsg = "Error opening file for update.";
       }
-    return false;
+      return false;
     }
 
-  // Store the new RPATH and RUNPATH strings.
-  for(int i=0; i < rp_count; ++i)
-    {
-    // Seek to the RPATH position.
-    if(!f.seekp(rp[i].Position))
-      {
-      if(emsg)
-        {
-        *emsg = "Error seeking to ";
-        *emsg += rp[i].Name;
-        *emsg += " position.";
+    // Store the new RPATH and RUNPATH strings.
+    for (int i = 0; i < rp_count; ++i) {
+      // Seek to the RPATH position.
+      if (!f.seekp(rp[i].Position)) {
+        if (emsg) {
+          *emsg = "Error seeking to ";
+          *emsg += rp[i].Name;
+          *emsg += " position.";
         }
-      return false;
+        return false;
       }
 
-    // Write the new rpath.  Follow it with enough null terminators to
-    // fill the string table entry.
-    f << rp[i].Value;
-    for(unsigned long j=rp[i].Value.length(); j < rp[i].Size; ++j)
-      {
-      f << '\0';
+      // Write the new rpath.  Follow it with enough null terminators to
+      // fill the string table entry.
+      f << rp[i].Value;
+      for (unsigned long j = rp[i].Value.length(); j < rp[i].Size; ++j) {
+        f << '\0';
       }
 
-    // Make sure it wrote correctly.
-    if(!f)
-      {
-      if(emsg)
-        {
-        *emsg = "Error writing the new ";
-        *emsg += rp[i].Name;
-        *emsg += " string to the file.";
+      // Make sure it wrote correctly.
+      if (!f) {
+        if (emsg) {
+          *emsg = "Error writing the new ";
+          *emsg += rp[i].Name;
+          *emsg += " string to the file.";
         }
-      return false;
+        return false;
       }
     }
   }
 
   // Everything was updated successfully.
-  if(changed)
-    {
+  if (changed) {
     *changed = true;
-    }
+  }
   return true;
 #else
   (void)file;
@@ -2727,38 +2365,32 @@ bool cmSystemTools::ChangeRPath(std::string const& file,
 bool cmSystemTools::VersionCompare(cmSystemTools::CompareOp op,
                                    const char* lhss, const char* rhss)
 {
-  const char *endl = lhss;
-  const char *endr = rhss;
+  const char* endl = lhss;
+  const char* endr = rhss;
   unsigned long lhs, rhs;
 
   while (((*endl >= '0') && (*endl <= '9')) ||
-         ((*endr >= '0') && (*endr <= '9')))
-    {
+         ((*endr >= '0') && (*endr <= '9'))) {
     // Do component-wise comparison.
     lhs = strtoul(endl, const_cast<char**>(&endl), 10);
     rhs = strtoul(endr, const_cast<char**>(&endr), 10);
 
-    if(lhs < rhs)
-      {
+    if (lhs < rhs) {
       // lhs < rhs, so true if operation is LESS
       return op == cmSystemTools::OP_LESS;
-      }
-    else if(lhs > rhs)
-      {
+    } else if (lhs > rhs) {
       // lhs > rhs, so true if operation is GREATER
       return op == cmSystemTools::OP_GREATER;
-      }
+    }
 
-    if (*endr == '.')
-      {
+    if (*endr == '.') {
       endr++;
-      }
+    }
 
-    if (*endl == '.')
-      {
+    if (*endl == '.') {
       endl++;
-      }
     }
+  }
   // lhs == rhs, so true if operation is EQUAL
   return op == cmSystemTools::OP_EQUAL;
 }
@@ -2766,177 +2398,152 @@ bool cmSystemTools::VersionCompare(cmSystemTools::CompareOp op,
 bool cmSystemTools::VersionCompareEqual(std::string const& lhs,
                                         std::string const& rhs)
 {
-  return cmSystemTools::VersionCompare(
-    cmSystemTools::OP_EQUAL, lhs.c_str(), rhs.c_str());
+  return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL, lhs.c_str(),
+                                       rhs.c_str());
 }
 
 bool cmSystemTools::VersionCompareGreater(std::string const& lhs,
                                           std::string const& rhs)
 {
-  return cmSystemTools::VersionCompare(
-    cmSystemTools::OP_GREATER, lhs.c_str(), rhs.c_str());
+  return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER, lhs.c_str(),
+                                       rhs.c_str());
 }
 
 bool cmSystemTools::RemoveRPath(std::string const& file, std::string* emsg,
                                 bool* removed)
 {
 #if defined(CMAKE_USE_ELF_PARSER)
-  if(removed)
-    {
+  if (removed) {
     *removed = false;
-    }
+  }
   int zeroCount = 0;
-  unsigned long zeroPosition[2] = {0,0};
-  unsigned long zeroSize[2] = {0,0};
+  unsigned long zeroPosition[2] = { 0, 0 };
+  unsigned long zeroSize[2] = { 0, 0 };
   unsigned long bytesBegin = 0;
   std::vector<char> bytes;
   {
-  // Parse the ELF binary.
-  cmELF elf(file.c_str());
+    // Parse the ELF binary.
+    cmELF elf(file.c_str());
 
-  // Get the RPATH and RUNPATH entries from it and sort them by index
-  // in the dynamic section header.
-  int se_count = 0;
-  cmELF::StringEntry const* se[2] = {0, 0};
-  if(cmELF::StringEntry const* se_rpath = elf.GetRPath())
-    {
-    se[se_count++] = se_rpath;
-    }
-  if(cmELF::StringEntry const* se_runpath = elf.GetRunPath())
-    {
-    se[se_count++] = se_runpath;
-    }
-  if(se_count == 0)
-    {
-    // There is no RPATH or RUNPATH anyway.
-    return true;
+    // Get the RPATH and RUNPATH entries from it and sort them by index
+    // in the dynamic section header.
+    int se_count = 0;
+    cmELF::StringEntry const* se[2] = { 0, 0 };
+    if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) {
+      se[se_count++] = se_rpath;
+    }
+    if (cmELF::StringEntry const* se_runpath = elf.GetRunPath()) {
+      se[se_count++] = se_runpath;
+    }
+    if (se_count == 0) {
+      // There is no RPATH or RUNPATH anyway.
+      return true;
     }
-  if(se_count == 2 && se[1]->IndexInSection < se[0]->IndexInSection)
-    {
-    std::swap(se[0], se[1]);
+    if (se_count == 2 && se[1]->IndexInSection < se[0]->IndexInSection) {
+      std::swap(se[0], se[1]);
     }
 
-  // Get the size of the dynamic section header.
-  unsigned int count = elf.GetDynamicEntryCount();
-  if(count == 0)
-    {
-    // This should happen only for invalid ELF files where a DT_NULL
-    // appears before the end of the table.
-    if(emsg)
-      {
-      *emsg = "DYNAMIC section contains a DT_NULL before the end.";
+    // Get the size of the dynamic section header.
+    unsigned int count = elf.GetDynamicEntryCount();
+    if (count == 0) {
+      // This should happen only for invalid ELF files where a DT_NULL
+      // appears before the end of the table.
+      if (emsg) {
+        *emsg = "DYNAMIC section contains a DT_NULL before the end.";
       }
-    return false;
+      return false;
     }
 
-  // Save information about the string entries to be zeroed.
-  zeroCount = se_count;
-  for(int i=0; i < se_count; ++i)
-    {
-    zeroPosition[i] = se[i]->Position;
-    zeroSize[i] = se[i]->Size;
-    }
-
-  // Get the range of file positions corresponding to each entry and
-  // the rest of the table after them.
-  unsigned long entryBegin[3] = {0,0,0};
-  unsigned long entryEnd[2] = {0,0};
-  for(int i=0; i < se_count; ++i)
-    {
-    entryBegin[i] = elf.GetDynamicEntryPosition(se[i]->IndexInSection);
-    entryEnd[i] = elf.GetDynamicEntryPosition(se[i]->IndexInSection+1);
-    }
-  entryBegin[se_count] = elf.GetDynamicEntryPosition(count);
-
-  // The data are to be written over the old table entries starting at
-  // the first one being removed.
-  bytesBegin = entryBegin[0];
-  unsigned long bytesEnd = entryBegin[se_count];
-
-  // Allocate a buffer to hold the part of the file to be written.
-  // Initialize it with zeros.
-  bytes.resize(bytesEnd - bytesBegin, 0);
-
-  // Read the part of the DYNAMIC section header that will move.
-  // The remainder of the buffer will be left with zeros which
-  // represent a DT_NULL entry.
-  char* data = &bytes[0];
-  for(int i=0; i < se_count; ++i)
-    {
-    // Read data between the entries being removed.
-    unsigned long sz = entryBegin[i+1] - entryEnd[i];
-    if(sz > 0 && !elf.ReadBytes(entryEnd[i], sz, data))
-      {
-      if(emsg)
-        {
-        *emsg = "Failed to read DYNAMIC section header.";
+    // Save information about the string entries to be zeroed.
+    zeroCount = se_count;
+    for (int i = 0; i < se_count; ++i) {
+      zeroPosition[i] = se[i]->Position;
+      zeroSize[i] = se[i]->Size;
+    }
+
+    // Get the range of file positions corresponding to each entry and
+    // the rest of the table after them.
+    unsigned long entryBegin[3] = { 0, 0, 0 };
+    unsigned long entryEnd[2] = { 0, 0 };
+    for (int i = 0; i < se_count; ++i) {
+      entryBegin[i] = elf.GetDynamicEntryPosition(se[i]->IndexInSection);
+      entryEnd[i] = elf.GetDynamicEntryPosition(se[i]->IndexInSection + 1);
+    }
+    entryBegin[se_count] = elf.GetDynamicEntryPosition(count);
+
+    // The data are to be written over the old table entries starting at
+    // the first one being removed.
+    bytesBegin = entryBegin[0];
+    unsigned long bytesEnd = entryBegin[se_count];
+
+    // Allocate a buffer to hold the part of the file to be written.
+    // Initialize it with zeros.
+    bytes.resize(bytesEnd - bytesBegin, 0);
+
+    // Read the part of the DYNAMIC section header that will move.
+    // The remainder of the buffer will be left with zeros which
+    // represent a DT_NULL entry.
+    char* data = &bytes[0];
+    for (int i = 0; i < se_count; ++i) {
+      // Read data between the entries being removed.
+      unsigned long sz = entryBegin[i + 1] - entryEnd[i];
+      if (sz > 0 && !elf.ReadBytes(entryEnd[i], sz, data)) {
+        if (emsg) {
+          *emsg = "Failed to read DYNAMIC section header.";
         }
-      return false;
+        return false;
       }
-    data += sz;
+      data += sz;
     }
   }
 
   // Open the file for update.
   cmsys::ofstream f(file.c_str(),
-                  std::ios::in | std::ios::out | std::ios::binary);
-  if(!f)
-    {
-    if(emsg)
-      {
+                    std::ios::in | std::ios::out | std::ios::binary);
+  if (!f) {
+    if (emsg) {
       *emsg = "Error opening file for update.";
-      }
-    return false;
     }
+    return false;
+  }
 
   // Write the new DYNAMIC table header.
-  if(!f.seekp(bytesBegin))
-    {
-    if(emsg)
-      {
+  if (!f.seekp(bytesBegin)) {
+    if (emsg) {
       *emsg = "Error seeking to DYNAMIC table header for RPATH.";
-      }
-    return false;
     }
-  if(!f.write(&bytes[0], bytes.size()))
-    {
-    if(emsg)
-      {
-      *emsg = "Error replacing DYNAMIC table header.";
-      }
     return false;
+  }
+  if (!f.write(&bytes[0], bytes.size())) {
+    if (emsg) {
+      *emsg = "Error replacing DYNAMIC table header.";
     }
+    return false;
+  }
 
   // Fill the RPATH and RUNPATH strings with zero bytes.
-  for(int i=0; i < zeroCount; ++i)
-    {
-    if(!f.seekp(zeroPosition[i]))
-      {
-      if(emsg)
-        {
+  for (int i = 0; i < zeroCount; ++i) {
+    if (!f.seekp(zeroPosition[i])) {
+      if (emsg) {
         *emsg = "Error seeking to RPATH position.";
-        }
-      return false;
       }
-    for(unsigned long j=0; j < zeroSize[i]; ++j)
-      {
+      return false;
+    }
+    for (unsigned long j = 0; j < zeroSize[i]; ++j) {
       f << '\0';
-      }
-    if(!f)
-      {
-      if(emsg)
-        {
+    }
+    if (!f) {
+      if (emsg) {
         *emsg = "Error writing the empty rpath string to the file.";
-        }
-      return false;
       }
+      return false;
     }
+  }
 
   // Everything was updated successfully.
-  if(removed)
-    {
+  if (removed) {
     *removed = true;
-    }
+  }
   return true;
 #else
   (void)file;
@@ -2955,27 +2562,21 @@ bool cmSystemTools::CheckRPath(std::string const& file,
 
   // Get the RPATH or RUNPATH entry from it.
   cmELF::StringEntry const* se = elf.GetRPath();
-  if(!se)
-    {
+  if (!se) {
     se = elf.GetRunPath();
-    }
+  }
 
   // Make sure the current rpath contains the new rpath.
-  if(newRPath.empty())
-    {
-    if(!se)
-      {
+  if (newRPath.empty()) {
+    if (!se) {
       return true;
-      }
     }
-  else
-    {
-    if(se &&
-       cmSystemToolsFindRPath(se->Value, newRPath) != std::string::npos)
-      {
+  } else {
+    if (se &&
+        cmSystemToolsFindRPath(se->Value, newRPath) != std::string::npos) {
       return true;
-      }
     }
+  }
   return false;
 #else
   (void)file;
@@ -2987,52 +2588,44 @@ bool cmSystemTools::CheckRPath(std::string const& file,
 bool cmSystemTools::RepeatedRemoveDirectory(const char* dir)
 {
   // Windows sometimes locks files temporarily so try a few times.
-  for(int i = 0; i < 10; ++i)
-    {
-    if(cmSystemTools::RemoveADirectory(dir))
-      {
+  for (int i = 0; i < 10; ++i) {
+    if (cmSystemTools::RemoveADirectory(dir)) {
       return true;
-      }
-    cmSystemTools::Delay(100);
     }
+    cmSystemTools::Delay(100);
+  }
   return false;
 }
 
 std::vector<std::string> cmSystemTools::tokenize(const std::string& str,
-                                  const std::string& sep)
+                                                 const std::string& sep)
 {
   std::vector<std::string> tokens;
   std::string::size_type tokend = 0;
 
-  do
-    {
-    std::string::size_type tokstart=str.find_first_not_of(sep, tokend);
-    if (tokstart==std::string::npos)
-      {
-      break;    // no more tokens
-      }
-    tokend=str.find_first_of(sep,tokstart);
-    if (tokend==std::string::npos)
-      {
+  do {
+    std::string::size_type tokstart = str.find_first_not_of(sep, tokend);
+    if (tokstart == std::string::npos) {
+      break; // no more tokens
+    }
+    tokend = str.find_first_of(sep, tokstart);
+    if (tokend == std::string::npos) {
       tokens.push_back(str.substr(tokstart));
-      }
-    else
-      {
-      tokens.push_back(str.substr(tokstart,tokend-tokstart));
-      }
-    } while (tokend!=std::string::npos);
+    } else {
+      tokens.push_back(str.substr(tokstart, tokend - tokstart));
+    }
+  } while (tokend != std::string::npos);
 
-  if (tokens.empty())
-    {
+  if (tokens.empty()) {
     tokens.push_back("");
-    }
+  }
   return tokens;
 }
 
 bool cmSystemTools::StringToLong(const char* str, long* value)
 {
   errno = 0;
-  char *endp;
+  char* endp;
   *value = strtol(str, &endp, 10);
   return (*endp == '\0') && (endp != str) && (errno == 0);
 }
@@ -3040,7 +2633,7 @@ bool cmSystemTools::StringToLong(const char* str, long* value)
 bool cmSystemTools::StringToULong(const char* str, unsigned long* value)
 {
   errno = 0;
-  char *endp;
+  char* endp;
   *value = strtoul(str, &endp, 10);
   return (*endp == '\0') && (endp != str) && (errno == 0);
 }
diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h
index d311750..df2c1f7 100644
--- a/Source/cmSystemTools.h
+++ b/Source/cmSystemTools.h
@@ -25,7 +25,7 @@ class cmSystemToolsFileTime;
  * cmSystemTools is a class that provides helper functions
  * for the CMake build system.
  */
-class cmSystemTools: public cmsys::SystemTools
+class cmSystemTools : public cmsys::SystemTools
 {
 public:
   typedef cmsys::SystemTools Superclass;
@@ -38,7 +38,7 @@ public:
                          std::vector<std::string>& argsOut);
   static void ExpandListArgument(const std::string& arg,
                                  std::vector<std::string>& argsOut,
-                                 bool emptyArgs=false);
+                                 bool emptyArgs = false);
 
   /**
    * Look for and replace registry values in a string
@@ -64,64 +64,59 @@ public:
    *  title as a const char*, and a reference to bool that when
    *  set to false, will disable furthur messages (cancel).
    */
-  static void SetMessageCallback(MessageCallback f, void* clientData=0);
+  static void SetMessageCallback(MessageCallback f, void* clientData = 0);
 
   /**
    * Display an error message.
    */
-  static void Error(const char* m, const char* m2=0,
-                    const char* m3=0, const char* m4=0);
+  static void Error(const char* m, const char* m2 = 0, const char* m3 = 0,
+                    const char* m4 = 0);
 
   /**
    * Display a message.
    */
-  static void Message(const char* m, const char* title=0);
+  static void Message(const char* m, const char* title = 0);
 
   typedef void (*OutputCallback)(const char*, size_t length, void*);
 
   ///! Send a string to stdout
   static void Stdout(const char* s);
   static void Stdout(const char* s, size_t length);
-  static void SetStdoutCallback(OutputCallback, void* clientData=0);
+  static void SetStdoutCallback(OutputCallback, void* clientData = 0);
 
   ///! Send a string to stderr
   static void Stderr(const char* s);
   static void Stderr(const char* s, size_t length);
-  static void SetStderrCallback(OutputCallback, void* clientData=0);
-
+  static void SetStderrCallback(OutputCallback, void* clientData = 0);
 
   typedef bool (*InterruptCallback)(void*);
-  static void SetInterruptCallback(InterruptCallback f, void* clientData=0);
+  static void SetInterruptCallback(InterruptCallback f, void* clientData = 0);
   static bool GetInterruptFlag();
 
   ///! Return true if there was an error at any point.
   static bool GetErrorOccuredFlag()
-    {
-      return cmSystemTools::s_ErrorOccured ||
-        cmSystemTools::s_FatalErrorOccured ||
-        GetInterruptFlag();
-    }
+  {
+    return cmSystemTools::s_ErrorOccured ||
+      cmSystemTools::s_FatalErrorOccured || GetInterruptFlag();
+  }
   ///! If this is set to true, cmake stops processing commands.
   static void SetFatalErrorOccured()
-    {
-      cmSystemTools::s_FatalErrorOccured = true;
-    }
-  static void SetErrorOccured()
-    {
-      cmSystemTools::s_ErrorOccured = true;
-    }
- ///! Return true if there was an error at any point.
+  {
+    cmSystemTools::s_FatalErrorOccured = true;
+  }
+  static void SetErrorOccured() { cmSystemTools::s_ErrorOccured = true; }
+  ///! Return true if there was an error at any point.
   static bool GetFatalErrorOccured()
-    {
-      return cmSystemTools::s_FatalErrorOccured || GetInterruptFlag();
-    }
+  {
+    return cmSystemTools::s_FatalErrorOccured || GetInterruptFlag();
+  }
 
   ///! Set the error occurred flag and fatal error back to false
   static void ResetErrorOccuredFlag()
-    {
-      cmSystemTools::s_FatalErrorOccured = false;
-      cmSystemTools::s_ErrorOccured = false;
-    }
+  {
+    cmSystemTools::s_FatalErrorOccured = false;
+    cmSystemTools::s_ErrorOccured = false;
+  }
 
   /**
    * Does a string indicates that CMake/CPack/CTest internally
@@ -150,8 +145,7 @@ public:
   static bool IsPathToFramework(const char* value);
 
   static bool DoesFileExistWithExtensions(
-    const char *name,
-    const std::vector<std::string>& sourceExts);
+    const char* name, const std::vector<std::string>& sourceExts);
 
   /**
    * Check if the given file exists in one of the parent directory of the
@@ -159,7 +153,8 @@ public:
    * Toplevel specifies the top-most directory to where it will look.
    */
   static std::string FileExistsInParentDirectories(const char* fname,
-    const char* directory, const char* toplevel);
+                                                   const char* directory,
+                                                   const char* toplevel);
 
   static void Glob(const std::string& directory, const std::string& regexp,
                    std::vector<std::string>& files);
@@ -176,13 +171,11 @@ public:
    * files only. This method returns true if search was succesfull.
    */
   static bool SimpleGlob(const std::string& glob,
-                         std::vector<std::string>& files,
-                         int type = 0);
+                         std::vector<std::string>& files, int type = 0);
 
   ///! Copy a file.
   static bool cmCopyFile(const char* source, const char* destination);
-  static bool CopyFileIfDifferent(const char* source,
-    const char* destination);
+  static bool CopyFileIfDifferent(const char* source, const char* destination);
 
   /** Rename a file or directory within a single disk volume (atomic
       if possible).  */
@@ -219,17 +212,17 @@ public:
    * it into this function or it will not work.  The command must be correctly
    * escaped for this to with spaces.
    */
-   enum OutputOption
-   {
-     OUTPUT_NONE = 0,
-     OUTPUT_MERGE,
-     OUTPUT_FORWARD,
-     OUTPUT_PASSTHROUGH
-   };
+  enum OutputOption
+  {
+    OUTPUT_NONE = 0,
+    OUTPUT_MERGE,
+    OUTPUT_FORWARD,
+    OUTPUT_PASSTHROUGH
+  };
   static bool RunSingleCommand(const char* command,
                                std::string* captureStdOut = 0,
-                               std::string* captureStdErr = 0,
-                               int* retVal = 0, const char* dir = 0,
+                               std::string* captureStdErr = 0, int* retVal = 0,
+                               const char* dir = 0,
                                OutputOption outputflag = OUTPUT_MERGE,
                                double timeout = 0.0);
   /**
@@ -239,8 +232,8 @@ public:
    */
   static bool RunSingleCommand(std::vector<std::string> const& command,
                                std::string* captureStdOut = 0,
-                               std::string* captureStdErr = 0,
-                               int* retVal = 0, const char* dir = 0,
+                               std::string* captureStdErr = 0, int* retVal = 0,
+                               const char* dir = 0,
                                OutputOption outputflag = OUTPUT_MERGE,
                                double timeout = 0.0);
 
@@ -261,14 +254,15 @@ public:
 
   static void EnableMessages() { s_DisableMessages = false; }
   static void DisableMessages() { s_DisableMessages = true; }
-  static void DisableRunCommandOutput() {s_DisableRunCommandOutput = true; }
-  static void EnableRunCommandOutput() {s_DisableRunCommandOutput = false; }
+  static void DisableRunCommandOutput() { s_DisableRunCommandOutput = true; }
+  static void EnableRunCommandOutput() { s_DisableRunCommandOutput = false; }
   static bool GetRunCommandOutput() { return s_DisableRunCommandOutput; }
 
   /**
    * Some constants for different file formats.
    */
-  enum FileFormat {
+  enum FileFormat
+  {
     NO_FILE_FORMAT = 0,
     C_FILE_FORMAT,
     CXX_FILE_FORMAT,
@@ -284,7 +278,8 @@ public:
     UNKNOWN_FILE_FORMAT
   };
 
-  enum CompareOp {
+  enum CompareOp
+  {
     OP_LESS,
     OP_GREATER,
     OP_EQUAL
@@ -307,8 +302,8 @@ public:
   /** Windows if this is true, the CreateProcess in RunCommand will
    *  not show new consol windows when running programs.
    */
-  static void SetRunCommandHideConsole(bool v){s_RunCommandHideConsole = v;}
-  static bool GetRunCommandHideConsole(){ return s_RunCommandHideConsole;}
+  static void SetRunCommandHideConsole(bool v) { s_RunCommandHideConsole = v; }
+  static bool GetRunCommandHideConsole() { return s_RunCommandHideConsole; }
   /** Call cmSystemTools::Error with the message m, plus the
    * result of strerror(errno)
    */
@@ -316,21 +311,14 @@ public:
 
   /** a general output handler for cmsysProcess  */
   static int WaitForLine(cmsysProcess* process, std::string& line,
-                         double timeout,
-                         std::vector<char>& out,
+                         double timeout, std::vector<char>& out,
                          std::vector<char>& err);
 
   /** Split a string on its newlines into multiple lines.  Returns
       false only if the last line stored had no newline.  */
   static bool Split(const char* s, std::vector<std::string>& l);
-  static void SetForceUnixPaths(bool v)
-    {
-      s_ForceUnixPaths = v;
-    }
-  static bool GetForceUnixPaths()
-    {
-      return s_ForceUnixPaths;
-    }
+  static void SetForceUnixPaths(bool v) { s_ForceUnixPaths = v; }
+  static bool GetForceUnixPaths() { return s_ForceUnixPaths; }
 
   // ConvertToOutputPath use s_ForceUnixPaths
   static std::string ConvertToOutputPath(const char* path);
@@ -377,6 +365,7 @@ public:
   public:
     SaveRestoreEnvironment();
     virtual ~SaveRestoreEnvironment();
+
   private:
     std::vector<std::string> Env;
   };
@@ -393,8 +382,7 @@ public:
     TarCompressXZ,
     TarCompressNone
   };
-  static bool ListTar(const char* outFileName,
-                      bool verbose);
+  static bool ListTar(const char* outFileName, bool verbose);
   static bool CreateTar(const char* outFileName,
                         const std::vector<std::string>& files,
                         cmTarCompression compressType, bool verbose,
@@ -434,8 +422,8 @@ public:
   static std::string const& GetCMakeRoot();
 
   /** Echo a message in color using KWSys's Terminal cprintf.  */
-  static void MakefileColorEcho(int color, const char* message,
-                                bool newLine, bool enabled);
+  static void MakefileColorEcho(int color, const char* message, bool newLine,
+                                bool enabled);
 
   /** Try to guess the soname of a shared library.  */
   static bool GuessLibrarySOName(std::string const& fullPath,
@@ -443,13 +431,11 @@ public:
 
   /** Try to guess the install name of a shared library.  */
   static bool GuessLibraryInstallName(std::string const& fullPath,
-                                 std::string& soname);
+                                      std::string& soname);
 
   /** Try to set the RPATH in an ELF binary.  */
-  static bool ChangeRPath(std::string const& file,
-                          std::string const& oldRPath,
-                          std::string const& newRPath,
-                          std::string* emsg = 0,
+  static bool ChangeRPath(std::string const& file, std::string const& oldRPath,
+                          std::string const& newRPath, std::string* emsg = 0,
                           bool* changed = 0);
 
   /** Try to remove the RPATH from an ELF binary.  */
@@ -458,8 +444,7 @@ public:
 
   /** Check whether the RPATH in an ELF binary contains the path
       given.  */
-  static bool CheckRPath(std::string const& file,
-                         std::string const& newRPath);
+  static bool CheckRPath(std::string const& file, std::string const& newRPath);
 
   /** Remove a directory; repeat a few times in case of locked files.  */
   static bool RepeatedRemoveDirectory(const char* dir);
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index d7d301f..5e0d2b7 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -67,15 +67,12 @@ void cmTarget::SetType(cmState::TargetType type, const std::string& name)
   this->Name = name;
   // only add dependency information for library targets
   this->TargetTypeValue = type;
-  if(this->TargetTypeValue >= cmState::STATIC_LIBRARY
-     && this->TargetTypeValue <= cmState::MODULE_LIBRARY)
-    {
+  if (this->TargetTypeValue >= cmState::STATIC_LIBRARY &&
+      this->TargetTypeValue <= cmState::MODULE_LIBRARY) {
     this->RecordDependencies = true;
-    }
-  else
-    {
+  } else {
     this->RecordDependencies = false;
-    }
+  }
 }
 
 void cmTarget::SetMakefile(cmMakefile* mf)
@@ -84,9 +81,9 @@ void cmTarget::SetMakefile(cmMakefile* mf)
   this->Makefile = mf;
 
   // Check whether this is a DLL platform.
-  this->DLLPlatform = (this->Makefile->IsOn("WIN32") ||
-                       this->Makefile->IsOn("CYGWIN") ||
-                       this->Makefile->IsOn("MINGW"));
+  this->DLLPlatform =
+    (this->Makefile->IsOn("WIN32") || this->Makefile->IsOn("CYGWIN") ||
+     this->Makefile->IsOn("MINGW"));
 
   // Check whether we are targeting an Android platform.
   this->IsAndroid =
@@ -94,9 +91,8 @@ void cmTarget::SetMakefile(cmMakefile* mf)
            "Android") == 0;
 
   // Setup default property values.
-  if (this->GetType() != cmState::INTERFACE_LIBRARY
-      && this->GetType() != cmState::UTILITY)
-    {
+  if (this->GetType() != cmState::INTERFACE_LIBRARY &&
+      this->GetType() != cmState::UTILITY) {
     this->SetPropertyDefault("ANDROID_API", 0);
     this->SetPropertyDefault("ANDROID_API_MIN", 0);
     this->SetPropertyDefault("ANDROID_ARCH", 0);
@@ -154,15 +150,14 @@ void cmTarget::SetMakefile(cmMakefile* mf)
     this->SetPropertyDefault("CXX_EXTENSIONS", 0);
     this->SetPropertyDefault("LINK_SEARCH_START_STATIC", 0);
     this->SetPropertyDefault("LINK_SEARCH_END_STATIC", 0);
-    }
+  }
 
   // Collect the set of configuration types.
   std::vector<std::string> configNames;
   mf->GetConfigurations(configNames);
 
   // Setup per-configuration property default values.
-  if (this->GetType() != cmState::UTILITY)
-    {
+  if (this->GetType() != cmState::UTILITY) {
     const char* configProps[] = {
       /* clang-format needs this comment to break after the opening brace */
       "ARCHIVE_OUTPUT_DIRECTORY_",
@@ -171,140 +166,129 @@ void cmTarget::SetMakefile(cmMakefile* mf)
       "PDB_OUTPUT_DIRECTORY_",
       "COMPILE_PDB_OUTPUT_DIRECTORY_",
       "MAP_IMPORTED_CONFIG_",
-      0};
-    for(std::vector<std::string>::iterator ci = configNames.begin();
-        ci != configNames.end(); ++ci)
-      {
+      0
+    };
+    for (std::vector<std::string>::iterator ci = configNames.begin();
+         ci != configNames.end(); ++ci) {
       std::string configUpper = cmSystemTools::UpperCase(*ci);
-      for(const char** p = configProps; *p; ++p)
-        {
-        if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY
-            && strcmp(*p, "MAP_IMPORTED_CONFIG_") != 0)
-          {
+      for (const char** p = configProps; *p; ++p) {
+        if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY &&
+            strcmp(*p, "MAP_IMPORTED_CONFIG_") != 0) {
           continue;
-          }
+        }
         std::string property = *p;
         property += configUpper;
         this->SetPropertyDefault(property, 0);
-        }
+      }
 
       // Initialize per-configuration name postfix property from the
       // variable only for non-executable targets.  This preserves
       // compatibility with previous CMake versions in which executables
       // did not support this variable.  Projects may still specify the
       // property directly.
-      if(this->TargetTypeValue != cmState::EXECUTABLE
-          && this->TargetTypeValue != cmState::INTERFACE_LIBRARY)
-        {
+      if (this->TargetTypeValue != cmState::EXECUTABLE &&
+          this->TargetTypeValue != cmState::INTERFACE_LIBRARY) {
         std::string property = cmSystemTools::UpperCase(*ci);
         property += "_POSTFIX";
         this->SetPropertyDefault(property, 0);
-        }
       }
     }
+  }
 
   // Save the backtrace of target construction.
   this->Backtrace = this->Makefile->GetBacktrace();
 
-  if (!this->IsImported())
-    {
+  if (!this->IsImported()) {
     // Initialize the INCLUDE_DIRECTORIES property based on the current value
     // of the same directory property:
     const cmStringRange parentIncludes =
-        this->Makefile->GetIncludeDirectoriesEntries();
+      this->Makefile->GetIncludeDirectoriesEntries();
     const cmBacktraceRange parentIncludesBts =
-        this->Makefile->GetIncludeDirectoriesBacktraces();
+      this->Makefile->GetIncludeDirectoriesBacktraces();
 
     this->Internal->IncludeDirectoriesEntries.insert(
-          this->Internal->IncludeDirectoriesEntries.end(),
-          parentIncludes.begin(), parentIncludes.end());
+      this->Internal->IncludeDirectoriesEntries.end(), parentIncludes.begin(),
+      parentIncludes.end());
     this->Internal->IncludeDirectoriesBacktraces.insert(
-          this->Internal->IncludeDirectoriesBacktraces.end(),
-          parentIncludesBts.begin(), parentIncludesBts.end());
+      this->Internal->IncludeDirectoriesBacktraces.end(),
+      parentIncludesBts.begin(), parentIncludesBts.end());
 
     const std::set<std::string> parentSystemIncludes =
-                                this->Makefile->GetSystemIncludeDirectories();
+      this->Makefile->GetSystemIncludeDirectories();
 
     this->SystemIncludeDirectories.insert(parentSystemIncludes.begin(),
                                           parentSystemIncludes.end());
 
     const cmStringRange parentOptions =
-                                this->Makefile->GetCompileOptionsEntries();
+      this->Makefile->GetCompileOptionsEntries();
     const cmBacktraceRange parentOptionsBts =
-                                this->Makefile->GetCompileOptionsBacktraces();
+      this->Makefile->GetCompileOptionsBacktraces();
 
     this->Internal->CompileOptionsEntries.insert(
-          this->Internal->CompileOptionsEntries.end(),
-          parentOptions.begin(), parentOptions.end());
+      this->Internal->CompileOptionsEntries.end(), parentOptions.begin(),
+      parentOptions.end());
     this->Internal->CompileOptionsBacktraces.insert(
-          this->Internal->CompileOptionsBacktraces.end(),
-          parentOptionsBts.begin(), parentOptionsBts.end());
-    }
+      this->Internal->CompileOptionsBacktraces.end(), parentOptionsBts.begin(),
+      parentOptionsBts.end());
+  }
 
-  if (this->GetType() != cmState::INTERFACE_LIBRARY
-      && this->GetType() != cmState::UTILITY)
-    {
+  if (this->GetType() != cmState::INTERFACE_LIBRARY &&
+      this->GetType() != cmState::UTILITY) {
     this->SetPropertyDefault("C_VISIBILITY_PRESET", 0);
     this->SetPropertyDefault("CXX_VISIBILITY_PRESET", 0);
     this->SetPropertyDefault("VISIBILITY_INLINES_HIDDEN", 0);
-    }
+  }
 
-  if(this->TargetTypeValue == cmState::EXECUTABLE)
-    {
+  if (this->TargetTypeValue == cmState::EXECUTABLE) {
     this->SetPropertyDefault("ANDROID_GUI", 0);
     this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", 0);
     this->SetPropertyDefault("ENABLE_EXPORTS", 0);
-    }
-  if(this->TargetTypeValue == cmState::SHARED_LIBRARY
-      || this->TargetTypeValue == cmState::MODULE_LIBRARY)
-    {
+  }
+  if (this->TargetTypeValue == cmState::SHARED_LIBRARY ||
+      this->TargetTypeValue == cmState::MODULE_LIBRARY) {
     this->SetProperty("POSITION_INDEPENDENT_CODE", "True");
-    }
-  if(this->TargetTypeValue == cmState::SHARED_LIBRARY)
-    {
+  }
+  if (this->TargetTypeValue == cmState::SHARED_LIBRARY) {
     this->SetPropertyDefault("WINDOWS_EXPORT_ALL_SYMBOLS", 0);
-    }
+  }
 
-  if (this->GetType() != cmState::INTERFACE_LIBRARY
-      && this->GetType() != cmState::UTILITY)
-    {
+  if (this->GetType() != cmState::INTERFACE_LIBRARY &&
+      this->GetType() != cmState::UTILITY) {
     this->SetPropertyDefault("POSITION_INDEPENDENT_CODE", 0);
-    }
+  }
 
   // Record current policies for later use.
   this->Makefile->RecordPolicies(this->PolicyMap);
 
-  if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->TargetTypeValue == cmState::INTERFACE_LIBRARY) {
     // This policy is checked in a few conditions. The properties relevant
     // to the policy are always ignored for cmState::INTERFACE_LIBRARY targets,
     // so ensure that the conditions don't lead to nonsense.
     this->PolicyMap.Set(cmPolicies::CMP0022, cmPolicies::NEW);
-    }
+  }
 
-  if (this->GetType() != cmState::INTERFACE_LIBRARY
-      && this->GetType() != cmState::UTILITY)
-    {
+  if (this->GetType() != cmState::INTERFACE_LIBRARY &&
+      this->GetType() != cmState::UTILITY) {
     this->SetPropertyDefault("JOB_POOL_COMPILE", 0);
     this->SetPropertyDefault("JOB_POOL_LINK", 0);
-    }
+  }
 }
 
-void cmTarget::AddUtility(const std::string& u, cmMakefile *makefile)
+void cmTarget::AddUtility(const std::string& u, cmMakefile* makefile)
 {
-  if(this->Utilities.insert(u).second && makefile)
-    {
+  if (this->Utilities.insert(u).second && makefile) {
     this->UtilityBacktraces.insert(
-            std::make_pair(u, makefile->GetBacktrace()));
-    }
+      std::make_pair(u, makefile->GetBacktrace()));
+  }
 }
 
 cmListFileBacktrace const* cmTarget::GetUtilityBacktrace(
-    const std::string& u) const
+  const std::string& u) const
 {
   std::map<std::string, cmListFileBacktrace>::const_iterator i =
     this->UtilityBacktraces.find(u);
-  if(i == this->UtilityBacktraces.end()) return 0;
+  if (i == this->UtilityBacktraces.end())
+    return 0;
 
   return &i->second;
 }
@@ -322,9 +306,8 @@ bool cmTarget::IsExecutableWithExports() const
 
 bool cmTarget::HasImportLibrary() const
 {
-  return (this->DLLPlatform &&
-          (this->GetType() == cmState::SHARED_LIBRARY ||
-           this->IsExecutableWithExports()));
+  return (this->DLLPlatform && (this->GetType() == cmState::SHARED_LIBRARY ||
+                                this->IsExecutableWithExports()));
 }
 
 bool cmTarget::IsFrameworkOnApple() const
@@ -343,46 +326,40 @@ bool cmTarget::IsAppBundleOnApple() const
 
 void cmTarget::AddTracedSources(std::vector<std::string> const& srcs)
 {
-  if (!srcs.empty())
-    {
+  if (!srcs.empty()) {
     cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
     this->Internal->SourceEntries.push_back(cmJoin(srcs, ";"));
     this->Internal->SourceBacktraces.push_back(lfbt);
-    }
+  }
 }
 
 void cmTarget::AddSources(std::vector<std::string> const& srcs)
 {
   std::string srcFiles;
   const char* sep = "";
-  for(std::vector<std::string>::const_iterator i = srcs.begin();
-      i != srcs.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = srcs.begin();
+       i != srcs.end(); ++i) {
     std::string filename = *i;
     const char* src = filename.c_str();
 
-    if(!(src[0] == '$' && src[1] == '<'))
-      {
-      if(!filename.empty())
-        {
+    if (!(src[0] == '$' && src[1] == '<')) {
+      if (!filename.empty()) {
         filename = this->ProcessSourceItemCMP0049(filename);
-        if(filename.empty())
-          {
+        if (filename.empty()) {
           return;
-          }
         }
-      this->Makefile->GetOrCreateSource(filename);
       }
+      this->Makefile->GetOrCreateSource(filename);
+    }
     srcFiles += sep;
     srcFiles += filename;
     sep = ";";
-    }
-  if (!srcFiles.empty())
-    {
+  }
+  if (!srcFiles.empty()) {
     cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
     this->Internal->SourceEntries.push_back(srcFiles);
     this->Internal->SourceBacktraces.push_back(lfbt);
-    }
+  }
 }
 
 std::string cmTarget::ProcessSourceItemCMP0049(const std::string& s)
@@ -392,13 +369,11 @@ std::string cmTarget::ProcessSourceItemCMP0049(const std::string& s)
   // For backwards compatibility replace varibles in source names.
   // This should eventually be removed.
   this->Makefile->ExpandVariablesInString(src);
-  if (src != s)
-    {
+  if (src != s) {
     std::ostringstream e;
     bool noMessage = false;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0049))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0049)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0049) << "\n";
         break;
@@ -409,30 +384,27 @@ std::string cmTarget::ProcessSourceItemCMP0049(const std::string& s)
       case cmPolicies::REQUIRED_IF_USED:
       case cmPolicies::NEW:
         messageType = cmake::FATAL_ERROR;
-      }
-    if (!noMessage)
-      {
-      e << "Legacy variable expansion in source file \""
-        << s << "\" expanded to \"" << src << "\" in target \""
-        << this->GetName() << "\".  This behavior will be removed in a "
-        "future version of CMake.";
+    }
+    if (!noMessage) {
+      e << "Legacy variable expansion in source file \"" << s
+        << "\" expanded to \"" << src << "\" in target \"" << this->GetName()
+        << "\".  This behavior will be removed in a "
+           "future version of CMake.";
       this->Makefile->IssueMessage(messageType, e.str());
-      if (messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return "";
-        }
       }
     }
+  }
   return src;
 }
 
 cmSourceFile* cmTarget::AddSourceCMP0049(const std::string& s)
 {
   std::string src = this->ProcessSourceItemCMP0049(s);
-  if(!s.empty() && src.empty())
-    {
+  if (!s.empty() && src.empty()) {
     return 0;
-    }
+  }
   return this->AddSource(src);
 }
 
@@ -443,7 +415,6 @@ struct CreateLocation
   CreateLocation(cmMakefile const* mf)
     : Makefile(mf)
   {
-
   }
 
   cmSourceFileLocation operator()(const std::string& filename)
@@ -459,25 +430,23 @@ struct LocationMatcher
   LocationMatcher(const cmSourceFileLocation& needle)
     : Needle(needle)
   {
-
   }
 
-  bool operator()(cmSourceFileLocation &loc)
+  bool operator()(cmSourceFileLocation& loc)
   {
     return loc.Matches(this->Needle);
   }
 };
 
-
 struct TargetPropertyEntryFinder
 {
 private:
   const cmSourceFileLocation& Needle;
+
 public:
   TargetPropertyEntryFinder(const cmSourceFileLocation& needle)
     : Needle(needle)
   {
-
   }
 
   bool operator()(std::string const& entry)
@@ -489,7 +458,7 @@ public:
                    CreateLocation(this->Needle.GetMakefile()));
 
     return std::find_if(locations.begin(), locations.end(),
-        LocationMatcher(this->Needle)) != locations.end();
+                        LocationMatcher(this->Needle)) != locations.end();
   }
 };
 
@@ -498,45 +467,41 @@ cmSourceFile* cmTarget::AddSource(const std::string& src)
   cmSourceFileLocation sfl(this->Makefile, src);
   if (std::find_if(this->Internal->SourceEntries.begin(),
                    this->Internal->SourceEntries.end(),
-                   TargetPropertyEntryFinder(sfl))
-                                      == this->Internal->SourceEntries.end())
-    {
+                   TargetPropertyEntryFinder(sfl)) ==
+      this->Internal->SourceEntries.end()) {
     cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
     this->Internal->SourceEntries.push_back(src);
     this->Internal->SourceBacktraces.push_back(lfbt);
-    }
-  if (cmGeneratorExpression::Find(src) != std::string::npos)
-    {
+  }
+  if (cmGeneratorExpression::Find(src) != std::string::npos) {
     return 0;
-    }
+  }
   return this->Makefile->GetOrCreateSource(src);
 }
 
-void cmTarget::MergeLinkLibraries( cmMakefile& mf,
-                                   const std::string& selfname,
-                                   const LinkLibraryVectorType& libs )
+void cmTarget::MergeLinkLibraries(cmMakefile& mf, const std::string& selfname,
+                                  const LinkLibraryVectorType& libs)
 {
   // Only add on libraries we haven't added on before.
   // Assumption: the global link libraries could only grow, never shrink
   LinkLibraryVectorType::const_iterator i = libs.begin();
   i += this->PrevLinkedLibraries.size();
-  for( ; i != libs.end(); ++i )
-    {
+  for (; i != libs.end(); ++i) {
     // This is equivalent to the target_link_libraries plain signature.
-    this->AddLinkLibrary( mf, selfname, i->first, i->second );
-    this->AppendProperty("INTERFACE_LINK_LIBRARIES",
+    this->AddLinkLibrary(mf, selfname, i->first, i->second);
+    this->AppendProperty(
+      "INTERFACE_LINK_LIBRARIES",
       this->GetDebugGeneratorExpressions(i->first, i->second).c_str());
-    }
+  }
   this->PrevLinkedLibraries = libs;
 }
 
 void cmTarget::AddLinkDirectory(const std::string& d)
 {
   // Make sure we don't add unnecessary search directories.
-  if(this->LinkDirectoriesEmmitted.insert(d).second)
-    {
+  if (this->LinkDirectoriesEmmitted.insert(d).second) {
     this->LinkDirectories.push_back(d);
-    }
+  }
 }
 
 const std::vector<std::string>& cmTarget::GetLinkDirectories() const
@@ -544,61 +509,54 @@ const std::vector<std::string>& cmTarget::GetLinkDirectories() const
   return this->LinkDirectories;
 }
 
-void cmTarget::ClearDependencyInformation( cmMakefile& mf,
-                                           const std::string& target )
+void cmTarget::ClearDependencyInformation(cmMakefile& mf,
+                                          const std::string& target)
 {
   // Clear the dependencies. The cache variable must exist iff we are
   // recording dependency information for this target.
   std::string depname = target;
   depname += "_LIB_DEPENDS";
-  if (this->RecordDependencies)
-    {
-    mf.AddCacheDefinition(depname, "",
-                          "Dependencies for target", cmState::STATIC);
-    }
-  else
-    {
-    if (mf.GetDefinition( depname ))
-      {
+  if (this->RecordDependencies) {
+    mf.AddCacheDefinition(depname, "", "Dependencies for target",
+                          cmState::STATIC);
+  } else {
+    if (mf.GetDefinition(depname)) {
       std::string message = "Target ";
       message += target;
       message += " has dependency information when it shouldn't.\n";
       message += "Your cache is probably stale. Please remove the entry\n  ";
       message += depname;
       message += "\nfrom the cache.";
-      cmSystemTools::Error( message.c_str() );
-      }
+      cmSystemTools::Error(message.c_str());
     }
+  }
 }
 
-std::string cmTarget::GetDebugGeneratorExpressions(const std::string &value,
-                                  cmTargetLinkLibraryType llt) const
+std::string cmTarget::GetDebugGeneratorExpressions(
+  const std::string& value, cmTargetLinkLibraryType llt) const
 {
-  if (llt == GENERAL_LibraryType)
-    {
+  if (llt == GENERAL_LibraryType) {
     return value;
-    }
+  }
 
   // Get the list of configurations considered to be DEBUG.
   std::vector<std::string> debugConfigs =
-                      this->Makefile->GetCMakeInstance()->GetDebugConfigs();
+    this->Makefile->GetCMakeInstance()->GetDebugConfigs();
 
   std::string configString = "$<CONFIG:" + debugConfigs[0] + ">";
 
-  if (debugConfigs.size() > 1)
-    {
-    for(std::vector<std::string>::const_iterator
-          li = debugConfigs.begin() + 1; li != debugConfigs.end(); ++li)
-      {
+  if (debugConfigs.size() > 1) {
+    for (std::vector<std::string>::const_iterator li =
+           debugConfigs.begin() + 1;
+         li != debugConfigs.end(); ++li) {
       configString += ",$<CONFIG:" + *li + ">";
-      }
-    configString = "$<OR:" + configString + ">";
     }
+    configString = "$<OR:" + configString + ">";
+  }
 
-  if (llt == OPTIMIZED_LibraryType)
-    {
+  if (llt == OPTIMIZED_LibraryType) {
     configString = "$<NOT:" + configString + ">";
-    }
+  }
   return "$<" + configString + ":" + value + ">";
 }
 
@@ -611,64 +569,57 @@ bool cmTarget::PushTLLCommandTrace(TLLSignature signature,
                                    cmListFileContext const& lfc)
 {
   bool ret = true;
-  if (!this->TLLCommands.empty())
-    {
-    if (this->TLLCommands.back().first != signature)
-      {
+  if (!this->TLLCommands.empty()) {
+    if (this->TLLCommands.back().first != signature) {
       ret = false;
-      }
     }
-  if (this->TLLCommands.empty() || this->TLLCommands.back().second != lfc)
-    {
+  }
+  if (this->TLLCommands.empty() || this->TLLCommands.back().second != lfc) {
     this->TLLCommands.push_back(std::make_pair(signature, lfc));
-    }
+  }
   return ret;
 }
 
-void cmTarget::GetTllSignatureTraces(std::ostringstream &s,
+void cmTarget::GetTllSignatureTraces(std::ostringstream& s,
                                      TLLSignature sig) const
 {
-  const char *sigString = (sig == cmTarget::KeywordTLLSignature ? "keyword"
-                                                                : "plain");
+  const char* sigString =
+    (sig == cmTarget::KeywordTLLSignature ? "keyword" : "plain");
   s << "The uses of the " << sigString << " signature are here:\n";
   typedef std::vector<std::pair<TLLSignature, cmListFileContext> > Container;
   cmOutputConverter converter(this->GetMakefile()->GetStateSnapshot());
-  for(Container::const_iterator it = this->TLLCommands.begin();
-      it != this->TLLCommands.end(); ++it)
-    {
-    if (it->first == sig)
-      {
+  for (Container::const_iterator it = this->TLLCommands.begin();
+       it != this->TLLCommands.end(); ++it) {
+    if (it->first == sig) {
       cmListFileContext lfc = it->second;
       lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
       s << " * " << lfc << std::endl;
-      }
     }
+  }
 }
 
-void cmTarget::AddLinkLibrary(cmMakefile& mf,
-                              const std::string& target,
+void cmTarget::AddLinkLibrary(cmMakefile& mf, const std::string& target,
                               const std::string& lib,
                               cmTargetLinkLibraryType llt)
 {
-  cmTarget *tgt = this->Makefile->FindTargetToUse(lib);
+  cmTarget* tgt = this->Makefile->FindTargetToUse(lib);
   {
-  const bool isNonImportedTarget = tgt && !tgt->IsImported();
+    const bool isNonImportedTarget = tgt && !tgt->IsImported();
 
-  const std::string libName =
+    const std::string libName =
       (isNonImportedTarget && llt != GENERAL_LibraryType)
       ? targetNameGenex(lib)
       : lib;
-  this->AppendProperty("LINK_LIBRARIES",
-                       this->GetDebugGeneratorExpressions(libName,
-                                                          llt).c_str());
+    this->AppendProperty(
+      "LINK_LIBRARIES",
+      this->GetDebugGeneratorExpressions(libName, llt).c_str());
   }
 
-  if (cmGeneratorExpression::Find(lib) != std::string::npos
-      || (tgt && tgt->GetType() == cmState::INTERFACE_LIBRARY)
-      || (target == lib ))
-    {
+  if (cmGeneratorExpression::Find(lib) != std::string::npos ||
+      (tgt && tgt->GetType() == cmState::INTERFACE_LIBRARY) ||
+      (target == lib)) {
     return;
-    }
+  }
 
   cmTarget::LibraryID tmp;
   tmp.first = lib;
@@ -683,18 +634,15 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
   // may be purposefully duplicated to handle recursive dependencies,
   // and we removing one instance will break the link line. Duplicates
   // will be appropriately eliminated at emit time.
-  if(this->RecordDependencies)
-    {
+  if (this->RecordDependencies) {
     std::string targetEntry = target;
     targetEntry += "_LIB_DEPENDS";
     std::string dependencies;
-    const char* old_val = mf.GetDefinition( targetEntry );
-    if( old_val )
-      {
+    const char* old_val = mf.GetDefinition(targetEntry);
+    if (old_val) {
       dependencies += old_val;
-      }
-    switch (llt)
-      {
+    }
+    switch (llt) {
       case GENERAL_LibraryType:
         dependencies += "general";
         break;
@@ -704,19 +652,16 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
       case OPTIMIZED_LibraryType:
         dependencies += "optimized";
         break;
-      }
+    }
     dependencies += ";";
     dependencies += lib;
     dependencies += ";";
-    mf.AddCacheDefinition( targetEntry, dependencies.c_str(),
-                           "Dependencies for the target",
-                           cmState::STATIC );
-    }
-
+    mf.AddCacheDefinition(targetEntry, dependencies.c_str(),
+                          "Dependencies for the target", cmState::STATIC);
+  }
 }
 
-void
-cmTarget::AddSystemIncludeDirectories(const std::set<std::string> &incs)
+void cmTarget::AddSystemIncludeDirectories(const std::set<std::string>& incs)
 {
   this->SystemIncludeDirectories.insert(incs.begin(), incs.end());
 }
@@ -783,13 +728,11 @@ cmBacktraceRange cmTarget::GetLinkImplementationBacktraces() const
 
 static bool whiteListedInterfaceProperty(const std::string& prop)
 {
-  if(cmHasLiteralPrefix(prop, "INTERFACE_"))
-    {
+  if (cmHasLiteralPrefix(prop, "INTERFACE_")) {
     return true;
-    }
+  }
   static UNORDERED_SET<std::string> builtIns;
-  if (builtIns.empty())
-    {
+  if (builtIns.empty()) {
     builtIns.insert("COMPATIBLE_INTERFACE_BOOL");
     builtIns.insert("COMPATIBLE_INTERFACE_NUMBER_MAX");
     builtIns.insert("COMPATIBLE_INTERFACE_NUMBER_MIN");
@@ -798,276 +741,218 @@ static bool whiteListedInterfaceProperty(const std::string& prop)
     builtIns.insert("IMPORTED");
     builtIns.insert("NAME");
     builtIns.insert("TYPE");
-    }
+  }
 
-  if (builtIns.count(prop))
-    {
+  if (builtIns.count(prop)) {
     return true;
-    }
+  }
 
-  if (cmHasLiteralPrefix(prop, "MAP_IMPORTED_CONFIG_"))
-    {
+  if (cmHasLiteralPrefix(prop, "MAP_IMPORTED_CONFIG_")) {
     return true;
-    }
+  }
 
   return false;
 }
 
 void cmTarget::SetProperty(const std::string& prop, const char* value)
 {
-  if (this->GetType() == cmState::INTERFACE_LIBRARY
-      && !whiteListedInterfaceProperty(prop))
-    {
+  if (this->GetType() == cmState::INTERFACE_LIBRARY &&
+      !whiteListedInterfaceProperty(prop)) {
     std::ostringstream e;
     e << "INTERFACE_LIBRARY targets may only have whitelisted properties.  "
-         "The property \"" << prop << "\" is not allowed.";
+         "The property \""
+      << prop << "\" is not allowed.";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
-  else if (prop == "NAME")
-    {
+  } else if (prop == "NAME") {
     std::ostringstream e;
     e << "NAME property is read-only\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
-  else if(prop == "INCLUDE_DIRECTORIES")
-    {
+  } else if (prop == "INCLUDE_DIRECTORIES") {
     this->Internal->IncludeDirectoriesEntries.clear();
     this->Internal->IncludeDirectoriesBacktraces.clear();
-    if (value)
-      {
+    if (value) {
       this->Internal->IncludeDirectoriesEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->IncludeDirectoriesBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "COMPILE_OPTIONS")
-    {
+  } else if (prop == "COMPILE_OPTIONS") {
     this->Internal->CompileOptionsEntries.clear();
     this->Internal->CompileOptionsBacktraces.clear();
-    if (value)
-      {
+    if (value) {
       this->Internal->CompileOptionsEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->CompileOptionsBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "COMPILE_FEATURES")
-    {
+  } else if (prop == "COMPILE_FEATURES") {
     this->Internal->CompileFeaturesEntries.clear();
     this->Internal->CompileFeaturesBacktraces.clear();
-    if (value)
-      {
+    if (value) {
       this->Internal->CompileFeaturesEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->CompileFeaturesBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "COMPILE_DEFINITIONS")
-    {
+  } else if (prop == "COMPILE_DEFINITIONS") {
     this->Internal->CompileDefinitionsEntries.clear();
     this->Internal->CompileDefinitionsBacktraces.clear();
-    if (value)
-      {
+    if (value) {
       this->Internal->CompileDefinitionsEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->CompileDefinitionsBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "EXPORT_NAME" && this->IsImported())
-    {
+  } else if (prop == "EXPORT_NAME" && this->IsImported()) {
     std::ostringstream e;
     e << "EXPORT_NAME property can't be set on imported targets (\""
-          << this->Name << "\")\n";
+      << this->Name << "\")\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
-  else if (prop == "LINK_LIBRARIES")
-    {
+  } else if (prop == "LINK_LIBRARIES") {
     this->Internal->LinkImplementationPropertyEntries.clear();
     this->Internal->LinkImplementationPropertyBacktraces.clear();
-    if (value)
-      {
+    if (value) {
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->LinkImplementationPropertyEntries.push_back(value);
       this->Internal->LinkImplementationPropertyBacktraces.push_back(lfbt);
-      }
     }
-  else if (prop == "SOURCES")
-    {
-    if(this->IsImported())
-      {
+  } else if (prop == "SOURCES") {
+    if (this->IsImported()) {
       std::ostringstream e;
       e << "SOURCES property can't be set on imported targets (\""
-            << this->Name << "\")\n";
+        << this->Name << "\")\n";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
+    }
 
     this->Internal->SourceEntries.clear();
     this->Internal->SourceBacktraces.clear();
-    if (value)
-      {
+    if (value) {
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->SourceEntries.push_back(value);
       this->Internal->SourceBacktraces.push_back(lfbt);
-      }
     }
-  else
-    {
+  } else {
     this->Properties.SetProperty(prop, value);
-    }
+  }
 }
 
 void cmTarget::AppendProperty(const std::string& prop, const char* value,
                               bool asString)
 {
-  if (this->GetType() == cmState::INTERFACE_LIBRARY
-      && !whiteListedInterfaceProperty(prop))
-    {
+  if (this->GetType() == cmState::INTERFACE_LIBRARY &&
+      !whiteListedInterfaceProperty(prop)) {
     std::ostringstream e;
     e << "INTERFACE_LIBRARY targets may only have whitelisted properties.  "
-         "The property \"" << prop << "\" is not allowed.";
+         "The property \""
+      << prop << "\" is not allowed.";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
-  else if (prop == "NAME")
-    {
+  } else if (prop == "NAME") {
     std::ostringstream e;
     e << "NAME property is read-only\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     return;
-    }
-  else if(prop == "INCLUDE_DIRECTORIES")
-    {
-    if (value && *value)
-      {
+  } else if (prop == "INCLUDE_DIRECTORIES") {
+    if (value && *value) {
       this->Internal->IncludeDirectoriesEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->IncludeDirectoriesBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "COMPILE_OPTIONS")
-    {
-    if (value && *value)
-      {
+  } else if (prop == "COMPILE_OPTIONS") {
+    if (value && *value) {
       this->Internal->CompileOptionsEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->CompileOptionsBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "COMPILE_FEATURES")
-    {
-    if (value && *value)
-      {
+  } else if (prop == "COMPILE_FEATURES") {
+    if (value && *value) {
       this->Internal->CompileFeaturesEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->CompileFeaturesBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "COMPILE_DEFINITIONS")
-    {
-    if (value && *value)
-      {
+  } else if (prop == "COMPILE_DEFINITIONS") {
+    if (value && *value) {
       this->Internal->CompileDefinitionsEntries.push_back(value);
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->CompileDefinitionsBacktraces.push_back(lfbt);
-      }
     }
-  else if(prop == "EXPORT_NAME" && this->IsImported())
-    {
+  } else if (prop == "EXPORT_NAME" && this->IsImported()) {
     std::ostringstream e;
     e << "EXPORT_NAME property can't be set on imported targets (\""
-          << this->Name << "\")\n";
+      << this->Name << "\")\n";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
-    }
-  else if (prop == "LINK_LIBRARIES")
-    {
-    if (value && *value)
-      {
+  } else if (prop == "LINK_LIBRARIES") {
+    if (value && *value) {
       cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
       this->Internal->LinkImplementationPropertyEntries.push_back(value);
       this->Internal->LinkImplementationPropertyBacktraces.push_back(lfbt);
-      }
     }
-  else if (prop == "SOURCES")
-    {
-    if(this->IsImported())
-      {
+  } else if (prop == "SOURCES") {
+    if (this->IsImported()) {
       std::ostringstream e;
       e << "SOURCES property can't be set on imported targets (\""
-            << this->Name << "\")\n";
+        << this->Name << "\")\n";
       this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
       return;
-      }
+    }
     cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
     this->Internal->SourceEntries.push_back(value);
     this->Internal->SourceBacktraces.push_back(lfbt);
-    }
-  else
-    {
+  } else {
     this->Properties.AppendProperty(prop, value, asString);
-    }
+  }
 }
 
 void cmTarget::AppendBuildInterfaceIncludes()
 {
-  if(this->GetType() != cmState::SHARED_LIBRARY &&
-     this->GetType() != cmState::STATIC_LIBRARY &&
-     this->GetType() != cmState::MODULE_LIBRARY &&
-     this->GetType() != cmState::INTERFACE_LIBRARY &&
-     !this->IsExecutableWithExports())
-    {
+  if (this->GetType() != cmState::SHARED_LIBRARY &&
+      this->GetType() != cmState::STATIC_LIBRARY &&
+      this->GetType() != cmState::MODULE_LIBRARY &&
+      this->GetType() != cmState::INTERFACE_LIBRARY &&
+      !this->IsExecutableWithExports()) {
     return;
-    }
-  if (this->BuildInterfaceIncludesAppended)
-    {
+  }
+  if (this->BuildInterfaceIncludesAppended) {
     return;
-    }
+  }
   this->BuildInterfaceIncludesAppended = true;
 
-  if (this->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE"))
-    {
-    const char *binDir = this->Makefile->GetCurrentBinaryDirectory();
-    const char *srcDir = this->Makefile->GetCurrentSourceDirectory();
-    const std::string dirs = std::string(binDir ? binDir : "")
-                            + std::string(binDir ? ";" : "")
-                            + std::string(srcDir ? srcDir : "");
-    if (!dirs.empty())
-      {
+  if (this->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR_IN_INTERFACE")) {
+    const char* binDir = this->Makefile->GetCurrentBinaryDirectory();
+    const char* srcDir = this->Makefile->GetCurrentSourceDirectory();
+    const std::string dirs = std::string(binDir ? binDir : "") +
+      std::string(binDir ? ";" : "") + std::string(srcDir ? srcDir : "");
+    if (!dirs.empty()) {
       this->AppendProperty("INTERFACE_INCLUDE_DIRECTORIES",
-                            ("$<BUILD_INTERFACE:" + dirs + ">").c_str());
-      }
+                           ("$<BUILD_INTERFACE:" + dirs + ">").c_str());
     }
+  }
 }
 
 void cmTarget::InsertInclude(std::string const& entry,
-                             cmListFileBacktrace const& bt,
-                             bool before)
+                             cmListFileBacktrace const& bt, bool before)
 {
-  std::vector<std::string>::iterator position =
-      before ? this->Internal->IncludeDirectoriesEntries.begin()
-             : this->Internal->IncludeDirectoriesEntries.end();
+  std::vector<std::string>::iterator position = before
+    ? this->Internal->IncludeDirectoriesEntries.begin()
+    : this->Internal->IncludeDirectoriesEntries.end();
 
-  std::vector<cmListFileBacktrace>::iterator btPosition =
-      before ? this->Internal->IncludeDirectoriesBacktraces.begin()
-             : this->Internal->IncludeDirectoriesBacktraces.end();
+  std::vector<cmListFileBacktrace>::iterator btPosition = before
+    ? this->Internal->IncludeDirectoriesBacktraces.begin()
+    : this->Internal->IncludeDirectoriesBacktraces.end();
 
   this->Internal->IncludeDirectoriesEntries.insert(position, entry);
   this->Internal->IncludeDirectoriesBacktraces.insert(btPosition, bt);
 }
 
 void cmTarget::InsertCompileOption(std::string const& entry,
-                                   cmListFileBacktrace const& bt,
-                                   bool before)
+                                   cmListFileBacktrace const& bt, bool before)
 {
-  std::vector<std::string>::iterator position =
-      before ? this->Internal->CompileOptionsEntries.begin()
-             : this->Internal->CompileOptionsEntries.end();
+  std::vector<std::string>::iterator position = before
+    ? this->Internal->CompileOptionsEntries.begin()
+    : this->Internal->CompileOptionsEntries.end();
 
-  std::vector<cmListFileBacktrace>::iterator btPosition =
-      before ? this->Internal->CompileOptionsBacktraces.begin()
-             : this->Internal->CompileOptionsBacktraces.end();
+  std::vector<cmListFileBacktrace>::iterator btPosition = before
+    ? this->Internal->CompileOptionsBacktraces.begin()
+    : this->Internal->CompileOptionsBacktraces.end();
 
   this->Internal->CompileOptionsEntries.insert(position, entry);
   this->Internal->CompileOptionsBacktraces.insert(btPosition, bt);
@@ -1080,22 +965,20 @@ void cmTarget::InsertCompileDefinition(std::string const& entry,
   this->Internal->CompileDefinitionsBacktraces.push_back(bt);
 }
 
-static void cmTargetCheckLINK_INTERFACE_LIBRARIES(
-  const std::string& prop, const char* value, cmMakefile* context,
-  bool imported)
+static void cmTargetCheckLINK_INTERFACE_LIBRARIES(const std::string& prop,
+                                                  const char* value,
+                                                  cmMakefile* context,
+                                                  bool imported)
 {
   // Look for link-type keywords in the value.
-  static cmsys::RegularExpression
-    keys("(^|;)(debug|optimized|general)(;|$)");
-  if(!keys.find(value))
-    {
+  static cmsys::RegularExpression keys("(^|;)(debug|optimized|general)(;|$)");
+  if (!keys.find(value)) {
     return;
-    }
+  }
 
   // Support imported and non-imported versions of the property.
-  const char* base = (imported?
-                      "IMPORTED_LINK_INTERFACE_LIBRARIES" :
-                      "LINK_INTERFACE_LIBRARIES");
+  const char* base = (imported ? "IMPORTED_LINK_INTERFACE_LIBRARIES"
+                               : "LINK_INTERFACE_LIBRARIES");
 
   // Report an error.
   std::ostringstream e;
@@ -1104,8 +987,7 @@ static void cmTargetCheckLINK_INTERFACE_LIBRARIES(
     << "The " << base << " property has a per-configuration "
     << "version called " << base << "_<CONFIG> which may be "
     << "used to specify per-configuration rules.";
-  if(!imported)
-    {
+  if (!imported) {
     e << "  "
       << "Alternatively, an IMPORTED library may be created, configured "
       << "with a per-configuration location, and then named in the "
@@ -1118,7 +1000,7 @@ static void cmTargetCheckLINK_INTERFACE_LIBRARIES(
       << "The command automatically recognizes link-type keywords and sets "
       << "the LINK_INTERFACE_LIBRARIES and LINK_INTERFACE_LIBRARIES_DEBUG "
       << "properties accordingly.";
-    }
+  }
   context->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
@@ -1126,20 +1008,20 @@ static void cmTargetCheckINTERFACE_LINK_LIBRARIES(const char* value,
                                                   cmMakefile* context)
 {
   // Look for link-type keywords in the value.
-  static cmsys::RegularExpression
-    keys("(^|;)(debug|optimized|general)(;|$)");
-  if(!keys.find(value))
-    {
+  static cmsys::RegularExpression keys("(^|;)(debug|optimized|general)(;|$)");
+  if (!keys.find(value)) {
     return;
-    }
+  }
 
   // Report an error.
   std::ostringstream e;
 
   e << "Property INTERFACE_LINK_LIBRARIES may not contain link-type "
-    "keyword \"" << keys.match(2) << "\".  The INTERFACE_LINK_LIBRARIES "
-    "property may contain configuration-sensitive generator-expressions "
-    "which may be used to specify per-configuration rules.";
+       "keyword \""
+    << keys.match(2)
+    << "\".  The INTERFACE_LINK_LIBRARIES "
+       "property may contain configuration-sensitive generator-expressions "
+       "which may be used to specify per-configuration rules.";
 
   context->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
@@ -1148,27 +1030,21 @@ void cmTarget::CheckProperty(const std::string& prop,
                              cmMakefile* context) const
 {
   // Certain properties need checking.
-  if(cmHasLiteralPrefix(prop, "LINK_INTERFACE_LIBRARIES"))
-    {
-    if(const char* value = this->GetProperty(prop))
-      {
+  if (cmHasLiteralPrefix(prop, "LINK_INTERFACE_LIBRARIES")) {
+    if (const char* value = this->GetProperty(prop)) {
       cmTargetCheckLINK_INTERFACE_LIBRARIES(prop, value, context, false);
-      }
     }
-  if(cmHasLiteralPrefix(prop, "IMPORTED_LINK_INTERFACE_LIBRARIES"))
-    {
-    if(const char* value = this->GetProperty(prop))
-      {
+  }
+  if (cmHasLiteralPrefix(prop, "IMPORTED_LINK_INTERFACE_LIBRARIES")) {
+    if (const char* value = this->GetProperty(prop)) {
       cmTargetCheckLINK_INTERFACE_LIBRARIES(prop, value, context, true);
-      }
     }
-  if(cmHasLiteralPrefix(prop, "INTERFACE_LINK_LIBRARIES"))
-    {
-    if(const char* value = this->GetProperty(prop))
-      {
+  }
+  if (cmHasLiteralPrefix(prop, "INTERFACE_LINK_LIBRARIES")) {
+    if (const char* value = this->GetProperty(prop)) {
       cmTargetCheckINTERFACE_LINK_LIBRARIES(value, context);
-      }
     }
+  }
 }
 
 void cmTarget::MarkAsImported(bool global)
@@ -1179,15 +1055,13 @@ void cmTarget::MarkAsImported(bool global)
 
 bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const
 {
-  if (this->IsImported())
-    {
+  if (this->IsImported()) {
     return true;
-    }
+  }
   std::ostringstream e;
-  const char *modal = 0;
+  const char* modal = 0;
   cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-  switch (context->GetPolicyStatus(cmPolicies::CMP0026))
-    {
+  switch (context->GetPolicyStatus(cmPolicies::CMP0026)) {
     case cmPolicies::WARN:
       e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0026) << "\n";
       modal = "should";
@@ -1198,66 +1072,60 @@ bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const
     case cmPolicies::NEW:
       modal = "may";
       messageType = cmake::FATAL_ERROR;
-    }
+  }
 
-  if (modal)
-    {
+  if (modal) {
     e << "The LOCATION property " << modal << " not be read from target \""
-      << this->GetName() << "\".  Use the target name directly with "
-      "add_custom_command, or use the generator expression $<TARGET_FILE>, "
-      "as appropriate.\n";
+      << this->GetName()
+      << "\".  Use the target name directly with "
+         "add_custom_command, or use the generator expression $<TARGET_FILE>, "
+         "as appropriate.\n";
     context->IssueMessage(messageType, e.str());
-    }
+  }
 
   return messageType != cmake::FATAL_ERROR;
 }
 
-const char *cmTarget::GetProperty(const std::string& prop) const
+const char* cmTarget::GetProperty(const std::string& prop) const
 {
   return this->GetProperty(prop, this->Makefile);
 }
 
-const char *cmTarget::GetProperty(const std::string& prop,
+const char* cmTarget::GetProperty(const std::string& prop,
                                   cmMakefile* context) const
 {
-  if (this->GetType() == cmState::INTERFACE_LIBRARY
-      && !whiteListedInterfaceProperty(prop))
-    {
+  if (this->GetType() == cmState::INTERFACE_LIBRARY &&
+      !whiteListedInterfaceProperty(prop)) {
     std::ostringstream e;
     e << "INTERFACE_LIBRARY targets may only have whitelisted properties.  "
-         "The property \"" << prop << "\" is not allowed.";
+         "The property \""
+      << prop << "\" is not allowed.";
     context->IssueMessage(cmake::FATAL_ERROR, e.str());
     return 0;
-    }
+  }
 
   // Watch for special "computed" properties that are dependent on
   // other properties or variables.  Always recompute them.
-  if(this->GetType() == cmState::EXECUTABLE ||
-     this->GetType() == cmState::STATIC_LIBRARY ||
-     this->GetType() == cmState::SHARED_LIBRARY ||
-     this->GetType() == cmState::MODULE_LIBRARY ||
-     this->GetType() == cmState::UNKNOWN_LIBRARY)
-    {
+  if (this->GetType() == cmState::EXECUTABLE ||
+      this->GetType() == cmState::STATIC_LIBRARY ||
+      this->GetType() == cmState::SHARED_LIBRARY ||
+      this->GetType() == cmState::MODULE_LIBRARY ||
+      this->GetType() == cmState::UNKNOWN_LIBRARY) {
     static const std::string propLOCATION = "LOCATION";
-    if(prop == propLOCATION)
-      {
-      if (!this->HandleLocationPropertyPolicy(context))
-        {
+    if (prop == propLOCATION) {
+      if (!this->HandleLocationPropertyPolicy(context)) {
         return 0;
-        }
+      }
 
       // Set the LOCATION property of the target.
       //
       // For an imported target this is the location of an arbitrary
       // available configuration.
       //
-      if(this->IsImported())
-        {
+      if (this->IsImported()) {
         this->Properties.SetProperty(
-                propLOCATION, this->ImportedGetFullPath("", false).c_str());
-        }
-      else
-        {
+          propLOCATION, this->ImportedGetFullPath("", false).c_str());
+      } else {
         // For a non-imported target this is deprecated because it
         // cannot take into account the per-configuration name of the
         // target because the configuration type may not be known at
@@ -1265,64 +1133,51 @@ const char *cmTarget::GetProperty(const std::string& prop,
         cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
         gg->CreateGenerationObjects();
         cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName());
-        this->Properties.SetProperty(propLOCATION,
-                                     gt->GetLocationForBuild());
-        }
-
+        this->Properties.SetProperty(propLOCATION, gt->GetLocationForBuild());
       }
 
+    }
+
     // Support "LOCATION_<CONFIG>".
-    else if(cmHasLiteralPrefix(prop, "LOCATION_"))
-      {
-      if (!this->HandleLocationPropertyPolicy(context))
-        {
+    else if (cmHasLiteralPrefix(prop, "LOCATION_")) {
+      if (!this->HandleLocationPropertyPolicy(context)) {
         return 0;
-        }
+      }
       const char* configName = prop.c_str() + 9;
 
-      if (this->IsImported())
-        {
+      if (this->IsImported()) {
         this->Properties.SetProperty(
-                prop, this->ImportedGetFullPath(configName, false).c_str());
-        }
-      else
-        {
+          prop, this->ImportedGetFullPath(configName, false).c_str());
+      } else {
         cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
         gg->CreateGenerationObjects();
         cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName());
         this->Properties.SetProperty(
-                prop, gt->GetFullPath(configName, false).c_str());
-        }
+          prop, gt->GetFullPath(configName, false).c_str());
       }
+    }
     // Support "<CONFIG>_LOCATION".
-    else if(cmHasLiteralSuffix(prop, "_LOCATION"))
-      {
+    else if (cmHasLiteralSuffix(prop, "_LOCATION")) {
       std::string configName(prop.c_str(), prop.size() - 9);
-      if(configName != "IMPORTED")
-        {
-        if (!this->HandleLocationPropertyPolicy(context))
-          {
+      if (configName != "IMPORTED") {
+        if (!this->HandleLocationPropertyPolicy(context)) {
           return 0;
-          }
-        if (this->IsImported())
-          {
+        }
+        if (this->IsImported()) {
           this->Properties.SetProperty(
-                  prop, this->ImportedGetFullPath(configName, false).c_str());
-          }
-        else
-          {
+            prop, this->ImportedGetFullPath(configName, false).c_str());
+        } else {
           cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
           gg->CreateGenerationObjects();
           cmGeneratorTarget* gt = gg->FindGeneratorTarget(this->GetName());
           this->Properties.SetProperty(
-                  prop, gt->GetFullPath(configName, false).c_str());
-          }
+            prop, gt->GetFullPath(configName, false).c_str());
         }
       }
     }
+  }
   static UNORDERED_SET<std::string> specialProps;
-#define MAKE_STATIC_PROP(PROP) \
-  static const std::string prop##PROP = #PROP
+#define MAKE_STATIC_PROP(PROP) static const std::string prop##PROP = #PROP
   MAKE_STATIC_PROP(LINK_LIBRARIES);
   MAKE_STATIC_PROP(TYPE);
   MAKE_STATIC_PROP(INCLUDE_DIRECTORIES);
@@ -1335,8 +1190,7 @@ const char *cmTarget::GetProperty(const std::string& prop,
   MAKE_STATIC_PROP(SOURCE_DIR);
   MAKE_STATIC_PROP(SOURCES);
 #undef MAKE_STATIC_PROP
-  if(specialProps.empty())
-    {
+  if (specialProps.empty()) {
     specialProps.insert(propLINK_LIBRARIES);
     specialProps.insert(propTYPE);
     specialProps.insert(propINCLUDE_DIRECTORIES);
@@ -1348,124 +1202,92 @@ const char *cmTarget::GetProperty(const std::string& prop,
     specialProps.insert(propBINARY_DIR);
     specialProps.insert(propSOURCE_DIR);
     specialProps.insert(propSOURCES);
-    }
-  if(specialProps.count(prop))
-    {
-    if(prop == propLINK_LIBRARIES)
-      {
-      if (this->Internal->LinkImplementationPropertyEntries.empty())
-        {
+  }
+  if (specialProps.count(prop)) {
+    if (prop == propLINK_LIBRARIES) {
+      if (this->Internal->LinkImplementationPropertyEntries.empty()) {
         return 0;
-        }
+      }
 
       static std::string output;
       output = cmJoin(this->Internal->LinkImplementationPropertyEntries, ";");
       return output.c_str();
-      }
+    }
     // the type property returns what type the target is
-    else if (prop == propTYPE)
-      {
+    else if (prop == propTYPE) {
       return cmState::GetTargetTypeName(this->GetType());
-      }
-    else if(prop == propINCLUDE_DIRECTORIES)
-      {
-      if (this->Internal->IncludeDirectoriesEntries.empty())
-        {
+    } else if (prop == propINCLUDE_DIRECTORIES) {
+      if (this->Internal->IncludeDirectoriesEntries.empty()) {
         return 0;
-        }
+      }
 
       static std::string output;
       output = cmJoin(this->Internal->IncludeDirectoriesEntries, ";");
       return output.c_str();
-      }
-    else if(prop == propCOMPILE_FEATURES)
-      {
-      if (this->Internal->CompileFeaturesEntries.empty())
-        {
+    } else if (prop == propCOMPILE_FEATURES) {
+      if (this->Internal->CompileFeaturesEntries.empty()) {
         return 0;
-        }
+      }
 
       static std::string output;
       output = cmJoin(this->Internal->CompileFeaturesEntries, ";");
       return output.c_str();
-      }
-    else if(prop == propCOMPILE_OPTIONS)
-      {
-      if (this->Internal->CompileOptionsEntries.empty())
-        {
+    } else if (prop == propCOMPILE_OPTIONS) {
+      if (this->Internal->CompileOptionsEntries.empty()) {
         return 0;
-        }
+      }
 
       static std::string output;
       output = cmJoin(this->Internal->CompileOptionsEntries, ";");
       return output.c_str();
-      }
-    else if(prop == propCOMPILE_DEFINITIONS)
-      {
-      if (this->Internal->CompileDefinitionsEntries.empty())
-        {
+    } else if (prop == propCOMPILE_DEFINITIONS) {
+      if (this->Internal->CompileDefinitionsEntries.empty()) {
         return 0;
-        }
+      }
 
       static std::string output;
       output = cmJoin(this->Internal->CompileDefinitionsEntries, ";");
       return output.c_str();
-      }
-    else if (prop == propIMPORTED)
-      {
-      return this->IsImported()?"TRUE":"FALSE";
-      }
-    else if (prop == propNAME)
-      {
+    } else if (prop == propIMPORTED) {
+      return this->IsImported() ? "TRUE" : "FALSE";
+    } else if (prop == propNAME) {
       return this->GetName().c_str();
-      }
-    else if (prop == propBINARY_DIR)
-      {
+    } else if (prop == propBINARY_DIR) {
       return this->GetMakefile()->GetCurrentBinaryDirectory();
-      }
-    else if (prop == propSOURCE_DIR)
-      {
+    } else if (prop == propSOURCE_DIR) {
       return this->GetMakefile()->GetCurrentSourceDirectory();
-      }
-    else if(prop == propSOURCES)
-      {
-      if (this->Internal->SourceEntries.empty())
-        {
+    } else if (prop == propSOURCES) {
+      if (this->Internal->SourceEntries.empty()) {
         return 0;
-        }
+      }
 
       std::ostringstream ss;
       const char* sep = "";
-      for(std::vector<std::string>::const_iterator
-            i = this->Internal->SourceEntries.begin();
-          i != this->Internal->SourceEntries.end(); ++i)
-        {
+      for (std::vector<std::string>::const_iterator i =
+             this->Internal->SourceEntries.begin();
+           i != this->Internal->SourceEntries.end(); ++i) {
         std::string const& entry = *i;
 
         std::vector<std::string> files;
         cmSystemTools::ExpandListArgument(entry, files);
-        for (std::vector<std::string>::const_iterator
-            li = files.begin(); li != files.end(); ++li)
-          {
-          if(cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
-              (*li)[li->size() - 1] == '>')
-            {
-            std::string objLibName = li->substr(17, li->size()-18);
-
-            if (cmGeneratorExpression::Find(objLibName) != std::string::npos)
-              {
+        for (std::vector<std::string>::const_iterator li = files.begin();
+             li != files.end(); ++li) {
+          if (cmHasLiteralPrefix(*li, "$<TARGET_OBJECTS:") &&
+              (*li)[li->size() - 1] == '>') {
+            std::string objLibName = li->substr(17, li->size() - 18);
+
+            if (cmGeneratorExpression::Find(objLibName) != std::string::npos) {
               ss << sep;
               sep = ";";
               ss << *li;
               continue;
-              }
+            }
 
             bool addContent = false;
             bool noMessage = true;
             std::ostringstream e;
             cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-            switch(context->GetPolicyStatus(cmPolicies::CMP0051))
-              {
+            switch (context->GetPolicyStatus(cmPolicies::CMP0051)) {
               case cmPolicies::WARN:
                 e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0051) << "\n";
                 noMessage = false;
@@ -1475,63 +1297,58 @@ const char *cmTarget::GetProperty(const std::string& prop,
               case cmPolicies::REQUIRED_IF_USED:
               case cmPolicies::NEW:
                 addContent = true;
-              }
-            if (!noMessage)
-              {
-              e << "Target \"" << this->Name << "\" contains "
-              "$<TARGET_OBJECTS> generator expression in its sources list.  "
-              "This content was not previously part of the SOURCES property "
-              "when that property was read at configure time.  Code reading "
-              "that property needs to be adapted to ignore the generator "
-              "expression using the string(GENEX_STRIP) command.";
+            }
+            if (!noMessage) {
+              e << "Target \"" << this->Name
+                << "\" contains "
+                   "$<TARGET_OBJECTS> generator expression in its sources "
+                   "list.  "
+                   "This content was not previously part of the SOURCES "
+                   "property "
+                   "when that property was read at configure time.  Code "
+                   "reading "
+                   "that property needs to be adapted to ignore the generator "
+                   "expression using the string(GENEX_STRIP) command.";
               context->IssueMessage(messageType, e.str());
-              }
-            if (addContent)
-              {
+            }
+            if (addContent) {
               ss << sep;
               sep = ";";
               ss << *li;
-              }
             }
-          else if (cmGeneratorExpression::Find(*li) == std::string::npos)
-            {
+          } else if (cmGeneratorExpression::Find(*li) == std::string::npos) {
             ss << sep;
             sep = ";";
             ss << *li;
-            }
-          else
-            {
-            cmSourceFile *sf = this->Makefile->GetOrCreateSource(*li);
+          } else {
+            cmSourceFile* sf = this->Makefile->GetOrCreateSource(*li);
             // Construct what is known about this source file location.
             cmSourceFileLocation const& location = sf->GetLocation();
             std::string sname = location.GetDirectory();
-            if(!sname.empty())
-              {
+            if (!sname.empty()) {
               sname += "/";
-              }
+            }
             sname += location.GetName();
 
             ss << sep;
             sep = ";";
             // Append this list entry.
             ss << sname;
-            }
           }
         }
-      this->Properties.SetProperty("SOURCES", ss.str().c_str());
       }
+      this->Properties.SetProperty("SOURCES", ss.str().c_str());
     }
+  }
 
-  const char *retVal = this->Properties.GetPropertyValue(prop);
-  if (!retVal)
-    {
-    const bool chain = this->GetMakefile()->GetState()->
-                      IsPropertyChained(prop, cmProperty::TARGET);
-    if (chain)
-      {
+  const char* retVal = this->Properties.GetPropertyValue(prop);
+  if (!retVal) {
+    const bool chain = this->GetMakefile()->GetState()->IsPropertyChained(
+      prop, cmProperty::TARGET);
+    if (chain) {
       return this->Makefile->GetProperty(prop, chain);
-      }
     }
+  }
   return retVal;
 }
 
@@ -1542,75 +1359,67 @@ bool cmTarget::GetPropertyAsBool(const std::string& prop) const
 
 const char* cmTarget::GetSuffixVariableInternal(bool implib) const
 {
-  switch(this->GetType())
-    {
+  switch (this->GetType()) {
     case cmState::STATIC_LIBRARY:
       return "CMAKE_STATIC_LIBRARY_SUFFIX";
     case cmState::SHARED_LIBRARY:
-      return (implib
-              ? "CMAKE_IMPORT_LIBRARY_SUFFIX"
-              : "CMAKE_SHARED_LIBRARY_SUFFIX");
+      return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX"
+                     : "CMAKE_SHARED_LIBRARY_SUFFIX");
     case cmState::MODULE_LIBRARY:
-      return (implib
-              ? "CMAKE_IMPORT_LIBRARY_SUFFIX"
-              : "CMAKE_SHARED_MODULE_SUFFIX");
+      return (implib ? "CMAKE_IMPORT_LIBRARY_SUFFIX"
+                     : "CMAKE_SHARED_MODULE_SUFFIX");
     case cmState::EXECUTABLE:
       return (implib
-              ? "CMAKE_IMPORT_LIBRARY_SUFFIX"
+                ? "CMAKE_IMPORT_LIBRARY_SUFFIX"
                 // Android GUI application packages store the native
                 // binary as a shared library.
-              : (this->IsAndroid && this->GetPropertyAsBool("ANDROID_GUI")?
-                 "CMAKE_SHARED_LIBRARY_SUFFIX" : "CMAKE_EXECUTABLE_SUFFIX"));
+                : (this->IsAndroid && this->GetPropertyAsBool("ANDROID_GUI")
+                     ? "CMAKE_SHARED_LIBRARY_SUFFIX"
+                     : "CMAKE_EXECUTABLE_SUFFIX"));
     default:
       break;
-    }
+  }
   return "";
 }
 
-
 const char* cmTarget::GetPrefixVariableInternal(bool implib) const
 {
-  switch(this->GetType())
-    {
+  switch (this->GetType()) {
     case cmState::STATIC_LIBRARY:
       return "CMAKE_STATIC_LIBRARY_PREFIX";
     case cmState::SHARED_LIBRARY:
-      return (implib
-              ? "CMAKE_IMPORT_LIBRARY_PREFIX"
-              : "CMAKE_SHARED_LIBRARY_PREFIX");
+      return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX"
+                     : "CMAKE_SHARED_LIBRARY_PREFIX");
     case cmState::MODULE_LIBRARY:
-      return (implib
-              ? "CMAKE_IMPORT_LIBRARY_PREFIX"
-              : "CMAKE_SHARED_MODULE_PREFIX");
+      return (implib ? "CMAKE_IMPORT_LIBRARY_PREFIX"
+                     : "CMAKE_SHARED_MODULE_PREFIX");
     case cmState::EXECUTABLE:
       return (implib
-              ? "CMAKE_IMPORT_LIBRARY_PREFIX"
+                ? "CMAKE_IMPORT_LIBRARY_PREFIX"
                 // Android GUI application packages store the native
                 // binary as a shared library.
-              : (this->IsAndroid && this->GetPropertyAsBool("ANDROID_GUI")?
-                 "CMAKE_SHARED_LIBRARY_PREFIX" : ""));
+                : (this->IsAndroid && this->GetPropertyAsBool("ANDROID_GUI")
+                     ? "CMAKE_SHARED_LIBRARY_PREFIX"
+                     : ""));
     default:
       break;
-    }
+  }
   return "";
 }
 
-std::string
-cmTarget::ImportedGetFullPath(const std::string& config, bool pimplib) const
+std::string cmTarget::ImportedGetFullPath(const std::string& config,
+                                          bool pimplib) const
 {
   assert(this->IsImported());
 
   // Lookup/compute/cache the import information for this
   // configuration.
   std::string config_upper;
-  if(!config.empty())
-    {
+  if (!config.empty()) {
     config_upper = cmSystemTools::UpperCase(config);
-    }
-  else
-    {
+  } else {
     config_upper = "NOCONFIG";
-    }
+  }
 
   std::string result;
 
@@ -1618,58 +1427,41 @@ cmTarget::ImportedGetFullPath(const std::string& config, bool pimplib) const
   const char* imp = 0;
   std::string suffix;
 
-  if(this->GetType() != cmState::INTERFACE_LIBRARY
-     && this->GetMappedConfig(config_upper, &loc, &imp, suffix))
-    {
-    if (!pimplib)
-      {
-      if(loc)
-        {
+  if (this->GetType() != cmState::INTERFACE_LIBRARY &&
+      this->GetMappedConfig(config_upper, &loc, &imp, suffix)) {
+    if (!pimplib) {
+      if (loc) {
         result = loc;
-        }
-      else
-        {
+      } else {
         std::string impProp = "IMPORTED_LOCATION";
         impProp += suffix;
-        if(const char* config_location = this->GetProperty(impProp))
-          {
+        if (const char* config_location = this->GetProperty(impProp)) {
           result = config_location;
-          }
-        else if(const char* location =
-                this->GetProperty("IMPORTED_LOCATION"))
-          {
+        } else if (const char* location =
+                     this->GetProperty("IMPORTED_LOCATION")) {
           result = location;
-          }
         }
       }
-    else
-      {
-      if(imp)
-        {
+    } else {
+      if (imp) {
         result = imp;
-        }
-      else if(this->GetType() == cmState::SHARED_LIBRARY ||
-              this->IsExecutableWithExports())
-        {
+      } else if (this->GetType() == cmState::SHARED_LIBRARY ||
+                 this->IsExecutableWithExports()) {
         std::string impProp = "IMPORTED_IMPLIB";
         impProp += suffix;
-        if(const char* config_implib = this->GetProperty(impProp))
-          {
+        if (const char* config_implib = this->GetProperty(impProp)) {
           result = config_implib;
-          }
-        else if(const char* implib = this->GetProperty("IMPORTED_IMPLIB"))
-          {
+        } else if (const char* implib = this->GetProperty("IMPORTED_IMPLIB")) {
           result = implib;
-          }
         }
       }
     }
+  }
 
-  if(result.empty())
-    {
+  if (result.empty()) {
     result = this->GetName();
     result += "-NOTFOUND";
-    }
+  }
   return result;
 }
 
@@ -1680,29 +1472,24 @@ void cmTarget::SetPropertyDefault(const std::string& property,
   std::string var = "CMAKE_";
   var += property;
 
-  if(const char* value = this->Makefile->GetDefinition(var))
-    {
+  if (const char* value = this->Makefile->GetDefinition(var)) {
     this->SetProperty(property, value);
-    }
-  else if(default_value)
-    {
+  } else if (default_value) {
     this->SetProperty(property, default_value);
-    }
+  }
 }
 
 bool cmTarget::GetMappedConfig(std::string const& desired_config,
-                               const char** loc,
-                               const char** imp,
+                               const char** loc, const char** imp,
                                std::string& suffix) const
 {
-  if (this->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->GetType() == cmState::INTERFACE_LIBRARY) {
     // This method attempts to find a config-specific LOCATION for the
     // IMPORTED library. In the case of cmState::INTERFACE_LIBRARY, there is no
     // LOCATION at all, so leaving *loc and *imp unchanged is the appropriate
     // and valid response.
     return true;
-    }
+  }
 
   // Track the configuration-specific property suffix.
   suffix = "_";
@@ -1710,11 +1497,10 @@ bool cmTarget::GetMappedConfig(std::string const& desired_config,
 
   std::vector<std::string> mappedConfigs;
   {
-  std::string mapProp = "MAP_IMPORTED_CONFIG_";
-  mapProp += desired_config;
-  if(const char* mapValue = this->GetProperty(mapProp))
-    {
-    cmSystemTools::ExpandListArgument(mapValue, mappedConfigs);
+    std::string mapProp = "MAP_IMPORTED_CONFIG_";
+    mapProp += desired_config;
+    if (const char* mapValue = this->GetProperty(mapProp)) {
+      cmSystemTools::ExpandListArgument(mapValue, mappedConfigs);
     }
   }
 
@@ -1724,99 +1510,86 @@ bool cmTarget::GetMappedConfig(std::string const& desired_config,
   bool allowImp = this->HasImportLibrary();
 
   // If a mapping was found, check its configurations.
-  for(std::vector<std::string>::const_iterator mci = mappedConfigs.begin();
-      !*loc && !*imp && mci != mappedConfigs.end(); ++mci)
-    {
+  for (std::vector<std::string>::const_iterator mci = mappedConfigs.begin();
+       !*loc && !*imp && mci != mappedConfigs.end(); ++mci) {
     // Look for this configuration.
     std::string mcUpper = cmSystemTools::UpperCase(*mci);
     std::string locProp = "IMPORTED_LOCATION_";
     locProp += mcUpper;
     *loc = this->GetProperty(locProp);
-    if(allowImp)
-      {
+    if (allowImp) {
       std::string impProp = "IMPORTED_IMPLIB_";
       impProp += mcUpper;
       *imp = this->GetProperty(impProp);
-      }
+    }
 
     // If it was found, use it for all properties below.
-    if(*loc || *imp)
-      {
+    if (*loc || *imp) {
       suffix = "_";
       suffix += mcUpper;
-      }
     }
+  }
 
   // If we needed to find one of the mapped configurations but did not
   // then the target is not found.  The project does not want any
   // other configuration.
-  if(!mappedConfigs.empty() && !*loc && !*imp)
-    {
+  if (!mappedConfigs.empty() && !*loc && !*imp) {
     return false;
-    }
+  }
 
   // If we have not yet found it then there are no mapped
   // configurations.  Look for an exact-match.
-  if(!*loc && !*imp)
-    {
+  if (!*loc && !*imp) {
     std::string locProp = "IMPORTED_LOCATION";
     locProp += suffix;
     *loc = this->GetProperty(locProp);
-    if(allowImp)
-      {
+    if (allowImp) {
       std::string impProp = "IMPORTED_IMPLIB";
       impProp += suffix;
       *imp = this->GetProperty(impProp);
-      }
     }
+  }
 
   // If we have not yet found it then there are no mapped
   // configurations and no exact match.
-  if(!*loc && !*imp)
-    {
+  if (!*loc && !*imp) {
     // The suffix computed above is not useful.
     suffix = "";
 
     // Look for a configuration-less location.  This may be set by
     // manually-written code.
     *loc = this->GetProperty("IMPORTED_LOCATION");
-    if(allowImp)
-      {
+    if (allowImp) {
       *imp = this->GetProperty("IMPORTED_IMPLIB");
-      }
     }
+  }
 
   // If we have not yet found it then the project is willing to try
   // any available configuration.
-  if(!*loc && !*imp)
-    {
+  if (!*loc && !*imp) {
     std::vector<std::string> availableConfigs;
-    if(const char* iconfigs = this->GetProperty("IMPORTED_CONFIGURATIONS"))
-      {
+    if (const char* iconfigs = this->GetProperty("IMPORTED_CONFIGURATIONS")) {
       cmSystemTools::ExpandListArgument(iconfigs, availableConfigs);
-      }
-    for(std::vector<std::string>::const_iterator
-          aci = availableConfigs.begin();
-        !*loc && !*imp && aci != availableConfigs.end(); ++aci)
-      {
+    }
+    for (std::vector<std::string>::const_iterator aci =
+           availableConfigs.begin();
+         !*loc && !*imp && aci != availableConfigs.end(); ++aci) {
       suffix = "_";
       suffix += cmSystemTools::UpperCase(*aci);
       std::string locProp = "IMPORTED_LOCATION";
       locProp += suffix;
       *loc = this->GetProperty(locProp);
-      if(allowImp)
-        {
+      if (allowImp) {
         std::string impProp = "IMPORTED_IMPLIB";
         impProp += suffix;
         *imp = this->GetProperty(impProp);
-        }
       }
     }
+  }
   // If we have not yet found it then the target is not available.
-  if(!*loc && !*imp)
-    {
+  if (!*loc && !*imp) {
     return false;
-    }
+  }
 
   return true;
 }
@@ -1826,8 +1599,8 @@ cmTargetInternalPointer::cmTargetInternalPointer()
   this->Pointer = new cmTargetInternals;
 }
 
-cmTargetInternalPointer
-::cmTargetInternalPointer(cmTargetInternalPointer const& r)
+cmTargetInternalPointer::cmTargetInternalPointer(
+  cmTargetInternalPointer const& r)
 {
   // Ideally cmTarget instances should never be copied.  However until
   // we can make a sweep to remove that, this copy constructor avoids
@@ -1840,10 +1613,12 @@ cmTargetInternalPointer::~cmTargetInternalPointer()
   delete this->Pointer;
 }
 
-cmTargetInternalPointer&
-cmTargetInternalPointer::operator=(cmTargetInternalPointer const& r)
+cmTargetInternalPointer& cmTargetInternalPointer::operator=(
+  cmTargetInternalPointer const& r)
 {
-  if(this == &r) { return *this; } // avoid warning on HP about self check
+  if (this == &r) {
+    return *this;
+  } // avoid warning on HP about self check
   // Ideally cmTarget instances should never be copied.  However until
   // we can make a sweep to remove that, this copy constructor avoids
   // allowing the resources (Internals) to be copied.
diff --git a/Source/cmTarget.h b/Source/cmTarget.h
index 262cc9b..71ba0cd 100644
--- a/Source/cmTarget.h
+++ b/Source/cmTarget.h
@@ -21,11 +21,11 @@
 
 #include <cmsys/auto_ptr.hxx>
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# ifdef CMake_HAVE_CXX11_UNORDERED_MAP
-#  include <unordered_map>
-# else
-#  include <cmsys/hash_map.hxx>
-# endif
+#ifdef CMake_HAVE_CXX11_UNORDERED_MAP
+#include <unordered_map>
+#else
+#include <cmsys/hash_map.hxx>
+#endif
 #endif
 
 class cmake;
@@ -61,15 +61,17 @@ class cmTarget
 {
 public:
   cmTarget();
-  enum CustomCommandType { PRE_BUILD, PRE_LINK, POST_BUILD };
+  enum CustomCommandType
+  {
+    PRE_BUILD,
+    PRE_LINK,
+    POST_BUILD
+  };
 
   /**
    * Return the type of target.
    */
-  cmState::TargetType GetType() const
-    {
-    return this->TargetTypeValue;
-    }
+  cmState::TargetType GetType() const { return this->TargetTypeValue; }
 
   /**
    * Set the target type
@@ -79,15 +81,17 @@ public:
   void MarkAsImported(bool global = false);
 
   ///! Set/Get the name of the target
-  const std::string& GetName() const {return this->Name;}
+  const std::string& GetName() const { return this->Name; }
 
   ///! Set the cmMakefile that owns this target
-  void SetMakefile(cmMakefile *mf);
-  cmMakefile *GetMakefile() const { return this->Makefile;}
+  void SetMakefile(cmMakefile* mf);
+  cmMakefile* GetMakefile() const { return this->Makefile; }
 
-#define DECLARE_TARGET_POLICY(POLICY) \
-  cmPolicies::PolicyStatus GetPolicyStatus ## POLICY () const \
-    { return this->PolicyMap.Get(cmPolicies::POLICY); }
+#define DECLARE_TARGET_POLICY(POLICY)                                         \
+  cmPolicies::PolicyStatus GetPolicyStatus##POLICY() const                    \
+  {                                                                           \
+    return this->PolicyMap.Get(cmPolicies::POLICY);                           \
+  }
 
   CM_FOR_EACH_TARGET_POLICY(DECLARE_TARGET_POLICY)
 
@@ -96,18 +100,30 @@ public:
   /**
    * Get the list of the custom commands for this target
    */
-  std::vector<cmCustomCommand> const &GetPreBuildCommands() const
-    {return this->PreBuildCommands;}
-  std::vector<cmCustomCommand> const &GetPreLinkCommands() const
-    {return this->PreLinkCommands;}
-  std::vector<cmCustomCommand> const &GetPostBuildCommands() const
-    {return this->PostBuildCommands;}
-  void AddPreBuildCommand(cmCustomCommand const &cmd)
-    {this->PreBuildCommands.push_back(cmd);}
-  void AddPreLinkCommand(cmCustomCommand const &cmd)
-    {this->PreLinkCommands.push_back(cmd);}
-  void AddPostBuildCommand(cmCustomCommand const &cmd)
-    {this->PostBuildCommands.push_back(cmd);}
+  std::vector<cmCustomCommand> const& GetPreBuildCommands() const
+  {
+    return this->PreBuildCommands;
+  }
+  std::vector<cmCustomCommand> const& GetPreLinkCommands() const
+  {
+    return this->PreLinkCommands;
+  }
+  std::vector<cmCustomCommand> const& GetPostBuildCommands() const
+  {
+    return this->PostBuildCommands;
+  }
+  void AddPreBuildCommand(cmCustomCommand const& cmd)
+  {
+    this->PreBuildCommands.push_back(cmd);
+  }
+  void AddPreLinkCommand(cmCustomCommand const& cmd)
+  {
+    this->PreLinkCommands.push_back(cmd);
+  }
+  void AddPostBuildCommand(cmCustomCommand const& cmd)
+  {
+    this->PostBuildCommands.push_back(cmd);
+  }
 
   /**
    * Add sources to the target.
@@ -120,28 +136,30 @@ public:
   //* how we identify a library, by name and type
   typedef std::pair<std::string, cmTargetLinkLibraryType> LibraryID;
 
-  typedef std::vector<LibraryID > LinkLibraryVectorType;
-  const LinkLibraryVectorType &GetOriginalLinkLibraries() const
-    {return this->OriginalLinkLibraries;}
+  typedef std::vector<LibraryID> LinkLibraryVectorType;
+  const LinkLibraryVectorType& GetOriginalLinkLibraries() const
+  {
+    return this->OriginalLinkLibraries;
+  }
 
   /**
    * Clear the dependency information recorded for this target, if any.
    */
   void ClearDependencyInformation(cmMakefile& mf, const std::string& target);
 
-  void AddLinkLibrary(cmMakefile& mf,
-                      const std::string& target, const std::string& lib,
-                      cmTargetLinkLibraryType llt);
-  enum TLLSignature {
+  void AddLinkLibrary(cmMakefile& mf, const std::string& target,
+                      const std::string& lib, cmTargetLinkLibraryType llt);
+  enum TLLSignature
+  {
     KeywordTLLSignature,
     PlainTLLSignature
   };
   bool PushTLLCommandTrace(TLLSignature signature,
                            cmListFileContext const& lfc);
-  void GetTllSignatureTraces(std::ostringstream &s, TLLSignature sig) const;
+  void GetTllSignatureTraces(std::ostringstream& s, TLLSignature sig) const;
 
-  void MergeLinkLibraries( cmMakefile& mf, const std::string& selfname,
-                           const LinkLibraryVectorType& libs );
+  void MergeLinkLibraries(cmMakefile& mf, const std::string& selfname,
+                          const LinkLibraryVectorType& libs);
 
   const std::vector<std::string>& GetLinkDirectories() const;
 
@@ -151,16 +169,21 @@ public:
    * Set the path where this target should be installed. This is relative to
    * INSTALL_PREFIX
    */
-  std::string GetInstallPath() const {return this->InstallPath;}
-  void SetInstallPath(const char *name) {this->InstallPath = name;}
+  std::string GetInstallPath() const { return this->InstallPath; }
+  void SetInstallPath(const char* name) { this->InstallPath = name; }
 
   /**
    * Set the path where this target (if it has a runtime part) should be
    * installed. This is relative to INSTALL_PREFIX
    */
-  std::string GetRuntimeInstallPath() const {return this->RuntimeInstallPath;}
-  void SetRuntimeInstallPath(const char *name) {
-    this->RuntimeInstallPath = name; }
+  std::string GetRuntimeInstallPath() const
+  {
+    return this->RuntimeInstallPath;
+  }
+  void SetRuntimeInstallPath(const char* name)
+  {
+    this->RuntimeInstallPath = name;
+  }
 
   /**
    * Get/Set whether there is an install rule for this target.
@@ -172,31 +195,31 @@ public:
    * name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE
    * commands. It is not a full path nor does it have an extension.
    */
-  void AddUtility(const std::string& u, cmMakefile *makefile = 0);
+  void AddUtility(const std::string& u, cmMakefile* makefile = 0);
   ///! Get the utilities used by this target
-  std::set<std::string>const& GetUtilities() const { return this->Utilities; }
+  std::set<std::string> const& GetUtilities() const { return this->Utilities; }
   cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const;
 
   ///! Set/Get a property of this target file
-  void SetProperty(const std::string& prop, const char *value);
-  void AppendProperty(const std::string&  prop, const char* value,
-          bool asString=false);
-  const char *GetProperty(const std::string& prop) const;
-  const char *GetProperty(const std::string& prop, cmMakefile* context) const;
+  void SetProperty(const std::string& prop, const char* value);
+  void AppendProperty(const std::string& prop, const char* value,
+                      bool asString = false);
+  const char* GetProperty(const std::string& prop) const;
+  const char* GetProperty(const std::string& prop, cmMakefile* context) const;
   bool GetPropertyAsBool(const std::string& prop) const;
   void CheckProperty(const std::string& prop, cmMakefile* context) const;
 
-  bool IsImported() const {return this->IsImportedTarget;}
+  bool IsImported() const { return this->IsImportedTarget; }
   bool IsImportedGloballyVisible() const
-  { return this->ImportedGloballyVisible; }
+  {
+    return this->ImportedGloballyVisible;
+  }
 
   // Get the properties
-  cmPropertyMap &GetProperties() const { return this->Properties; }
+  cmPropertyMap& GetProperties() const { return this->Properties; }
 
-  bool GetMappedConfig(std::string const& desired_config,
-                       const char** loc,
-                       const char** imp,
-                       std::string& suffix) const;
+  bool GetMappedConfig(std::string const& desired_config, const char** loc,
+                       const char** imp, std::string& suffix) const;
 
   /** Return whether this target is an executable with symbol exports
       enabled.  */
@@ -212,23 +235,23 @@ public:
   /** Get a backtrace from the creation of the target.  */
   cmListFileBacktrace const& GetBacktrace() const;
 
-  void InsertInclude(std::string const& entry,
-                     cmListFileBacktrace const& bt,
+  void InsertInclude(std::string const& entry, cmListFileBacktrace const& bt,
                      bool before = false);
   void InsertCompileOption(std::string const& entry,
-                           cmListFileBacktrace const& bt,
-                           bool before = false);
+                           cmListFileBacktrace const& bt, bool before = false);
   void InsertCompileDefinition(std::string const& entry,
                                cmListFileBacktrace const& bt);
 
   void AppendBuildInterfaceIncludes();
 
-  std::string GetDebugGeneratorExpressions(const std::string &value,
-                                  cmTargetLinkLibraryType llt) const;
+  std::string GetDebugGeneratorExpressions(const std::string& value,
+                                           cmTargetLinkLibraryType llt) const;
 
-  void AddSystemIncludeDirectories(const std::set<std::string> &incs);
-  std::set<std::string> const & GetSystemIncludeDirectories() const
-    { return this->SystemIncludeDirectories; }
+  void AddSystemIncludeDirectories(const std::set<std::string>& incs);
+  std::set<std::string> const& GetSystemIncludeDirectories() const
+  {
+    return this->SystemIncludeDirectories;
+  }
 
   cmStringRange GetIncludeDirectoriesEntries() const;
   cmBacktraceRange GetIncludeDirectoriesBacktraces() const;
@@ -247,7 +270,8 @@ public:
   cmStringRange GetLinkImplementationEntries() const;
   cmBacktraceRange GetLinkImplementationBacktraces() const;
 
-  struct StrictTargetComparison {
+  struct StrictTargetComparison
+  {
     bool operator()(cmTarget const* t1, cmTarget const* t2) const;
   };
 
@@ -313,10 +337,14 @@ typedef std::unordered_map<std::string, cmTarget> cmTargets;
 typedef cmsys::hash_map<std::string, cmTarget> cmTargets;
 #endif
 #else
-typedef std::map<std::string,cmTarget> cmTargets;
+typedef std::map<std::string, cmTarget> cmTargets;
 #endif
 
-class cmTargetSet: public std::set<std::string> {};
-class cmTargetManifest: public std::map<std::string, cmTargetSet> {};
+class cmTargetSet : public std::set<std::string>
+{
+};
+class cmTargetManifest : public std::map<std::string, cmTargetSet>
+{
+};
 
 #endif
diff --git a/Source/cmTargetCompileDefinitionsCommand.cxx b/Source/cmTargetCompileDefinitionsCommand.cxx
index e50e783..0711a5c 100644
--- a/Source/cmTargetCompileDefinitionsCommand.cxx
+++ b/Source/cmTargetCompileDefinitionsCommand.cxx
@@ -13,54 +13,50 @@
 
 #include "cmAlgorithms.h"
 
-bool cmTargetCompileDefinitionsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmTargetCompileDefinitionsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   return this->HandleArguments(args, "COMPILE_DEFINITIONS");
 }
 
-void cmTargetCompileDefinitionsCommand
-::HandleImportedTarget(const std::string &tgt)
+void cmTargetCompileDefinitionsCommand::HandleImportedTarget(
+  const std::string& tgt)
 {
   std::ostringstream e;
-  e << "Cannot specify compile definitions for imported target \""
-    << tgt << "\".";
+  e << "Cannot specify compile definitions for imported target \"" << tgt
+    << "\".";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-void cmTargetCompileDefinitionsCommand
-::HandleMissingTarget(const std::string &name)
+void cmTargetCompileDefinitionsCommand::HandleMissingTarget(
+  const std::string& name)
 {
   std::ostringstream e;
-  e << "Cannot specify compile definitions for target \"" << name << "\" "
+  e << "Cannot specify compile definitions for target \"" << name
+    << "\" "
        "which is not built by this project.";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-std::string cmTargetCompileDefinitionsCommand
-::Join(const std::vector<std::string> &content)
+std::string cmTargetCompileDefinitionsCommand::Join(
+  const std::vector<std::string>& content)
 {
   std::string defs;
   std::string sep;
-  for(std::vector<std::string>::const_iterator it = content.begin();
-    it != content.end(); ++it)
-    {
-    if (cmHasLiteralPrefix(it->c_str(), "-D"))
-      {
+  for (std::vector<std::string>::const_iterator it = content.begin();
+       it != content.end(); ++it) {
+    if (cmHasLiteralPrefix(it->c_str(), "-D")) {
       defs += sep + it->substr(2);
-      }
-    else
-      {
+    } else {
       defs += sep + *it;
-      }
-    sep = ";";
     }
+    sep = ";";
+  }
   return defs;
 }
 
-bool cmTargetCompileDefinitionsCommand
-::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                                   bool, bool)
+bool cmTargetCompileDefinitionsCommand::HandleDirectContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool, bool)
 {
   tgt->AppendProperty("COMPILE_DEFINITIONS", this->Join(content).c_str());
   return true;
diff --git a/Source/cmTargetCompileDefinitionsCommand.h b/Source/cmTargetCompileDefinitionsCommand.h
index b548c70..29d86c5 100644
--- a/Source/cmTargetCompileDefinitionsCommand.h
+++ b/Source/cmTargetCompileDefinitionsCommand.h
@@ -21,33 +21,30 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTargetCompileDefinitionsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTargetCompileDefinitionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_compile_definitions";}
+  virtual std::string GetName() const { return "target_compile_definitions"; }
 
   cmTypeMacro(cmTargetCompileDefinitionsCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string &tgt);
-  virtual void HandleMissingTarget(const std::string &name);
+  virtual void HandleImportedTarget(const std::string& tgt);
+  virtual void HandleMissingTarget(const std::string& name);
 
-  virtual bool HandleDirectContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
+  virtual bool HandleDirectContent(cmTarget* tgt,
+                                   const std::vector<std::string>& content,
                                    bool prepend, bool system);
-  virtual std::string Join(const std::vector<std::string> &content);
+  virtual std::string Join(const std::vector<std::string>& content);
 };
 
 #endif
diff --git a/Source/cmTargetCompileFeaturesCommand.cxx b/Source/cmTargetCompileFeaturesCommand.cxx
index 4bc8181..3ac791a 100644
--- a/Source/cmTargetCompileFeaturesCommand.cxx
+++ b/Source/cmTargetCompileFeaturesCommand.cxx
@@ -14,49 +14,46 @@
 #include "cmAlgorithms.h"
 
 bool cmTargetCompileFeaturesCommand::InitialPass(
-  std::vector<std::string> const& args,
-  cmExecutionStatus &)
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   return this->HandleArguments(args, "COMPILE_FEATURES", NO_FLAGS);
 }
 
-void cmTargetCompileFeaturesCommand
-::HandleImportedTarget(const std::string &tgt)
+void cmTargetCompileFeaturesCommand::HandleImportedTarget(
+  const std::string& tgt)
 {
   std::ostringstream e;
-  e << "Cannot specify compile features for imported target \""
-    << tgt << "\".";
+  e << "Cannot specify compile features for imported target \"" << tgt
+    << "\".";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-void cmTargetCompileFeaturesCommand
-::HandleMissingTarget(const std::string &name)
+void cmTargetCompileFeaturesCommand::HandleMissingTarget(
+  const std::string& name)
 {
   std::ostringstream e;
-  e << "Cannot specify compile features for target \"" << name << "\" "
+  e << "Cannot specify compile features for target \"" << name
+    << "\" "
        "which is not built by this project.";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-std::string cmTargetCompileFeaturesCommand
-::Join(const std::vector<std::string> &content)
+std::string cmTargetCompileFeaturesCommand::Join(
+  const std::vector<std::string>& content)
 {
   return cmJoin(content, ";");
 }
 
-bool cmTargetCompileFeaturesCommand
-::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                                   bool, bool)
+bool cmTargetCompileFeaturesCommand::HandleDirectContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool, bool)
 {
-  for(std::vector<std::string>::const_iterator it = content.begin();
-    it != content.end(); ++it)
-    {
+  for (std::vector<std::string>::const_iterator it = content.begin();
+       it != content.end(); ++it) {
     std::string error;
-    if(!this->Makefile->AddRequiredTargetFeature(tgt, *it, &error))
-      {
+    if (!this->Makefile->AddRequiredTargetFeature(tgt, *it, &error)) {
       this->SetError(error);
       return false;
-      }
     }
+  }
   return true;
 }
diff --git a/Source/cmTargetCompileFeaturesCommand.h b/Source/cmTargetCompileFeaturesCommand.h
index fa7ae8d..3d883e9 100644
--- a/Source/cmTargetCompileFeaturesCommand.h
+++ b/Source/cmTargetCompileFeaturesCommand.h
@@ -16,26 +16,23 @@
 
 class cmTargetCompileFeaturesCommand : public cmTargetPropCommandBase
 {
-  virtual cmCommand* Clone()
-    {
-    return new cmTargetCompileFeaturesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTargetCompileFeaturesCommand; }
 
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
-  virtual std::string GetName() const { return "target_compile_features";}
+  virtual std::string GetName() const { return "target_compile_features"; }
 
   cmTypeMacro(cmTargetCompileFeaturesCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string &tgt);
-  virtual void HandleMissingTarget(const std::string &name);
+  virtual void HandleImportedTarget(const std::string& tgt);
+  virtual void HandleMissingTarget(const std::string& name);
 
-  virtual bool HandleDirectContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
+  virtual bool HandleDirectContent(cmTarget* tgt,
+                                   const std::vector<std::string>& content,
                                    bool prepend, bool system);
-  virtual std::string Join(const std::vector<std::string> &content);
+  virtual std::string Join(const std::vector<std::string>& content);
 };
 
 #endif
diff --git a/Source/cmTargetCompileOptionsCommand.cxx b/Source/cmTargetCompileOptionsCommand.cxx
index d7c19c8..065f618 100644
--- a/Source/cmTargetCompileOptionsCommand.cxx
+++ b/Source/cmTargetCompileOptionsCommand.cxx
@@ -13,39 +13,38 @@
 
 #include "cmAlgorithms.h"
 
-bool cmTargetCompileOptionsCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmTargetCompileOptionsCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   return this->HandleArguments(args, "COMPILE_OPTIONS", PROCESS_BEFORE);
 }
 
-void cmTargetCompileOptionsCommand
-::HandleImportedTarget(const std::string &tgt)
+void cmTargetCompileOptionsCommand::HandleImportedTarget(
+  const std::string& tgt)
 {
   std::ostringstream e;
-  e << "Cannot specify compile options for imported target \""
-    << tgt << "\".";
+  e << "Cannot specify compile options for imported target \"" << tgt << "\".";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-void cmTargetCompileOptionsCommand
-::HandleMissingTarget(const std::string &name)
+void cmTargetCompileOptionsCommand::HandleMissingTarget(
+  const std::string& name)
 {
   std::ostringstream e;
-  e << "Cannot specify compile options for target \"" << name << "\" "
+  e << "Cannot specify compile options for target \"" << name
+    << "\" "
        "which is not built by this project.";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-std::string cmTargetCompileOptionsCommand
-::Join(const std::vector<std::string> &content)
+std::string cmTargetCompileOptionsCommand::Join(
+  const std::vector<std::string>& content)
 {
   return cmJoin(content, ";");
 }
 
-bool cmTargetCompileOptionsCommand
-::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                                   bool, bool)
+bool cmTargetCompileOptionsCommand::HandleDirectContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool, bool)
 {
   cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
   tgt->InsertCompileOption(this->Join(content), lfbt);
diff --git a/Source/cmTargetCompileOptionsCommand.h b/Source/cmTargetCompileOptionsCommand.h
index d43534d..231448b 100644
--- a/Source/cmTargetCompileOptionsCommand.h
+++ b/Source/cmTargetCompileOptionsCommand.h
@@ -21,33 +21,30 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTargetCompileOptionsCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTargetCompileOptionsCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_compile_options";}
+  virtual std::string GetName() const { return "target_compile_options"; }
 
   cmTypeMacro(cmTargetCompileOptionsCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string &tgt);
-  virtual void HandleMissingTarget(const std::string &name);
+  virtual void HandleImportedTarget(const std::string& tgt);
+  virtual void HandleMissingTarget(const std::string& name);
 
-  virtual bool HandleDirectContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
+  virtual bool HandleDirectContent(cmTarget* tgt,
+                                   const std::vector<std::string>& content,
                                    bool prepend, bool system);
-  virtual std::string Join(const std::vector<std::string> &content);
+  virtual std::string Join(const std::vector<std::string>& content);
 };
 
 #endif
diff --git a/Source/cmTargetDepend.h b/Source/cmTargetDepend.h
index c5059ee..954d8f6 100644
--- a/Source/cmTargetDepend.h
+++ b/Source/cmTargetDepend.h
@@ -26,24 +26,36 @@ class cmTargetDepend
   // mutable members to acheive a map with set syntax.
   mutable bool Link;
   mutable bool Util;
+
 public:
   cmTargetDepend(cmGeneratorTarget const* t)
-    : Target(t), Link(false), Util(false) {}
+    : Target(t)
+    , Link(false)
+    , Util(false)
+  {
+  }
   operator cmGeneratorTarget const*() const { return this->Target; }
   cmGeneratorTarget const* operator->() const { return this->Target; }
   cmGeneratorTarget const& operator*() const { return *this->Target; }
-  friend bool operator < (cmTargetDepend const& l, cmTargetDepend const& r)
-    { return l.Target < r.Target; }
+  friend bool operator<(cmTargetDepend const& l, cmTargetDepend const& r)
+  {
+    return l.Target < r.Target;
+  }
   void SetType(bool strong) const
-    {
-    if(strong) { this->Util = true; }
-    else { this->Link = true; }
+  {
+    if (strong) {
+      this->Util = true;
+    } else {
+      this->Link = true;
     }
+  }
   bool IsLink() const { return this->Link; }
   bool IsUtil() const { return this->Util; }
 };
 
 /** Unordered set of (direct) dependencies of a target. */
-class cmTargetDependSet: public std::set<cmTargetDepend> {};
+class cmTargetDependSet : public std::set<cmTargetDepend>
+{
+};
 
 #endif
diff --git a/Source/cmTargetIncludeDirectoriesCommand.cxx b/Source/cmTargetIncludeDirectoriesCommand.cxx
index 01d9164..4486b0e 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.cxx
+++ b/Source/cmTargetIncludeDirectoriesCommand.cxx
@@ -13,96 +13,86 @@
 
 #include "cmGeneratorExpression.h"
 
-bool cmTargetIncludeDirectoriesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmTargetIncludeDirectoriesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   return this->HandleArguments(args, "INCLUDE_DIRECTORIES",
                                ArgumentFlags(PROCESS_BEFORE | PROCESS_SYSTEM));
 }
 
-void cmTargetIncludeDirectoriesCommand
-::HandleImportedTarget(const std::string &tgt)
+void cmTargetIncludeDirectoriesCommand::HandleImportedTarget(
+  const std::string& tgt)
 {
   std::ostringstream e;
-  e << "Cannot specify include directories for imported target \""
-    << tgt << "\".";
+  e << "Cannot specify include directories for imported target \"" << tgt
+    << "\".";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-void cmTargetIncludeDirectoriesCommand
-::HandleMissingTarget(const std::string &name)
+void cmTargetIncludeDirectoriesCommand::HandleMissingTarget(
+  const std::string& name)
 {
   std::ostringstream e;
-  e << "Cannot specify include directories for target \"" << name << "\" "
+  e << "Cannot specify include directories for target \"" << name
+    << "\" "
        "which is not built by this project.";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-std::string cmTargetIncludeDirectoriesCommand
-::Join(const std::vector<std::string> &content)
+std::string cmTargetIncludeDirectoriesCommand::Join(
+  const std::vector<std::string>& content)
 {
   std::string dirs;
   std::string sep;
   std::string prefix =
-      this->Makefile->GetCurrentSourceDirectory() + std::string("/");
-  for(std::vector<std::string>::const_iterator it = content.begin();
-    it != content.end(); ++it)
-    {
-    if (cmSystemTools::FileIsFullPath(it->c_str())
-        || cmGeneratorExpression::Find(*it) == 0)
-      {
+    this->Makefile->GetCurrentSourceDirectory() + std::string("/");
+  for (std::vector<std::string>::const_iterator it = content.begin();
+       it != content.end(); ++it) {
+    if (cmSystemTools::FileIsFullPath(it->c_str()) ||
+        cmGeneratorExpression::Find(*it) == 0) {
       dirs += sep + *it;
-      }
-    else
-      {
+    } else {
       dirs += sep + prefix + *it;
-      }
-    sep = ";";
     }
+    sep = ";";
+  }
   return dirs;
 }
 
-bool cmTargetIncludeDirectoriesCommand
-::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                      bool prepend, bool system)
+bool cmTargetIncludeDirectoriesCommand::HandleDirectContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool prepend,
+  bool system)
 {
   cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
   tgt->InsertInclude(this->Join(content), lfbt, prepend);
-  if (system)
-    {
+  if (system) {
     std::string prefix =
       this->Makefile->GetCurrentSourceDirectory() + std::string("/");
     std::set<std::string> sdirs;
     for (std::vector<std::string>::const_iterator it = content.begin();
-      it != content.end(); ++it)
-      {
-      if (cmSystemTools::FileIsFullPath(it->c_str())
-          || cmGeneratorExpression::Find(*it) == 0)
-        {
+         it != content.end(); ++it) {
+      if (cmSystemTools::FileIsFullPath(it->c_str()) ||
+          cmGeneratorExpression::Find(*it) == 0) {
         sdirs.insert(*it);
-        }
-      else
-        {
+      } else {
         sdirs.insert(prefix + *it);
-        }
       }
-    tgt->AddSystemIncludeDirectories(sdirs);
     }
+    tgt->AddSystemIncludeDirectories(sdirs);
+  }
   return true;
 }
 
-void cmTargetIncludeDirectoriesCommand
-::HandleInterfaceContent(cmTarget *tgt,
-                         const std::vector<std::string> &content,
-                         bool prepend, bool system)
+void cmTargetIncludeDirectoriesCommand::HandleInterfaceContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool prepend,
+  bool system)
 {
-  cmTargetPropCommandBase::HandleInterfaceContent(tgt, content,
-                                                  prepend, system);
+  cmTargetPropCommandBase::HandleInterfaceContent(tgt, content, prepend,
+                                                  system);
 
-  if (system)
-    {
+  if (system) {
     std::string joined = this->Join(content);
     tgt->AppendProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
                         joined.c_str());
-    }
+  }
 }
diff --git a/Source/cmTargetIncludeDirectoriesCommand.h b/Source/cmTargetIncludeDirectoriesCommand.h
index 14d1d1e..4c907bd 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.h
+++ b/Source/cmTargetIncludeDirectoriesCommand.h
@@ -21,37 +21,34 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTargetIncludeDirectoriesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTargetIncludeDirectoriesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_include_directories";}
+  virtual std::string GetName() const { return "target_include_directories"; }
 
   cmTypeMacro(cmTargetIncludeDirectoriesCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string &tgt);
-  virtual void HandleMissingTarget(const std::string &name);
+  virtual void HandleImportedTarget(const std::string& tgt);
+  virtual void HandleMissingTarget(const std::string& name);
 
-  virtual bool HandleDirectContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
-                                   bool prepend, bool system);
-  virtual void HandleInterfaceContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
+  virtual bool HandleDirectContent(cmTarget* tgt,
+                                   const std::vector<std::string>& content,
                                    bool prepend, bool system);
+  virtual void HandleInterfaceContent(cmTarget* tgt,
+                                      const std::vector<std::string>& content,
+                                      bool prepend, bool system);
 
-  virtual std::string Join(const std::vector<std::string> &content);
+  virtual std::string Join(const std::vector<std::string>& content);
 };
 
 #endif
diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx
index 04f0b45..774577a 100644
--- a/Source/cmTargetLinkLibrariesCommand.cxx
+++ b/Source/cmTargetLinkLibrariesCommand.cxx
@@ -13,68 +13,60 @@
 
 #include "cmGeneratorExpression.h"
 
-const char* cmTargetLinkLibrariesCommand::LinkLibraryTypeNames[3] =
-{
-  "general",
-  "debug",
-  "optimized"
+const char* cmTargetLinkLibrariesCommand::LinkLibraryTypeNames[3] = {
+  "general", "debug", "optimized"
 };
 
 // cmTargetLinkLibrariesCommand
-bool cmTargetLinkLibrariesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmTargetLinkLibrariesCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
   // must have one argument
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
-  if (this->Makefile->IsAlias(args[0]))
-    {
+  if (this->Makefile->IsAlias(args[0])) {
     this->SetError("can not be used on an ALIAS target.");
     return false;
-    }
+  }
   // Lookup the target for which libraries are specified.
   this->Target =
-    this->Makefile->GetCMakeInstance()
-    ->GetGlobalGenerator()->FindTarget(args[0]);
-  if(!this->Target)
-    {
-    cmake::MessageType t = cmake::FATAL_ERROR;  // fail by default
+    this->Makefile->GetCMakeInstance()->GetGlobalGenerator()->FindTarget(
+      args[0]);
+  if (!this->Target) {
+    cmake::MessageType t = cmake::FATAL_ERROR; // fail by default
     std::ostringstream e;
     e << "Cannot specify link libraries for target \"" << args[0] << "\" "
       << "which is not built by this project.";
     // The bad target is the only argument. Check how policy CMP0016 is set,
     // and accept, warn or fail respectively:
-    if (args.size() < 2)
-      {
-      switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0016))
-        {
+    if (args.size() < 2) {
+      switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0016)) {
         case cmPolicies::WARN:
           t = cmake::AUTHOR_WARNING;
           // Print the warning.
           e << "\n"
             << "CMake does not support this but it used to work accidentally "
             << "and is being allowed for compatibility."
-            << "\n" << cmPolicies::GetPolicyWarning(cmPolicies::CMP0016);
-           break;
-        case cmPolicies::OLD:          // OLD behavior does not warn.
+            << "\n"
+            << cmPolicies::GetPolicyWarning(cmPolicies::CMP0016);
+          break;
+        case cmPolicies::OLD: // OLD behavior does not warn.
           t = cmake::MESSAGE;
           break;
         case cmPolicies::REQUIRED_IF_USED:
         case cmPolicies::REQUIRED_ALWAYS:
           e << "\n" << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0016);
           break;
-        case cmPolicies::NEW:  // NEW behavior prints the error.
+        case cmPolicies::NEW: // NEW behavior prints the error.
           break;
-        }
       }
+    }
 
     // now actually print the message
-    switch(t)
-      {
+    switch (t) {
       case cmake::AUTHOR_WARNING:
         this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str());
         break;
@@ -84,27 +76,24 @@ bool cmTargetLinkLibrariesCommand
         break;
       default:
         break;
-      }
-    return true;
     }
+    return true;
+  }
 
-  if(this->Target->GetType() == cmState::OBJECT_LIBRARY)
-    {
+  if (this->Target->GetType() == cmState::OBJECT_LIBRARY) {
     std::ostringstream e;
     e << "Object library target \"" << args[0] << "\" "
       << "may not link to anything.";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
     return true;
-    }
+  }
 
-  if (this->Target->GetType() == cmState::UTILITY)
-    {
+  if (this->Target->GetType() == cmState::UTILITY) {
     std::ostringstream e;
-    const char *modal = 0;
+    const char* modal = 0;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0039))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0039)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0039) << "\n";
         modal = "should";
@@ -115,25 +104,21 @@ bool cmTargetLinkLibrariesCommand
       case cmPolicies::NEW:
         modal = "must";
         messageType = cmake::FATAL_ERROR;
-      }
-    if (modal)
-      {
-      e <<
-        "Utility target \"" << this->Target->GetName() << "\" " << modal
+    }
+    if (modal) {
+      e << "Utility target \"" << this->Target->GetName() << "\" " << modal
         << " not be used as the target of a target_link_libraries call.";
       this->Makefile->IssueMessage(messageType, e.str());
-      if(messageType == cmake::FATAL_ERROR)
-        {
+      if (messageType == cmake::FATAL_ERROR) {
         return false;
-        }
       }
     }
+  }
 
   // but we might not have any libs after variable expansion
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     return true;
-    }
+  }
 
   // Keep track of link configuration specifiers.
   cmTargetLinkLibraryType llt = GENERAL_LibraryType;
@@ -145,137 +130,98 @@ bool cmTargetLinkLibrariesCommand
 
   // add libraries, note that there is an optional prefix
   // of debug and optimized that can be used
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    if(args[i] == "LINK_INTERFACE_LIBRARIES")
-      {
+  for (unsigned int i = 1; i < args.size(); ++i) {
+    if (args[i] == "LINK_INTERFACE_LIBRARIES") {
       this->CurrentProcessingState = ProcessingPlainLinkInterface;
-      if(i != 1)
-        {
+      if (i != 1) {
         this->Makefile->IssueMessage(
           cmake::FATAL_ERROR,
           "The LINK_INTERFACE_LIBRARIES option must appear as the second "
-          "argument, just after the target name."
-          );
+          "argument, just after the target name.");
         return true;
-        }
       }
-    else if(args[i] == "INTERFACE")
-      {
-      if(i != 1
-          && this->CurrentProcessingState != ProcessingKeywordPrivateInterface
-          && this->CurrentProcessingState != ProcessingKeywordPublicInterface
-          && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
-        {
+    } else if (args[i] == "INTERFACE") {
+      if (i != 1 &&
+          this->CurrentProcessingState != ProcessingKeywordPrivateInterface &&
+          this->CurrentProcessingState != ProcessingKeywordPublicInterface &&
+          this->CurrentProcessingState != ProcessingKeywordLinkInterface) {
         this->Makefile->IssueMessage(
-          cmake::FATAL_ERROR,
-          "The INTERFACE option must appear as the second "
-          "argument, just after the target name."
-          );
+          cmake::FATAL_ERROR, "The INTERFACE option must appear as the second "
+                              "argument, just after the target name.");
         return true;
-        }
-      this->CurrentProcessingState = ProcessingKeywordLinkInterface;
       }
-    else if(args[i] == "LINK_PUBLIC")
-      {
-      if(i != 1
-          && this->CurrentProcessingState != ProcessingPlainPrivateInterface
-          && this->CurrentProcessingState != ProcessingPlainPublicInterface)
-        {
+      this->CurrentProcessingState = ProcessingKeywordLinkInterface;
+    } else if (args[i] == "LINK_PUBLIC") {
+      if (i != 1 &&
+          this->CurrentProcessingState != ProcessingPlainPrivateInterface &&
+          this->CurrentProcessingState != ProcessingPlainPublicInterface) {
         this->Makefile->IssueMessage(
           cmake::FATAL_ERROR,
           "The LINK_PUBLIC or LINK_PRIVATE option must appear as the second "
-          "argument, just after the target name."
-          );
+          "argument, just after the target name.");
         return true;
-        }
-      this->CurrentProcessingState = ProcessingPlainPublicInterface;
       }
-    else if(args[i] == "PUBLIC")
-      {
-      if(i != 1
-          && this->CurrentProcessingState != ProcessingKeywordPrivateInterface
-          && this->CurrentProcessingState != ProcessingKeywordPublicInterface
-          && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
-        {
+      this->CurrentProcessingState = ProcessingPlainPublicInterface;
+    } else if (args[i] == "PUBLIC") {
+      if (i != 1 &&
+          this->CurrentProcessingState != ProcessingKeywordPrivateInterface &&
+          this->CurrentProcessingState != ProcessingKeywordPublicInterface &&
+          this->CurrentProcessingState != ProcessingKeywordLinkInterface) {
         this->Makefile->IssueMessage(
           cmake::FATAL_ERROR,
           "The PUBLIC or PRIVATE option must appear as the second "
-          "argument, just after the target name."
-          );
+          "argument, just after the target name.");
         return true;
-        }
-      this->CurrentProcessingState = ProcessingKeywordPublicInterface;
       }
-    else if(args[i] == "LINK_PRIVATE")
-      {
-      if(i != 1
-          && this->CurrentProcessingState != ProcessingPlainPublicInterface
-          && this->CurrentProcessingState != ProcessingPlainPrivateInterface)
-        {
+      this->CurrentProcessingState = ProcessingKeywordPublicInterface;
+    } else if (args[i] == "LINK_PRIVATE") {
+      if (i != 1 &&
+          this->CurrentProcessingState != ProcessingPlainPublicInterface &&
+          this->CurrentProcessingState != ProcessingPlainPrivateInterface) {
         this->Makefile->IssueMessage(
           cmake::FATAL_ERROR,
           "The LINK_PUBLIC or LINK_PRIVATE option must appear as the second "
-          "argument, just after the target name."
-          );
+          "argument, just after the target name.");
         return true;
-        }
-      this->CurrentProcessingState = ProcessingPlainPrivateInterface;
       }
-    else if(args[i] == "PRIVATE")
-      {
-      if(i != 1
-          && this->CurrentProcessingState != ProcessingKeywordPrivateInterface
-          && this->CurrentProcessingState != ProcessingKeywordPublicInterface
-          && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
-        {
+      this->CurrentProcessingState = ProcessingPlainPrivateInterface;
+    } else if (args[i] == "PRIVATE") {
+      if (i != 1 &&
+          this->CurrentProcessingState != ProcessingKeywordPrivateInterface &&
+          this->CurrentProcessingState != ProcessingKeywordPublicInterface &&
+          this->CurrentProcessingState != ProcessingKeywordLinkInterface) {
         this->Makefile->IssueMessage(
           cmake::FATAL_ERROR,
           "The PUBLIC or PRIVATE option must appear as the second "
-          "argument, just after the target name."
-          );
+          "argument, just after the target name.");
         return true;
-        }
-      this->CurrentProcessingState = ProcessingKeywordPrivateInterface;
       }
-    else if(args[i] == "debug")
-      {
-      if(haveLLT)
-        {
+      this->CurrentProcessingState = ProcessingKeywordPrivateInterface;
+    } else if (args[i] == "debug") {
+      if (haveLLT) {
         this->LinkLibraryTypeSpecifierWarning(llt, DEBUG_LibraryType);
-        }
+      }
       llt = DEBUG_LibraryType;
       haveLLT = true;
-      }
-    else if(args[i] == "optimized")
-      {
-      if(haveLLT)
-        {
+    } else if (args[i] == "optimized") {
+      if (haveLLT) {
         this->LinkLibraryTypeSpecifierWarning(llt, OPTIMIZED_LibraryType);
-        }
+      }
       llt = OPTIMIZED_LibraryType;
       haveLLT = true;
-      }
-    else if(args[i] == "general")
-      {
-      if(haveLLT)
-        {
+    } else if (args[i] == "general") {
+      if (haveLLT) {
         this->LinkLibraryTypeSpecifierWarning(llt, GENERAL_LibraryType);
-        }
+      }
       llt = GENERAL_LibraryType;
       haveLLT = true;
-      }
-    else if(haveLLT)
-      {
+    } else if (haveLLT) {
       // The link type was specified by the previous argument.
       haveLLT = false;
-      if (!this->HandleLibrary(args[i], llt))
-        {
+      if (!this->HandleLibrary(args[i], llt)) {
         return false;
-        }
       }
-    else
-      {
+    } else {
       // Lookup old-style cache entry if type is unspecified.  So if you
       // do a target_link_libraries(foo optimized bar) it will stay optimized
       // and not use the lookup.  As there maybe the case where someone has
@@ -285,95 +231,85 @@ bool cmTargetLinkLibrariesCommand
       llt = GENERAL_LibraryType;
       std::string linkType = args[0];
       linkType += "_LINK_TYPE";
-      const char* linkTypeString =
-        this->Makefile->GetDefinition( linkType );
-      if(linkTypeString)
-        {
-        if(strcmp(linkTypeString, "debug") == 0)
-          {
+      const char* linkTypeString = this->Makefile->GetDefinition(linkType);
+      if (linkTypeString) {
+        if (strcmp(linkTypeString, "debug") == 0) {
           llt = DEBUG_LibraryType;
-          }
-        if(strcmp(linkTypeString, "optimized") == 0)
-          {
+        }
+        if (strcmp(linkTypeString, "optimized") == 0) {
           llt = OPTIMIZED_LibraryType;
-          }
         }
-      if (!this->HandleLibrary(args[i], llt))
-        {
+      }
+      if (!this->HandleLibrary(args[i], llt)) {
         return false;
-        }
       }
     }
+  }
 
   // Make sure the last argument was not a library type specifier.
-  if(haveLLT)
-    {
+  if (haveLLT) {
     std::ostringstream e;
     e << "The \"" << this->LinkLibraryTypeNames[llt]
       << "\" argument must be followed by a library.";
     this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
     cmSystemTools::SetFatalErrorOccured();
-    }
+  }
 
-  const cmPolicies::PolicyStatus policy22Status
-                      = this->Target->GetPolicyStatusCMP0022();
+  const cmPolicies::PolicyStatus policy22Status =
+    this->Target->GetPolicyStatusCMP0022();
 
   // If any of the LINK_ options were given, make sure the
   // LINK_INTERFACE_LIBRARIES target property exists.
   // Use of any of the new keywords implies awareness of
   // this property. And if no libraries are named, it should
   // result in an empty link interface.
-  if((policy22Status == cmPolicies::OLD ||
-      policy22Status == cmPolicies::WARN) &&
+  if ((policy22Status == cmPolicies::OLD ||
+       policy22Status == cmPolicies::WARN) &&
       this->CurrentProcessingState != ProcessingLinkLibraries &&
-     !this->Target->GetProperty("LINK_INTERFACE_LIBRARIES"))
-    {
+      !this->Target->GetProperty("LINK_INTERFACE_LIBRARIES")) {
     this->Target->SetProperty("LINK_INTERFACE_LIBRARIES", "");
-    }
+  }
 
   return true;
 }
 
-void
-cmTargetLinkLibrariesCommand
-::LinkLibraryTypeSpecifierWarning(int left, int right)
+void cmTargetLinkLibrariesCommand::LinkLibraryTypeSpecifierWarning(int left,
+                                                                   int right)
 {
   std::ostringstream w;
-  w << "Link library type specifier \""
-    << this->LinkLibraryTypeNames[left] << "\" is followed by specifier \""
-    << this->LinkLibraryTypeNames[right] << "\" instead of a library name.  "
+  w << "Link library type specifier \"" << this->LinkLibraryTypeNames[left]
+    << "\" is followed by specifier \"" << this->LinkLibraryTypeNames[right]
+    << "\" instead of a library name.  "
     << "The first specifier will be ignored.";
   this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
 }
 
-bool
-cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
-                                            cmTargetLinkLibraryType llt)
+bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
+                                                 cmTargetLinkLibraryType llt)
 {
-  if(this->Target->GetType() == cmState::INTERFACE_LIBRARY
-      && this->CurrentProcessingState != ProcessingKeywordLinkInterface)
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
+  if (this->Target->GetType() == cmState::INTERFACE_LIBRARY &&
+      this->CurrentProcessingState != ProcessingKeywordLinkInterface) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
       "INTERFACE library can only be used with the INTERFACE keyword of "
       "target_link_libraries");
     return false;
-    }
+  }
 
   cmTarget::TLLSignature sig =
-        (this->CurrentProcessingState == ProcessingPlainPrivateInterface
-      || this->CurrentProcessingState == ProcessingPlainPublicInterface
-      || this->CurrentProcessingState == ProcessingKeywordPrivateInterface
-      || this->CurrentProcessingState == ProcessingKeywordPublicInterface
-      || this->CurrentProcessingState == ProcessingKeywordLinkInterface)
-        ? cmTarget::KeywordTLLSignature : cmTarget::PlainTLLSignature;
+    (this->CurrentProcessingState == ProcessingPlainPrivateInterface ||
+     this->CurrentProcessingState == ProcessingPlainPublicInterface ||
+     this->CurrentProcessingState == ProcessingKeywordPrivateInterface ||
+     this->CurrentProcessingState == ProcessingKeywordPublicInterface ||
+     this->CurrentProcessingState == ProcessingKeywordLinkInterface)
+    ? cmTarget::KeywordTLLSignature
+    : cmTarget::PlainTLLSignature;
   if (!this->Target->PushTLLCommandTrace(
-        sig, this->Makefile->GetExecutionContext()))
-    {
+        sig, this->Makefile->GetExecutionContext())) {
     std::ostringstream e;
-    const char *modal = 0;
+    const char* modal = 0;
     cmake::MessageType messageType = cmake::AUTHOR_WARNING;
-    switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0023))
-      {
+    switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0023)) {
       case cmPolicies::WARN:
         e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0023) << "\n";
         modal = "should";
@@ -384,82 +320,74 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
       case cmPolicies::NEW:
         modal = "must";
         messageType = cmake::FATAL_ERROR;
-      }
+    }
 
-      if(modal)
-        {
-        // If the sig is a keyword form and there is a conflict, the existing
-        // form must be the plain form.
-        const char *existingSig
-                    = (sig == cmTarget::KeywordTLLSignature ? "plain"
-                                                            : "keyword");
-          e <<
-            "The " << existingSig << " signature for target_link_libraries "
-            "has already been used with the target \""
-          << this->Target->GetName() << "\".  All uses of "
-             "target_link_libraries with a target " << modal << " be either "
-             "all-keyword or all-plain.\n";
-        this->Target->GetTllSignatureTraces(e,
+    if (modal) {
+      // If the sig is a keyword form and there is a conflict, the existing
+      // form must be the plain form.
+      const char* existingSig =
+        (sig == cmTarget::KeywordTLLSignature ? "plain" : "keyword");
+      e << "The " << existingSig << " signature for target_link_libraries "
+                                    "has already been used with the target \""
+        << this->Target->GetName() << "\".  All uses of "
+                                      "target_link_libraries with a target "
+        << modal << " be either "
+                    "all-keyword or all-plain.\n";
+      this->Target->GetTllSignatureTraces(e,
                                           sig == cmTarget::KeywordTLLSignature
                                             ? cmTarget::PlainTLLSignature
                                             : cmTarget::KeywordTLLSignature);
-        this->Makefile->IssueMessage(messageType, e.str());
-        if(messageType == cmake::FATAL_ERROR)
-          {
-          return false;
-          }
-        }
+      this->Makefile->IssueMessage(messageType, e.str());
+      if (messageType == cmake::FATAL_ERROR) {
+        return false;
+      }
     }
+  }
 
   // Handle normal case first.
-  if(this->CurrentProcessingState != ProcessingKeywordLinkInterface
-      && this->CurrentProcessingState != ProcessingPlainLinkInterface)
-    {
-    this->Makefile
-      ->AddLinkLibraryForTarget(this->Target->GetName(), lib, llt);
-    if(this->CurrentProcessingState == ProcessingLinkLibraries)
-      {
-      this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
+  if (this->CurrentProcessingState != ProcessingKeywordLinkInterface &&
+      this->CurrentProcessingState != ProcessingPlainLinkInterface) {
+    this->Makefile->AddLinkLibraryForTarget(this->Target->GetName(), lib, llt);
+    if (this->CurrentProcessingState == ProcessingLinkLibraries) {
+      this->Target->AppendProperty(
+        "INTERFACE_LINK_LIBRARIES",
         this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
       return true;
-      }
-    else if(this->CurrentProcessingState != ProcessingKeywordPublicInterface
-            && this->CurrentProcessingState != ProcessingPlainPublicInterface)
-      {
-      if (this->Target->GetType() == cmState::STATIC_LIBRARY)
-        {
-        std::string configLib = this->Target
-                                     ->GetDebugGeneratorExpressions(lib, llt);
-        if (cmGeneratorExpression::IsValidTargetName(lib)
-            || cmGeneratorExpression::Find(lib) != std::string::npos)
-          {
+    } else if (this->CurrentProcessingState !=
+                 ProcessingKeywordPublicInterface &&
+               this->CurrentProcessingState !=
+                 ProcessingPlainPublicInterface) {
+      if (this->Target->GetType() == cmState::STATIC_LIBRARY) {
+        std::string configLib =
+          this->Target->GetDebugGeneratorExpressions(lib, llt);
+        if (cmGeneratorExpression::IsValidTargetName(lib) ||
+            cmGeneratorExpression::Find(lib) != std::string::npos) {
           configLib = "$<LINK_ONLY:" + configLib + ">";
-          }
+        }
         this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
                                      configLib.c_str());
-        }
+      }
       // Not a 'public' or 'interface' library. Do not add to interface
       // property.
       return true;
-      }
     }
+  }
 
-  this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
-              this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
+  this->Target->AppendProperty(
+    "INTERFACE_LINK_LIBRARIES",
+    this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
 
-  const cmPolicies::PolicyStatus policy22Status
-                      = this->Target->GetPolicyStatusCMP0022();
+  const cmPolicies::PolicyStatus policy22Status =
+    this->Target->GetPolicyStatusCMP0022();
 
-  if (policy22Status != cmPolicies::OLD
-      && policy22Status != cmPolicies::WARN)
-    {
+  if (policy22Status != cmPolicies::OLD &&
+      policy22Status != cmPolicies::WARN) {
     return true;
-    }
+  }
 
-  if (this->Target->GetType() == cmState::INTERFACE_LIBRARY)
-    {
+  if (this->Target->GetType() == cmState::INTERFACE_LIBRARY) {
     return true;
-    }
+  }
 
   // Get the list of configurations considered to be DEBUG.
   std::vector<std::string> debugConfigs =
@@ -467,34 +395,29 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
   std::string prop;
 
   // Include this library in the link interface for the target.
-  if(llt == DEBUG_LibraryType || llt == GENERAL_LibraryType)
-    {
+  if (llt == DEBUG_LibraryType || llt == GENERAL_LibraryType) {
     // Put in the DEBUG configuration interfaces.
-    for(std::vector<std::string>::const_iterator i = debugConfigs.begin();
-        i != debugConfigs.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = debugConfigs.begin();
+         i != debugConfigs.end(); ++i) {
       prop = "LINK_INTERFACE_LIBRARIES_";
       prop += *i;
       this->Target->AppendProperty(prop, lib.c_str());
-      }
     }
-  if(llt == OPTIMIZED_LibraryType || llt == GENERAL_LibraryType)
-    {
+  }
+  if (llt == OPTIMIZED_LibraryType || llt == GENERAL_LibraryType) {
     // Put in the non-DEBUG configuration interfaces.
     this->Target->AppendProperty("LINK_INTERFACE_LIBRARIES", lib.c_str());
 
     // Make sure the DEBUG configuration interfaces exist so that the
     // general one will not be used as a fall-back.
-    for(std::vector<std::string>::const_iterator i = debugConfigs.begin();
-        i != debugConfigs.end(); ++i)
-      {
+    for (std::vector<std::string>::const_iterator i = debugConfigs.begin();
+         i != debugConfigs.end(); ++i) {
       prop = "LINK_INTERFACE_LIBRARIES_";
       prop += *i;
-      if(!this->Target->GetProperty(prop))
-        {
+      if (!this->Target->GetProperty(prop)) {
         this->Target->SetProperty(prop, "");
-        }
       }
     }
+  }
   return true;
 }
diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h
index f061e6d..016993d 100644
--- a/Source/cmTargetLinkLibrariesCommand.h
+++ b/Source/cmTargetLinkLibrariesCommand.h
@@ -27,30 +27,29 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTargetLinkLibrariesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTargetLinkLibrariesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_link_libraries";}
+  virtual std::string GetName() const { return "target_link_libraries"; }
 
   cmTypeMacro(cmTargetLinkLibrariesCommand, cmCommand);
+
 private:
   void LinkLibraryTypeSpecifierWarning(int left, int right);
   static const char* LinkLibraryTypeNames[3];
 
   cmTarget* Target;
-  enum ProcessingState {
+  enum ProcessingState
+  {
     ProcessingLinkLibraries,
     ProcessingPlainLinkInterface,
     ProcessingKeywordLinkInterface,
@@ -65,6 +64,4 @@ private:
   bool HandleLibrary(const std::string& lib, cmTargetLinkLibraryType llt);
 };
 
-
-
 #endif
diff --git a/Source/cmTargetPropCommandBase.cxx b/Source/cmTargetPropCommandBase.cxx
index 0c51b71..487074f 100644
--- a/Source/cmTargetPropCommandBase.cxx
+++ b/Source/cmTargetPropCommandBase.cxx
@@ -14,164 +14,135 @@
 
 #include "cmGlobalGenerator.h"
 
-bool cmTargetPropCommandBase
-::HandleArguments(std::vector<std::string> const& args,
-                  const std::string& prop,
-                  ArgumentFlags flags)
+bool cmTargetPropCommandBase::HandleArguments(
+  std::vector<std::string> const& args, const std::string& prop,
+  ArgumentFlags flags)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // Lookup the target for which libraries are specified.
-  if (this->Makefile->IsAlias(args[0]))
-    {
+  if (this->Makefile->IsAlias(args[0])) {
     this->SetError("can not be used on an ALIAS target.");
     return false;
-    }
+  }
   this->Target =
-    this->Makefile->GetCMakeInstance()
-    ->GetGlobalGenerator()->FindTarget(args[0]);
-  if(!this->Target)
-    {
+    this->Makefile->GetCMakeInstance()->GetGlobalGenerator()->FindTarget(
+      args[0]);
+  if (!this->Target) {
     this->Target = this->Makefile->FindTargetToUse(args[0]);
-    }
-  if(!this->Target)
-    {
+  }
+  if (!this->Target) {
     this->HandleMissingTarget(args[0]);
     return false;
-    }
-  if ((this->Target->GetType() != cmState::SHARED_LIBRARY)
-    && (this->Target->GetType() != cmState::STATIC_LIBRARY)
-    && (this->Target->GetType() != cmState::OBJECT_LIBRARY)
-    && (this->Target->GetType() != cmState::MODULE_LIBRARY)
-    && (this->Target->GetType() != cmState::INTERFACE_LIBRARY)
-    && (this->Target->GetType() != cmState::EXECUTABLE))
-    {
+  }
+  if ((this->Target->GetType() != cmState::SHARED_LIBRARY) &&
+      (this->Target->GetType() != cmState::STATIC_LIBRARY) &&
+      (this->Target->GetType() != cmState::OBJECT_LIBRARY) &&
+      (this->Target->GetType() != cmState::MODULE_LIBRARY) &&
+      (this->Target->GetType() != cmState::INTERFACE_LIBRARY) &&
+      (this->Target->GetType() != cmState::EXECUTABLE)) {
     this->SetError("called with non-compilable target type");
     return false;
-    }
+  }
 
   bool system = false;
   unsigned int argIndex = 1;
 
-  if ((flags & PROCESS_SYSTEM) && args[argIndex] == "SYSTEM")
-    {
-    if (args.size() < 3)
-      {
+  if ((flags & PROCESS_SYSTEM) && args[argIndex] == "SYSTEM") {
+    if (args.size() < 3) {
       this->SetError("called with incorrect number of arguments");
       return false;
-      }
+    }
     system = true;
     ++argIndex;
-    }
+  }
 
   bool prepend = false;
-  if ((flags & PROCESS_BEFORE) && args[argIndex] == "BEFORE")
-    {
-    if (args.size() < 3)
-      {
+  if ((flags & PROCESS_BEFORE) && args[argIndex] == "BEFORE") {
+    if (args.size() < 3) {
       this->SetError("called with incorrect number of arguments");
       return false;
-      }
+    }
     prepend = true;
     ++argIndex;
-    }
+  }
 
   this->Property = prop;
 
-  while (argIndex < args.size())
-    {
-    if (!this->ProcessContentArgs(args, argIndex, prepend, system))
-      {
+  while (argIndex < args.size()) {
+    if (!this->ProcessContentArgs(args, argIndex, prepend, system)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
-bool cmTargetPropCommandBase
-::ProcessContentArgs(std::vector<std::string> const& args,
-                     unsigned int &argIndex, bool prepend, bool system)
+bool cmTargetPropCommandBase::ProcessContentArgs(
+  std::vector<std::string> const& args, unsigned int& argIndex, bool prepend,
+  bool system)
 {
   const std::string scope = args[argIndex];
 
-  if(scope != "PUBLIC"
-      && scope != "PRIVATE"
-      && scope != "INTERFACE" )
-    {
+  if (scope != "PUBLIC" && scope != "PRIVATE" && scope != "INTERFACE") {
     this->SetError("called with invalid arguments");
     return false;
-    }
+  }
 
-  if(this->Target->IsImported())
-    {
+  if (this->Target->IsImported()) {
     this->HandleImportedTarget(args[0]);
     return false;
-    }
+  }
 
-  if (this->Target->GetType() == cmState::INTERFACE_LIBRARY
-      && scope != "INTERFACE")
-    {
+  if (this->Target->GetType() == cmState::INTERFACE_LIBRARY &&
+      scope != "INTERFACE") {
     this->SetError("may only be set INTERFACE properties on INTERFACE "
-      "targets");
+                   "targets");
     return false;
-    }
+  }
 
   ++argIndex;
 
   std::vector<std::string> content;
 
-  for(unsigned int i=argIndex; i < args.size(); ++i, ++argIndex)
-    {
-    if(args[i] == "PUBLIC"
-        || args[i] == "PRIVATE"
-        || args[i] == "INTERFACE" )
-      {
+  for (unsigned int i = argIndex; i < args.size(); ++i, ++argIndex) {
+    if (args[i] == "PUBLIC" || args[i] == "PRIVATE" ||
+        args[i] == "INTERFACE") {
       return this->PopulateTargetProperies(scope, content, prepend, system);
-      }
-    content.push_back(args[i]);
     }
+    content.push_back(args[i]);
+  }
   return this->PopulateTargetProperies(scope, content, prepend, system);
 }
 
-bool cmTargetPropCommandBase
-::PopulateTargetProperies(const std::string &scope,
-                          const std::vector<std::string> &content,
-                          bool prepend, bool system)
+bool cmTargetPropCommandBase::PopulateTargetProperies(
+  const std::string& scope, const std::vector<std::string>& content,
+  bool prepend, bool system)
 {
-  if (scope == "PRIVATE" || scope == "PUBLIC")
-    {
-    if (!this->HandleDirectContent(this->Target, content, prepend, system))
-      {
+  if (scope == "PRIVATE" || scope == "PUBLIC") {
+    if (!this->HandleDirectContent(this->Target, content, prepend, system)) {
       return false;
-      }
     }
-  if (scope == "INTERFACE" || scope == "PUBLIC")
-    {
+  }
+  if (scope == "INTERFACE" || scope == "PUBLIC") {
     this->HandleInterfaceContent(this->Target, content, prepend, system);
-    }
+  }
   return true;
 }
 
-void cmTargetPropCommandBase::HandleInterfaceContent(cmTarget *tgt,
-                                  const std::vector<std::string> &content,
-                                  bool prepend, bool)
+void cmTargetPropCommandBase::HandleInterfaceContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool prepend, bool)
 {
-  if (prepend)
-    {
+  if (prepend) {
     const std::string propName = std::string("INTERFACE_") + this->Property;
-    const char *propValue = tgt->GetProperty(propName);
-    const std::string totalContent = this->Join(content) + (propValue
-                                              ? std::string(";") + propValue
-                                              : std::string());
+    const char* propValue = tgt->GetProperty(propName);
+    const std::string totalContent = this->Join(content) +
+      (propValue ? std::string(";") + propValue : std::string());
     tgt->SetProperty(propName, totalContent.c_str());
-    }
-  else
-    {
+  } else {
     tgt->AppendProperty("INTERFACE_" + this->Property,
-                          this->Join(content).c_str());
-    }
+                        this->Join(content).c_str());
+  }
 }
diff --git a/Source/cmTargetPropCommandBase.h b/Source/cmTargetPropCommandBase.h
index 4f1f108..88591dc 100644
--- a/Source/cmTargetPropCommandBase.h
+++ b/Source/cmTargetPropCommandBase.h
@@ -20,8 +20,8 @@ class cmTarget;
 class cmTargetPropCommandBase : public cmCommand
 {
 public:
-
-  enum ArgumentFlags {
+  enum ArgumentFlags
+  {
     NO_FLAGS = 0,
     PROCESS_BEFORE = 1,
     PROCESS_SYSTEM = 2
@@ -32,27 +32,29 @@ public:
                        ArgumentFlags flags = NO_FLAGS);
 
   cmTypeMacro(cmTargetPropCommandBase, cmCommand);
+
 protected:
   std::string Property;
-  cmTarget *Target;
+  cmTarget* Target;
+
+  virtual void HandleInterfaceContent(cmTarget* tgt,
+                                      const std::vector<std::string>& content,
+                                      bool prepend, bool system);
 
-  virtual void HandleInterfaceContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
-                                   bool prepend, bool system);
 private:
-  virtual void HandleImportedTarget(const std::string &tgt) = 0;
-  virtual void HandleMissingTarget(const std::string &name) = 0;
+  virtual void HandleImportedTarget(const std::string& tgt) = 0;
+  virtual void HandleMissingTarget(const std::string& name) = 0;
 
-  virtual bool HandleDirectContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
+  virtual bool HandleDirectContent(cmTarget* tgt,
+                                   const std::vector<std::string>& content,
                                    bool prepend, bool system) = 0;
 
-  virtual std::string Join(const std::vector<std::string> &content) = 0;
+  virtual std::string Join(const std::vector<std::string>& content) = 0;
 
   bool ProcessContentArgs(std::vector<std::string> const& args,
-                          unsigned int &argIndex, bool prepend, bool system);
-  bool PopulateTargetProperies(const std::string &scope,
-                               const std::vector<std::string> &content,
+                          unsigned int& argIndex, bool prepend, bool system);
+  bool PopulateTargetProperies(const std::string& scope,
+                               const std::vector<std::string>& content,
                                bool prepend, bool system);
 };
 
diff --git a/Source/cmTargetSourcesCommand.cxx b/Source/cmTargetSourcesCommand.cxx
index 390ba38..64372dc 100644
--- a/Source/cmTargetSourcesCommand.cxx
+++ b/Source/cmTargetSourcesCommand.cxx
@@ -13,39 +13,36 @@
 
 #include "cmGeneratorExpression.h"
 
-bool cmTargetSourcesCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmTargetSourcesCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
   return this->HandleArguments(args, "SOURCES");
 }
 
-void cmTargetSourcesCommand
-::HandleImportedTarget(const std::string &tgt)
+void cmTargetSourcesCommand::HandleImportedTarget(const std::string& tgt)
 {
   std::ostringstream e;
-  e << "Cannot specify sources for imported target \""
-    << tgt << "\".";
+  e << "Cannot specify sources for imported target \"" << tgt << "\".";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-void cmTargetSourcesCommand
-::HandleMissingTarget(const std::string &name)
+void cmTargetSourcesCommand::HandleMissingTarget(const std::string& name)
 {
   std::ostringstream e;
-  e << "Cannot specify sources for target \"" << name << "\" "
+  e << "Cannot specify sources for target \"" << name
+    << "\" "
        "which is not built by this project.";
   this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
 }
 
-std::string cmTargetSourcesCommand
-::Join(const std::vector<std::string> &content)
+std::string cmTargetSourcesCommand::Join(
+  const std::vector<std::string>& content)
 {
   return cmJoin(content, ";");
 }
 
-bool cmTargetSourcesCommand
-::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                      bool, bool)
+bool cmTargetSourcesCommand::HandleDirectContent(
+  cmTarget* tgt, const std::vector<std::string>& content, bool, bool)
 {
   tgt->AppendProperty("SOURCES", this->Join(content).c_str());
   return true;
diff --git a/Source/cmTargetSourcesCommand.h b/Source/cmTargetSourcesCommand.h
index 3768f30..304e176 100644
--- a/Source/cmTargetSourcesCommand.h
+++ b/Source/cmTargetSourcesCommand.h
@@ -21,34 +21,31 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTargetSourcesCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTargetSourcesCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "target_sources";}
+  virtual std::string GetName() const { return "target_sources"; }
 
   cmTypeMacro(cmTargetSourcesCommand, cmTargetPropCommandBase);
 
 private:
-  virtual void HandleImportedTarget(const std::string &tgt);
-  virtual void HandleMissingTarget(const std::string &name);
+  virtual void HandleImportedTarget(const std::string& tgt);
+  virtual void HandleMissingTarget(const std::string& name);
 
-  virtual bool HandleDirectContent(cmTarget *tgt,
-                                   const std::vector<std::string> &content,
+  virtual bool HandleDirectContent(cmTarget* tgt,
+                                   const std::vector<std::string>& content,
                                    bool prepend, bool system);
 
-  virtual std::string Join(const std::vector<std::string> &content);
+  virtual std::string Join(const std::vector<std::string>& content);
 };
 
 #endif
diff --git a/Source/cmTest.cxx b/Source/cmTest.cxx
index ec61ec6..0658e95 100644
--- a/Source/cmTest.cxx
+++ b/Source/cmTest.cxx
@@ -42,18 +42,16 @@ void cmTest::SetCommand(std::vector<std::string> const& command)
   this->Command = command;
 }
 
-const char *cmTest::GetProperty(const std::string& prop) const
+const char* cmTest::GetProperty(const std::string& prop) const
 {
-  const char *retVal = this->Properties.GetPropertyValue(prop);
-  if (!retVal)
-    {
-    const bool chain = this->Makefile->GetState()->
-          IsPropertyChained(prop, cmProperty::TEST);
-    if (chain)
-      {
+  const char* retVal = this->Properties.GetPropertyValue(prop);
+  if (!retVal) {
+    const bool chain =
+      this->Makefile->GetState()->IsPropertyChained(prop, cmProperty::TEST);
+    if (chain) {
       return this->Makefile->GetProperty(prop, chain);
-      }
     }
+  }
   return retVal;
 }
 
@@ -67,8 +65,8 @@ void cmTest::SetProperty(const std::string& prop, const char* value)
   this->Properties.SetProperty(prop, value);
 }
 
-void cmTest::AppendProperty(const std::string& prop,
-                            const char* value, bool asString)
+void cmTest::AppendProperty(const std::string& prop, const char* value,
+                            bool asString)
 {
   this->Properties.AppendProperty(prop, value, asString);
 }
diff --git a/Source/cmTest.h b/Source/cmTest.h
index 46013af..db68008 100644
--- a/Source/cmTest.h
+++ b/Source/cmTest.h
@@ -37,21 +37,18 @@ public:
   std::string GetName() const { return this->Name; }
 
   void SetCommand(std::vector<std::string> const& command);
-  std::vector<std::string> const& GetCommand() const
-    {
-    return this->Command;
-    }
+  std::vector<std::string> const& GetCommand() const { return this->Command; }
 
   ///! Set/Get a property of this source file
-  void SetProperty(const std::string& prop, const char *value);
-  void AppendProperty(const std::string& prop,
-                      const char* value,bool asString=false);
-  const char *GetProperty(const std::string& prop) const;
+  void SetProperty(const std::string& prop, const char* value);
+  void AppendProperty(const std::string& prop, const char* value,
+                      bool asString = false);
+  const char* GetProperty(const std::string& prop) const;
   bool GetPropertyAsBool(const std::string& prop) const;
-  cmPropertyMap &GetProperties() { return this->Properties; }
+  cmPropertyMap& GetProperties() { return this->Properties; }
 
   /** Get the cmMakefile instance that owns this test.  */
-  cmMakefile *GetMakefile() { return this->Makefile;}
+  cmMakefile* GetMakefile() { return this->Makefile; }
 
   /** Get the backtrace of the command that created this test.  */
   cmListFileBacktrace const& GetBacktrace() const;
@@ -72,4 +69,3 @@ private:
 };
 
 #endif
-
diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx
index 42e8090..e599825 100644
--- a/Source/cmTestGenerator.cxx
+++ b/Source/cmTestGenerator.cxx
@@ -17,19 +17,17 @@
 #include "cmSystemTools.h"
 #include "cmTest.h"
 
-cmTestGenerator
-::cmTestGenerator(cmTest* test,
-                  std::vector<std::string> const& configurations):
-  cmScriptGenerator("CTEST_CONFIGURATION_TYPE", configurations),
-  Test(test)
+cmTestGenerator::cmTestGenerator(
+  cmTest* test, std::vector<std::string> const& configurations)
+  : cmScriptGenerator("CTEST_CONFIGURATION_TYPE", configurations)
+  , Test(test)
 {
   this->ActionsPerConfig = !test->GetOldStyle();
   this->TestGenerated = false;
   this->LG = 0;
 }
 
-cmTestGenerator
-::~cmTestGenerator()
+cmTestGenerator::~cmTestGenerator()
 {
 }
 
@@ -48,19 +46,16 @@ void cmTestGenerator::GenerateScriptConfigs(std::ostream& os,
 void cmTestGenerator::GenerateScriptActions(std::ostream& os,
                                             Indent const& indent)
 {
-  if(this->ActionsPerConfig)
-    {
+  if (this->ActionsPerConfig) {
     // This is the per-config generation in a single-configuration
     // build generator case.  The superclass will call our per-config
     // method.
     this->cmScriptGenerator::GenerateScriptActions(os, indent);
-    }
-  else
-    {
+  } else {
     // This is an old-style test, so there is only one config.
-    //assert(this->Test->GetOldStyle());
+    // assert(this->Test->GetOldStyle());
     this->GenerateOldStyle(os, indent);
-    }
+  }
 }
 
 void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
@@ -81,68 +76,54 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
   // Check whether the command executable is a target whose name is to
   // be translated.
   std::string exe = command[0];
-  cmGeneratorTarget* target =
-      this->LG->FindGeneratorTargetToUse(exe);
-  if(target && target->GetType() == cmState::EXECUTABLE)
-    {
+  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(exe);
+  if (target && target->GetType() == cmState::EXECUTABLE) {
     // Use the target file on disk.
     exe = target->GetFullPath(config);
 
     // Prepend with the emulator when cross compiling if required.
-    const char * emulator =
-      target->GetProperty("CROSSCOMPILING_EMULATOR");
-    if (emulator != 0)
-      {
+    const char* emulator = target->GetProperty("CROSSCOMPILING_EMULATOR");
+    if (emulator != 0) {
       std::vector<std::string> emulatorWithArgs;
       cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs);
       std::string emulatorExe(emulatorWithArgs[0]);
       cmSystemTools::ConvertToUnixSlashes(emulatorExe);
       os << cmOutputConverter::EscapeForCMake(emulatorExe) << " ";
-      for(std::vector<std::string>::const_iterator ei =
-          emulatorWithArgs.begin()+1;
-          ei != emulatorWithArgs.end();
-          ++ei)
-        {
+      for (std::vector<std::string>::const_iterator ei =
+             emulatorWithArgs.begin() + 1;
+           ei != emulatorWithArgs.end(); ++ei) {
         os << cmOutputConverter::EscapeForCMake(*ei) << " ";
-        }
       }
     }
-  else
-    {
+  } else {
     // Use the command name given.
     exe = ge.Parse(exe.c_str())->Evaluate(this->LG, config);
     cmSystemTools::ConvertToUnixSlashes(exe);
-    }
+  }
 
   // Generate the command line with full escapes.
   os << cmOutputConverter::EscapeForCMake(exe);
-  for(std::vector<std::string>::const_iterator ci = command.begin()+1;
-      ci != command.end(); ++ci)
-    {
+  for (std::vector<std::string>::const_iterator ci = command.begin() + 1;
+       ci != command.end(); ++ci) {
     os << " " << cmOutputConverter::EscapeForCMake(
-                                         ge.Parse(*ci)->Evaluate(
-                                            this->LG, config));
-    }
+                   ge.Parse(*ci)->Evaluate(this->LG, config));
+  }
 
   // Finish the test command.
   os << ")\n";
 
   // Output properties for the test.
   cmPropertyMap& pm = this->Test->GetProperties();
-  if(!pm.empty())
-    {
+  if (!pm.empty()) {
     os << indent << "set_tests_properties(" << this->Test->GetName()
        << " PROPERTIES ";
-    for(cmPropertyMap::const_iterator i = pm.begin();
-        i != pm.end(); ++i)
-      {
-      os << " " << i->first
-         << " " << cmOutputConverter::EscapeForCMake(
-           ge.Parse(i->second.GetValue())->Evaluate(this->LG,
-                                                    config));
-      }
-    os << ")" << std::endl;
+    for (cmPropertyMap::const_iterator i = pm.begin(); i != pm.end(); ++i) {
+      os << " " << i->first << " "
+         << cmOutputConverter::EscapeForCMake(
+              ge.Parse(i->second.GetValue())->Evaluate(this->LG, config));
     }
+    os << ")" << std::endl;
+  }
 }
 
 void cmTestGenerator::GenerateScriptNoConfig(std::ostream& os,
@@ -153,9 +134,9 @@ void cmTestGenerator::GenerateScriptNoConfig(std::ostream& os,
 
 bool cmTestGenerator::NeedsScriptNoConfig() const
 {
-  return (this->TestGenerated && // test generated for at least one config
+  return (this->TestGenerated &&    // test generated for at least one config
           this->ActionsPerConfig && // test is config-aware
-          this->Configurations.empty() && // test runs in all configs
+          this->Configurations.empty() &&      // test runs in all configs
           !this->ConfigurationTypes->empty()); // config-dependent command
 }
 
@@ -173,40 +154,34 @@ void cmTestGenerator::GenerateOldStyle(std::ostream& fout,
   fout << "add_test(";
   fout << this->Test->GetName() << " \"" << exe << "\"";
 
-  for(std::vector<std::string>::const_iterator argit = command.begin()+1;
-      argit != command.end(); ++argit)
-    {
+  for (std::vector<std::string>::const_iterator argit = command.begin() + 1;
+       argit != command.end(); ++argit) {
     // Just double-quote all arguments so they are re-parsed
     // correctly by the test system.
     fout << " \"";
-    for(std::string::const_iterator c = argit->begin();
-        c != argit->end(); ++c)
-      {
+    for (std::string::const_iterator c = argit->begin(); c != argit->end();
+         ++c) {
       // Escape quotes within arguments.  We should escape
       // backslashes too but we cannot because it makes the result
       // inconsistent with previous behavior of this command.
-      if((*c == '"'))
-        {
+      if ((*c == '"')) {
         fout << '\\';
-        }
-      fout << *c;
       }
-    fout << "\"";
+      fout << *c;
     }
+    fout << "\"";
+  }
   fout << ")" << std::endl;
 
   // Output properties for the test.
   cmPropertyMap& pm = this->Test->GetProperties();
-  if(!pm.empty())
-    {
+  if (!pm.empty()) {
     fout << indent << "set_tests_properties(" << this->Test->GetName()
          << " PROPERTIES ";
-    for(cmPropertyMap::const_iterator i = pm.begin();
-        i != pm.end(); ++i)
-      {
-      fout << " " << i->first
-           << " " << cmOutputConverter::EscapeForCMake(i->second.GetValue());
-      }
-    fout << ")" << std::endl;
+    for (cmPropertyMap::const_iterator i = pm.begin(); i != pm.end(); ++i) {
+      fout << " " << i->first << " "
+           << cmOutputConverter::EscapeForCMake(i->second.GetValue());
     }
+    fout << ")" << std::endl;
+  }
 }
diff --git a/Source/cmTestGenerator.h b/Source/cmTestGenerator.h
index de8ab78..f946a1c 100644
--- a/Source/cmTestGenerator.h
+++ b/Source/cmTestGenerator.h
@@ -21,12 +21,12 @@ class cmLocalGenerator;
  * \brief Support class for generating install scripts.
  *
  */
-class cmTestGenerator: public cmScriptGenerator
+class cmTestGenerator : public cmScriptGenerator
 {
 public:
   cmTestGenerator(cmTest* test,
-                  std::vector<std::string> const&
-                  configurations = std::vector<std::string>());
+                  std::vector<std::string> const& configurations =
+                    std::vector<std::string>());
   virtual ~cmTestGenerator();
 
   void Compute(cmLocalGenerator* lg);
diff --git a/Source/cmTimestamp.cxx b/Source/cmTimestamp.cxx
index 90bc4de..c624d0f 100644
--- a/Source/cmTimestamp.cxx
+++ b/Source/cmTimestamp.cxx
@@ -19,84 +19,74 @@
 // include sys/stat.h after sys/types.h
 #include <sys/stat.h>
 
-std::string cmTimestamp::CurrentTime(
-  const std::string& formatString, bool utcFlag)
+std::string cmTimestamp::CurrentTime(const std::string& formatString,
+                                     bool utcFlag)
 {
   time_t currentTimeT = time(0);
-  if(currentTimeT == time_t(-1))
-    {
+  if (currentTimeT == time_t(-1)) {
     return std::string();
-    }
+  }
 
   return CreateTimestampFromTimeT(currentTimeT, formatString, utcFlag);
 }
 
 std::string cmTimestamp::FileModificationTime(const char* path,
-  const std::string& formatString, bool utcFlag)
+                                              const std::string& formatString,
+                                              bool utcFlag)
 {
-  if(!cmsys::SystemTools::FileExists(path))
-    {
+  if (!cmsys::SystemTools::FileExists(path)) {
     return std::string();
-    }
+  }
 
   time_t mtime = cmsys::SystemTools::ModifiedTime(path);
   return CreateTimestampFromTimeT(mtime, formatString, utcFlag);
 }
 
 std::string cmTimestamp::CreateTimestampFromTimeT(time_t timeT,
-  std::string formatString, bool utcFlag) const
+                                                  std::string formatString,
+                                                  bool utcFlag) const
 {
-  if(formatString.empty())
-    {
+  if (formatString.empty()) {
     formatString = "%Y-%m-%dT%H:%M:%S";
-    if(utcFlag)
-      {
+    if (utcFlag) {
       formatString += "Z";
-      }
     }
+  }
 
   struct tm timeStruct;
   memset(&timeStruct, 0, sizeof(timeStruct));
 
-  struct tm* ptr = (struct tm*) 0;
-  if(utcFlag)
-    {
+  struct tm* ptr = (struct tm*)0;
+  if (utcFlag) {
     ptr = gmtime(&timeT);
-    }
-  else
-    {
+  } else {
     ptr = localtime(&timeT);
-    }
+  }
 
-  if(ptr == 0)
-    {
+  if (ptr == 0) {
     return std::string();
-    }
+  }
 
   timeStruct = *ptr;
 
   std::string result;
-  for(std::string::size_type i = 0; i < formatString.size(); ++i)
-    {
+  for (std::string::size_type i = 0; i < formatString.size(); ++i) {
     char c1 = formatString[i];
-    char c2 = (i + 1 < formatString.size()) ?
-      formatString[i + 1] : static_cast<char>(0);
+    char c2 = (i + 1 < formatString.size()) ? formatString[i + 1]
+                                            : static_cast<char>(0);
 
-    if(c1 == '%' && c2 != 0)
-      {
+    if (c1 == '%' && c2 != 0) {
       result += AddTimestampComponent(c2, timeStruct, timeT);
       ++i;
-      }
-    else
-      {
+    } else {
       result += c1;
-      }
     }
+  }
 
   return result;
 }
 
-time_t cmTimestamp::CreateUtcTimeTFromTm(struct tm &tm) const
+time_t cmTimestamp::CreateUtcTimeTFromTm(struct tm& tm) const
 {
 #if defined(_MSC_VER) && _MSC_VER >= 1400
   return _mkgmtime(&tm);
@@ -104,10 +94,9 @@ time_t cmTimestamp::CreateUtcTimeTFromTm(struct tm &tm) const
   // From Linux timegm() manpage.
 
   std::string tz_old = "TZ=";
-  if (const char* tz = cmSystemTools::GetEnv("TZ"))
-    {
+  if (const char* tz = cmSystemTools::GetEnv("TZ")) {
     tz_old += tz;
-    }
+  }
 
   // The standard says that "TZ=" or "TZ=[UNRECOGNIZED_TZ]" means UTC.
   // It seems that "TZ=" does NOT work, at least under Windows
@@ -127,14 +116,14 @@ time_t cmTimestamp::CreateUtcTimeTFromTm(struct tm &tm) const
 #endif
 }
 
-std::string cmTimestamp::AddTimestampComponent(
-  char flag, struct tm& timeStruct, const time_t timeT) const
+std::string cmTimestamp::AddTimestampComponent(char flag,
+                                               struct tm& timeStruct,
+                                               const time_t timeT) const
 {
   std::string formatString = "%";
   formatString += flag;
 
-  switch(flag)
-    {
+  switch (flag) {
     case 'd':
     case 'H':
     case 'I':
@@ -148,35 +137,34 @@ std::string cmTimestamp::AddTimestampComponent(
     case 'Y':
       break;
     case 's': // Seconds since UNIX epoch (midnight 1-jan-1970)
-      {
+    {
       // Build a time_t for UNIX epoch and substract from the input "timeT":
       struct tm tmUnixEpoch;
       memset(&tmUnixEpoch, 0, sizeof(tmUnixEpoch));
       tmUnixEpoch.tm_mday = 1;
-      tmUnixEpoch.tm_year = 1970-1900;
+      tmUnixEpoch.tm_year = 1970 - 1900;
 
       const time_t unixEpoch = this->CreateUtcTimeTFromTm(tmUnixEpoch);
-      if (unixEpoch == -1)
-        {
-        cmSystemTools::Error("Error generating UNIX epoch in "
+      if (unixEpoch == -1) {
+        cmSystemTools::Error(
+          "Error generating UNIX epoch in "
           "STRING(TIMESTAMP ...). Please, file a bug report aginst CMake");
         return std::string();
-        }
+      }
 
       std::stringstream ss;
       ss << static_cast<long int>(difftime(timeT, unixEpoch));
       return ss.str();
-      }
-    default:
-      {
+    }
+    default: {
       return formatString;
-      }
     }
+  }
 
   char buffer[16];
 
-  size_t size = strftime(buffer, sizeof(buffer),
-    formatString.c_str(), &timeStruct);
+  size_t size =
+    strftime(buffer, sizeof(buffer), formatString.c_str(), &timeStruct);
 
   return std::string(buffer, size);
 }
diff --git a/Source/cmTimestamp.h b/Source/cmTimestamp.h
index 72d5cc2..77e1f7a 100644
--- a/Source/cmTimestamp.h
+++ b/Source/cmTimestamp.h
@@ -29,17 +29,17 @@ public:
   std::string CurrentTime(const std::string& formatString, bool utcFlag);
 
   std::string FileModificationTime(const char* path,
-    const std::string& formatString, bool utcFlag);
+                                   const std::string& formatString,
+                                   bool utcFlag);
 
 private:
   time_t CreateUtcTimeTFromTm(struct tm& timeStruct) const;
 
-  std::string CreateTimestampFromTimeT(
-    time_t timeT, std::string formatString, bool utcFlag) const;
+  std::string CreateTimestampFromTimeT(time_t timeT, std::string formatString,
+                                       bool utcFlag) const;
 
-  std::string AddTimestampComponent(
-    char flag, struct tm& timeStruct, time_t timeT) const;
+  std::string AddTimestampComponent(char flag, struct tm& timeStruct,
+                                    time_t timeT) const;
 };
 
-
 #endif
diff --git a/Source/cmTryCompileCommand.cxx b/Source/cmTryCompileCommand.cxx
index 87fbbdf..7930d23 100644
--- a/Source/cmTryCompileCommand.cxx
+++ b/Source/cmTryCompileCommand.cxx
@@ -12,31 +12,28 @@
 #include "cmTryCompileCommand.h"
 
 // cmTryCompileCommand
-bool cmTryCompileCommand
-::InitialPass(std::vector<std::string> const& argv, cmExecutionStatus &)
+bool cmTryCompileCommand::InitialPass(std::vector<std::string> const& argv,
+                                      cmExecutionStatus&)
 {
-  if(argv.size() < 3)
-    {
+  if (argv.size() < 3) {
     return false;
-    }
+  }
 
-  if(this->Makefile->GetCMakeInstance()->GetWorkingMode() ==
-                                                      cmake::FIND_PACKAGE_MODE)
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
-         "The TRY_COMPILE() command is not supported in --find-package mode.");
+  if (this->Makefile->GetCMakeInstance()->GetWorkingMode() ==
+      cmake::FIND_PACKAGE_MODE) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "The TRY_COMPILE() command is not supported in --find-package mode.");
     return false;
-    }
+  }
 
   this->TryCompileCode(argv, false);
 
   // if They specified clean then we clean up what we can
-  if (this->SrcFileSignature)
-    {
-    if(!this->Makefile->GetCMakeInstance()->GetDebugTryCompile())
-      {
+  if (this->SrcFileSignature) {
+    if (!this->Makefile->GetCMakeInstance()->GetDebugTryCompile()) {
       this->CleanupFiles(this->BinaryDirectory.c_str());
-      }
     }
+  }
   return true;
 }
diff --git a/Source/cmTryCompileCommand.h b/Source/cmTryCompileCommand.h
index a09c47f..e50d54c 100644
--- a/Source/cmTryCompileCommand.h
+++ b/Source/cmTryCompileCommand.h
@@ -25,26 +25,21 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTryCompileCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTryCompileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "try_compile";}
+  virtual std::string GetName() const { return "try_compile"; }
 
   cmTypeMacro(cmTryCompileCommand, cmCoreTryCompile);
-
 };
 
-
 #endif
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index 3acc43c..19837a7 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -15,21 +15,20 @@
 #include <cmsys/FStream.hxx>
 
 // cmTryRunCommand
-bool cmTryRunCommand
-::InitialPass(std::vector<std::string> const& argv, cmExecutionStatus &)
+bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv,
+                                  cmExecutionStatus&)
 {
-  if(argv.size() < 4)
-    {
+  if (argv.size() < 4) {
     return false;
-    }
+  }
 
-  if(this->Makefile->GetCMakeInstance()->GetWorkingMode() ==
-                                                      cmake::FIND_PACKAGE_MODE)
-    {
-    this->Makefile->IssueMessage(cmake::FATAL_ERROR,
-            "The TRY_RUN() command is not supported in --find-package mode.");
+  if (this->Makefile->GetCMakeInstance()->GetWorkingMode() ==
+      cmake::FIND_PACKAGE_MODE) {
+    this->Makefile->IssueMessage(
+      cmake::FATAL_ERROR,
+      "The TRY_RUN() command is not supported in --find-package mode.");
     return false;
-    }
+  }
 
   // build an arg list for TryCompile and extract the runArgs,
   std::vector<std::string> tryCompile;
@@ -42,95 +41,73 @@ bool cmTryRunCommand
 
   std::string runArgs;
   unsigned int i;
-  for (i = 1; i < argv.size(); ++i)
-    {
-    if (argv[i] == "ARGS")
-      {
+  for (i = 1; i < argv.size(); ++i) {
+    if (argv[i] == "ARGS") {
       ++i;
       while (i < argv.size() && argv[i] != "COMPILE_DEFINITIONS" &&
-             argv[i] != "CMAKE_FLAGS" &&
-             argv[i] != "LINK_LIBRARIES")
-        {
+             argv[i] != "CMAKE_FLAGS" && argv[i] != "LINK_LIBRARIES") {
         runArgs += " ";
         runArgs += argv[i];
         ++i;
-        }
-      if (i < argv.size())
-        {
+      }
+      if (i < argv.size()) {
         tryCompile.push_back(argv[i]);
-        }
       }
-    else
-      {
-      if (argv[i] == "OUTPUT_VARIABLE")
-        {
-        if ( argv.size() <= (i+1) )
-          {
+    } else {
+      if (argv[i] == "OUTPUT_VARIABLE") {
+        if (argv.size() <= (i + 1)) {
           cmSystemTools::Error(
             "OUTPUT_VARIABLE specified but there is no variable");
           return false;
-          }
+        }
         i++;
         this->OutputVariable = argv[i];
-        }
-      else if (argv[i] == "RUN_OUTPUT_VARIABLE")
-        {
-        if (argv.size() <= (i + 1))
-          {
+      } else if (argv[i] == "RUN_OUTPUT_VARIABLE") {
+        if (argv.size() <= (i + 1)) {
           cmSystemTools::Error(
             "RUN_OUTPUT_VARIABLE specified but there is no variable");
           return false;
-          }
+        }
         i++;
         this->RunOutputVariable = argv[i];
-        }
-      else if (argv[i] == "COMPILE_OUTPUT_VARIABLE")
-        {
-        if (argv.size() <= (i + 1))
-          {
+      } else if (argv[i] == "COMPILE_OUTPUT_VARIABLE") {
+        if (argv.size() <= (i + 1)) {
           cmSystemTools::Error(
             "COMPILE_OUTPUT_VARIABLE specified but there is no variable");
           return false;
-          }
+        }
         i++;
         this->CompileOutputVariable = argv[i];
-        }
-      else
-        {
+      } else {
         tryCompile.push_back(argv[i]);
-        }
       }
     }
+  }
 
   // although they could be used together, don't allow it, because
   // using OUTPUT_VARIABLE makes crosscompiling harder
-  if (this->OutputVariable.size()
-      && (!this->RunOutputVariable.empty()
-       || !this->CompileOutputVariable.empty()))
-    {
+  if (this->OutputVariable.size() && (!this->RunOutputVariable.empty() ||
+                                      !this->CompileOutputVariable.empty())) {
     cmSystemTools::Error(
       "You cannot use OUTPUT_VARIABLE together with COMPILE_OUTPUT_VARIABLE "
       "or RUN_OUTPUT_VARIABLE. Please use only COMPILE_OUTPUT_VARIABLE and/or "
       "RUN_OUTPUT_VARIABLE.");
     return false;
-    }
+  }
 
   bool captureRunOutput = false;
-  if (!this->OutputVariable.empty())
-    {
+  if (!this->OutputVariable.empty()) {
     captureRunOutput = true;
     tryCompile.push_back("OUTPUT_VARIABLE");
     tryCompile.push_back(this->OutputVariable);
-    }
-  if (!this->CompileOutputVariable.empty())
-    {
+  }
+  if (!this->CompileOutputVariable.empty()) {
     tryCompile.push_back("OUTPUT_VARIABLE");
     tryCompile.push_back(this->CompileOutputVariable);
-    }
-  if (!this->RunOutputVariable.empty())
-    {
+  }
+  if (!this->RunOutputVariable.empty()) {
     captureRunOutput = true;
-    }
+  }
 
   this->RunResultVariable = argv[0];
   this->CompileResultVariable = argv[1];
@@ -139,56 +116,44 @@ bool cmTryRunCommand
   int res = this->TryCompileCode(tryCompile, true);
 
   // now try running the command if it compiled
-  if (!res)
-    {
-    if (this->OutputFile.empty())
-      {
+  if (!res) {
+    if (this->OutputFile.empty()) {
       cmSystemTools::Error(this->FindErrorMessage.c_str());
-      }
-    else
-      {
+    } else {
       // "run" it and capture the output
       std::string runOutputContents;
       if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING") &&
-          !this->Makefile->IsDefinitionSet("CMAKE_CROSSCOMPILING_EMULATOR"))
-        {
-        this->DoNotRunExecutable(runArgs,
-                                 argv[3],
+          !this->Makefile->IsDefinitionSet("CMAKE_CROSSCOMPILING_EMULATOR")) {
+        this->DoNotRunExecutable(runArgs, argv[3],
                                  captureRunOutput ? &runOutputContents : 0);
-        }
-      else
-        {
+      } else {
         this->RunExecutable(runArgs, &runOutputContents);
-        }
+      }
 
       // now put the output into the variables
-      if(!this->RunOutputVariable.empty())
-        {
+      if (!this->RunOutputVariable.empty()) {
         this->Makefile->AddDefinition(this->RunOutputVariable,
                                       runOutputContents.c_str());
-        }
+      }
 
-      if(!this->OutputVariable.empty())
-        {
+      if (!this->OutputVariable.empty()) {
         // if the TryCompileCore saved output in this outputVariable then
         // prepend that output to this output
-        const char* compileOutput
-                 = this->Makefile->GetDefinition(this->OutputVariable);
-        if (compileOutput)
-          {
+        const char* compileOutput =
+          this->Makefile->GetDefinition(this->OutputVariable);
+        if (compileOutput) {
           runOutputContents = std::string(compileOutput) + runOutputContents;
-          }
+        }
         this->Makefile->AddDefinition(this->OutputVariable,
                                       runOutputContents.c_str());
-        }
       }
     }
+  }
 
   // if we created a directory etc, then cleanup after ourselves
-  if(!this->Makefile->GetCMakeInstance()->GetDebugTryCompile())
-    {
+  if (!this->Makefile->GetCMakeInstance()->GetDebugTryCompile()) {
     this->CleanupFiles(this->BinaryDirectory.c_str());
-    }
+  }
   return true;
 }
 
@@ -199,47 +164,40 @@ void cmTryRunCommand::RunExecutable(const std::string& runArgs,
 
   std::string finalCommand;
   const std::string emulator =
-  this->Makefile->GetSafeDefinition("CMAKE_CROSSCOMPILING_EMULATOR");
-  if (!emulator.empty())
-    {
+    this->Makefile->GetSafeDefinition("CMAKE_CROSSCOMPILING_EMULATOR");
+  if (!emulator.empty()) {
     std::vector<std::string> emulatorWithArgs;
     cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs);
-    finalCommand += cmSystemTools::ConvertToRunCommandPath(
-                                 emulatorWithArgs[0].c_str());
+    finalCommand +=
+      cmSystemTools::ConvertToRunCommandPath(emulatorWithArgs[0].c_str());
     finalCommand += " ";
     for (std::vector<std::string>::const_iterator ei =
-         emulatorWithArgs.begin()+1;
-         ei != emulatorWithArgs.end(); ++ei)
-      {
+           emulatorWithArgs.begin() + 1;
+         ei != emulatorWithArgs.end(); ++ei) {
       finalCommand += "\"";
       finalCommand += *ei;
       finalCommand += "\"";
       finalCommand += " ";
-      }
     }
-  finalCommand += cmSystemTools::ConvertToRunCommandPath(
-                               this->OutputFile.c_str());
-  if (!runArgs.empty())
-    {
+  }
+  finalCommand +=
+    cmSystemTools::ConvertToRunCommandPath(this->OutputFile.c_str());
+  if (!runArgs.empty()) {
     finalCommand += runArgs;
-    }
+  }
   int timeout = 0;
-  bool worked = cmSystemTools::RunSingleCommand(finalCommand.c_str(),
-                out, out, &retVal,
-                0, cmSystemTools::OUTPUT_NONE, timeout);
+  bool worked =
+    cmSystemTools::RunSingleCommand(finalCommand.c_str(), out, out, &retVal, 0,
+                                    cmSystemTools::OUTPUT_NONE, timeout);
   // set the run var
   char retChar[1000];
-  if (worked)
-    {
+  if (worked) {
     sprintf(retChar, "%i", retVal);
-    }
-  else
-    {
+  } else {
     strcpy(retChar, "FAILED_TO_RUN");
-    }
+  }
   this->Makefile->AddCacheDefinition(this->RunResultVariable, retChar,
-                                     "Result of TRY_RUN",
-                                     cmState::INTERNAL);
+                                     "Result of TRY_RUN", cmState::INTERNAL);
 }
 
 /* This is only used when cross compiling. Instead of running the
@@ -247,34 +205,32 @@ void cmTryRunCommand::RunExecutable(const std::string& runArgs,
  the executable would have produced.
 */
 void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
-                                    const std::string& srcFile,
-                                    std::string* out
-                                    )
+                                         const std::string& srcFile,
+                                         std::string* out)
 {
   // copy the executable out of the CMakeFiles/ directory, so it is not
   // removed at the end of TRY_RUN and the user can run it manually
   // on the target platform.
-  std::string copyDest =  this->Makefile->GetHomeOutputDirectory();
+  std::string copyDest = this->Makefile->GetHomeOutputDirectory();
   copyDest += cmake::GetCMakeFilesDirectory();
   copyDest += "/";
-  copyDest += cmSystemTools::GetFilenameWithoutExtension(
-                                                     this->OutputFile);
+  copyDest += cmSystemTools::GetFilenameWithoutExtension(this->OutputFile);
   copyDest += "-";
   copyDest += this->RunResultVariable;
   copyDest += cmSystemTools::GetFilenameExtension(this->OutputFile);
   cmSystemTools::CopyFileAlways(this->OutputFile, copyDest);
 
-  std::string resultFileName =  this->Makefile->GetHomeOutputDirectory();
+  std::string resultFileName = this->Makefile->GetHomeOutputDirectory();
   resultFileName += "/TryRunResults.cmake";
 
   std::string detailsString = "For details see ";
   detailsString += resultFileName;
 
-  std::string internalRunOutputName=this->RunResultVariable+"__TRYRUN_OUTPUT";
+  std::string internalRunOutputName =
+    this->RunResultVariable + "__TRYRUN_OUTPUT";
   bool error = false;
 
-  if (this->Makefile->GetDefinition(this->RunResultVariable) == 0)
-    {
+  if (this->Makefile->GetDefinition(this->RunResultVariable) == 0) {
     // if the variables doesn't exist, create it with a helpful error text
     // and mark it as advanced
     std::string comment;
@@ -283,58 +239,48 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
     comment += detailsString;
     this->Makefile->AddCacheDefinition(this->RunResultVariable,
                                        "PLEASE_FILL_OUT-FAILED_TO_RUN",
-                                       comment.c_str(),
-                                       cmState::STRING);
+                                       comment.c_str(), cmState::STRING);
 
     cmState* state = this->Makefile->GetState();
-    const char* existingValue
-                        = state->GetCacheEntryValue(this->RunResultVariable);
-    if (existingValue)
-      {
+    const char* existingValue =
+      state->GetCacheEntryValue(this->RunResultVariable);
+    if (existingValue) {
       state->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
-      }
+    }
 
     error = true;
-    }
+  }
 
   // is the output from the executable used ?
-  if (out!=0)
-    {
-    if (this->Makefile->GetDefinition(internalRunOutputName) == 0)
-      {
+  if (out != 0) {
+    if (this->Makefile->GetDefinition(internalRunOutputName) == 0) {
       // if the variables doesn't exist, create it with a helpful error text
       // and mark it as advanced
       std::string comment;
-      comment+="Output of TRY_RUN(), contains the text, which the executable "
-           "would have printed on stdout and stderr on its target platform.\n";
+      comment +=
+        "Output of TRY_RUN(), contains the text, which the executable "
+        "would have printed on stdout and stderr on its target platform.\n";
       comment += detailsString;
 
       this->Makefile->AddCacheDefinition(internalRunOutputName,
                                          "PLEASE_FILL_OUT-NOTFOUND",
-                                         comment.c_str(),
-                                         cmState::STRING);
+                                         comment.c_str(), cmState::STRING);
       cmState* state = this->Makefile->GetState();
-      const char* existing =
-          state->GetCacheEntryValue(internalRunOutputName);
-      if (existing)
-        {
-        state->SetCacheEntryProperty(internalRunOutputName,
-                                      "ADVANCED", "1");
-        }
+      const char* existing = state->GetCacheEntryValue(internalRunOutputName);
+      if (existing) {
+        state->SetCacheEntryProperty(internalRunOutputName, "ADVANCED", "1");
+      }
 
       error = true;
-      }
     }
+  }
 
-  if (error)
-    {
+  if (error) {
     static bool firstTryRun = true;
     cmsys::ofstream file(resultFileName.c_str(),
-                                  firstTryRun ? std::ios::out : std::ios::app);
-    if ( file )
-      {
-      if (firstTryRun)
-        {
+                         firstTryRun ? std::ios::out : std::ios::app);
+    if (file) {
+      if (firstTryRun) {
         /* clang-format off */
         file << "# This file was generated by CMake because it detected "
                 "TRY_RUN() commands\n"
@@ -344,9 +290,9 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
                 "appropriate values\n"
                 "# and use it then to preset the CMake cache (using -C).\n\n";
         /* clang-format on */
-        }
+      }
 
-      std::string comment ="\n";
+      std::string comment = "\n";
       comment += this->RunResultVariable;
       comment += "\n   indicates whether the executable would have been able "
                  "to run on its\n"
@@ -355,19 +301,19 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
       comment += " to\n"
                  "   the exit code (in many cases 0 for success), otherwise "
                  "enter \"FAILED_TO_RUN\".\n";
-      if (out!=0)
-        {
+      if (out != 0) {
         comment += internalRunOutputName;
-        comment += "\n   contains the text the executable "
-                   "would have printed on stdout and stderr.\n"
-                  "   If the executable would not have been able to run, set ";
+        comment +=
+          "\n   contains the text the executable "
+          "would have printed on stdout and stderr.\n"
+          "   If the executable would not have been able to run, set ";
         comment += internalRunOutputName;
         comment += " empty.\n"
                    "   Otherwise check if the output is evaluated by the "
                    "calling CMake code. If so,\n"
                    "   check what the source file would have printed when "
                    "called with the given arguments.\n";
-        }
+      }
       comment += "The ";
       comment += this->CompileResultVariable;
       comment += " variable holds the build result for this TRY_RUN().\n\n"
@@ -386,31 +332,28 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
            << this->Makefile->GetDefinition(this->RunResultVariable)
            << "\"\n     CACHE STRING \"Result from TRY_RUN\" FORCE)\n\n";
 
-      if (out!=0)
-        {
+      if (out != 0) {
         file << "set( " << internalRunOutputName << " \n     \""
              << this->Makefile->GetDefinition(internalRunOutputName)
              << "\"\n     CACHE STRING \"Output from TRY_RUN\" FORCE)\n\n";
-        }
-      file.close();
       }
+      file.close();
+    }
     firstTryRun = false;
 
     std::string errorMessage = "TRY_RUN() invoked in cross-compiling mode, "
                                "please set the following cache variables "
                                "appropriately:\n";
     errorMessage += "   " + this->RunResultVariable + " (advanced)\n";
-    if (out!=0)
-      {
+    if (out != 0) {
       errorMessage += "   " + internalRunOutputName + " (advanced)\n";
-      }
+    }
     errorMessage += detailsString;
     cmSystemTools::Error(errorMessage.c_str());
     return;
-    }
+  }
 
-  if (out!=0)
-    {
+  if (out != 0) {
     (*out) = this->Makefile->GetDefinition(internalRunOutputName);
-    }
+  }
 }
diff --git a/Source/cmTryRunCommand.h b/Source/cmTryRunCommand.h
index 9b97b16..26c0777 100644
--- a/Source/cmTryRunCommand.h
+++ b/Source/cmTryRunCommand.h
@@ -25,24 +25,22 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmTryRunCommand;
-    }
+  virtual cmCommand* Clone() { return new cmTryRunCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "try_run";}
+  virtual std::string GetName() const { return "try_run"; }
 
   cmTypeMacro(cmTryRunCommand, cmCoreTryCompile);
+
 private:
   void RunExecutable(const std::string& runArgs,
                      std::string* runOutputContents);
@@ -57,5 +55,4 @@ private:
   std::string CompileOutputVariable;
 };
 
-
 #endif
diff --git a/Source/cmUnsetCommand.cxx b/Source/cmUnsetCommand.cxx
index 053cdfc..c04c44a 100644
--- a/Source/cmUnsetCommand.cxx
+++ b/Source/cmUnsetCommand.cxx
@@ -13,53 +13,46 @@
 
 // cmUnsetCommand
 bool cmUnsetCommand::InitialPass(std::vector<std::string> const& args,
-                                 cmExecutionStatus &)
+                                 cmExecutionStatus&)
 {
-  if(args.size() < 1 || args.size() > 2)
-    {
+  if (args.size() < 1 || args.size() > 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   const char* variable = args[0].c_str();
 
   // unset(ENV{VAR})
-  if (cmHasLiteralPrefix(variable, "ENV{") && strlen(variable) > 5)
-    {
+  if (cmHasLiteralPrefix(variable, "ENV{") && strlen(variable) > 5) {
     // what is the variable name
-    char *envVarName = new char [strlen(variable)];
-    strncpy(envVarName,variable+4,strlen(variable)-5);
-    envVarName[strlen(variable)-5] = '\0';
+    char* envVarName = new char[strlen(variable)];
+    strncpy(envVarName, variable + 4, strlen(variable) - 5);
+    envVarName[strlen(variable) - 5] = '\0';
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
     cmSystemTools::UnsetEnv(envVarName);
 #endif
     delete[] envVarName;
     return true;
-    }
+  }
   // unset(VAR)
-  else if (args.size() == 1)
-    {
+  else if (args.size() == 1) {
     this->Makefile->RemoveDefinition(variable);
     return true;
-    }
+  }
   // unset(VAR CACHE)
-  else if ((args.size() == 2) && (args[1] == "CACHE"))
-    {
+  else if ((args.size() == 2) && (args[1] == "CACHE")) {
     this->Makefile->RemoveCacheDefinition(variable);
     return true;
-    }
+  }
   // unset(VAR PARENT_SCOPE)
-  else if ((args.size() == 2) && (args[1] == "PARENT_SCOPE"))
-    {
+  else if ((args.size() == 2) && (args[1] == "PARENT_SCOPE")) {
     this->Makefile->RaiseScope(variable, 0);
     return true;
-    }
+  }
   // ERROR: second argument isn't CACHE or PARENT_SCOPE
-  else
-    {
+  else {
     this->SetError("called with an invalid second argument");
     return false;
-    }
+  }
 }
-
diff --git a/Source/cmUnsetCommand.h b/Source/cmUnsetCommand.h
index 62c2bd3..faa8f9b 100644
--- a/Source/cmUnsetCommand.h
+++ b/Source/cmUnsetCommand.h
@@ -25,17 +25,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmUnsetCommand;
-    }
+  virtual cmCommand* Clone() { return new cmUnsetCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -45,11 +42,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const {return "unset";}
+  virtual std::string GetName() const { return "unset"; }
 
   cmTypeMacro(cmUnsetCommand, cmCommand);
 };
 
-
-
 #endif
diff --git a/Source/cmUseMangledMesaCommand.cxx b/Source/cmUseMangledMesaCommand.cxx
index f30071e..1eb493a 100644
--- a/Source/cmUseMangledMesaCommand.cxx
+++ b/Source/cmUseMangledMesaCommand.cxx
@@ -16,57 +16,53 @@
 #include <cmsys/FStream.hxx>
 #include <cmsys/RegularExpression.hxx>
 
-bool cmUseMangledMesaCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmUseMangledMesaCommand::InitialPass(std::vector<std::string> const& args,
+                                          cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0030,
-      "The use_mangled_mesa command should not be called; see CMP0030."))
-    { return true; }
+  if (this->Disallowed(
+        cmPolicies::CMP0030,
+        "The use_mangled_mesa command should not be called; see CMP0030.")) {
+    return true;
+  }
   // expected two arguments:
   // arguement one: the full path to gl_mangle.h
   // arguement two : directory for output of edited headers
-  if(args.size() != 2)
-    {
+  if (args.size() != 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   const char* inputDir = args[0].c_str();
   std::string glh = inputDir;
   glh += "/";
   glh += "gl.h";
-  if(!cmSystemTools::FileExists(glh.c_str()))
-    {
+  if (!cmSystemTools::FileExists(glh.c_str())) {
     std::string e = "Bad path to Mesa, could not find: ";
     e += glh;
     e += " ";
     this->SetError(e);
     return false;
-    }
+  }
   const char* destDir = args[1].c_str();
   std::vector<std::string> files;
   cmSystemTools::Glob(inputDir, "\\.h$", files);
-  if(files.empty())
-    {
+  if (files.empty()) {
     cmSystemTools::Error("Could not open Mesa Directory ", inputDir);
     return false;
-    }
+  }
   cmSystemTools::MakeDirectory(destDir);
-  for(std::vector<std::string>::iterator i = files.begin();
-      i != files.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = files.begin(); i != files.end();
+       ++i) {
     std::string path = inputDir;
     path += "/";
     path += *i;
     this->CopyAndFullPathMesaHeader(path.c_str(), destDir);
-    }
+  }
 
   return true;
 }
 
-void
-cmUseMangledMesaCommand::
-CopyAndFullPathMesaHeader(const char* source,
-                          const char* outdir)
+void cmUseMangledMesaCommand::CopyAndFullPathMesaHeader(const char* source,
+                                                        const char* outdir)
 {
   std::string dir, file;
   cmSystemTools::SplitProgramPath(source, dir, file);
@@ -76,20 +72,18 @@ CopyAndFullPathMesaHeader(const char* source,
   std::string tempOutputFile = outFile;
   tempOutputFile += ".tmp";
   cmsys::ofstream fout(tempOutputFile.c_str());
-  if(!fout)
-    {
+  if (!fout) {
     cmSystemTools::Error("Could not open file for write in copy operation: ",
                          tempOutputFile.c_str(), outdir);
     cmSystemTools::ReportLastSystemError("");
     return;
-    }
+  }
   cmsys::ifstream fin(source);
-  if(!fin)
-    {
+  if (!fin) {
     cmSystemTools::Error("Could not open file for read in copy operation",
                          source);
     return;
-    }
+  }
   // now copy input to output and expand variables in the
   // input file at the same time
   std::string inLine;
@@ -100,36 +94,25 @@ CopyAndFullPathMesaHeader(const char* source,
   cmsys::RegularExpression glDirLine("(gl|GL)(/|\\\\)([^<\"]+)");
   // regular expression for gl GL or xmesa in a file (match(1) of above)
   cmsys::RegularExpression glLine("(gl|GL|xmesa)");
-  while(cmSystemTools::GetLineFromStream(fin,inLine))
-    {
-    if(includeLine.find(inLine.c_str()))
-      {
+  while (cmSystemTools::GetLineFromStream(fin, inLine)) {
+    if (includeLine.find(inLine.c_str())) {
       std::string includeFile = includeLine.match(1);
-      if(glDirLine.find(includeFile.c_str()))
-        {
+      if (glDirLine.find(includeFile.c_str())) {
         std::string gfile = glDirLine.match(3);
         fout << "#include \"" << outdir << "/" << gfile << "\"\n";
-        }
-      else if(glLine.find(includeFile.c_str()))
-        {
-        fout << "#include \"" << outdir << "/" <<
-          includeLine.match(1) << "\"\n";
-        }
-      else
-        {
+      } else if (glLine.find(includeFile.c_str())) {
+        fout << "#include \"" << outdir << "/" << includeLine.match(1)
+             << "\"\n";
+      } else {
         fout << inLine << "\n";
-        }
       }
-    else
-      {
+    } else {
       fout << inLine << "\n";
-      }
     }
+  }
   // close the files before attempting to copy
   fin.close();
   fout.close();
-  cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(),
-                                     outFile.c_str());
+  cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(), outFile.c_str());
   cmSystemTools::RemoveFile(tempOutputFile.c_str());
 }
-
diff --git a/Source/cmUseMangledMesaCommand.h b/Source/cmUseMangledMesaCommand.h
index 1af2bfe..5a97a61 100644
--- a/Source/cmUseMangledMesaCommand.h
+++ b/Source/cmUseMangledMesaCommand.h
@@ -20,12 +20,11 @@ public:
   cmTypeMacro(cmUseMangledMesaCommand, cmCommand);
   virtual cmCommand* Clone() { return new cmUseMangledMesaCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const { return "use_mangled_mesa";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "use_mangled_mesa"; }
   virtual bool IsScriptable() const { return true; }
 protected:
-  void CopyAndFullPathMesaHeader(const char* source,
-                                 const char* outdir);
+  void CopyAndFullPathMesaHeader(const char* source, const char* outdir);
 };
 
 #endif
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index 3f1e333..f7d766e 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -12,24 +12,24 @@
 #include "cmUtilitySourceCommand.h"
 
 // cmUtilitySourceCommand
-bool cmUtilitySourceCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0034,
-      "The utility_source command should not be called; see CMP0034."))
-    { return true; }
-  if(args.size() < 3)
-    {
+  if (this->Disallowed(
+        cmPolicies::CMP0034,
+        "The utility_source command should not be called; see CMP0034.")) {
+    return true;
+  }
+  if (args.size() < 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::vector<std::string>::const_iterator arg = args.begin();
 
   // The first argument is the cache entry name.
   std::string cacheEntry = *arg++;
-  const char* cacheValue =
-    this->Makefile->GetDefinition(cacheEntry);
+  const char* cacheValue = this->Makefile->GetDefinition(cacheEntry);
   // If it exists already and appears up to date then we are done.  If
   // the string contains "(IntDir)" but that is not the
   // CMAKE_CFG_INTDIR setting then the value is out of date.
@@ -37,34 +37,28 @@ bool cmUtilitySourceCommand
     this->Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
 
   bool haveCacheValue = false;
-  if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING"))
-    {
+  if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING")) {
     haveCacheValue = (cacheValue != 0);
-    if (!haveCacheValue)
-      {
+    if (!haveCacheValue) {
       std::string msg = "UTILITY_SOURCE is used in cross compiling mode for ";
       msg += cacheEntry;
       msg += ". If your intention is to run this executable, you need to "
-            "preload the cache with the full path to a version of that "
-            "program, which runs on this build machine.";
-      cmSystemTools::Message(msg.c_str() ,"Warning");
-      }
-    }
-  else
-    {
-    cmState *state =
-        this->Makefile->GetState();
-    haveCacheValue = (cacheValue &&
-     (strstr(cacheValue, "(IntDir)") == 0 ||
-      (intDir && strcmp(intDir, "$(IntDir)") == 0)) &&
-     (state->GetCacheMajorVersion() != 0 &&
-      state->GetCacheMinorVersion() != 0 ));
+             "preload the cache with the full path to a version of that "
+             "program, which runs on this build machine.";
+      cmSystemTools::Message(msg.c_str(), "Warning");
     }
-
-  if(haveCacheValue)
-    {
+  } else {
+    cmState* state = this->Makefile->GetState();
+    haveCacheValue =
+      (cacheValue && (strstr(cacheValue, "(IntDir)") == 0 ||
+                      (intDir && strcmp(intDir, "$(IntDir)") == 0)) &&
+       (state->GetCacheMajorVersion() != 0 &&
+        state->GetCacheMinorVersion() != 0));
+  }
+
+  if (haveCacheValue) {
     return true;
-    }
+  }
 
   // The second argument is the utility's executable name, which will be
   // needed later.
@@ -74,59 +68,52 @@ bool cmUtilitySourceCommand
   // of the utility.
   std::string relativeSource = *arg++;
   std::string utilitySource = this->Makefile->GetCurrentSourceDirectory();
-  utilitySource = utilitySource+"/"+relativeSource;
+  utilitySource = utilitySource + "/" + relativeSource;
 
   // If the directory doesn't exist, the source has not been included.
-  if(!cmSystemTools::FileExists(utilitySource.c_str()))
-    { return true; }
+  if (!cmSystemTools::FileExists(utilitySource.c_str())) {
+    return true;
+  }
 
   // Make sure all the files exist in the source directory.
-  while(arg != args.end())
-    {
-    std::string file = utilitySource+"/"+*arg++;
-    if(!cmSystemTools::FileExists(file.c_str()))
-      { return true; }
+  while (arg != args.end()) {
+    std::string file = utilitySource + "/" + *arg++;
+    if (!cmSystemTools::FileExists(file.c_str())) {
+      return true;
     }
+  }
 
   // The source exists.
   std::string cmakeCFGout =
     this->Makefile->GetRequiredDefinition("CMAKE_CFG_INTDIR");
   std::string utilityDirectory = this->Makefile->GetCurrentBinaryDirectory();
   std::string exePath;
-  if (this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"))
-    {
+  if (this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH")) {
     exePath = this->Makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
-    }
-  if(!exePath.empty())
-    {
+  }
+  if (!exePath.empty()) {
     utilityDirectory = exePath;
-    }
-  else
-    {
-    utilityDirectory += "/"+relativeSource;
-    }
+  } else {
+    utilityDirectory += "/" + relativeSource;
+  }
 
   // Construct the cache entry for the executable's location.
-  std::string utilityExecutable =
-    utilityDirectory+"/"+cmakeCFGout+"/"
-    +utilityName+this->Makefile->GetDefinition("CMAKE_EXECUTABLE_SUFFIX");
+  std::string utilityExecutable = utilityDirectory + "/" + cmakeCFGout + "/" +
+    utilityName + this->Makefile->GetDefinition("CMAKE_EXECUTABLE_SUFFIX");
 
   // make sure we remove any /./ in the name
   cmSystemTools::ReplaceString(utilityExecutable, "/./", "/");
 
   // Enter the value into the cache.
-  this->Makefile->AddCacheDefinition(cacheEntry,
-                                 utilityExecutable.c_str(),
-                                 "Path to an internal program.",
-                                 cmState::FILEPATH);
+  this->Makefile->AddCacheDefinition(cacheEntry, utilityExecutable.c_str(),
+                                     "Path to an internal program.",
+                                     cmState::FILEPATH);
   // add a value into the cache that maps from the
   // full path to the name of the project
   cmSystemTools::ConvertToUnixSlashes(utilityExecutable);
-  this->Makefile->AddCacheDefinition(utilityExecutable,
-                                 utilityName.c_str(),
-                                 "Executable to project name.",
-                                 cmState::INTERNAL);
+  this->Makefile->AddCacheDefinition(utilityExecutable, utilityName.c_str(),
+                                     "Executable to project name.",
+                                     cmState::INTERNAL);
 
   return true;
 }
-
diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h
index 8863ff5..a709de1 100644
--- a/Source/cmUtilitySourceCommand.h
+++ b/Source/cmUtilitySourceCommand.h
@@ -20,8 +20,8 @@ public:
   cmTypeMacro(cmUtilitySourceCommand, cmCommand);
   virtual cmCommand* Clone() { return new cmUtilitySourceCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const { return "utility_source";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "utility_source"; }
 };
 
 #endif
diff --git a/Source/cmUuid.cxx b/Source/cmUuid.cxx
index 5f8935f..6d09bdf 100644
--- a/Source/cmUuid.cxx
+++ b/Source/cmUuid.cxx
@@ -26,16 +26,16 @@ cmUuid::cmUuid()
 }
 
 std::string cmUuid::FromMd5(std::vector<unsigned char> const& uuidNamespace,
-  std::string const& name) const
+                            std::string const& name) const
 {
   std::vector<unsigned char> hashInput;
   this->CreateHashInput(uuidNamespace, name, hashInput);
 
-  cmsysMD5_s *md5 = cmsysMD5_New();
+  cmsysMD5_s* md5 = cmsysMD5_New();
   cmsysMD5_Initialize(md5);
   cmsysMD5_Append(md5, &hashInput[0], int(hashInput.size()));
 
-  unsigned char digest[16] = {0};
+  unsigned char digest[16] = { 0 };
   cmsysMD5_Finalize(md5, digest);
 
   cmsysMD5_Delete(md5);
@@ -44,16 +44,16 @@ std::string cmUuid::FromMd5(std::vector<unsigned char> const& uuidNamespace,
 }
 
 std::string cmUuid::FromSha1(std::vector<unsigned char> const& uuidNamespace,
-    std::string const& name) const
+                             std::string const& name) const
 {
   std::vector<unsigned char> hashInput;
   this->CreateHashInput(uuidNamespace, name, hashInput);
 
-  SHA_CTX *sha = new SHA_CTX;
+  SHA_CTX* sha = new SHA_CTX;
   SHA1_Init(sha);
   SHA1_Update(sha, &hashInput[0], hashInput.size());
 
-  unsigned char digest[SHA1_DIGEST_LENGTH] = {0};
+  unsigned char digest[SHA1_DIGEST_LENGTH] = { 0 };
   SHA1_Final(digest, sha);
 
   delete sha;
@@ -62,25 +62,24 @@ std::string cmUuid::FromSha1(std::vector<unsigned char> const& uuidNamespace,
 }
 
 void cmUuid::CreateHashInput(std::vector<unsigned char> const& uuidNamespace,
-  std::string const& name, std::vector<unsigned char> &output) const
+                             std::string const& name,
+                             std::vector<unsigned char>& output) const
 {
   output = uuidNamespace;
 
-  if(!name.empty())
-    {
+  if (!name.empty()) {
     output.resize(output.size() + name.size());
 
-    memcpy(&output[0] + uuidNamespace.size(),
-      name.c_str(), name.size());
-    }
+    memcpy(&output[0] + uuidNamespace.size(), name.c_str(), name.size());
+  }
 }
 
-std::string cmUuid::FromDigest(
-  const unsigned char* digest, unsigned char version) const
+std::string cmUuid::FromDigest(const unsigned char* digest,
+                               unsigned char version) const
 {
   typedef unsigned char byte_t;
 
-  byte_t uuid[16] = {0};
+  byte_t uuid[16] = { 0 };
   memcpy(uuid, digest, 16);
 
   uuid[6] &= 0xF;
@@ -93,30 +92,26 @@ std::string cmUuid::FromDigest(
 }
 
 bool cmUuid::StringToBinary(std::string const& input,
-  std::vector<unsigned char> &output) const
+                            std::vector<unsigned char>& output) const
 {
   output.clear();
   output.reserve(16);
 
-  if(input.length() != 36)
-    {
+  if (input.length() != 36) {
     return false;
-    }
+  }
   size_t index = 0;
-  for(size_t i = 0; i < this->Groups.size(); ++i)
-    {
-    if(i != 0 && input[index++] != '-')
-      {
+  for (size_t i = 0; i < this->Groups.size(); ++i) {
+    if (i != 0 && input[index++] != '-') {
       return false;
-      }
+    }
     size_t digits = this->Groups[i] * 2;
-    if(!StringToBinaryImpl(input.substr(index, digits), output))
-      {
+    if (!StringToBinaryImpl(input.substr(index, digits), output)) {
       return false;
-      }
+    }
 
     index += digits;
-    }
+  }
 
   return true;
 }
@@ -126,20 +121,17 @@ std::string cmUuid::BinaryToString(const unsigned char* input) const
   std::string output;
 
   size_t inputIndex = 0;
-  for(size_t i = 0; i < this->Groups.size(); ++i)
-    {
-    if(i != 0)
-      {
+  for (size_t i = 0; i < this->Groups.size(); ++i) {
+    if (i != 0) {
       output += '-';
-      }
+    }
 
     size_t bytes = this->Groups[i];
-    for(size_t j = 0; j < bytes; ++j)
-      {
+    for (size_t j = 0; j < bytes; ++j) {
       unsigned char byte = input[inputIndex++];
       output += this->ByteToHex(byte);
-      }
     }
+  }
 
   return output;
 }
@@ -147,68 +139,54 @@ std::string cmUuid::BinaryToString(const unsigned char* input) const
 std::string cmUuid::ByteToHex(unsigned char byte) const
 {
   std::string result;
-  for(int i = 0; i < 2; ++i)
-    {
+  for (int i = 0; i < 2; ++i) {
     unsigned char rest = byte % 16;
     byte /= 16;
 
-    char c = (rest < 0xA) ?
-      char('0' + rest) :
-      char('a' + (rest - 0xA));
+    char c = (rest < 0xA) ? char('0' + rest) : char('a' + (rest - 0xA));
 
     result = c + result;
-    }
+  }
 
   return result;
 }
 
 bool cmUuid::StringToBinaryImpl(std::string const& input,
-  std::vector<unsigned char> &output) const
+                                std::vector<unsigned char>& output) const
 {
-  if(input.size()%2)
-    {
+  if (input.size() % 2) {
     return false;
-    }
+  }
 
-  for(size_t i = 0; i < input.size(); i +=2)
-    {
+  for (size_t i = 0; i < input.size(); i += 2) {
     char c1 = 0;
-    if(!IntFromHexDigit(input[i], c1))
-      {
+    if (!IntFromHexDigit(input[i], c1)) {
       return false;
-      }
+    }
 
     char c2 = 0;
-    if(!IntFromHexDigit(input[i + 1], c2))
-      {
+    if (!IntFromHexDigit(input[i + 1], c2)) {
       return false;
-      }
+    }
 
     output.push_back(char(c1 << 4 | c2));
-    }
+  }
 
   return true;
 }
 
 bool cmUuid::IntFromHexDigit(char input, char& output) const
 {
-  if(input >= '0' && input <= '9')
-    {
+  if (input >= '0' && input <= '9') {
     output = char(input - '0');
     return true;
-    }
-  else if(input >= 'a' && input <= 'f')
-    {
+  } else if (input >= 'a' && input <= 'f') {
     output = char(input - 'a' + 0xA);
     return true;
-    }
-  else if(input >= 'A' && input <= 'F')
-    {
+  } else if (input >= 'A' && input <= 'F') {
     output = char(input - 'A' + 0xA);
     return true;
-    }
-  else
-    {
+  } else {
     return false;
-    }
+  }
 }
diff --git a/Source/cmUuid.h b/Source/cmUuid.h
index 0dda357..2bd7ec5 100644
--- a/Source/cmUuid.h
+++ b/Source/cmUuid.h
@@ -24,25 +24,26 @@ public:
   cmUuid();
 
   std::string FromMd5(std::vector<unsigned char> const& uuidNamespace,
-    std::string const& name) const;
+                      std::string const& name) const;
 
   std::string FromSha1(std::vector<unsigned char> const& uuidNamespace,
-    std::string const& name) const;
+                       std::string const& name) const;
 
   bool StringToBinary(std::string const& input,
-    std::vector<unsigned char> &output) const;
+                      std::vector<unsigned char>& output) const;
 
 private:
   std::string ByteToHex(unsigned char byte) const;
 
   void CreateHashInput(std::vector<unsigned char> const& uuidNamespace,
-    std::string const& name, std::vector<unsigned char> &output) const;
+                       std::string const& name,
+                       std::vector<unsigned char>& output) const;
 
   std::string FromDigest(const unsigned char* digest,
-    unsigned char version) const;
+                         unsigned char version) const;
 
   bool StringToBinaryImpl(std::string const& input,
-    std::vector<unsigned char> &output) const;
+                          std::vector<unsigned char>& output) const;
 
   std::string BinaryToString(const unsigned char* input) const;
 
@@ -51,5 +52,4 @@ private:
   std::vector<int> Groups;
 };
 
-
 #endif
diff --git a/Source/cmVS10CLFlagTable.h b/Source/cmVS10CLFlagTable.h
index a7b1b36..dbd760e 100644
--- a/Source/cmVS10CLFlagTable.h
+++ b/Source/cmVS10CLFlagTable.h
@@ -1,270 +1,204 @@
-static cmVS7FlagTable cmVS10CLFlagTable[] =
-{
-
-  //Enum Properties
-  {"DebugInformationFormat", "Z7",
-   "C7 compatible", "OldStyle", 0},
-  {"DebugInformationFormat", "Zi",
-   "Program Database", "ProgramDatabase", 0},
-  {"DebugInformationFormat", "ZI",
-   "Program Database for Edit And Continue", "EditAndContinue", 0},
-
-  {"WarningLevel", "W0",
-   "Turn Off All Warnings", "TurnOffAllWarnings", 0},
-  {"WarningLevel", "W1",
-   "Level1", "Level1", 0},
-  {"WarningLevel", "W2",
-   "Level2", "Level2", 0},
-  {"WarningLevel", "W3",
-   "Level3", "Level3", 0},
-  {"WarningLevel", "W4",
-   "Level4", "Level4", 0},
-  {"WarningLevel", "Wall",
-   "EnableAllWarnings", "EnableAllWarnings", 0},
-
-  {"Optimization", "Od",
-   "Disabled", "Disabled", 0},
-  {"Optimization", "O1",
-   "Minimize Size", "MinSpace", 0},
-  {"Optimization", "O2",
-   "Maximize Speed", "MaxSpeed", 0},
-  {"Optimization", "Ox",
-   "Full Optimization", "Full", 0},
-
-  {"InlineFunctionExpansion", "",
-   "Default", "Default", 0},
-  {"InlineFunctionExpansion", "Ob0",
-   "Disabled", "Disabled", 0},
-  {"InlineFunctionExpansion", "Ob1",
-   "Only __inline", "OnlyExplicitInline", 0},
-  {"InlineFunctionExpansion", "Ob2",
-   "Any Suitable", "AnySuitable", 0},
-
-  {"FavorSizeOrSpeed", "Os",
-   "Favor small code", "Size", 0},
-  {"FavorSizeOrSpeed", "Ot",
-   "Favor fast code", "Speed", 0},
-  {"FavorSizeOrSpeed", "",
-   "Neither", "Neither", 0},
-
-  {"ExceptionHandling", "EHa",
-   "Yes with SEH Exceptions", "Async", 0},
-  {"ExceptionHandling", "EHsc",
-   "Yes", "Sync", 0},
-  {"ExceptionHandling", "EHs",
-   "Yes with Extern C functions", "SyncCThrow", 0},
-  {"ExceptionHandling", "",
-   "No", "false", 0},
-
-  {"BasicRuntimeChecks", "RTCs",
-   "Stack Frames", "StackFrameRuntimeCheck", 0},
-  {"BasicRuntimeChecks", "RTCu",
-   "Uninitialized variables", "UninitializedLocalUsageCheck", 0},
-  {"BasicRuntimeChecks", "RTC1",
-   "Both (/RTC1, equiv. to /RTCsu)", "EnableFastChecks", 0},
-  {"BasicRuntimeChecks", "",
-   "Default", "Default", 0},
-
-  {"RuntimeLibrary", "MT",
-   "Multi-threaded", "MultiThreaded", 0},
-  {"RuntimeLibrary", "MTd",
-   "Multi-threaded Debug", "MultiThreadedDebug", 0},
-  {"RuntimeLibrary", "MD",
-   "Multi-threaded DLL", "MultiThreadedDLL", 0},
-  {"RuntimeLibrary", "MDd",
-   "Multi-threaded Debug DLL", "MultiThreadedDebugDLL", 0},
-
-  {"StructMemberAlignment", "Zp1",
-   "1 Byte", "1Byte", 0},
-  {"StructMemberAlignment", "Zp2",
-   "2 Bytes", "2Bytes", 0},
-  {"StructMemberAlignment", "Zp4",
-   "4 Byte", "4Bytes", 0},
-  {"StructMemberAlignment", "Zp8",
-   "8 Bytes", "8Bytes", 0},
-  {"StructMemberAlignment", "Zp16",
-   "16 Bytes", "16Bytes", 0},
-  {"StructMemberAlignment", "",
-   "Default", "Default", 0},
-
-  {"EnableEnhancedInstructionSet", "arch:SSE",
-   "Streaming SIMD Extensions (/arch:SSE)", "StreamingSIMDExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:SSE2",
-   "Streaming SIMD Extensions 2 (/arch:SSE2)", "StreamingSIMDExtensions2", 0},
-  {"EnableEnhancedInstructionSet", "",
-   "Not Set", "NotSet", 0},
-
-  {"FloatingPointModel", "fp:precise",
-   "Precise", "Precise", 0},
-  {"FloatingPointModel", "fp:strict",
-   "Strict", "Strict", 0},
-  {"FloatingPointModel", "fp:fast",
-   "Fast", "Fast", 0},
-
-  {"PrecompiledHeader", "Yc",
-   "Create", "Create",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "Yu",
-   "Use", "Use",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "",
-   "Not Using Precompiled Headers", "NotUsing", 0},
-
-  {"AssemblerOutput", "",
-   "No Listing", "NoListing", 0},
-  {"AssemblerOutput", "FA",
-   "Assembly-Only Listing", "AssemblyCode", 0},
-  {"AssemblerOutput", "FAc",
-   "Assembly With Machine Code", "AssemblyAndMachineCode", 0},
-  {"AssemblerOutput", "FAs",
-   "Assembly With Source Code", "AssemblyAndSourceCode", 0},
-  {"AssemblerOutput", "FAcs",
-   "Assembly, Machine Code and Source", "All", 0},
-
-  {"CallingConvention", "Gd",
-   "__cdecl", "Cdecl", 0},
-  {"CallingConvention", "Gr",
-   "__fastcall", "FastCall", 0},
-  {"CallingConvention", "Gz",
-   "__stdcall", "StdCall", 0},
-
-  {"CompileAs", "",
-   "Default", "Default", 0},
-  {"CompileAs", "TC",
-   "Compile as C Code", "CompileAsC", 0},
-  {"CompileAs", "TP",
-   "Compile as C++ Code", "CompileAsCpp", 0},
-
-  {"ErrorReporting", "errorReport:none",
-   "Do Not Send Report", "None", 0},
-  {"ErrorReporting", "errorReport:prompt",
-   "Prompt Immediately", "Prompt", 0},
-  {"ErrorReporting", "errorReport:queue",
-   "Queue For Next Login", "Queue", 0},
-  {"ErrorReporting", "errorReport:send",
-   "Send Automatically", "Send", 0},
-
-  {"CompileAsManaged", "",
-   "No Common Language RunTime Support", "false", 0},
-  {"CompileAsManaged", "clr",
-   "Common Language RunTime Support", "true", 0},
-  {"CompileAsManaged", "clr:pure",
-   "Pure MSIL Common Language RunTime Support", "Pure", 0},
-  {"CompileAsManaged", "clr:safe",
-   "Safe MSIL Common Language RunTime Support", "Safe", 0},
-  {"CompileAsManaged", "clr:oldSyntax",
-   "Common Language RunTime Support, Old Syntax", "OldSyntax", 0},
-
-
-  //Bool Properties
-  {"SuppressStartupBanner", "nologo-", "", "false", 0},
-  {"SuppressStartupBanner", "nologo", "", "true", 0},
-  {"TreatWarningAsError", "WX-", "", "false", 0},
-  {"TreatWarningAsError", "WX", "", "true", 0},
-  {"IntrinsicFunctions", "Oi", "", "true", 0},
-  {"OmitFramePointers", "Oy-", "", "false", 0},
-  {"OmitFramePointers", "Oy", "", "true", 0},
-  {"EnableFiberSafeOptimizations", "GT", "", "true", 0},
-  {"WholeProgramOptimization", "GL", "", "true", 0},
-  {"UndefineAllPreprocessorDefinitions", "u", "", "true", 0},
-  {"IgnoreStandardIncludePath", "X", "", "true", 0},
-  {"PreprocessToFile", "P", "", "true", 0},
-  {"PreprocessSuppressLineNumbers", "EP", "", "true", 0},
-  {"PreprocessKeepComments", "C", "", "true", 0},
-  {"StringPooling", "GF-", "", "false", 0},
-  {"StringPooling", "GF", "", "true", 0},
-  {"MinimalRebuild", "Gm-", "", "false", 0},
-  {"MinimalRebuild", "Gm", "", "true", 0},
-  {"SmallerTypeCheck", "RTCc", "", "true", 0},
-  {"BufferSecurityCheck", "GS-", "", "false", 0},
-  {"BufferSecurityCheck", "GS", "", "true", 0},
-  {"FunctionLevelLinking", "Gy-", "", "false", 0},
-  {"FunctionLevelLinking", "Gy", "", "true", 0},
-  {"FloatingPointExceptions", "fp:except-", "", "false", 0},
-  {"FloatingPointExceptions", "fp:except", "", "true", 0},
-  {"CreateHotpatchableImage", "hotpatch", "", "true", 0},
-  {"DisableLanguageExtensions", "Za", "", "true", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0},
-  {"RuntimeTypeInfo", "GR-", "", "false", 0},
-  {"RuntimeTypeInfo", "GR", "", "true", 0},
-  {"OpenMPSupport", "openmp-", "", "false", 0},
-  {"OpenMPSupport", "openmp", "", "true", 0},
-  {"ExpandAttributedSource", "Fx", "", "true", 0},
-  {"ShowIncludes", "showIncludes", "", "true", 0},
-  {"EnablePREfast", "analyze-", "", "false", 0},
-  {"EnablePREfast", "analyze", "", "true", 0},
-  {"UseFullPaths", "FC", "", "true", 0},
-  {"OmitDefaultLibName", "Zl", "", "true", 0},
-  {"UseUnicodeForAssemblerListing", "FAu", "", "true", 0},
-
-  //Bool Properties With Argument
-  {"MultiProcessorCompilation", "MP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"ProcessorNumber", "MP", "Multi-processor Compilation", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateXMLDocumentationFiles", "doc", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"BrowseInformation", "FR", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"BrowseInformationFile", "FR", "Enable Browse Information", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalIncludeDirectories", "I",
-   "Additional Include Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalUsingDirectories", "AI",
-   "Resolve #using References",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PreprocessorDefinitions", "D ",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"UndefinePreprocessorDefinitions", "U",
-   "Undefine Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DisableSpecificWarnings", "wd",
-   "Disable Specific Warnings",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedIncludeFiles", "FI",
-   "Forced Include File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedUsingFiles", "FU",
-   "Forced #using File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"TreatSpecificWarningsAsErrors", "we",
-   "Treat Specific Warnings As Errors",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-
-  //String Properties
+static cmVS7FlagTable cmVS10CLFlagTable[] = {
+
+  // Enum Properties
+  { "DebugInformationFormat", "Z7", "C7 compatible", "OldStyle", 0 },
+  { "DebugInformationFormat", "Zi", "Program Database", "ProgramDatabase", 0 },
+  { "DebugInformationFormat", "ZI", "Program Database for Edit And Continue",
+    "EditAndContinue", 0 },
+
+  { "WarningLevel", "W0", "Turn Off All Warnings", "TurnOffAllWarnings", 0 },
+  { "WarningLevel", "W1", "Level1", "Level1", 0 },
+  { "WarningLevel", "W2", "Level2", "Level2", 0 },
+  { "WarningLevel", "W3", "Level3", "Level3", 0 },
+  { "WarningLevel", "W4", "Level4", "Level4", 0 },
+  { "WarningLevel", "Wall", "EnableAllWarnings", "EnableAllWarnings", 0 },
+
+  { "Optimization", "Od", "Disabled", "Disabled", 0 },
+  { "Optimization", "O1", "Minimize Size", "MinSpace", 0 },
+  { "Optimization", "O2", "Maximize Speed", "MaxSpeed", 0 },
+  { "Optimization", "Ox", "Full Optimization", "Full", 0 },
+
+  { "InlineFunctionExpansion", "", "Default", "Default", 0 },
+  { "InlineFunctionExpansion", "Ob0", "Disabled", "Disabled", 0 },
+  { "InlineFunctionExpansion", "Ob1", "Only __inline", "OnlyExplicitInline",
+    0 },
+  { "InlineFunctionExpansion", "Ob2", "Any Suitable", "AnySuitable", 0 },
+
+  { "FavorSizeOrSpeed", "Os", "Favor small code", "Size", 0 },
+  { "FavorSizeOrSpeed", "Ot", "Favor fast code", "Speed", 0 },
+  { "FavorSizeOrSpeed", "", "Neither", "Neither", 0 },
+
+  { "ExceptionHandling", "EHa", "Yes with SEH Exceptions", "Async", 0 },
+  { "ExceptionHandling", "EHsc", "Yes", "Sync", 0 },
+  { "ExceptionHandling", "EHs", "Yes with Extern C functions", "SyncCThrow",
+    0 },
+  { "ExceptionHandling", "", "No", "false", 0 },
+
+  { "BasicRuntimeChecks", "RTCs", "Stack Frames", "StackFrameRuntimeCheck",
+    0 },
+  { "BasicRuntimeChecks", "RTCu", "Uninitialized variables",
+    "UninitializedLocalUsageCheck", 0 },
+  { "BasicRuntimeChecks", "RTC1", "Both (/RTC1, equiv. to /RTCsu)",
+    "EnableFastChecks", 0 },
+  { "BasicRuntimeChecks", "", "Default", "Default", 0 },
+
+  { "RuntimeLibrary", "MT", "Multi-threaded", "MultiThreaded", 0 },
+  { "RuntimeLibrary", "MTd", "Multi-threaded Debug", "MultiThreadedDebug", 0 },
+  { "RuntimeLibrary", "MD", "Multi-threaded DLL", "MultiThreadedDLL", 0 },
+  { "RuntimeLibrary", "MDd", "Multi-threaded Debug DLL",
+    "MultiThreadedDebugDLL", 0 },
+
+  { "StructMemberAlignment", "Zp1", "1 Byte", "1Byte", 0 },
+  { "StructMemberAlignment", "Zp2", "2 Bytes", "2Bytes", 0 },
+  { "StructMemberAlignment", "Zp4", "4 Byte", "4Bytes", 0 },
+  { "StructMemberAlignment", "Zp8", "8 Bytes", "8Bytes", 0 },
+  { "StructMemberAlignment", "Zp16", "16 Bytes", "16Bytes", 0 },
+  { "StructMemberAlignment", "", "Default", "Default", 0 },
+
+  { "EnableEnhancedInstructionSet", "arch:SSE",
+    "Streaming SIMD Extensions (/arch:SSE)", "StreamingSIMDExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:SSE2",
+    "Streaming SIMD Extensions 2 (/arch:SSE2)", "StreamingSIMDExtensions2",
+    0 },
+  { "EnableEnhancedInstructionSet", "", "Not Set", "NotSet", 0 },
+
+  { "FloatingPointModel", "fp:precise", "Precise", "Precise", 0 },
+  { "FloatingPointModel", "fp:strict", "Strict", "Strict", 0 },
+  { "FloatingPointModel", "fp:fast", "Fast", "Fast", 0 },
+
+  { "PrecompiledHeader", "Yc", "Create", "Create",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "Yu", "Use", "Use",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "", "Not Using Precompiled Headers", "NotUsing", 0 },
+
+  { "AssemblerOutput", "", "No Listing", "NoListing", 0 },
+  { "AssemblerOutput", "FA", "Assembly-Only Listing", "AssemblyCode", 0 },
+  { "AssemblerOutput", "FAc", "Assembly With Machine Code",
+    "AssemblyAndMachineCode", 0 },
+  { "AssemblerOutput", "FAs", "Assembly With Source Code",
+    "AssemblyAndSourceCode", 0 },
+  { "AssemblerOutput", "FAcs", "Assembly, Machine Code and Source", "All", 0 },
+
+  { "CallingConvention", "Gd", "__cdecl", "Cdecl", 0 },
+  { "CallingConvention", "Gr", "__fastcall", "FastCall", 0 },
+  { "CallingConvention", "Gz", "__stdcall", "StdCall", 0 },
+
+  { "CompileAs", "", "Default", "Default", 0 },
+  { "CompileAs", "TC", "Compile as C Code", "CompileAsC", 0 },
+  { "CompileAs", "TP", "Compile as C++ Code", "CompileAsCpp", 0 },
+
+  { "ErrorReporting", "errorReport:none", "Do Not Send Report", "None", 0 },
+  { "ErrorReporting", "errorReport:prompt", "Prompt Immediately", "Prompt",
+    0 },
+  { "ErrorReporting", "errorReport:queue", "Queue For Next Login", "Queue",
+    0 },
+  { "ErrorReporting", "errorReport:send", "Send Automatically", "Send", 0 },
+
+  { "CompileAsManaged", "", "No Common Language RunTime Support", "false", 0 },
+  { "CompileAsManaged", "clr", "Common Language RunTime Support", "true", 0 },
+  { "CompileAsManaged", "clr:pure",
+    "Pure MSIL Common Language RunTime Support", "Pure", 0 },
+  { "CompileAsManaged", "clr:safe",
+    "Safe MSIL Common Language RunTime Support", "Safe", 0 },
+  { "CompileAsManaged", "clr:oldSyntax",
+    "Common Language RunTime Support, Old Syntax", "OldSyntax", 0 },
+
+  // Bool Properties
+  { "SuppressStartupBanner", "nologo-", "", "false", 0 },
+  { "SuppressStartupBanner", "nologo", "", "true", 0 },
+  { "TreatWarningAsError", "WX-", "", "false", 0 },
+  { "TreatWarningAsError", "WX", "", "true", 0 },
+  { "IntrinsicFunctions", "Oi", "", "true", 0 },
+  { "OmitFramePointers", "Oy-", "", "false", 0 },
+  { "OmitFramePointers", "Oy", "", "true", 0 },
+  { "EnableFiberSafeOptimizations", "GT", "", "true", 0 },
+  { "WholeProgramOptimization", "GL", "", "true", 0 },
+  { "UndefineAllPreprocessorDefinitions", "u", "", "true", 0 },
+  { "IgnoreStandardIncludePath", "X", "", "true", 0 },
+  { "PreprocessToFile", "P", "", "true", 0 },
+  { "PreprocessSuppressLineNumbers", "EP", "", "true", 0 },
+  { "PreprocessKeepComments", "C", "", "true", 0 },
+  { "StringPooling", "GF-", "", "false", 0 },
+  { "StringPooling", "GF", "", "true", 0 },
+  { "MinimalRebuild", "Gm-", "", "false", 0 },
+  { "MinimalRebuild", "Gm", "", "true", 0 },
+  { "SmallerTypeCheck", "RTCc", "", "true", 0 },
+  { "BufferSecurityCheck", "GS-", "", "false", 0 },
+  { "BufferSecurityCheck", "GS", "", "true", 0 },
+  { "FunctionLevelLinking", "Gy-", "", "false", 0 },
+  { "FunctionLevelLinking", "Gy", "", "true", 0 },
+  { "FloatingPointExceptions", "fp:except-", "", "false", 0 },
+  { "FloatingPointExceptions", "fp:except", "", "true", 0 },
+  { "CreateHotpatchableImage", "hotpatch", "", "true", 0 },
+  { "DisableLanguageExtensions", "Za", "", "true", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0 },
+  { "RuntimeTypeInfo", "GR-", "", "false", 0 },
+  { "RuntimeTypeInfo", "GR", "", "true", 0 },
+  { "OpenMPSupport", "openmp-", "", "false", 0 },
+  { "OpenMPSupport", "openmp", "", "true", 0 },
+  { "ExpandAttributedSource", "Fx", "", "true", 0 },
+  { "ShowIncludes", "showIncludes", "", "true", 0 },
+  { "EnablePREfast", "analyze-", "", "false", 0 },
+  { "EnablePREfast", "analyze", "", "true", 0 },
+  { "UseFullPaths", "FC", "", "true", 0 },
+  { "OmitDefaultLibName", "Zl", "", "true", 0 },
+  { "UseUnicodeForAssemblerListing", "FAu", "", "true", 0 },
+
+  // Bool Properties With Argument
+  { "MultiProcessorCompilation", "MP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "ProcessorNumber", "MP", "Multi-processor Compilation", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateXMLDocumentationFiles", "doc", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "BrowseInformation", "FR", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "BrowseInformationFile", "FR", "Enable Browse Information", "",
+    cmVS7FlagTable::UserValueRequired },
+
+  // String List Properties
+  { "AdditionalIncludeDirectories", "I", "Additional Include Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalUsingDirectories", "AI", "Resolve #using References", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PreprocessorDefinitions", "D ", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "UndefinePreprocessorDefinitions", "U",
+    "Undefine Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DisableSpecificWarnings", "wd", "Disable Specific Warnings", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedIncludeFiles", "FI", "Forced Include File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedUsingFiles", "FU", "Forced #using File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "TreatSpecificWarningsAsErrors", "we", "Treat Specific Warnings As Errors",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+
+  // String Properties
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"PreprocessOutputPath", "Fi",
-   "Preprocess Output Path",
-   "", cmVS7FlagTable::UserValue},
-  {"PrecompiledHeaderFile", "Yc",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderFile", "Yu",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderOutputFile", "Fp",
-   "Precompiled Header Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"AssemblerListingLocation", "Fa",
-   "ASM List Location",
-   "", cmVS7FlagTable::UserValue},
-  {"ObjectFileName", "Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDataBaseFileName", "Fd",
-   "Program Database File Name",
-   "", cmVS7FlagTable::UserValue},
+  { "PreprocessOutputPath", "Fi", "Preprocess Output Path", "",
+    cmVS7FlagTable::UserValue },
+  { "PrecompiledHeaderFile", "Yc", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderFile", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderOutputFile", "Fp", "Precompiled Header Output File", "",
+    cmVS7FlagTable::UserValue },
+  { "AssemblerListingLocation", "Fa", "ASM List Location", "",
+    cmVS7FlagTable::UserValue },
+  { "ObjectFileName", "Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDataBaseFileName", "Fd", "Program Database File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [XMLDocumentationFileName] - no command line Switch.
   // Skip [BrowseInformationFile] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS10LibFlagTable.h b/Source/cmVS10LibFlagTable.h
index 79aeeff..65f28ef 100644
--- a/Source/cmVS10LibFlagTable.h
+++ b/Source/cmVS10LibFlagTable.h
@@ -1,102 +1,76 @@
-static cmVS7FlagTable cmVS10LibFlagTable[] =
-{
+static cmVS7FlagTable cmVS10LibFlagTable[] = {
 
-  //Enum Properties
-  {"ErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"ErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"ErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"ErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  // Enum Properties
+  { "ErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "ErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "ErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "ErrorReporting", "ERRORREPORT:NONE", "No Error Report", "NoErrorReport",
+    0 },
 
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWSCE",
-   "WindowsCE", "WindowsCE", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
+  // Bool Properties
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "TreatLibWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLibWarningAsErrors", "WX", "", "true", 0 },
+  { "Verbose", "VERBOSE", "", "true", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "", "true", 0 },
 
-  //Bool Properties
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"TreatLibWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLibWarningAsErrors", "WX", "", "true", 0},
-  {"Verbose", "VERBOSE", "", "true", 0},
-  {"LinkTimeCodeGeneration", "LTCG", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
+  // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ExportNamedFunctions", "EXPORT:",
-   "Export Named Functions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"RemoveObjects", "REMOVE:",
-   "Remove Objects",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "RemoveObjects", "REMOVE:", "Remove Objects", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue},
-  {"DisplayLibrary", "LIST:",
-   "Display Library to standard output",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue },
+  { "DisplayLibrary", "LIST:", "Display Library to standard output", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"Name", "NAME:",
-   "Name",
-   "", cmVS7FlagTable::UserValue},
+  { "Name", "NAME:", "Name", "", cmVS7FlagTable::UserValue },
   // Skip [TrackerLogDirectory] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS10LinkFlagTable.h b/Source/cmVS10LinkFlagTable.h
index dd92329..c30ea9a 100644
--- a/Source/cmVS10LinkFlagTable.h
+++ b/Source/cmVS10LinkFlagTable.h
@@ -1,303 +1,244 @@
-static cmVS7FlagTable cmVS10LinkFlagTable[] =
-{
-
-  //Enum Properties
-  {"ShowProgress", "",
-   "Not Set", "NotSet", 0},
-  {"ShowProgress", "VERBOSE",
-   "Display all progress messages", "LinkVerbose", 0},
-  {"ShowProgress", "VERBOSE:Lib",
-   "For Libraries Searched", "LinkVerboseLib", 0},
-  {"ShowProgress", "VERBOSE:ICF",
-   "About COMDAT folding during optimized linking", "LinkVerboseICF", 0},
-  {"ShowProgress", "VERBOSE:REF",
-   "About data removed during optimized linking", "LinkVerboseREF", 0},
-  {"ShowProgress", "VERBOSE:SAFESEH",
-   "About Modules incompatible with SEH", "LinkVerboseSAFESEH", 0},
-  {"ShowProgress", "VERBOSE:CLR",
-   "About linker activity related to managed code", "LinkVerboseCLR", 0},
-
-  {"ForceFileOutput", "FORCE",
-   "Enabled", "Enabled", 0},
-  {"ForceFileOutput", "FORCE:MULTIPLE",
-   "Multiply Defined Symbol Only", "MultiplyDefinedSymbolOnly", 0},
-  {"ForceFileOutput", "FORCE:UNRESOLVED",
-   "Undefined Symbol Only", "UndefinedSymbolOnly", 0},
-
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN",
-   "Enabled", "Enabled", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:5",
-   "X86 Image Only", "X86Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:6",
-   "X64 Image Only", "X64Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:16",
-   "Itanium Image Only", "ItaniumImage", 0},
-
-  {"UACExecutionLevel", "level='asInvoker'",
-   "asInvoker", "AsInvoker", 0},
-  {"UACExecutionLevel", "level='highestAvailable'",
-   "highestAvailable", "HighestAvailable", 0},
-  {"UACExecutionLevel", "level='requireAdministrator'",
-   "requireAdministrator", "RequireAdministrator", 0},
-
-  {"SubSystem", "",
-   "Not Set", "NotSet", 0},
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWSCE",
-   "WindowsCE", "WindowsCE", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
-
-  {"Driver", "",
-   "Not Set", "NotSet", 0},
-  {"Driver", "Driver",
-   "Driver", "Driver", 0},
-  {"Driver", "DRIVER:UPONLY",
-   "UP Only", "UpOnly", 0},
-  {"Driver", "DRIVER:WDM",
-   "WDM", "WDM", 0},
-
-  {"LinkTimeCodeGeneration", "",
-   "Default", "Default", 0},
-  {"LinkTimeCodeGeneration", "LTCG",
-   "Use Link Time Code Generation", "UseLinkTimeCodeGeneration", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGInstrument",
-   "Profile Guided Optimization - Instrument", "PGInstrument", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGOptimize",
-   "Profile Guided Optimization - Optimization", "PGOptimization", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGUpdate",
-   "Profile Guided Optimization - Update", "PGUpdate", 0},
-
-  {"TargetMachine", "",
-   "Not Set", "NotSet", 0},
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
-
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA",
-   "MTA threading attribute", "MTAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA",
-   "STA threading attribute", "STAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
-   "Default threading attribute", "DefaultThreadingAttribute", 0},
-
-  {"CLRImageType", "CLRIMAGETYPE:IJW",
-   "Force IJW image", "ForceIJWImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:PURE",
-   "Force Pure IL Image", "ForcePureILImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:SAFE",
-   "Force Safe IL Image", "ForceSafeILImage", 0},
-  {"CLRImageType", "",
-   "Default image type", "Default", 0},
-
-  {"LinkErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"LinkErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"LinkErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"LinkErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
-
-  {"CLRSupportLastError", "CLRSupportLastError",
-   "Enabled", "Enabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:NO",
-   "Disabled", "Disabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL",
-   "System Dlls Only", "SystemDlls", 0},
-
-
-  //Bool Properties
-  {"LinkIncremental", "INCREMENTAL:NO", "", "false", 0},
-  {"LinkIncremental", "INCREMENTAL", "", "true", 0},
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"LinkStatus", "LTCG:NOSTATUS", "", "false", 0},
-  {"LinkStatus", "LTCG:STATUS", "", "true", 0},
-  {"PreventDllBinding", "ALLOWBIND:NO", "", "false", 0},
-  {"PreventDllBinding", "ALLOWBIND", "", "true", 0},
-  {"TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLinkerWarningAsErrors", "WX", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"GenerateManifest", "MANIFEST:NO", "", "false", 0},
-  {"GenerateManifest", "MANIFEST", "", "true", 0},
-  {"AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0},
-  {"UACUIAccess", "uiAccess='false'", "", "false", 0},
-  {"UACUIAccess", "uiAccess='true'", "", "true", 0},
-  {"GenerateDebugInformation", "DEBUG", "", "true",
-   cmVS7FlagTable::CaseInsensitive},
-  {"MapExports", "MAPINFO:EXPORTS", "", "true", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0},
-  {"TerminalServerAware", "TSAWARE:NO", "", "false", 0},
-  {"TerminalServerAware", "TSAWARE", "", "true", 0},
-  {"SwapRunFromCD", "SWAPRUN:CD", "", "true", 0},
-  {"SwapRunFromNET", "SWAPRUN:NET", "", "true", 0},
-  {"OptimizeReferences", "OPT:NOREF", "", "false", 0},
-  {"OptimizeReferences", "OPT:REF", "", "true", 0},
-  {"EnableCOMDATFolding", "OPT:NOICF", "", "false", 0},
-  {"EnableCOMDATFolding", "OPT:ICF", "", "true", 0},
-  {"IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0},
-  {"NoEntryPoint", "NOENTRY", "", "true", 0},
-  {"SetChecksum", "RELEASE", "", "true", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0},
-  {"FixedBaseAddress", "FIXED:NO", "", "false", 0},
-  {"FixedBaseAddress", "FIXED", "", "true", 0},
-  {"DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0},
-  {"DataExecutionPrevention", "NXCOMPAT", "", "true", 0},
-  {"TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0},
-  {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0},
-  {"SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0},
-  {"Profile", "PROFILE", "", "true", 0},
-  {"LinkDelaySign", "DELAYSIGN:NO", "", "false", 0},
-  {"LinkDelaySign", "DELAYSIGN", "", "true", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0},
-  {"LinkDLL", "DLL", "", "true", 0},
-
-  //Bool Properties With Argument
-  {"EnableUAC", "MANIFESTUAC:NO", "", "false", 0},
-  {"EnableUAC", "MANIFESTUAC:", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateMapFile", "MAP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"MapFileName", "MAP:", "Generate Map File", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+static cmVS7FlagTable cmVS10LinkFlagTable[] = {
+
+  // Enum Properties
+  { "ShowProgress", "", "Not Set", "NotSet", 0 },
+  { "ShowProgress", "VERBOSE", "Display all progress messages", "LinkVerbose",
+    0 },
+  { "ShowProgress", "VERBOSE:Lib", "For Libraries Searched", "LinkVerboseLib",
+    0 },
+  { "ShowProgress", "VERBOSE:ICF",
+    "About COMDAT folding during optimized linking", "LinkVerboseICF", 0 },
+  { "ShowProgress", "VERBOSE:REF",
+    "About data removed during optimized linking", "LinkVerboseREF", 0 },
+  { "ShowProgress", "VERBOSE:SAFESEH", "About Modules incompatible with SEH",
+    "LinkVerboseSAFESEH", 0 },
+  { "ShowProgress", "VERBOSE:CLR",
+    "About linker activity related to managed code", "LinkVerboseCLR", 0 },
+
+  { "ForceFileOutput", "FORCE", "Enabled", "Enabled", 0 },
+  { "ForceFileOutput", "FORCE:MULTIPLE", "Multiply Defined Symbol Only",
+    "MultiplyDefinedSymbolOnly", 0 },
+  { "ForceFileOutput", "FORCE:UNRESOLVED", "Undefined Symbol Only",
+    "UndefinedSymbolOnly", 0 },
+
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN", "Enabled", "Enabled", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:5", "X86 Image Only",
+    "X86Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:6", "X64 Image Only",
+    "X64Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:16", "Itanium Image Only",
+    "ItaniumImage", 0 },
+
+  { "UACExecutionLevel", "level='asInvoker'", "asInvoker", "AsInvoker", 0 },
+  { "UACExecutionLevel", "level='highestAvailable'", "highestAvailable",
+    "HighestAvailable", 0 },
+  { "UACExecutionLevel", "level='requireAdministrator'",
+    "requireAdministrator", "RequireAdministrator", 0 },
+
+  { "SubSystem", "", "Not Set", "NotSet", 0 },
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
+
+  { "Driver", "", "Not Set", "NotSet", 0 },
+  { "Driver", "Driver", "Driver", "Driver", 0 },
+  { "Driver", "DRIVER:UPONLY", "UP Only", "UpOnly", 0 },
+  { "Driver", "DRIVER:WDM", "WDM", "WDM", 0 },
+
+  { "LinkTimeCodeGeneration", "", "Default", "Default", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "Use Link Time Code Generation",
+    "UseLinkTimeCodeGeneration", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGInstrument",
+    "Profile Guided Optimization - Instrument", "PGInstrument", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGOptimize",
+    "Profile Guided Optimization - Optimization", "PGOptimization", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGUpdate",
+    "Profile Guided Optimization - Update", "PGUpdate", 0 },
+
+  { "TargetMachine", "", "Not Set", "NotSet", 0 },
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
+
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA", "MTA threading attribute",
+    "MTAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA", "STA threading attribute",
+    "STAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
+    "Default threading attribute", "DefaultThreadingAttribute", 0 },
+
+  { "CLRImageType", "CLRIMAGETYPE:IJW", "Force IJW image", "ForceIJWImage",
+    0 },
+  { "CLRImageType", "CLRIMAGETYPE:PURE", "Force Pure IL Image",
+    "ForcePureILImage", 0 },
+  { "CLRImageType", "CLRIMAGETYPE:SAFE", "Force Safe IL Image",
+    "ForceSafeILImage", 0 },
+  { "CLRImageType", "", "Default image type", "Default", 0 },
+
+  { "LinkErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:NONE", "No Error Report",
+    "NoErrorReport", 0 },
+
+  { "CLRSupportLastError", "CLRSupportLastError", "Enabled", "Enabled", 0 },
+  { "CLRSupportLastError", "CLRSupportLastError:NO", "Disabled", "Disabled",
+    0 },
+  { "CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL", "System Dlls Only",
+    "SystemDlls", 0 },
+
+  // Bool Properties
+  { "LinkIncremental", "INCREMENTAL:NO", "", "false", 0 },
+  { "LinkIncremental", "INCREMENTAL", "", "true", 0 },
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "LinkStatus", "LTCG:NOSTATUS", "", "false", 0 },
+  { "LinkStatus", "LTCG:STATUS", "", "true", 0 },
+  { "PreventDllBinding", "ALLOWBIND:NO", "", "false", 0 },
+  { "PreventDllBinding", "ALLOWBIND", "", "true", 0 },
+  { "TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLinkerWarningAsErrors", "WX", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "GenerateManifest", "MANIFEST:NO", "", "false", 0 },
+  { "GenerateManifest", "MANIFEST", "", "true", 0 },
+  { "AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='false'", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='true'", "", "true", 0 },
+  { "GenerateDebugInformation", "DEBUG", "", "true",
+    cmVS7FlagTable::CaseInsensitive },
+  { "MapExports", "MAPINFO:EXPORTS", "", "true", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0 },
+  { "TerminalServerAware", "TSAWARE:NO", "", "false", 0 },
+  { "TerminalServerAware", "TSAWARE", "", "true", 0 },
+  { "SwapRunFromCD", "SWAPRUN:CD", "", "true", 0 },
+  { "SwapRunFromNET", "SWAPRUN:NET", "", "true", 0 },
+  { "OptimizeReferences", "OPT:NOREF", "", "false", 0 },
+  { "OptimizeReferences", "OPT:REF", "", "true", 0 },
+  { "EnableCOMDATFolding", "OPT:NOICF", "", "false", 0 },
+  { "EnableCOMDATFolding", "OPT:ICF", "", "true", 0 },
+  { "IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0 },
+  { "NoEntryPoint", "NOENTRY", "", "true", 0 },
+  { "SetChecksum", "RELEASE", "", "true", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0 },
+  { "FixedBaseAddress", "FIXED:NO", "", "false", 0 },
+  { "FixedBaseAddress", "FIXED", "", "true", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT", "", "true", 0 },
+  { "TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0 },
+  { "SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0 },
+  { "SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0 },
+  { "Profile", "PROFILE", "", "true", 0 },
+  { "LinkDelaySign", "DELAYSIGN:NO", "", "false", 0 },
+  { "LinkDelaySign", "DELAYSIGN", "", "true", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0 },
+  { "LinkDLL", "DLL", "", "true", 0 },
+
+  // Bool Properties With Argument
+  { "EnableUAC", "MANIFESTUAC:NO", "", "false", 0 },
+  { "EnableUAC", "MANIFESTUAC:", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateMapFile", "MAP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "MapFileName", "MAP:", "Generate Map File", "",
+    cmVS7FlagTable::UserValueRequired },
+
+  // String List Properties
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AddModuleNamesToAssembly", "ASSEMBLYMODULE:",
-   "Add Module to Assembly",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
-   "Embed Managed Resource File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DelayLoadDLLs", "DELAYLOAD:",
-   "Delay Loaded Dlls",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:",
-   "Assembly Link Resource",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-   "Additional Manifest Dependencies",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"Version", "VERSION:",
-   "Version",
-   "", cmVS7FlagTable::UserValue},
-  {"SpecifySectionAttributes", "SECTION:",
-   "Specify Section Attributes",
-   "", cmVS7FlagTable::UserValue},
-  {"MSDOSStubFileName", "STUB:",
-   "MS-DOS Stub File Name",
-   "", cmVS7FlagTable::UserValue},
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AddModuleNamesToAssembly", "ASSEMBLYMODULE:", "Add Module to Assembly",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
+    "Embed Managed Resource File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DelayLoadDLLs", "DELAYLOAD:", "Delay Loaded Dlls", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
+    "Additional Manifest Dependencies", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "Version", "VERSION:", "Version", "", cmVS7FlagTable::UserValue },
+  { "SpecifySectionAttributes", "SECTION:", "Specify Section Attributes", "",
+    cmVS7FlagTable::UserValue },
+  { "MSDOSStubFileName", "STUB:", "MS-DOS Stub File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File",
-   "", cmVS7FlagTable::UserValue},
-  {"ManifestFile", "ManifestFile:",
-   "Manifest File",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDatabaseFile", "PDB:",
-   "Generate Program Database File",
-   "", cmVS7FlagTable::UserValue},
-  {"StripPrivateSymbols", "PDBSTRIPPED:",
-   "Strip Private Symbols",
-   "", cmVS7FlagTable::UserValue},
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File", "",
+    cmVS7FlagTable::UserValue },
+  { "ManifestFile", "ManifestFile:", "Manifest File", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDatabaseFile", "PDB:", "Generate Program Database File", "",
+    cmVS7FlagTable::UserValue },
+  { "StripPrivateSymbols", "PDBSTRIPPED:", "Strip Private Symbols", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MapFileName] - no command line Switch.
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"HeapReserveSize", "HEAP:",
-   "Heap Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "HeapReserveSize", "HEAP:", "Heap Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [HeapCommitSize] - no command line Switch.
-  {"StackReserveSize", "STACK:",
-   "Stack Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "StackReserveSize", "STACK:", "Stack Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [StackCommitSize] - no command line Switch.
-  {"FunctionOrder", "ORDER:@",
-   "Function Order",
-   "", cmVS7FlagTable::UserValue},
-  {"ProfileGuidedDatabase", "PGD:",
-   "Profile Guided Database",
-   "", cmVS7FlagTable::UserValue},
-  {"MidlCommandFile", "MIDL:@",
-   "MIDL Commands",
-   "", cmVS7FlagTable::UserValue},
-  {"MergedIDLBaseFileName", "IDLOUT:",
-   "Merged IDL Base File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"TypeLibraryFile", "TLBOUT:",
-   "Type Library",
-   "", cmVS7FlagTable::UserValue},
-  {"EntryPointSymbol", "ENTRY:",
-   "Entry Point",
-   "", cmVS7FlagTable::UserValue},
-  {"BaseAddress", "BASE:",
-   "Base Address",
-   "", cmVS7FlagTable::UserValue},
-  {"ImportLibrary", "IMPLIB:",
-   "Import Library",
-   "", cmVS7FlagTable::UserValue},
-  {"MergeSections", "MERGE:",
-   "Merge Sections",
-   "", cmVS7FlagTable::UserValue},
-  {"LinkKeyFile", "KEYFILE:",
-   "Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"KeyContainer", "KEYCONTAINER:",
-   "Key Container",
-   "", cmVS7FlagTable::UserValue},
+  { "FunctionOrder", "ORDER:@", "Function Order", "",
+    cmVS7FlagTable::UserValue },
+  { "ProfileGuidedDatabase", "PGD:", "Profile Guided Database", "",
+    cmVS7FlagTable::UserValue },
+  { "MidlCommandFile", "MIDL:@", "MIDL Commands", "",
+    cmVS7FlagTable::UserValue },
+  { "MergedIDLBaseFileName", "IDLOUT:", "Merged IDL Base File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "TypeLibraryFile", "TLBOUT:", "Type Library", "",
+    cmVS7FlagTable::UserValue },
+  { "EntryPointSymbol", "ENTRY:", "Entry Point", "",
+    cmVS7FlagTable::UserValue },
+  { "BaseAddress", "BASE:", "Base Address", "", cmVS7FlagTable::UserValue },
+  { "ImportLibrary", "IMPLIB:", "Import Library", "",
+    cmVS7FlagTable::UserValue },
+  { "MergeSections", "MERGE:", "Merge Sections", "",
+    cmVS7FlagTable::UserValue },
+  { "LinkKeyFile", "KEYFILE:", "Key File", "", cmVS7FlagTable::UserValue },
+  { "KeyContainer", "KEYCONTAINER:", "Key Container", "",
+    cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS10MASMFlagTable.h b/Source/cmVS10MASMFlagTable.h
index 8fb6f33..82e5270 100644
--- a/Source/cmVS10MASMFlagTable.h
+++ b/Source/cmVS10MASMFlagTable.h
@@ -1,96 +1,78 @@
-static cmVS7FlagTable cmVS10MASMFlagTable[] =
-{
+static cmVS7FlagTable cmVS10MASMFlagTable[] = {
 
-  //Enum Properties
-  {"PreserveIdentifierCase", "",
-   "Default", "0", 0},
-  {"PreserveIdentifierCase", "/Cp",
-   "Preserves Identifier Case (/Cp)", "1", 0},
-  {"PreserveIdentifierCase", "/Cu",
-   "Maps all identifiers to upper case. (/Cu)", "2", 0},
-  {"PreserveIdentifierCase", "/Cx",
-   "Preserves case in public and extern symbols. (/Cx)", "3", 0},
+  // Enum Properties
+  { "PreserveIdentifierCase", "", "Default", "0", 0 },
+  { "PreserveIdentifierCase", "/Cp", "Preserves Identifier Case (/Cp)", "1",
+    0 },
+  { "PreserveIdentifierCase", "/Cu",
+    "Maps all identifiers to upper case. (/Cu)", "2", 0 },
+  { "PreserveIdentifierCase", "/Cx",
+    "Preserves case in public and extern symbols. (/Cx)", "3", 0 },
 
-  {"WarningLevel", "/W0",
-   "Warning Level 0 (/W0)", "0", 0},
-  {"WarningLevel", "/W1",
-   "Warning Level 1 (/W1)", "1", 0},
-  {"WarningLevel", "/W2",
-   "Warning Level 2 (/W2)", "2", 0},
-  {"WarningLevel", "/W3",
-   "Warning Level 3 (/W3)", "3", 0},
+  { "WarningLevel", "/W0", "Warning Level 0 (/W0)", "0", 0 },
+  { "WarningLevel", "/W1", "Warning Level 1 (/W1)", "1", 0 },
+  { "WarningLevel", "/W2", "Warning Level 2 (/W2)", "2", 0 },
+  { "WarningLevel", "/W3", "Warning Level 3 (/W3)", "3", 0 },
 
-  {"PackAlignmentBoundary", "",
-   "Default", "0", 0},
-  {"PackAlignmentBoundary", "/Zp1",
-   "One Byte Boundary (/Zp1)", "1", 0},
-  {"PackAlignmentBoundary", "/Zp2",
-   "Two Byte Boundary (/Zp2)", "2", 0},
-  {"PackAlignmentBoundary", "/Zp4",
-   "Four Byte Boundary (/Zp4)", "3", 0},
-  {"PackAlignmentBoundary", "/Zp8",
-   "Eight Byte Boundary (/Zp8)", "4", 0},
-  {"PackAlignmentBoundary", "/Zp16",
-   "Sixteen Byte Boundary (/Zp16)", "5", 0},
+  { "PackAlignmentBoundary", "", "Default", "0", 0 },
+  { "PackAlignmentBoundary", "/Zp1", "One Byte Boundary (/Zp1)", "1", 0 },
+  { "PackAlignmentBoundary", "/Zp2", "Two Byte Boundary (/Zp2)", "2", 0 },
+  { "PackAlignmentBoundary", "/Zp4", "Four Byte Boundary (/Zp4)", "3", 0 },
+  { "PackAlignmentBoundary", "/Zp8", "Eight Byte Boundary (/Zp8)", "4", 0 },
+  { "PackAlignmentBoundary", "/Zp16", "Sixteen Byte Boundary (/Zp16)", "5",
+    0 },
 
-  {"CallingConvention", "",
-   "Default", "0", 0},
-  {"CallingConvention", "/Gd",
-   "Use C-style Calling Convention (/Gd)", "1", 0},
-  {"CallingConvention", "/Gz",
-   "Use stdcall Calling Convention (/Gz)", "2", 0},
-  {"CallingConvention", "/Gc",
-   "Use Pascal Calling Convention (/Gc)", "3", 0},
+  { "CallingConvention", "", "Default", "0", 0 },
+  { "CallingConvention", "/Gd", "Use C-style Calling Convention (/Gd)", "1",
+    0 },
+  { "CallingConvention", "/Gz", "Use stdcall Calling Convention (/Gz)", "2",
+    0 },
+  { "CallingConvention", "/Gc", "Use Pascal Calling Convention (/Gc)", "3",
+    0 },
 
-  {"ErrorReporting", "/errorReport:prompt",
-   "Prompt to send report immediately (/errorReport:prompt)", "0", 0},
-  {"ErrorReporting", "/errorReport:queue",
-   "Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
-  {"ErrorReporting", "/errorReport:send",
-   "Automatically send report (/errorReport:send)", "2", 0},
-  {"ErrorReporting", "/errorReport:none",
-   "Do not send report (/errorReport:none)", "3", 0},
+  { "ErrorReporting", "/errorReport:prompt",
+    "Prompt to send report immediately (/errorReport:prompt)", "0", 0 },
+  { "ErrorReporting", "/errorReport:queue",
+    "Prompt to send report at the next logon (/errorReport:queue)", "1", 0 },
+  { "ErrorReporting", "/errorReport:send",
+    "Automatically send report (/errorReport:send)", "2", 0 },
+  { "ErrorReporting", "/errorReport:none",
+    "Do not send report (/errorReport:none)", "3", 0 },
 
+  // Bool Properties
+  { "NoLogo", "/nologo", "", "true", 0 },
+  { "GeneratePreprocessedSourceListing", "/EP", "", "true", 0 },
+  { "ListAllAvailableInformation", "/Sa", "", "true", 0 },
+  { "UseSafeExceptionHandlers", "/safeseh", "", "true", 0 },
+  { "AddFirstPassListing", "/Sf", "", "true", 0 },
+  { "EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0 },
+  { "DisableSymbolTable", "/Sn", "", "true", 0 },
+  { "EnableFalseConditionalsInListing", "/Sx", "", "true", 0 },
+  { "TreatWarningsAsErrors", "/WX", "", "true", 0 },
+  { "MakeAllSymbolsPublic", "/Zf", "", "true", 0 },
+  { "GenerateDebugInformation", "/Zi", "", "true", 0 },
+  { "EnableMASM51Compatibility", "/Zm", "", "true", 0 },
+  { "PerformSyntaxCheckOnly", "/Zs", "", "true", 0 },
 
-  //Bool Properties
-  {"NoLogo", "/nologo", "", "true", 0},
-  {"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
-  {"ListAllAvailableInformation", "/Sa", "", "true", 0},
-  {"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
-  {"AddFirstPassListing", "/Sf", "", "true", 0},
-  {"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
-  {"DisableSymbolTable", "/Sn", "", "true", 0},
-  {"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
-  {"TreatWarningsAsErrors", "/WX", "", "true", 0},
-  {"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
-  {"GenerateDebugInformation", "/Zi", "", "true", 0},
-  {"EnableMASM51Compatibility", "/Zm", "", "true", 0},
-  {"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
-  {"PreprocessorDefinitions", "/D",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IncludePaths", "/I",
-   "Include Paths",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"BrowseFile", "/FR",
-   "Generate Browse Information File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "PreprocessorDefinitions", "/D", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IncludePaths", "/I", "Include Paths", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "BrowseFile", "/FR", "Generate Browse Information File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
 
-  //String Properties
+  // String Properties
   // Skip [Inputs] - no command line Switch.
-  {"ObjectFileName", "/Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"AssembledCodeListingFile", "/Fl",
-   "Assembled Code Listing File",
-   "", cmVS7FlagTable::UserValue},
+  { "ObjectFileName", "/Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "AssembledCodeListingFile", "/Fl", "Assembled Code Listing File", "",
+    cmVS7FlagTable::UserValue },
   // Skip [CommandLineTemplate] - no command line Switch.
   // Skip [ExecutionDescription] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS10RCFlagTable.h b/Source/cmVS10RCFlagTable.h
index 9049986..32f35e5 100644
--- a/Source/cmVS10RCFlagTable.h
+++ b/Source/cmVS10RCFlagTable.h
@@ -1,7 +1,6 @@
-static cmVS7FlagTable cmVS10RCFlagTable[] =
-{
-  //Bool Properties
-  {"NullTerminateStrings", "n", "", "true", 0},
+static cmVS7FlagTable cmVS10RCFlagTable[] = {
+  // Bool Properties
+  { "NullTerminateStrings", "n", "", "true", 0 },
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS11CLFlagTable.h b/Source/cmVS11CLFlagTable.h
index a61ab16..7531709 100644
--- a/Source/cmVS11CLFlagTable.h
+++ b/Source/cmVS11CLFlagTable.h
@@ -1,288 +1,219 @@
-static cmVS7FlagTable cmVS11CLFlagTable[] =
-{
-
-  //Enum Properties
-  {"DebugInformationFormat", "",
-   "None", "None", 0},
-  {"DebugInformationFormat", "Z7",
-   "C7 compatible", "OldStyle", 0},
-  {"DebugInformationFormat", "Zi",
-   "Program Database", "ProgramDatabase", 0},
-  {"DebugInformationFormat", "ZI",
-   "Program Database for Edit And Continue", "EditAndContinue", 0},
-
-  {"WarningLevel", "W0",
-   "Turn Off All Warnings", "TurnOffAllWarnings", 0},
-  {"WarningLevel", "W1",
-   "Level1", "Level1", 0},
-  {"WarningLevel", "W2",
-   "Level2", "Level2", 0},
-  {"WarningLevel", "W3",
-   "Level3", "Level3", 0},
-  {"WarningLevel", "W4",
-   "Level4", "Level4", 0},
-  {"WarningLevel", "Wall",
-   "EnableAllWarnings", "EnableAllWarnings", 0},
-
-  {"Optimization", "Od",
-   "Disabled", "Disabled", 0},
-  {"Optimization", "O1",
-   "Minimize Size", "MinSpace", 0},
-  {"Optimization", "O2",
-   "Maximize Speed", "MaxSpeed", 0},
-  {"Optimization", "Ox",
-   "Full Optimization", "Full", 0},
-
-  {"InlineFunctionExpansion", "",
-   "Default", "Default", 0},
-  {"InlineFunctionExpansion", "Ob0",
-   "Disabled", "Disabled", 0},
-  {"InlineFunctionExpansion", "Ob1",
-   "Only __inline", "OnlyExplicitInline", 0},
-  {"InlineFunctionExpansion", "Ob2",
-   "Any Suitable", "AnySuitable", 0},
-
-  {"FavorSizeOrSpeed", "Os",
-   "Favor small code", "Size", 0},
-  {"FavorSizeOrSpeed", "Ot",
-   "Favor fast code", "Speed", 0},
-  {"FavorSizeOrSpeed", "",
-   "Neither", "Neither", 0},
-
-  {"ExceptionHandling", "EHa",
-   "Yes with SEH Exceptions", "Async", 0},
-  {"ExceptionHandling", "EHsc",
-   "Yes", "Sync", 0},
-  {"ExceptionHandling", "EHs",
-   "Yes with Extern C functions", "SyncCThrow", 0},
-  {"ExceptionHandling", "",
-   "No", "false", 0},
-
-  {"BasicRuntimeChecks", "RTCs",
-   "Stack Frames", "StackFrameRuntimeCheck", 0},
-  {"BasicRuntimeChecks", "RTCu",
-   "Uninitialized variables", "UninitializedLocalUsageCheck", 0},
-  {"BasicRuntimeChecks", "RTC1",
-   "Both (/RTC1, equiv. to /RTCsu)", "EnableFastChecks", 0},
-  {"BasicRuntimeChecks", "",
-   "Default", "Default", 0},
-
-  {"RuntimeLibrary", "MT",
-   "Multi-threaded", "MultiThreaded", 0},
-  {"RuntimeLibrary", "MTd",
-   "Multi-threaded Debug", "MultiThreadedDebug", 0},
-  {"RuntimeLibrary", "MD",
-   "Multi-threaded DLL", "MultiThreadedDLL", 0},
-  {"RuntimeLibrary", "MDd",
-   "Multi-threaded Debug DLL", "MultiThreadedDebugDLL", 0},
-
-  {"StructMemberAlignment", "Zp1",
-   "1 Byte", "1Byte", 0},
-  {"StructMemberAlignment", "Zp2",
-   "2 Bytes", "2Bytes", 0},
-  {"StructMemberAlignment", "Zp4",
-   "4 Byte", "4Bytes", 0},
-  {"StructMemberAlignment", "Zp8",
-   "8 Bytes", "8Bytes", 0},
-  {"StructMemberAlignment", "Zp16",
-   "16 Bytes", "16Bytes", 0},
-  {"StructMemberAlignment", "",
-   "Default", "Default", 0},
-
-  {"EnableEnhancedInstructionSet", "arch:SSE",
-   "Streaming SIMD Extensions", "StreamingSIMDExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:SSE2",
-   "Streaming SIMD Extensions 2", "StreamingSIMDExtensions2", 0},
-  {"EnableEnhancedInstructionSet", "arch:AVX",
-   "Advanced Vector Extensions", "AdvancedVectorExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:IA32",
-   "No Enhanced Instructions", "NoExtensions", 0},
-  {"EnableEnhancedInstructionSet", "",
-   "Not Set", "NotSet", 0},
-
-  {"FloatingPointModel", "fp:precise",
-   "Precise", "Precise", 0},
-  {"FloatingPointModel", "fp:strict",
-   "Strict", "Strict", 0},
-  {"FloatingPointModel", "fp:fast",
-   "Fast", "Fast", 0},
-
-  {"PrecompiledHeader", "Yc",
-   "Create", "Create",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "Yu",
-   "Use", "Use",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "",
-   "Not Using Precompiled Headers", "NotUsing", 0},
-
-  {"AssemblerOutput", "",
-   "No Listing", "NoListing", 0},
-  {"AssemblerOutput", "FA",
-   "Assembly-Only Listing", "AssemblyCode", 0},
-  {"AssemblerOutput", "FAc",
-   "Assembly With Machine Code", "AssemblyAndMachineCode", 0},
-  {"AssemblerOutput", "FAs",
-   "Assembly With Source Code", "AssemblyAndSourceCode", 0},
-  {"AssemblerOutput", "FAcs",
-   "Assembly, Machine Code and Source", "All", 0},
-
-  {"CallingConvention", "Gd",
-   "__cdecl", "Cdecl", 0},
-  {"CallingConvention", "Gr",
-   "__fastcall", "FastCall", 0},
-  {"CallingConvention", "Gz",
-   "__stdcall", "StdCall", 0},
-
-  {"CompileAs", "",
-   "Default", "Default", 0},
-  {"CompileAs", "TC",
-   "Compile as C Code", "CompileAsC", 0},
-  {"CompileAs", "TP",
-   "Compile as C++ Code", "CompileAsCpp", 0},
-
-  {"ErrorReporting", "errorReport:none",
-   "Do Not Send Report", "None", 0},
-  {"ErrorReporting", "errorReport:prompt",
-   "Prompt Immediately", "Prompt", 0},
-  {"ErrorReporting", "errorReport:queue",
-   "Queue For Next Login", "Queue", 0},
-  {"ErrorReporting", "errorReport:send",
-   "Send Automatically", "Send", 0},
-
-  {"CompileAsManaged", "",
-   "No Common Language RunTime Support", "false", 0},
-  {"CompileAsManaged", "clr",
-   "Common Language RunTime Support", "true", 0},
-  {"CompileAsManaged", "clr:pure",
-   "Pure MSIL Common Language RunTime Support", "Pure", 0},
-  {"CompileAsManaged", "clr:safe",
-   "Safe MSIL Common Language RunTime Support", "Safe", 0},
-  {"CompileAsManaged", "clr:oldSyntax",
-   "Common Language RunTime Support, Old Syntax", "OldSyntax", 0},
-
-
-  //Bool Properties
-  {"CompileAsWinRT", "ZW", "", "true", 0},
-  {"WinRTNoStdLib", "ZW:nostdlib", "", "true", 0},
-  {"SuppressStartupBanner", "nologo-", "", "false", 0},
-  {"SuppressStartupBanner", "nologo", "", "true", 0},
-  {"TreatWarningAsError", "WX-", "", "false", 0},
-  {"TreatWarningAsError", "WX", "", "true", 0},
-  {"SDLCheck", "sdl-", "", "false", 0},
-  {"SDLCheck", "sdl", "", "true", 0},
-  {"IntrinsicFunctions", "Oi", "", "true", 0},
-  {"OmitFramePointers", "Oy-", "", "false", 0},
-  {"OmitFramePointers", "Oy", "", "true", 0},
-  {"EnableFiberSafeOptimizations", "GT", "", "true", 0},
-  {"WholeProgramOptimization", "GL", "", "true", 0},
-  {"UndefineAllPreprocessorDefinitions", "u", "", "true", 0},
-  {"IgnoreStandardIncludePath", "X", "", "true", 0},
-  {"PreprocessToFile", "P", "", "true", 0},
-  {"PreprocessSuppressLineNumbers", "EP", "", "true", 0},
-  {"PreprocessKeepComments", "C", "", "true", 0},
-  {"StringPooling", "GF-", "", "false", 0},
-  {"StringPooling", "GF", "", "true", 0},
-  {"MinimalRebuild", "Gm-", "", "false", 0},
-  {"MinimalRebuild", "Gm", "", "true", 0},
-  {"SmallerTypeCheck", "RTCc", "", "true", 0},
-  {"BufferSecurityCheck", "GS-", "", "false", 0},
-  {"BufferSecurityCheck", "GS", "", "true", 0},
-  {"FunctionLevelLinking", "Gy-", "", "false", 0},
-  {"FunctionLevelLinking", "Gy", "", "true", 0},
-  {"EnableParallelCodeGeneration", "Qpar-", "", "false", 0},
-  {"EnableParallelCodeGeneration", "Qpar", "", "true", 0},
-  {"FloatingPointExceptions", "fp:except-", "", "false", 0},
-  {"FloatingPointExceptions", "fp:except", "", "true", 0},
-  {"CreateHotpatchableImage", "hotpatch", "", "true", 0},
-  {"DisableLanguageExtensions", "Za", "", "true", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0},
-  {"RuntimeTypeInfo", "GR-", "", "false", 0},
-  {"RuntimeTypeInfo", "GR", "", "true", 0},
-  {"OpenMPSupport", "openmp-", "", "false", 0},
-  {"OpenMPSupport", "openmp", "", "true", 0},
-  {"ExpandAttributedSource", "Fx", "", "true", 0},
-  {"UseUnicodeForAssemblerListing", "FAu", "", "true", 0},
-  {"ShowIncludes", "showIncludes", "", "true", 0},
-  {"EnablePREfast", "analyze-", "", "false", 0},
-  {"EnablePREfast", "analyze", "", "true", 0},
-  {"UseFullPaths", "FC", "", "true", 0},
-  {"OmitDefaultLibName", "Zl", "", "true", 0},
-
-  //Bool Properties With Argument
-  {"MultiProcessorCompilation", "MP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"ProcessorNumber", "MP", "Multi-processor Compilation", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateXMLDocumentationFiles", "doc", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"BrowseInformation", "FR", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"BrowseInformationFile", "FR", "Enable Browse Information", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalIncludeDirectories", "I",
-   "Additional Include Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalUsingDirectories", "AI",
-   "Additional #using Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PreprocessorDefinitions", "D ",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"UndefinePreprocessorDefinitions", "U",
-   "Undefine Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DisableSpecificWarnings", "wd",
-   "Disable Specific Warnings",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedIncludeFiles", "FI",
-   "Forced Include File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedUsingFiles", "FU",
-   "Forced #using File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PREfastLog", "analyze:log",
-   "Code Analysis Log",
-   "", cmVS7FlagTable::UserFollowing},
-  {"PREfastAdditionalPlugins", "analyze:plugin",
-   "Additional Code Analysis Native plugins",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"TreatSpecificWarningsAsErrors", "we",
-   "Treat Specific Warnings As Errors",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-
-  //String Properties
+static cmVS7FlagTable cmVS11CLFlagTable[] = {
+
+  // Enum Properties
+  { "DebugInformationFormat", "", "None", "None", 0 },
+  { "DebugInformationFormat", "Z7", "C7 compatible", "OldStyle", 0 },
+  { "DebugInformationFormat", "Zi", "Program Database", "ProgramDatabase", 0 },
+  { "DebugInformationFormat", "ZI", "Program Database for Edit And Continue",
+    "EditAndContinue", 0 },
+
+  { "WarningLevel", "W0", "Turn Off All Warnings", "TurnOffAllWarnings", 0 },
+  { "WarningLevel", "W1", "Level1", "Level1", 0 },
+  { "WarningLevel", "W2", "Level2", "Level2", 0 },
+  { "WarningLevel", "W3", "Level3", "Level3", 0 },
+  { "WarningLevel", "W4", "Level4", "Level4", 0 },
+  { "WarningLevel", "Wall", "EnableAllWarnings", "EnableAllWarnings", 0 },
+
+  { "Optimization", "Od", "Disabled", "Disabled", 0 },
+  { "Optimization", "O1", "Minimize Size", "MinSpace", 0 },
+  { "Optimization", "O2", "Maximize Speed", "MaxSpeed", 0 },
+  { "Optimization", "Ox", "Full Optimization", "Full", 0 },
+
+  { "InlineFunctionExpansion", "", "Default", "Default", 0 },
+  { "InlineFunctionExpansion", "Ob0", "Disabled", "Disabled", 0 },
+  { "InlineFunctionExpansion", "Ob1", "Only __inline", "OnlyExplicitInline",
+    0 },
+  { "InlineFunctionExpansion", "Ob2", "Any Suitable", "AnySuitable", 0 },
+
+  { "FavorSizeOrSpeed", "Os", "Favor small code", "Size", 0 },
+  { "FavorSizeOrSpeed", "Ot", "Favor fast code", "Speed", 0 },
+  { "FavorSizeOrSpeed", "", "Neither", "Neither", 0 },
+
+  { "ExceptionHandling", "EHa", "Yes with SEH Exceptions", "Async", 0 },
+  { "ExceptionHandling", "EHsc", "Yes", "Sync", 0 },
+  { "ExceptionHandling", "EHs", "Yes with Extern C functions", "SyncCThrow",
+    0 },
+  { "ExceptionHandling", "", "No", "false", 0 },
+
+  { "BasicRuntimeChecks", "RTCs", "Stack Frames", "StackFrameRuntimeCheck",
+    0 },
+  { "BasicRuntimeChecks", "RTCu", "Uninitialized variables",
+    "UninitializedLocalUsageCheck", 0 },
+  { "BasicRuntimeChecks", "RTC1", "Both (/RTC1, equiv. to /RTCsu)",
+    "EnableFastChecks", 0 },
+  { "BasicRuntimeChecks", "", "Default", "Default", 0 },
+
+  { "RuntimeLibrary", "MT", "Multi-threaded", "MultiThreaded", 0 },
+  { "RuntimeLibrary", "MTd", "Multi-threaded Debug", "MultiThreadedDebug", 0 },
+  { "RuntimeLibrary", "MD", "Multi-threaded DLL", "MultiThreadedDLL", 0 },
+  { "RuntimeLibrary", "MDd", "Multi-threaded Debug DLL",
+    "MultiThreadedDebugDLL", 0 },
+
+  { "StructMemberAlignment", "Zp1", "1 Byte", "1Byte", 0 },
+  { "StructMemberAlignment", "Zp2", "2 Bytes", "2Bytes", 0 },
+  { "StructMemberAlignment", "Zp4", "4 Byte", "4Bytes", 0 },
+  { "StructMemberAlignment", "Zp8", "8 Bytes", "8Bytes", 0 },
+  { "StructMemberAlignment", "Zp16", "16 Bytes", "16Bytes", 0 },
+  { "StructMemberAlignment", "", "Default", "Default", 0 },
+
+  { "EnableEnhancedInstructionSet", "arch:SSE", "Streaming SIMD Extensions",
+    "StreamingSIMDExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:SSE2", "Streaming SIMD Extensions 2",
+    "StreamingSIMDExtensions2", 0 },
+  { "EnableEnhancedInstructionSet", "arch:AVX", "Advanced Vector Extensions",
+    "AdvancedVectorExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:IA32", "No Enhanced Instructions",
+    "NoExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "", "Not Set", "NotSet", 0 },
+
+  { "FloatingPointModel", "fp:precise", "Precise", "Precise", 0 },
+  { "FloatingPointModel", "fp:strict", "Strict", "Strict", 0 },
+  { "FloatingPointModel", "fp:fast", "Fast", "Fast", 0 },
+
+  { "PrecompiledHeader", "Yc", "Create", "Create",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "Yu", "Use", "Use",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "", "Not Using Precompiled Headers", "NotUsing", 0 },
+
+  { "AssemblerOutput", "", "No Listing", "NoListing", 0 },
+  { "AssemblerOutput", "FA", "Assembly-Only Listing", "AssemblyCode", 0 },
+  { "AssemblerOutput", "FAc", "Assembly With Machine Code",
+    "AssemblyAndMachineCode", 0 },
+  { "AssemblerOutput", "FAs", "Assembly With Source Code",
+    "AssemblyAndSourceCode", 0 },
+  { "AssemblerOutput", "FAcs", "Assembly, Machine Code and Source", "All", 0 },
+
+  { "CallingConvention", "Gd", "__cdecl", "Cdecl", 0 },
+  { "CallingConvention", "Gr", "__fastcall", "FastCall", 0 },
+  { "CallingConvention", "Gz", "__stdcall", "StdCall", 0 },
+
+  { "CompileAs", "", "Default", "Default", 0 },
+  { "CompileAs", "TC", "Compile as C Code", "CompileAsC", 0 },
+  { "CompileAs", "TP", "Compile as C++ Code", "CompileAsCpp", 0 },
+
+  { "ErrorReporting", "errorReport:none", "Do Not Send Report", "None", 0 },
+  { "ErrorReporting", "errorReport:prompt", "Prompt Immediately", "Prompt",
+    0 },
+  { "ErrorReporting", "errorReport:queue", "Queue For Next Login", "Queue",
+    0 },
+  { "ErrorReporting", "errorReport:send", "Send Automatically", "Send", 0 },
+
+  { "CompileAsManaged", "", "No Common Language RunTime Support", "false", 0 },
+  { "CompileAsManaged", "clr", "Common Language RunTime Support", "true", 0 },
+  { "CompileAsManaged", "clr:pure",
+    "Pure MSIL Common Language RunTime Support", "Pure", 0 },
+  { "CompileAsManaged", "clr:safe",
+    "Safe MSIL Common Language RunTime Support", "Safe", 0 },
+  { "CompileAsManaged", "clr:oldSyntax",
+    "Common Language RunTime Support, Old Syntax", "OldSyntax", 0 },
+
+  // Bool Properties
+  { "CompileAsWinRT", "ZW", "", "true", 0 },
+  { "WinRTNoStdLib", "ZW:nostdlib", "", "true", 0 },
+  { "SuppressStartupBanner", "nologo-", "", "false", 0 },
+  { "SuppressStartupBanner", "nologo", "", "true", 0 },
+  { "TreatWarningAsError", "WX-", "", "false", 0 },
+  { "TreatWarningAsError", "WX", "", "true", 0 },
+  { "SDLCheck", "sdl-", "", "false", 0 },
+  { "SDLCheck", "sdl", "", "true", 0 },
+  { "IntrinsicFunctions", "Oi", "", "true", 0 },
+  { "OmitFramePointers", "Oy-", "", "false", 0 },
+  { "OmitFramePointers", "Oy", "", "true", 0 },
+  { "EnableFiberSafeOptimizations", "GT", "", "true", 0 },
+  { "WholeProgramOptimization", "GL", "", "true", 0 },
+  { "UndefineAllPreprocessorDefinitions", "u", "", "true", 0 },
+  { "IgnoreStandardIncludePath", "X", "", "true", 0 },
+  { "PreprocessToFile", "P", "", "true", 0 },
+  { "PreprocessSuppressLineNumbers", "EP", "", "true", 0 },
+  { "PreprocessKeepComments", "C", "", "true", 0 },
+  { "StringPooling", "GF-", "", "false", 0 },
+  { "StringPooling", "GF", "", "true", 0 },
+  { "MinimalRebuild", "Gm-", "", "false", 0 },
+  { "MinimalRebuild", "Gm", "", "true", 0 },
+  { "SmallerTypeCheck", "RTCc", "", "true", 0 },
+  { "BufferSecurityCheck", "GS-", "", "false", 0 },
+  { "BufferSecurityCheck", "GS", "", "true", 0 },
+  { "FunctionLevelLinking", "Gy-", "", "false", 0 },
+  { "FunctionLevelLinking", "Gy", "", "true", 0 },
+  { "EnableParallelCodeGeneration", "Qpar-", "", "false", 0 },
+  { "EnableParallelCodeGeneration", "Qpar", "", "true", 0 },
+  { "FloatingPointExceptions", "fp:except-", "", "false", 0 },
+  { "FloatingPointExceptions", "fp:except", "", "true", 0 },
+  { "CreateHotpatchableImage", "hotpatch", "", "true", 0 },
+  { "DisableLanguageExtensions", "Za", "", "true", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0 },
+  { "RuntimeTypeInfo", "GR-", "", "false", 0 },
+  { "RuntimeTypeInfo", "GR", "", "true", 0 },
+  { "OpenMPSupport", "openmp-", "", "false", 0 },
+  { "OpenMPSupport", "openmp", "", "true", 0 },
+  { "ExpandAttributedSource", "Fx", "", "true", 0 },
+  { "UseUnicodeForAssemblerListing", "FAu", "", "true", 0 },
+  { "ShowIncludes", "showIncludes", "", "true", 0 },
+  { "EnablePREfast", "analyze-", "", "false", 0 },
+  { "EnablePREfast", "analyze", "", "true", 0 },
+  { "UseFullPaths", "FC", "", "true", 0 },
+  { "OmitDefaultLibName", "Zl", "", "true", 0 },
+
+  // Bool Properties With Argument
+  { "MultiProcessorCompilation", "MP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "ProcessorNumber", "MP", "Multi-processor Compilation", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateXMLDocumentationFiles", "doc", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "BrowseInformation", "FR", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "BrowseInformationFile", "FR", "Enable Browse Information", "",
+    cmVS7FlagTable::UserValueRequired },
+
+  // String List Properties
+  { "AdditionalIncludeDirectories", "I", "Additional Include Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalUsingDirectories", "AI", "Additional #using Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PreprocessorDefinitions", "D ", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "UndefinePreprocessorDefinitions", "U",
+    "Undefine Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DisableSpecificWarnings", "wd", "Disable Specific Warnings", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedIncludeFiles", "FI", "Forced Include File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedUsingFiles", "FU", "Forced #using File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PREfastLog", "analyze:log", "Code Analysis Log", "",
+    cmVS7FlagTable::UserFollowing },
+  { "PREfastAdditionalPlugins", "analyze:plugin",
+    "Additional Code Analysis Native plugins", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "TreatSpecificWarningsAsErrors", "we", "Treat Specific Warnings As Errors",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+
+  // String Properties
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"PreprocessOutputPath", "Fi",
-   "Preprocess Output Path",
-   "", cmVS7FlagTable::UserValue},
-  {"PrecompiledHeaderFile", "Yc",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderFile", "Yu",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderOutputFile", "Fp",
-   "Precompiled Header Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"AssemblerListingLocation", "Fa",
-   "ASM List Location",
-   "", cmVS7FlagTable::UserValue},
-  {"ObjectFileName", "Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDataBaseFileName", "Fd",
-   "Program Database File Name",
-   "", cmVS7FlagTable::UserValue},
+  { "PreprocessOutputPath", "Fi", "Preprocess Output Path", "",
+    cmVS7FlagTable::UserValue },
+  { "PrecompiledHeaderFile", "Yc", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderFile", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderOutputFile", "Fp", "Precompiled Header Output File", "",
+    cmVS7FlagTable::UserValue },
+  { "AssemblerListingLocation", "Fa", "ASM List Location", "",
+    cmVS7FlagTable::UserValue },
+  { "ObjectFileName", "Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDataBaseFileName", "Fd", "Program Database File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [XMLDocumentationFileName] - no command line Switch.
   // Skip [BrowseInformationFile] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS11LibFlagTable.h b/Source/cmVS11LibFlagTable.h
index 9429442..8aacaac 100644
--- a/Source/cmVS11LibFlagTable.h
+++ b/Source/cmVS11LibFlagTable.h
@@ -1,102 +1,76 @@
-static cmVS7FlagTable cmVS11LibFlagTable[] =
-{
+static cmVS7FlagTable cmVS11LibFlagTable[] = {
 
-  //Enum Properties
-  {"ErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"ErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"ErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"ErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  // Enum Properties
+  { "ErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "ErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "ErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "ErrorReporting", "ERRORREPORT:NONE", "No Error Report", "NoErrorReport",
+    0 },
 
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWSCE",
-   "WindowsCE", "WindowsCE", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
+  // Bool Properties
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "TreatLibWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLibWarningAsErrors", "WX", "", "true", 0 },
+  { "Verbose", "VERBOSE", "", "true", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "", "true", 0 },
 
-  //Bool Properties
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"TreatLibWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLibWarningAsErrors", "WX", "", "true", 0},
-  {"Verbose", "VERBOSE", "", "true", 0},
-  {"LinkTimeCodeGeneration", "LTCG", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
+  // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ExportNamedFunctions", "EXPORT:",
-   "Export Named Functions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"RemoveObjects", "REMOVE:",
-   "Remove Objects",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "RemoveObjects", "REMOVE:", "Remove Objects", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue},
-  {"DisplayLibrary", "LIST:",
-   "Display Library to standard output",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue },
+  { "DisplayLibrary", "LIST:", "Display Library to standard output", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"Name", "NAME:",
-   "Name",
-   "", cmVS7FlagTable::UserValue},
+  { "Name", "NAME:", "Name", "", cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS11LinkFlagTable.h b/Source/cmVS11LinkFlagTable.h
index 2d6f6c0..1b3a046 100644
--- a/Source/cmVS11LinkFlagTable.h
+++ b/Source/cmVS11LinkFlagTable.h
@@ -1,341 +1,269 @@
-static cmVS7FlagTable cmVS11LinkFlagTable[] =
-{
+static cmVS7FlagTable cmVS11LinkFlagTable[] = {
 
-  //Enum Properties
-  {"ShowProgress", "",
-   "Not Set", "NotSet", 0},
-  {"ShowProgress", "VERBOSE",
-   "Display all progress messages", "LinkVerbose", 0},
-  {"ShowProgress", "VERBOSE:Lib",
-   "For Libraries Searched", "LinkVerboseLib", 0},
-  {"ShowProgress", "VERBOSE:ICF",
-   "About COMDAT folding during optimized linking", "LinkVerboseICF", 0},
-  {"ShowProgress", "VERBOSE:REF",
-   "About data removed during optimized linking", "LinkVerboseREF", 0},
-  {"ShowProgress", "VERBOSE:SAFESEH",
-   "About Modules incompatible with SEH", "LinkVerboseSAFESEH", 0},
-  {"ShowProgress", "VERBOSE:CLR",
-   "About linker activity related to managed code", "LinkVerboseCLR", 0},
+  // Enum Properties
+  { "ShowProgress", "", "Not Set", "NotSet", 0 },
+  { "ShowProgress", "VERBOSE", "Display all progress messages", "LinkVerbose",
+    0 },
+  { "ShowProgress", "VERBOSE:Lib", "For Libraries Searched", "LinkVerboseLib",
+    0 },
+  { "ShowProgress", "VERBOSE:ICF",
+    "About COMDAT folding during optimized linking", "LinkVerboseICF", 0 },
+  { "ShowProgress", "VERBOSE:REF",
+    "About data removed during optimized linking", "LinkVerboseREF", 0 },
+  { "ShowProgress", "VERBOSE:SAFESEH", "About Modules incompatible with SEH",
+    "LinkVerboseSAFESEH", 0 },
+  { "ShowProgress", "VERBOSE:CLR",
+    "About linker activity related to managed code", "LinkVerboseCLR", 0 },
 
-  {"ForceFileOutput", "FORCE",
-   "Enabled", "Enabled", 0},
-  {"ForceFileOutput", "FORCE:MULTIPLE",
-   "Multiply Defined Symbol Only", "MultiplyDefinedSymbolOnly", 0},
-  {"ForceFileOutput", "FORCE:UNRESOLVED",
-   "Undefined Symbol Only", "UndefinedSymbolOnly", 0},
+  { "ForceFileOutput", "FORCE", "Enabled", "Enabled", 0 },
+  { "ForceFileOutput", "FORCE:MULTIPLE", "Multiply Defined Symbol Only",
+    "MultiplyDefinedSymbolOnly", 0 },
+  { "ForceFileOutput", "FORCE:UNRESOLVED", "Undefined Symbol Only",
+    "UndefinedSymbolOnly", 0 },
 
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN",
-   "Enabled", "Enabled", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:5",
-   "X86 Image Only", "X86Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:6",
-   "X64 Image Only", "X64Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:16",
-   "Itanium Image Only", "ItaniumImage", 0},
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN", "Enabled", "Enabled", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:5", "X86 Image Only",
+    "X86Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:6", "X64 Image Only",
+    "X64Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:16", "Itanium Image Only",
+    "ItaniumImage", 0 },
 
-  {"UACExecutionLevel", "level='asInvoker'",
-   "asInvoker", "AsInvoker", 0},
-  {"UACExecutionLevel", "level='highestAvailable'",
-   "highestAvailable", "HighestAvailable", 0},
-  {"UACExecutionLevel", "level='requireAdministrator'",
-   "requireAdministrator", "RequireAdministrator", 0},
+  { "UACExecutionLevel", "level='asInvoker'", "asInvoker", "AsInvoker", 0 },
+  { "UACExecutionLevel", "level='highestAvailable'", "highestAvailable",
+    "HighestAvailable", 0 },
+  { "UACExecutionLevel", "level='requireAdministrator'",
+    "requireAdministrator", "RequireAdministrator", 0 },
 
-  {"SubSystem", "",
-   "Not Set", "NotSet", 0},
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "", "Not Set", "NotSet", 0 },
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
-  {"Driver", "",
-   "Not Set", "NotSet", 0},
-  {"Driver", "Driver",
-   "Driver", "Driver", 0},
-  {"Driver", "DRIVER:UPONLY",
-   "UP Only", "UpOnly", 0},
-  {"Driver", "DRIVER:WDM",
-   "WDM", "WDM", 0},
+  { "Driver", "", "Not Set", "NotSet", 0 },
+  { "Driver", "Driver", "Driver", "Driver", 0 },
+  { "Driver", "DRIVER:UPONLY", "UP Only", "UpOnly", 0 },
+  { "Driver", "DRIVER:WDM", "WDM", "WDM", 0 },
 
-  {"LinkTimeCodeGeneration", "",
-   "Default", "Default", 0},
-  {"LinkTimeCodeGeneration", "LTCG",
-   "Use Link Time Code Generation", "UseLinkTimeCodeGeneration", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGInstrument",
-   "Profile Guided Optimization - Instrument", "PGInstrument", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGOptimize",
-   "Profile Guided Optimization - Optimization", "PGOptimization", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGUpdate",
-   "Profile Guided Optimization - Update", "PGUpdate", 0},
+  { "LinkTimeCodeGeneration", "", "Default", "Default", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "Use Link Time Code Generation",
+    "UseLinkTimeCodeGeneration", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGInstrument",
+    "Profile Guided Optimization - Instrument", "PGInstrument", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGOptimize",
+    "Profile Guided Optimization - Optimization", "PGOptimization", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGUpdate",
+    "Profile Guided Optimization - Update", "PGUpdate", 0 },
 
-  {"GenerateWindowsMetadata", "WINMD",
-   "Yes", "true", 0},
-  {"GenerateWindowsMetadata", "WINMD:NO",
-   "No", "false", 0},
+  { "GenerateWindowsMetadata", "WINMD", "Yes", "true", 0 },
+  { "GenerateWindowsMetadata", "WINMD:NO", "No", "false", 0 },
 
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA1",
-   "SHA1", "SHA1", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA256",
-   "SHA256", "SHA256", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA384",
-   "SHA384", "SHA384", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA512",
-   "SHA512", "SHA512", 0},
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA1", "SHA1", "SHA1", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA256", "SHA256", "SHA256", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA384", "SHA384", "SHA384", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA512", "SHA512", "SHA512", 0 },
 
-  {"TargetMachine", "",
-   "Not Set", "NotSet", 0},
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "", "Not Set", "NotSet", 0 },
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA",
-   "MTA threading attribute", "MTAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA",
-   "STA threading attribute", "STAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
-   "Default threading attribute", "DefaultThreadingAttribute", 0},
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA", "MTA threading attribute",
+    "MTAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA", "STA threading attribute",
+    "STAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
+    "Default threading attribute", "DefaultThreadingAttribute", 0 },
 
-  {"CLRImageType", "CLRIMAGETYPE:IJW",
-   "Force IJW image", "ForceIJWImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:PURE",
-   "Force Pure IL Image", "ForcePureILImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:SAFE",
-   "Force Safe IL Image", "ForceSafeILImage", 0},
-  {"CLRImageType", "",
-   "Default image type", "Default", 0},
+  { "CLRImageType", "CLRIMAGETYPE:IJW", "Force IJW image", "ForceIJWImage",
+    0 },
+  { "CLRImageType", "CLRIMAGETYPE:PURE", "Force Pure IL Image",
+    "ForcePureILImage", 0 },
+  { "CLRImageType", "CLRIMAGETYPE:SAFE", "Force Safe IL Image",
+    "ForceSafeILImage", 0 },
+  { "CLRImageType", "", "Default image type", "Default", 0 },
 
-  {"SignHash", "CLRSIGNHASH:SHA1",
-   "SHA1", "SHA1", 0},
-  {"SignHash", "CLRSIGNHASH:SHA256",
-   "SHA256", "SHA256", 0},
-  {"SignHash", "CLRSIGNHASH:SHA384",
-   "SHA384", "SHA384", 0},
-  {"SignHash", "CLRSIGNHASH:SHA512",
-   "SHA512", "SHA512", 0},
+  { "SignHash", "CLRSIGNHASH:SHA1", "SHA1", "SHA1", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA256", "SHA256", "SHA256", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA384", "SHA384", "SHA384", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA512", "SHA512", "SHA512", 0 },
 
-  {"LinkErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"LinkErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"LinkErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"LinkErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  { "LinkErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:NONE", "No Error Report",
+    "NoErrorReport", 0 },
 
-  {"CLRSupportLastError", "CLRSupportLastError",
-   "Enabled", "Enabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:NO",
-   "Disabled", "Disabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL",
-   "System Dlls Only", "SystemDlls", 0},
+  { "CLRSupportLastError", "CLRSupportLastError", "Enabled", "Enabled", 0 },
+  { "CLRSupportLastError", "CLRSupportLastError:NO", "Disabled", "Disabled",
+    0 },
+  { "CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL", "System Dlls Only",
+    "SystemDlls", 0 },
 
+  // Bool Properties
+  { "LinkIncremental", "INCREMENTAL:NO", "", "false", 0 },
+  { "LinkIncremental", "INCREMENTAL", "", "true", 0 },
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "LinkStatus", "LTCG:NOSTATUS", "", "false", 0 },
+  { "LinkStatus", "LTCG:STATUS", "", "true", 0 },
+  { "PreventDllBinding", "ALLOWBIND:NO", "", "false", 0 },
+  { "PreventDllBinding", "ALLOWBIND", "", "true", 0 },
+  { "TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLinkerWarningAsErrors", "WX", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "GenerateManifest", "MANIFEST:NO", "", "false", 0 },
+  { "GenerateManifest", "MANIFEST", "", "true", 0 },
+  { "AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='false'", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='true'", "", "true", 0 },
+  { "ManifestEmbed", "manifest:embed", "", "true", 0 },
+  { "GenerateDebugInformation", "DEBUG", "", "true",
+    cmVS7FlagTable::CaseInsensitive },
+  { "MapExports", "MAPINFO:EXPORTS", "", "true", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0 },
+  { "TerminalServerAware", "TSAWARE:NO", "", "false", 0 },
+  { "TerminalServerAware", "TSAWARE", "", "true", 0 },
+  { "SwapRunFromCD", "SWAPRUN:CD", "", "true", 0 },
+  { "SwapRunFromNET", "SWAPRUN:NET", "", "true", 0 },
+  { "OptimizeReferences", "OPT:NOREF", "", "false", 0 },
+  { "OptimizeReferences", "OPT:REF", "", "true", 0 },
+  { "EnableCOMDATFolding", "OPT:NOICF", "", "false", 0 },
+  { "EnableCOMDATFolding", "OPT:ICF", "", "true", 0 },
+  { "IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0 },
+  { "AppContainer", "APPCONTAINER", "", "true", 0 },
+  { "WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN:NO", "", "false", 0 },
+  { "WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN", "", "true", 0 },
+  { "NoEntryPoint", "NOENTRY", "", "true", 0 },
+  { "SetChecksum", "RELEASE", "", "true", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0 },
+  { "FixedBaseAddress", "FIXED:NO", "", "false", 0 },
+  { "FixedBaseAddress", "FIXED", "", "true", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT", "", "true", 0 },
+  { "TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0 },
+  { "SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0 },
+  { "SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0 },
+  { "Profile", "PROFILE", "", "true", 0 },
+  { "LinkDelaySign", "DELAYSIGN:NO", "", "false", 0 },
+  { "LinkDelaySign", "DELAYSIGN", "", "true", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0 },
+  { "DetectOneDefinitionRule", "ODR", "", "true", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0 },
+  { "LinkDLL", "DLL", "", "true", 0 },
 
-  //Bool Properties
-  {"LinkIncremental", "INCREMENTAL:NO", "", "false", 0},
-  {"LinkIncremental", "INCREMENTAL", "", "true", 0},
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"LinkStatus", "LTCG:NOSTATUS", "", "false", 0},
-  {"LinkStatus", "LTCG:STATUS", "", "true", 0},
-  {"PreventDllBinding", "ALLOWBIND:NO", "", "false", 0},
-  {"PreventDllBinding", "ALLOWBIND", "", "true", 0},
-  {"TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLinkerWarningAsErrors", "WX", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"GenerateManifest", "MANIFEST:NO", "", "false", 0},
-  {"GenerateManifest", "MANIFEST", "", "true", 0},
-  {"AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0},
-  {"UACUIAccess", "uiAccess='false'", "", "false", 0},
-  {"UACUIAccess", "uiAccess='true'", "", "true", 0},
-  {"ManifestEmbed", "manifest:embed", "", "true", 0},
-  {"GenerateDebugInformation", "DEBUG", "", "true",
-   cmVS7FlagTable::CaseInsensitive},
-  {"MapExports", "MAPINFO:EXPORTS", "", "true", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0},
-  {"TerminalServerAware", "TSAWARE:NO", "", "false", 0},
-  {"TerminalServerAware", "TSAWARE", "", "true", 0},
-  {"SwapRunFromCD", "SWAPRUN:CD", "", "true", 0},
-  {"SwapRunFromNET", "SWAPRUN:NET", "", "true", 0},
-  {"OptimizeReferences", "OPT:NOREF", "", "false", 0},
-  {"OptimizeReferences", "OPT:REF", "", "true", 0},
-  {"EnableCOMDATFolding", "OPT:NOICF", "", "false", 0},
-  {"EnableCOMDATFolding", "OPT:ICF", "", "true", 0},
-  {"IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0},
-  {"AppContainer", "APPCONTAINER", "", "true", 0},
-  {"WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN:NO", "", "false", 0},
-  {"WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN", "", "true", 0},
-  {"NoEntryPoint", "NOENTRY", "", "true", 0},
-  {"SetChecksum", "RELEASE", "", "true", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0},
-  {"FixedBaseAddress", "FIXED:NO", "", "false", 0},
-  {"FixedBaseAddress", "FIXED", "", "true", 0},
-  {"DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0},
-  {"DataExecutionPrevention", "NXCOMPAT", "", "true", 0},
-  {"TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0},
-  {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0},
-  {"SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0},
-  {"Profile", "PROFILE", "", "true", 0},
-  {"LinkDelaySign", "DELAYSIGN:NO", "", "false", 0},
-  {"LinkDelaySign", "DELAYSIGN", "", "true", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0},
-  {"DetectOneDefinitionRule", "ODR", "", "true", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0},
-  {"LinkDLL", "DLL", "", "true", 0},
+  // Bool Properties With Argument
+  { "EnableUAC", "MANIFESTUAC:NO", "", "false", 0 },
+  { "EnableUAC", "MANIFESTUAC:", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateMapFile", "MAP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "MapFileName", "MAP:", "Generate Map File", "",
+    cmVS7FlagTable::UserValueRequired },
 
-  //Bool Properties With Argument
-  {"EnableUAC", "MANIFESTUAC:NO", "", "false", 0},
-  {"EnableUAC", "MANIFESTUAC:", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateMapFile", "MAP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"MapFileName", "MAP:", "Generate Map File", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AddModuleNamesToAssembly", "ASSEMBLYMODULE:",
-   "Add Module to Assembly",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
-   "Embed Managed Resource File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DelayLoadDLLs", "DELAYLOAD:",
-   "Delay Loaded Dlls",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:",
-   "Assembly Link Resource",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-   "Additional Manifest Dependencies",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ManifestInput", "manifestinput:",
-   "Manifest Input",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AddModuleNamesToAssembly", "ASSEMBLYMODULE:", "Add Module to Assembly",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
+    "Embed Managed Resource File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DelayLoadDLLs", "DELAYLOAD:", "Delay Loaded Dlls", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
+    "Additional Manifest Dependencies", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ManifestInput", "manifestinput:", "Manifest Input", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"Version", "VERSION:",
-   "Version",
-   "", cmVS7FlagTable::UserValue},
-  {"SpecifySectionAttributes", "SECTION:",
-   "Specify Section Attributes",
-   "", cmVS7FlagTable::UserValue},
-  {"MSDOSStubFileName", "STUB:",
-   "MS-DOS Stub File Name",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "Version", "VERSION:", "Version", "", cmVS7FlagTable::UserValue },
+  { "SpecifySectionAttributes", "SECTION:", "Specify Section Attributes", "",
+    cmVS7FlagTable::UserValue },
+  { "MSDOSStubFileName", "STUB:", "MS-DOS Stub File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File",
-   "", cmVS7FlagTable::UserValue},
-  {"ManifestFile", "ManifestFile:",
-   "Manifest File",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDatabaseFile", "PDB:",
-   "Generate Program Database File",
-   "", cmVS7FlagTable::UserValue},
-  {"StripPrivateSymbols", "PDBSTRIPPED:",
-   "Strip Private Symbols",
-   "", cmVS7FlagTable::UserValue},
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File", "",
+    cmVS7FlagTable::UserValue },
+  { "ManifestFile", "ManifestFile:", "Manifest File", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDatabaseFile", "PDB:", "Generate Program Database File", "",
+    cmVS7FlagTable::UserValue },
+  { "StripPrivateSymbols", "PDBSTRIPPED:", "Strip Private Symbols", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MapFileName] - no command line Switch.
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"HeapReserveSize", "HEAP:",
-   "Heap Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "HeapReserveSize", "HEAP:", "Heap Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [HeapCommitSize] - no command line Switch.
-  {"StackReserveSize", "STACK:",
-   "Stack Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "StackReserveSize", "STACK:", "Stack Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [StackCommitSize] - no command line Switch.
-  {"FunctionOrder", "ORDER:@",
-   "Function Order",
-   "", cmVS7FlagTable::UserValue},
-  {"ProfileGuidedDatabase", "PGD:",
-   "Profile Guided Database",
-   "", cmVS7FlagTable::UserValue},
-  {"MidlCommandFile", "MIDL:@",
-   "MIDL Commands",
-   "", cmVS7FlagTable::UserValue},
-  {"MergedIDLBaseFileName", "IDLOUT:",
-   "Merged IDL Base File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"TypeLibraryFile", "TLBOUT:",
-   "Type Library",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataFile", "WINMDFILE:",
-   "Windows Metadata File",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataLinkKeyFile", "WINMDKEYFILE:",
-   "Windows Metadata Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataKeyContainer", "WINMDKEYCONTAINER:",
-   "Windows Metadata Key Container",
-   "", cmVS7FlagTable::UserValue},
-  {"EntryPointSymbol", "ENTRY:",
-   "Entry Point",
-   "", cmVS7FlagTable::UserValue},
-  {"BaseAddress", "BASE:",
-   "Base Address",
-   "", cmVS7FlagTable::UserValue},
-  {"ImportLibrary", "IMPLIB:",
-   "Import Library",
-   "", cmVS7FlagTable::UserValue},
-  {"MergeSections", "MERGE:",
-   "Merge Sections",
-   "", cmVS7FlagTable::UserValue},
-  {"LinkKeyFile", "KEYFILE:",
-   "Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"KeyContainer", "KEYCONTAINER:",
-   "Key Container",
-   "", cmVS7FlagTable::UserValue},
+  { "FunctionOrder", "ORDER:@", "Function Order", "",
+    cmVS7FlagTable::UserValue },
+  { "ProfileGuidedDatabase", "PGD:", "Profile Guided Database", "",
+    cmVS7FlagTable::UserValue },
+  { "MidlCommandFile", "MIDL:@", "MIDL Commands", "",
+    cmVS7FlagTable::UserValue },
+  { "MergedIDLBaseFileName", "IDLOUT:", "Merged IDL Base File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "TypeLibraryFile", "TLBOUT:", "Type Library", "",
+    cmVS7FlagTable::UserValue },
+  { "WindowsMetadataFile", "WINMDFILE:", "Windows Metadata File", "",
+    cmVS7FlagTable::UserValue },
+  { "WindowsMetadataLinkKeyFile", "WINMDKEYFILE:", "Windows Metadata Key File",
+    "", cmVS7FlagTable::UserValue },
+  { "WindowsMetadataKeyContainer", "WINMDKEYCONTAINER:",
+    "Windows Metadata Key Container", "", cmVS7FlagTable::UserValue },
+  { "EntryPointSymbol", "ENTRY:", "Entry Point", "",
+    cmVS7FlagTable::UserValue },
+  { "BaseAddress", "BASE:", "Base Address", "", cmVS7FlagTable::UserValue },
+  { "ImportLibrary", "IMPLIB:", "Import Library", "",
+    cmVS7FlagTable::UserValue },
+  { "MergeSections", "MERGE:", "Merge Sections", "",
+    cmVS7FlagTable::UserValue },
+  { "LinkKeyFile", "KEYFILE:", "Key File", "", cmVS7FlagTable::UserValue },
+  { "KeyContainer", "KEYCONTAINER:", "Key Container", "",
+    cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS11MASMFlagTable.h b/Source/cmVS11MASMFlagTable.h
index 2ff95ad..1aca169 100644
--- a/Source/cmVS11MASMFlagTable.h
+++ b/Source/cmVS11MASMFlagTable.h
@@ -1,96 +1,78 @@
-static cmVS7FlagTable cmVS11MASMFlagTable[] =
-{
+static cmVS7FlagTable cmVS11MASMFlagTable[] = {
 
-  //Enum Properties
-  {"PreserveIdentifierCase", "",
-   "Default", "0", 0},
-  {"PreserveIdentifierCase", "/Cp",
-   "Preserves Identifier Case (/Cp)", "1", 0},
-  {"PreserveIdentifierCase", "/Cu",
-   "Maps all identifiers to upper case. (/Cu)", "2", 0},
-  {"PreserveIdentifierCase", "/Cx",
-   "Preserves case in public and extern symbols. (/Cx)", "3", 0},
+  // Enum Properties
+  { "PreserveIdentifierCase", "", "Default", "0", 0 },
+  { "PreserveIdentifierCase", "/Cp", "Preserves Identifier Case (/Cp)", "1",
+    0 },
+  { "PreserveIdentifierCase", "/Cu",
+    "Maps all identifiers to upper case. (/Cu)", "2", 0 },
+  { "PreserveIdentifierCase", "/Cx",
+    "Preserves case in public and extern symbols. (/Cx)", "3", 0 },
 
-  {"WarningLevel", "/W0",
-   "Warning Level 0 (/W0)", "0", 0},
-  {"WarningLevel", "/W1",
-   "Warning Level 1 (/W1)", "1", 0},
-  {"WarningLevel", "/W2",
-   "Warning Level 2 (/W2)", "2", 0},
-  {"WarningLevel", "/W3",
-   "Warning Level 3 (/W3)", "3", 0},
+  { "WarningLevel", "/W0", "Warning Level 0 (/W0)", "0", 0 },
+  { "WarningLevel", "/W1", "Warning Level 1 (/W1)", "1", 0 },
+  { "WarningLevel", "/W2", "Warning Level 2 (/W2)", "2", 0 },
+  { "WarningLevel", "/W3", "Warning Level 3 (/W3)", "3", 0 },
 
-  {"PackAlignmentBoundary", "",
-   "Default", "0", 0},
-  {"PackAlignmentBoundary", "/Zp1",
-   "One Byte Boundary (/Zp1)", "1", 0},
-  {"PackAlignmentBoundary", "/Zp2",
-   "Two Byte Boundary (/Zp2)", "2", 0},
-  {"PackAlignmentBoundary", "/Zp4",
-   "Four Byte Boundary (/Zp4)", "3", 0},
-  {"PackAlignmentBoundary", "/Zp8",
-   "Eight Byte Boundary (/Zp8)", "4", 0},
-  {"PackAlignmentBoundary", "/Zp16",
-   "Sixteen Byte Boundary (/Zp16)", "5", 0},
+  { "PackAlignmentBoundary", "", "Default", "0", 0 },
+  { "PackAlignmentBoundary", "/Zp1", "One Byte Boundary (/Zp1)", "1", 0 },
+  { "PackAlignmentBoundary", "/Zp2", "Two Byte Boundary (/Zp2)", "2", 0 },
+  { "PackAlignmentBoundary", "/Zp4", "Four Byte Boundary (/Zp4)", "3", 0 },
+  { "PackAlignmentBoundary", "/Zp8", "Eight Byte Boundary (/Zp8)", "4", 0 },
+  { "PackAlignmentBoundary", "/Zp16", "Sixteen Byte Boundary (/Zp16)", "5",
+    0 },
 
-  {"CallingConvention", "",
-   "Default", "0", 0},
-  {"CallingConvention", "/Gd",
-   "Use C-style Calling Convention (/Gd)", "1", 0},
-  {"CallingConvention", "/Gz",
-   "Use stdcall Calling Convention (/Gz)", "2", 0},
-  {"CallingConvention", "/Gc",
-   "Use Pascal Calling Convention (/Gc)", "3", 0},
+  { "CallingConvention", "", "Default", "0", 0 },
+  { "CallingConvention", "/Gd", "Use C-style Calling Convention (/Gd)", "1",
+    0 },
+  { "CallingConvention", "/Gz", "Use stdcall Calling Convention (/Gz)", "2",
+    0 },
+  { "CallingConvention", "/Gc", "Use Pascal Calling Convention (/Gc)", "3",
+    0 },
 
-  {"ErrorReporting", "/errorReport:prompt",
-   "Prompt to send report immediately (/errorReport:prompt)", "0", 0},
-  {"ErrorReporting", "/errorReport:queue",
-   "Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
-  {"ErrorReporting", "/errorReport:send",
-   "Automatically send report (/errorReport:send)", "2", 0},
-  {"ErrorReporting", "/errorReport:none",
-   "Do not send report (/errorReport:none)", "3", 0},
+  { "ErrorReporting", "/errorReport:prompt",
+    "Prompt to send report immediately (/errorReport:prompt)", "0", 0 },
+  { "ErrorReporting", "/errorReport:queue",
+    "Prompt to send report at the next logon (/errorReport:queue)", "1", 0 },
+  { "ErrorReporting", "/errorReport:send",
+    "Automatically send report (/errorReport:send)", "2", 0 },
+  { "ErrorReporting", "/errorReport:none",
+    "Do not send report (/errorReport:none)", "3", 0 },
 
+  // Bool Properties
+  { "NoLogo", "/nologo", "", "true", 0 },
+  { "GeneratePreprocessedSourceListing", "/EP", "", "true", 0 },
+  { "ListAllAvailableInformation", "/Sa", "", "true", 0 },
+  { "UseSafeExceptionHandlers", "/safeseh", "", "true", 0 },
+  { "AddFirstPassListing", "/Sf", "", "true", 0 },
+  { "EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0 },
+  { "DisableSymbolTable", "/Sn", "", "true", 0 },
+  { "EnableFalseConditionalsInListing", "/Sx", "", "true", 0 },
+  { "TreatWarningsAsErrors", "/WX", "", "true", 0 },
+  { "MakeAllSymbolsPublic", "/Zf", "", "true", 0 },
+  { "GenerateDebugInformation", "/Zi", "", "true", 0 },
+  { "EnableMASM51Compatibility", "/Zm", "", "true", 0 },
+  { "PerformSyntaxCheckOnly", "/Zs", "", "true", 0 },
 
-  //Bool Properties
-  {"NoLogo", "/nologo", "", "true", 0},
-  {"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
-  {"ListAllAvailableInformation", "/Sa", "", "true", 0},
-  {"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
-  {"AddFirstPassListing", "/Sf", "", "true", 0},
-  {"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
-  {"DisableSymbolTable", "/Sn", "", "true", 0},
-  {"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
-  {"TreatWarningsAsErrors", "/WX", "", "true", 0},
-  {"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
-  {"GenerateDebugInformation", "/Zi", "", "true", 0},
-  {"EnableMASM51Compatibility", "/Zm", "", "true", 0},
-  {"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
-  {"PreprocessorDefinitions", "/D",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IncludePaths", "/I",
-   "Include Paths",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"BrowseFile", "/FR",
-   "Generate Browse Information File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "PreprocessorDefinitions", "/D", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IncludePaths", "/I", "Include Paths", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "BrowseFile", "/FR", "Generate Browse Information File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
 
-  //String Properties
+  // String Properties
   // Skip [Inputs] - no command line Switch.
-  {"ObjectFileName", "/Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"AssembledCodeListingFile", "/Fl",
-   "Assembled Code Listing File",
-   "", cmVS7FlagTable::UserValue},
+  { "ObjectFileName", "/Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "AssembledCodeListingFile", "/Fl", "Assembled Code Listing File", "",
+    cmVS7FlagTable::UserValue },
   // Skip [CommandLineTemplate] - no command line Switch.
   // Skip [ExecutionDescription] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS11RCFlagTable.h b/Source/cmVS11RCFlagTable.h
index a7d2de1..666e434 100644
--- a/Source/cmVS11RCFlagTable.h
+++ b/Source/cmVS11RCFlagTable.h
@@ -1,7 +1,6 @@
-static cmVS7FlagTable cmVS11RCFlagTable[] =
-{
-  //Bool Properties
-  {"NullTerminateStrings", "n", "", "true", 0},
+static cmVS7FlagTable cmVS11RCFlagTable[] = {
+  // Bool Properties
+  { "NullTerminateStrings", "n", "", "true", 0 },
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS12CLFlagTable.h b/Source/cmVS12CLFlagTable.h
index 0a7916f..9515c91 100644
--- a/Source/cmVS12CLFlagTable.h
+++ b/Source/cmVS12CLFlagTable.h
@@ -1,294 +1,221 @@
-static cmVS7FlagTable cmVS12CLFlagTable[] =
-{
-
-  //Enum Properties
-  {"DebugInformationFormat", "",
-   "None", "None", 0},
-  {"DebugInformationFormat", "Z7",
-   "C7 compatible", "OldStyle", 0},
-  {"DebugInformationFormat", "Zi",
-   "Program Database", "ProgramDatabase", 0},
-  {"DebugInformationFormat", "ZI",
-   "Program Database for Edit And Continue", "EditAndContinue", 0},
-
-  {"WarningLevel", "W0",
-   "Turn Off All Warnings", "TurnOffAllWarnings", 0},
-  {"WarningLevel", "W1",
-   "Level1", "Level1", 0},
-  {"WarningLevel", "W2",
-   "Level2", "Level2", 0},
-  {"WarningLevel", "W3",
-   "Level3", "Level3", 0},
-  {"WarningLevel", "W4",
-   "Level4", "Level4", 0},
-  {"WarningLevel", "Wall",
-   "EnableAllWarnings", "EnableAllWarnings", 0},
-
-  {"Optimization", "",
-   "Custom", "Custom", 0},
-  {"Optimization", "Od",
-   "Disabled", "Disabled", 0},
-  {"Optimization", "O1",
-   "Minimize Size", "MinSpace", 0},
-  {"Optimization", "O2",
-   "Maximize Speed", "MaxSpeed", 0},
-  {"Optimization", "Ox",
-   "Full Optimization", "Full", 0},
-
-  {"InlineFunctionExpansion", "",
-   "Default", "Default", 0},
-  {"InlineFunctionExpansion", "Ob0",
-   "Disabled", "Disabled", 0},
-  {"InlineFunctionExpansion", "Ob1",
-   "Only __inline", "OnlyExplicitInline", 0},
-  {"InlineFunctionExpansion", "Ob2",
-   "Any Suitable", "AnySuitable", 0},
-
-  {"FavorSizeOrSpeed", "Os",
-   "Favor small code", "Size", 0},
-  {"FavorSizeOrSpeed", "Ot",
-   "Favor fast code", "Speed", 0},
-  {"FavorSizeOrSpeed", "",
-   "Neither", "Neither", 0},
-
-  {"ExceptionHandling", "EHa",
-   "Yes with SEH Exceptions", "Async", 0},
-  {"ExceptionHandling", "EHsc",
-   "Yes", "Sync", 0},
-  {"ExceptionHandling", "EHs",
-   "Yes with Extern C functions", "SyncCThrow", 0},
-  {"ExceptionHandling", "",
-   "No", "false", 0},
-
-  {"BasicRuntimeChecks", "RTCs",
-   "Stack Frames", "StackFrameRuntimeCheck", 0},
-  {"BasicRuntimeChecks", "RTCu",
-   "Uninitialized variables", "UninitializedLocalUsageCheck", 0},
-  {"BasicRuntimeChecks", "RTC1",
-   "Both (/RTC1, equiv. to /RTCsu)", "EnableFastChecks", 0},
-  {"BasicRuntimeChecks", "",
-   "Default", "Default", 0},
-
-  {"RuntimeLibrary", "MT",
-   "Multi-threaded", "MultiThreaded", 0},
-  {"RuntimeLibrary", "MTd",
-   "Multi-threaded Debug", "MultiThreadedDebug", 0},
-  {"RuntimeLibrary", "MD",
-   "Multi-threaded DLL", "MultiThreadedDLL", 0},
-  {"RuntimeLibrary", "MDd",
-   "Multi-threaded Debug DLL", "MultiThreadedDebugDLL", 0},
-
-  {"StructMemberAlignment", "Zp1",
-   "1 Byte", "1Byte", 0},
-  {"StructMemberAlignment", "Zp2",
-   "2 Bytes", "2Bytes", 0},
-  {"StructMemberAlignment", "Zp4",
-   "4 Byte", "4Bytes", 0},
-  {"StructMemberAlignment", "Zp8",
-   "8 Bytes", "8Bytes", 0},
-  {"StructMemberAlignment", "Zp16",
-   "16 Bytes", "16Bytes", 0},
-  {"StructMemberAlignment", "",
-   "Default", "Default", 0},
-
-  {"BufferSecurityCheck", "GS-",
-   "Disable Security Check", "false", 0},
-  {"BufferSecurityCheck", "GS",
-   "Enable Security Check", "true", 0},
-
-  {"EnableEnhancedInstructionSet", "arch:SSE",
-   "Streaming SIMD Extensions", "StreamingSIMDExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:SSE2",
-   "Streaming SIMD Extensions 2", "StreamingSIMDExtensions2", 0},
-  {"EnableEnhancedInstructionSet", "arch:AVX",
-   "Advanced Vector Extensions", "AdvancedVectorExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:IA32",
-   "No Enhanced Instructions", "NoExtensions", 0},
-  {"EnableEnhancedInstructionSet", "",
-   "Not Set", "NotSet", 0},
-
-  {"FloatingPointModel", "fp:precise",
-   "Precise", "Precise", 0},
-  {"FloatingPointModel", "fp:strict",
-   "Strict", "Strict", 0},
-  {"FloatingPointModel", "fp:fast",
-   "Fast", "Fast", 0},
-
-  {"PrecompiledHeader", "Yc",
-   "Create", "Create",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "Yu",
-   "Use", "Use",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "",
-   "Not Using Precompiled Headers", "NotUsing", 0},
-
-  {"AssemblerOutput", "",
-   "No Listing", "NoListing", 0},
-  {"AssemblerOutput", "FA",
-   "Assembly-Only Listing", "AssemblyCode", 0},
-  {"AssemblerOutput", "FAc",
-   "Assembly With Machine Code", "AssemblyAndMachineCode", 0},
-  {"AssemblerOutput", "FAs",
-   "Assembly With Source Code", "AssemblyAndSourceCode", 0},
-  {"AssemblerOutput", "FAcs",
-   "Assembly, Machine Code and Source", "All", 0},
-
-  {"CallingConvention", "Gd",
-   "__cdecl", "Cdecl", 0},
-  {"CallingConvention", "Gr",
-   "__fastcall", "FastCall", 0},
-  {"CallingConvention", "Gz",
-   "__stdcall", "StdCall", 0},
-  {"CallingConvention", "Gv",
-   "__vectorcall", "VectorCall", 0},
-
-  {"CompileAs", "",
-   "Default", "Default", 0},
-  {"CompileAs", "TC",
-   "Compile as C Code", "CompileAsC", 0},
-  {"CompileAs", "TP",
-   "Compile as C++ Code", "CompileAsCpp", 0},
-
-  {"ErrorReporting", "errorReport:none",
-   "Do Not Send Report", "None", 0},
-  {"ErrorReporting", "errorReport:prompt",
-   "Prompt Immediately", "Prompt", 0},
-  {"ErrorReporting", "errorReport:queue",
-   "Queue For Next Login", "Queue", 0},
-  {"ErrorReporting", "errorReport:send",
-   "Send Automatically", "Send", 0},
-
-  {"CompileAsManaged", "",
-   "No Common Language RunTime Support", "false", 0},
-  {"CompileAsManaged", "clr",
-   "Common Language RunTime Support", "true", 0},
-  {"CompileAsManaged", "clr:pure",
-   "Pure MSIL Common Language RunTime Support", "Pure", 0},
-  {"CompileAsManaged", "clr:safe",
-   "Safe MSIL Common Language RunTime Support", "Safe", 0},
-  {"CompileAsManaged", "clr:oldSyntax",
-   "Common Language RunTime Support, Old Syntax", "OldSyntax", 0},
-
-
-  //Bool Properties
-  {"CompileAsWinRT", "ZW", "", "true", 0},
-  {"WinRTNoStdLib", "ZW:nostdlib", "", "true", 0},
-  {"SuppressStartupBanner", "nologo", "", "true", 0},
-  {"TreatWarningAsError", "WX-", "", "false", 0},
-  {"TreatWarningAsError", "WX", "", "true", 0},
-  {"SDLCheck", "sdl-", "", "false", 0},
-  {"SDLCheck", "sdl", "", "true", 0},
-  {"IntrinsicFunctions", "Oi", "", "true", 0},
-  {"OmitFramePointers", "Oy-", "", "false", 0},
-  {"OmitFramePointers", "Oy", "", "true", 0},
-  {"EnableFiberSafeOptimizations", "GT", "", "true", 0},
-  {"WholeProgramOptimization", "GL", "", "true", 0},
-  {"UndefineAllPreprocessorDefinitions", "u", "", "true", 0},
-  {"IgnoreStandardIncludePath", "X", "", "true", 0},
-  {"PreprocessToFile", "P", "", "true", 0},
-  {"PreprocessSuppressLineNumbers", "EP", "", "true", 0},
-  {"PreprocessKeepComments", "C", "", "true", 0},
-  {"StringPooling", "GF-", "", "false", 0},
-  {"StringPooling", "GF", "", "true", 0},
-  {"MinimalRebuild", "Gm-", "", "false", 0},
-  {"MinimalRebuild", "Gm", "", "true", 0},
-  {"SmallerTypeCheck", "RTCc", "", "true", 0},
-  {"FunctionLevelLinking", "Gy-", "", "false", 0},
-  {"FunctionLevelLinking", "Gy", "", "true", 0},
-  {"EnableParallelCodeGeneration", "Qpar-", "", "false", 0},
-  {"EnableParallelCodeGeneration", "Qpar", "", "true", 0},
-  {"FloatingPointExceptions", "fp:except-", "", "false", 0},
-  {"FloatingPointExceptions", "fp:except", "", "true", 0},
-  {"CreateHotpatchableImage", "hotpatch", "", "true", 0},
-  {"DisableLanguageExtensions", "Za", "", "true", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0},
-  {"RuntimeTypeInfo", "GR-", "", "false", 0},
-  {"RuntimeTypeInfo", "GR", "", "true", 0},
-  {"OpenMPSupport", "openmp-", "", "false", 0},
-  {"OpenMPSupport", "openmp", "", "true", 0},
-  {"ExpandAttributedSource", "Fx", "", "true", 0},
-  {"UseUnicodeForAssemblerListing", "FAu", "", "true", 0},
-  {"ShowIncludes", "showIncludes", "", "true", 0},
-  {"EnablePREfast", "analyze-", "", "false", 0},
-  {"EnablePREfast", "analyze", "", "true", 0},
-  {"UseFullPaths", "FC", "", "true", 0},
-  {"OmitDefaultLibName", "Zl", "", "true", 0},
-
-  //Bool Properties With Argument
-  {"MultiProcessorCompilation", "MP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"ProcessorNumber", "MP", "Multi-processor Compilation", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateXMLDocumentationFiles", "doc", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"BrowseInformation", "FR", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"BrowseInformationFile", "FR", "Enable Browse Information", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalIncludeDirectories", "I",
-   "Additional Include Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalUsingDirectories", "AI",
-   "Additional #using Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PreprocessorDefinitions", "D ",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"UndefinePreprocessorDefinitions", "U",
-   "Undefine Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DisableSpecificWarnings", "wd",
-   "Disable Specific Warnings",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedIncludeFiles", "FI",
-   "Forced Include File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedUsingFiles", "FU",
-   "Forced #using File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PREfastLog", "analyze:log",
-   "Code Analysis Log",
-   "", cmVS7FlagTable::UserFollowing},
-  {"PREfastAdditionalPlugins", "analyze:plugin",
-   "Additional Code Analysis Native plugins",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"TreatSpecificWarningsAsErrors", "we",
-   "Treat Specific Warnings As Errors",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-
-  //String Properties
+static cmVS7FlagTable cmVS12CLFlagTable[] = {
+
+  // Enum Properties
+  { "DebugInformationFormat", "", "None", "None", 0 },
+  { "DebugInformationFormat", "Z7", "C7 compatible", "OldStyle", 0 },
+  { "DebugInformationFormat", "Zi", "Program Database", "ProgramDatabase", 0 },
+  { "DebugInformationFormat", "ZI", "Program Database for Edit And Continue",
+    "EditAndContinue", 0 },
+
+  { "WarningLevel", "W0", "Turn Off All Warnings", "TurnOffAllWarnings", 0 },
+  { "WarningLevel", "W1", "Level1", "Level1", 0 },
+  { "WarningLevel", "W2", "Level2", "Level2", 0 },
+  { "WarningLevel", "W3", "Level3", "Level3", 0 },
+  { "WarningLevel", "W4", "Level4", "Level4", 0 },
+  { "WarningLevel", "Wall", "EnableAllWarnings", "EnableAllWarnings", 0 },
+
+  { "Optimization", "", "Custom", "Custom", 0 },
+  { "Optimization", "Od", "Disabled", "Disabled", 0 },
+  { "Optimization", "O1", "Minimize Size", "MinSpace", 0 },
+  { "Optimization", "O2", "Maximize Speed", "MaxSpeed", 0 },
+  { "Optimization", "Ox", "Full Optimization", "Full", 0 },
+
+  { "InlineFunctionExpansion", "", "Default", "Default", 0 },
+  { "InlineFunctionExpansion", "Ob0", "Disabled", "Disabled", 0 },
+  { "InlineFunctionExpansion", "Ob1", "Only __inline", "OnlyExplicitInline",
+    0 },
+  { "InlineFunctionExpansion", "Ob2", "Any Suitable", "AnySuitable", 0 },
+
+  { "FavorSizeOrSpeed", "Os", "Favor small code", "Size", 0 },
+  { "FavorSizeOrSpeed", "Ot", "Favor fast code", "Speed", 0 },
+  { "FavorSizeOrSpeed", "", "Neither", "Neither", 0 },
+
+  { "ExceptionHandling", "EHa", "Yes with SEH Exceptions", "Async", 0 },
+  { "ExceptionHandling", "EHsc", "Yes", "Sync", 0 },
+  { "ExceptionHandling", "EHs", "Yes with Extern C functions", "SyncCThrow",
+    0 },
+  { "ExceptionHandling", "", "No", "false", 0 },
+
+  { "BasicRuntimeChecks", "RTCs", "Stack Frames", "StackFrameRuntimeCheck",
+    0 },
+  { "BasicRuntimeChecks", "RTCu", "Uninitialized variables",
+    "UninitializedLocalUsageCheck", 0 },
+  { "BasicRuntimeChecks", "RTC1", "Both (/RTC1, equiv. to /RTCsu)",
+    "EnableFastChecks", 0 },
+  { "BasicRuntimeChecks", "", "Default", "Default", 0 },
+
+  { "RuntimeLibrary", "MT", "Multi-threaded", "MultiThreaded", 0 },
+  { "RuntimeLibrary", "MTd", "Multi-threaded Debug", "MultiThreadedDebug", 0 },
+  { "RuntimeLibrary", "MD", "Multi-threaded DLL", "MultiThreadedDLL", 0 },
+  { "RuntimeLibrary", "MDd", "Multi-threaded Debug DLL",
+    "MultiThreadedDebugDLL", 0 },
+
+  { "StructMemberAlignment", "Zp1", "1 Byte", "1Byte", 0 },
+  { "StructMemberAlignment", "Zp2", "2 Bytes", "2Bytes", 0 },
+  { "StructMemberAlignment", "Zp4", "4 Byte", "4Bytes", 0 },
+  { "StructMemberAlignment", "Zp8", "8 Bytes", "8Bytes", 0 },
+  { "StructMemberAlignment", "Zp16", "16 Bytes", "16Bytes", 0 },
+  { "StructMemberAlignment", "", "Default", "Default", 0 },
+
+  { "BufferSecurityCheck", "GS-", "Disable Security Check", "false", 0 },
+  { "BufferSecurityCheck", "GS", "Enable Security Check", "true", 0 },
+
+  { "EnableEnhancedInstructionSet", "arch:SSE", "Streaming SIMD Extensions",
+    "StreamingSIMDExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:SSE2", "Streaming SIMD Extensions 2",
+    "StreamingSIMDExtensions2", 0 },
+  { "EnableEnhancedInstructionSet", "arch:AVX", "Advanced Vector Extensions",
+    "AdvancedVectorExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:IA32", "No Enhanced Instructions",
+    "NoExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "", "Not Set", "NotSet", 0 },
+
+  { "FloatingPointModel", "fp:precise", "Precise", "Precise", 0 },
+  { "FloatingPointModel", "fp:strict", "Strict", "Strict", 0 },
+  { "FloatingPointModel", "fp:fast", "Fast", "Fast", 0 },
+
+  { "PrecompiledHeader", "Yc", "Create", "Create",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "Yu", "Use", "Use",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "", "Not Using Precompiled Headers", "NotUsing", 0 },
+
+  { "AssemblerOutput", "", "No Listing", "NoListing", 0 },
+  { "AssemblerOutput", "FA", "Assembly-Only Listing", "AssemblyCode", 0 },
+  { "AssemblerOutput", "FAc", "Assembly With Machine Code",
+    "AssemblyAndMachineCode", 0 },
+  { "AssemblerOutput", "FAs", "Assembly With Source Code",
+    "AssemblyAndSourceCode", 0 },
+  { "AssemblerOutput", "FAcs", "Assembly, Machine Code and Source", "All", 0 },
+
+  { "CallingConvention", "Gd", "__cdecl", "Cdecl", 0 },
+  { "CallingConvention", "Gr", "__fastcall", "FastCall", 0 },
+  { "CallingConvention", "Gz", "__stdcall", "StdCall", 0 },
+  { "CallingConvention", "Gv", "__vectorcall", "VectorCall", 0 },
+
+  { "CompileAs", "", "Default", "Default", 0 },
+  { "CompileAs", "TC", "Compile as C Code", "CompileAsC", 0 },
+  { "CompileAs", "TP", "Compile as C++ Code", "CompileAsCpp", 0 },
+
+  { "ErrorReporting", "errorReport:none", "Do Not Send Report", "None", 0 },
+  { "ErrorReporting", "errorReport:prompt", "Prompt Immediately", "Prompt",
+    0 },
+  { "ErrorReporting", "errorReport:queue", "Queue For Next Login", "Queue",
+    0 },
+  { "ErrorReporting", "errorReport:send", "Send Automatically", "Send", 0 },
+
+  { "CompileAsManaged", "", "No Common Language RunTime Support", "false", 0 },
+  { "CompileAsManaged", "clr", "Common Language RunTime Support", "true", 0 },
+  { "CompileAsManaged", "clr:pure",
+    "Pure MSIL Common Language RunTime Support", "Pure", 0 },
+  { "CompileAsManaged", "clr:safe",
+    "Safe MSIL Common Language RunTime Support", "Safe", 0 },
+  { "CompileAsManaged", "clr:oldSyntax",
+    "Common Language RunTime Support, Old Syntax", "OldSyntax", 0 },
+
+  // Bool Properties
+  { "CompileAsWinRT", "ZW", "", "true", 0 },
+  { "WinRTNoStdLib", "ZW:nostdlib", "", "true", 0 },
+  { "SuppressStartupBanner", "nologo", "", "true", 0 },
+  { "TreatWarningAsError", "WX-", "", "false", 0 },
+  { "TreatWarningAsError", "WX", "", "true", 0 },
+  { "SDLCheck", "sdl-", "", "false", 0 },
+  { "SDLCheck", "sdl", "", "true", 0 },
+  { "IntrinsicFunctions", "Oi", "", "true", 0 },
+  { "OmitFramePointers", "Oy-", "", "false", 0 },
+  { "OmitFramePointers", "Oy", "", "true", 0 },
+  { "EnableFiberSafeOptimizations", "GT", "", "true", 0 },
+  { "WholeProgramOptimization", "GL", "", "true", 0 },
+  { "UndefineAllPreprocessorDefinitions", "u", "", "true", 0 },
+  { "IgnoreStandardIncludePath", "X", "", "true", 0 },
+  { "PreprocessToFile", "P", "", "true", 0 },
+  { "PreprocessSuppressLineNumbers", "EP", "", "true", 0 },
+  { "PreprocessKeepComments", "C", "", "true", 0 },
+  { "StringPooling", "GF-", "", "false", 0 },
+  { "StringPooling", "GF", "", "true", 0 },
+  { "MinimalRebuild", "Gm-", "", "false", 0 },
+  { "MinimalRebuild", "Gm", "", "true", 0 },
+  { "SmallerTypeCheck", "RTCc", "", "true", 0 },
+  { "FunctionLevelLinking", "Gy-", "", "false", 0 },
+  { "FunctionLevelLinking", "Gy", "", "true", 0 },
+  { "EnableParallelCodeGeneration", "Qpar-", "", "false", 0 },
+  { "EnableParallelCodeGeneration", "Qpar", "", "true", 0 },
+  { "FloatingPointExceptions", "fp:except-", "", "false", 0 },
+  { "FloatingPointExceptions", "fp:except", "", "true", 0 },
+  { "CreateHotpatchableImage", "hotpatch", "", "true", 0 },
+  { "DisableLanguageExtensions", "Za", "", "true", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0 },
+  { "RuntimeTypeInfo", "GR-", "", "false", 0 },
+  { "RuntimeTypeInfo", "GR", "", "true", 0 },
+  { "OpenMPSupport", "openmp-", "", "false", 0 },
+  { "OpenMPSupport", "openmp", "", "true", 0 },
+  { "ExpandAttributedSource", "Fx", "", "true", 0 },
+  { "UseUnicodeForAssemblerListing", "FAu", "", "true", 0 },
+  { "ShowIncludes", "showIncludes", "", "true", 0 },
+  { "EnablePREfast", "analyze-", "", "false", 0 },
+  { "EnablePREfast", "analyze", "", "true", 0 },
+  { "UseFullPaths", "FC", "", "true", 0 },
+  { "OmitDefaultLibName", "Zl", "", "true", 0 },
+
+  // Bool Properties With Argument
+  { "MultiProcessorCompilation", "MP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "ProcessorNumber", "MP", "Multi-processor Compilation", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateXMLDocumentationFiles", "doc", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "BrowseInformation", "FR", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "BrowseInformationFile", "FR", "Enable Browse Information", "",
+    cmVS7FlagTable::UserValueRequired },
+
+  // String List Properties
+  { "AdditionalIncludeDirectories", "I", "Additional Include Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalUsingDirectories", "AI", "Additional #using Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PreprocessorDefinitions", "D ", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "UndefinePreprocessorDefinitions", "U",
+    "Undefine Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DisableSpecificWarnings", "wd", "Disable Specific Warnings", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedIncludeFiles", "FI", "Forced Include File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedUsingFiles", "FU", "Forced #using File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PREfastLog", "analyze:log", "Code Analysis Log", "",
+    cmVS7FlagTable::UserFollowing },
+  { "PREfastAdditionalPlugins", "analyze:plugin",
+    "Additional Code Analysis Native plugins", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "TreatSpecificWarningsAsErrors", "we", "Treat Specific Warnings As Errors",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+
+  // String Properties
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"PreprocessOutputPath", "Fi",
-   "Preprocess Output Path",
-   "", cmVS7FlagTable::UserValue},
-  {"PrecompiledHeaderFile", "Yc",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderFile", "Yu",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderOutputFile", "Fp",
-   "Precompiled Header Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"AssemblerListingLocation", "Fa",
-   "ASM List Location",
-   "", cmVS7FlagTable::UserValue},
-  {"ObjectFileName", "Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDataBaseFileName", "Fd",
-   "Program Database File Name",
-   "", cmVS7FlagTable::UserValue},
+  { "PreprocessOutputPath", "Fi", "Preprocess Output Path", "",
+    cmVS7FlagTable::UserValue },
+  { "PrecompiledHeaderFile", "Yc", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderFile", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderOutputFile", "Fp", "Precompiled Header Output File", "",
+    cmVS7FlagTable::UserValue },
+  { "AssemblerListingLocation", "Fa", "ASM List Location", "",
+    cmVS7FlagTable::UserValue },
+  { "ObjectFileName", "Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDataBaseFileName", "Fd", "Program Database File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [XMLDocumentationFileName] - no command line Switch.
   // Skip [BrowseInformationFile] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS12LibFlagTable.h b/Source/cmVS12LibFlagTable.h
index 10bb805..0f7a259 100644
--- a/Source/cmVS12LibFlagTable.h
+++ b/Source/cmVS12LibFlagTable.h
@@ -1,102 +1,76 @@
-static cmVS7FlagTable cmVS12LibFlagTable[] =
-{
+static cmVS7FlagTable cmVS12LibFlagTable[] = {
 
-  //Enum Properties
-  {"ErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"ErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"ErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"ErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  // Enum Properties
+  { "ErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "ErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "ErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "ErrorReporting", "ERRORREPORT:NONE", "No Error Report", "NoErrorReport",
+    0 },
 
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWSCE",
-   "WindowsCE", "WindowsCE", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
+  // Bool Properties
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "TreatLibWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLibWarningAsErrors", "WX", "", "true", 0 },
+  { "Verbose", "VERBOSE", "", "true", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "", "true", 0 },
 
-  //Bool Properties
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"TreatLibWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLibWarningAsErrors", "WX", "", "true", 0},
-  {"Verbose", "VERBOSE", "", "true", 0},
-  {"LinkTimeCodeGeneration", "LTCG", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
+  // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ExportNamedFunctions", "EXPORT:",
-   "Export Named Functions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"RemoveObjects", "REMOVE:",
-   "Remove Objects",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "RemoveObjects", "REMOVE:", "Remove Objects", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue},
-  {"DisplayLibrary", "LIST:",
-   "Display Library to standard output",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue },
+  { "DisplayLibrary", "LIST:", "Display Library to standard output", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"Name", "NAME:",
-   "Name",
-   "", cmVS7FlagTable::UserValue},
+  { "Name", "NAME:", "Name", "", cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS12LinkFlagTable.h b/Source/cmVS12LinkFlagTable.h
index 0be5e34..168c34c 100644
--- a/Source/cmVS12LinkFlagTable.h
+++ b/Source/cmVS12LinkFlagTable.h
@@ -1,341 +1,269 @@
-static cmVS7FlagTable cmVS12LinkFlagTable[] =
-{
+static cmVS7FlagTable cmVS12LinkFlagTable[] = {
 
-  //Enum Properties
-  {"ShowProgress", "",
-   "Not Set", "NotSet", 0},
-  {"ShowProgress", "VERBOSE",
-   "Display all progress messages", "LinkVerbose", 0},
-  {"ShowProgress", "VERBOSE:Lib",
-   "For Libraries Searched", "LinkVerboseLib", 0},
-  {"ShowProgress", "VERBOSE:ICF",
-   "About COMDAT folding during optimized linking", "LinkVerboseICF", 0},
-  {"ShowProgress", "VERBOSE:REF",
-   "About data removed during optimized linking", "LinkVerboseREF", 0},
-  {"ShowProgress", "VERBOSE:SAFESEH",
-   "About Modules incompatible with SEH", "LinkVerboseSAFESEH", 0},
-  {"ShowProgress", "VERBOSE:CLR",
-   "About linker activity related to managed code", "LinkVerboseCLR", 0},
+  // Enum Properties
+  { "ShowProgress", "", "Not Set", "NotSet", 0 },
+  { "ShowProgress", "VERBOSE", "Display all progress messages", "LinkVerbose",
+    0 },
+  { "ShowProgress", "VERBOSE:Lib", "For Libraries Searched", "LinkVerboseLib",
+    0 },
+  { "ShowProgress", "VERBOSE:ICF",
+    "About COMDAT folding during optimized linking", "LinkVerboseICF", 0 },
+  { "ShowProgress", "VERBOSE:REF",
+    "About data removed during optimized linking", "LinkVerboseREF", 0 },
+  { "ShowProgress", "VERBOSE:SAFESEH", "About Modules incompatible with SEH",
+    "LinkVerboseSAFESEH", 0 },
+  { "ShowProgress", "VERBOSE:CLR",
+    "About linker activity related to managed code", "LinkVerboseCLR", 0 },
 
-  {"ForceFileOutput", "FORCE",
-   "Enabled", "Enabled", 0},
-  {"ForceFileOutput", "FORCE:MULTIPLE",
-   "Multiply Defined Symbol Only", "MultiplyDefinedSymbolOnly", 0},
-  {"ForceFileOutput", "FORCE:UNRESOLVED",
-   "Undefined Symbol Only", "UndefinedSymbolOnly", 0},
+  { "ForceFileOutput", "FORCE", "Enabled", "Enabled", 0 },
+  { "ForceFileOutput", "FORCE:MULTIPLE", "Multiply Defined Symbol Only",
+    "MultiplyDefinedSymbolOnly", 0 },
+  { "ForceFileOutput", "FORCE:UNRESOLVED", "Undefined Symbol Only",
+    "UndefinedSymbolOnly", 0 },
 
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN",
-   "Enabled", "Enabled", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:5",
-   "X86 Image Only", "X86Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:6",
-   "X64 Image Only", "X64Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:16",
-   "Itanium Image Only", "ItaniumImage", 0},
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN", "Enabled", "Enabled", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:5", "X86 Image Only",
+    "X86Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:6", "X64 Image Only",
+    "X64Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:16", "Itanium Image Only",
+    "ItaniumImage", 0 },
 
-  {"UACExecutionLevel", "level='asInvoker'",
-   "asInvoker", "AsInvoker", 0},
-  {"UACExecutionLevel", "level='highestAvailable'",
-   "highestAvailable", "HighestAvailable", 0},
-  {"UACExecutionLevel", "level='requireAdministrator'",
-   "requireAdministrator", "RequireAdministrator", 0},
+  { "UACExecutionLevel", "level='asInvoker'", "asInvoker", "AsInvoker", 0 },
+  { "UACExecutionLevel", "level='highestAvailable'", "highestAvailable",
+    "HighestAvailable", 0 },
+  { "UACExecutionLevel", "level='requireAdministrator'",
+    "requireAdministrator", "RequireAdministrator", 0 },
 
-  {"SubSystem", "",
-   "Not Set", "NotSet", 0},
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "", "Not Set", "NotSet", 0 },
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
-  {"Driver", "",
-   "Not Set", "NotSet", 0},
-  {"Driver", "Driver",
-   "Driver", "Driver", 0},
-  {"Driver", "DRIVER:UPONLY",
-   "UP Only", "UpOnly", 0},
-  {"Driver", "DRIVER:WDM",
-   "WDM", "WDM", 0},
+  { "Driver", "", "Not Set", "NotSet", 0 },
+  { "Driver", "Driver", "Driver", "Driver", 0 },
+  { "Driver", "DRIVER:UPONLY", "UP Only", "UpOnly", 0 },
+  { "Driver", "DRIVER:WDM", "WDM", "WDM", 0 },
 
-  {"LinkTimeCodeGeneration", "",
-   "Default", "Default", 0},
-  {"LinkTimeCodeGeneration", "LTCG",
-   "Use Link Time Code Generation", "UseLinkTimeCodeGeneration", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGInstrument",
-   "Profile Guided Optimization - Instrument", "PGInstrument", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGOptimize",
-   "Profile Guided Optimization - Optimization", "PGOptimization", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGUpdate",
-   "Profile Guided Optimization - Update", "PGUpdate", 0},
+  { "LinkTimeCodeGeneration", "", "Default", "Default", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "Use Link Time Code Generation",
+    "UseLinkTimeCodeGeneration", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGInstrument",
+    "Profile Guided Optimization - Instrument", "PGInstrument", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGOptimize",
+    "Profile Guided Optimization - Optimization", "PGOptimization", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGUpdate",
+    "Profile Guided Optimization - Update", "PGUpdate", 0 },
 
-  {"GenerateWindowsMetadata", "WINMD",
-   "Yes", "true", 0},
-  {"GenerateWindowsMetadata", "WINMD:NO",
-   "No", "false", 0},
+  { "GenerateWindowsMetadata", "WINMD", "Yes", "true", 0 },
+  { "GenerateWindowsMetadata", "WINMD:NO", "No", "false", 0 },
 
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA1",
-   "SHA1", "SHA1", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA256",
-   "SHA256", "SHA256", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA384",
-   "SHA384", "SHA384", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA512",
-   "SHA512", "SHA512", 0},
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA1", "SHA1", "SHA1", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA256", "SHA256", "SHA256", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA384", "SHA384", "SHA384", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA512", "SHA512", "SHA512", 0 },
 
-  {"TargetMachine", "",
-   "Not Set", "NotSet", 0},
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "", "Not Set", "NotSet", 0 },
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA",
-   "MTA threading attribute", "MTAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA",
-   "STA threading attribute", "STAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
-   "Default threading attribute", "DefaultThreadingAttribute", 0},
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA", "MTA threading attribute",
+    "MTAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA", "STA threading attribute",
+    "STAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
+    "Default threading attribute", "DefaultThreadingAttribute", 0 },
 
-  {"CLRImageType", "CLRIMAGETYPE:IJW",
-   "Force IJW image", "ForceIJWImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:PURE",
-   "Force Pure IL Image", "ForcePureILImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:SAFE",
-   "Force Safe IL Image", "ForceSafeILImage", 0},
-  {"CLRImageType", "",
-   "Default image type", "Default", 0},
+  { "CLRImageType", "CLRIMAGETYPE:IJW", "Force IJW image", "ForceIJWImage",
+    0 },
+  { "CLRImageType", "CLRIMAGETYPE:PURE", "Force Pure IL Image",
+    "ForcePureILImage", 0 },
+  { "CLRImageType", "CLRIMAGETYPE:SAFE", "Force Safe IL Image",
+    "ForceSafeILImage", 0 },
+  { "CLRImageType", "", "Default image type", "Default", 0 },
 
-  {"SignHash", "CLRSIGNHASH:SHA1",
-   "SHA1", "SHA1", 0},
-  {"SignHash", "CLRSIGNHASH:SHA256",
-   "SHA256", "SHA256", 0},
-  {"SignHash", "CLRSIGNHASH:SHA384",
-   "SHA384", "SHA384", 0},
-  {"SignHash", "CLRSIGNHASH:SHA512",
-   "SHA512", "SHA512", 0},
+  { "SignHash", "CLRSIGNHASH:SHA1", "SHA1", "SHA1", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA256", "SHA256", "SHA256", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA384", "SHA384", "SHA384", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA512", "SHA512", "SHA512", 0 },
 
-  {"LinkErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"LinkErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"LinkErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"LinkErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  { "LinkErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:NONE", "No Error Report",
+    "NoErrorReport", 0 },
 
-  {"CLRSupportLastError", "CLRSupportLastError",
-   "Enabled", "Enabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:NO",
-   "Disabled", "Disabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL",
-   "System Dlls Only", "SystemDlls", 0},
+  { "CLRSupportLastError", "CLRSupportLastError", "Enabled", "Enabled", 0 },
+  { "CLRSupportLastError", "CLRSupportLastError:NO", "Disabled", "Disabled",
+    0 },
+  { "CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL", "System Dlls Only",
+    "SystemDlls", 0 },
 
+  // Bool Properties
+  { "LinkIncremental", "INCREMENTAL:NO", "", "false", 0 },
+  { "LinkIncremental", "INCREMENTAL", "", "true", 0 },
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "LinkStatus", "LTCG:NOSTATUS", "", "false", 0 },
+  { "LinkStatus", "LTCG:STATUS", "", "true", 0 },
+  { "PreventDllBinding", "ALLOWBIND:NO", "", "false", 0 },
+  { "PreventDllBinding", "ALLOWBIND", "", "true", 0 },
+  { "TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLinkerWarningAsErrors", "WX", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "GenerateManifest", "MANIFEST:NO", "", "false", 0 },
+  { "GenerateManifest", "MANIFEST", "", "true", 0 },
+  { "AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='false'", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='true'", "", "true", 0 },
+  { "ManifestEmbed", "manifest:embed", "", "true", 0 },
+  { "GenerateDebugInformation", "DEBUG", "", "true",
+    cmVS7FlagTable::CaseInsensitive },
+  { "MapExports", "MAPINFO:EXPORTS", "", "true", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0 },
+  { "TerminalServerAware", "TSAWARE:NO", "", "false", 0 },
+  { "TerminalServerAware", "TSAWARE", "", "true", 0 },
+  { "SwapRunFromCD", "SWAPRUN:CD", "", "true", 0 },
+  { "SwapRunFromNET", "SWAPRUN:NET", "", "true", 0 },
+  { "OptimizeReferences", "OPT:NOREF", "", "false", 0 },
+  { "OptimizeReferences", "OPT:REF", "", "true", 0 },
+  { "EnableCOMDATFolding", "OPT:NOICF", "", "false", 0 },
+  { "EnableCOMDATFolding", "OPT:ICF", "", "true", 0 },
+  { "IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0 },
+  { "AppContainer", "APPCONTAINER", "", "true", 0 },
+  { "WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN:NO", "", "false", 0 },
+  { "WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN", "", "true", 0 },
+  { "NoEntryPoint", "NOENTRY", "", "true", 0 },
+  { "SetChecksum", "RELEASE", "", "true", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0 },
+  { "FixedBaseAddress", "FIXED:NO", "", "false", 0 },
+  { "FixedBaseAddress", "FIXED", "", "true", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT", "", "true", 0 },
+  { "TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0 },
+  { "SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0 },
+  { "SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0 },
+  { "Profile", "PROFILE", "", "true", 0 },
+  { "LinkDelaySign", "DELAYSIGN:NO", "", "false", 0 },
+  { "LinkDelaySign", "DELAYSIGN", "", "true", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0 },
+  { "DetectOneDefinitionRule", "ODR", "", "true", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0 },
+  { "LinkDLL", "DLL", "", "true", 0 },
 
-  //Bool Properties
-  {"LinkIncremental", "INCREMENTAL:NO", "", "false", 0},
-  {"LinkIncremental", "INCREMENTAL", "", "true", 0},
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"LinkStatus", "LTCG:NOSTATUS", "", "false", 0},
-  {"LinkStatus", "LTCG:STATUS", "", "true", 0},
-  {"PreventDllBinding", "ALLOWBIND:NO", "", "false", 0},
-  {"PreventDllBinding", "ALLOWBIND", "", "true", 0},
-  {"TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLinkerWarningAsErrors", "WX", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"GenerateManifest", "MANIFEST:NO", "", "false", 0},
-  {"GenerateManifest", "MANIFEST", "", "true", 0},
-  {"AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0},
-  {"UACUIAccess", "uiAccess='false'", "", "false", 0},
-  {"UACUIAccess", "uiAccess='true'", "", "true", 0},
-  {"ManifestEmbed", "manifest:embed", "", "true", 0},
-  {"GenerateDebugInformation", "DEBUG", "", "true",
-   cmVS7FlagTable::CaseInsensitive},
-  {"MapExports", "MAPINFO:EXPORTS", "", "true", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0},
-  {"TerminalServerAware", "TSAWARE:NO", "", "false", 0},
-  {"TerminalServerAware", "TSAWARE", "", "true", 0},
-  {"SwapRunFromCD", "SWAPRUN:CD", "", "true", 0},
-  {"SwapRunFromNET", "SWAPRUN:NET", "", "true", 0},
-  {"OptimizeReferences", "OPT:NOREF", "", "false", 0},
-  {"OptimizeReferences", "OPT:REF", "", "true", 0},
-  {"EnableCOMDATFolding", "OPT:NOICF", "", "false", 0},
-  {"EnableCOMDATFolding", "OPT:ICF", "", "true", 0},
-  {"IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0},
-  {"AppContainer", "APPCONTAINER", "", "true", 0},
-  {"WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN:NO", "", "false", 0},
-  {"WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN", "", "true", 0},
-  {"NoEntryPoint", "NOENTRY", "", "true", 0},
-  {"SetChecksum", "RELEASE", "", "true", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0},
-  {"FixedBaseAddress", "FIXED:NO", "", "false", 0},
-  {"FixedBaseAddress", "FIXED", "", "true", 0},
-  {"DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0},
-  {"DataExecutionPrevention", "NXCOMPAT", "", "true", 0},
-  {"TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0},
-  {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0},
-  {"SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0},
-  {"Profile", "PROFILE", "", "true", 0},
-  {"LinkDelaySign", "DELAYSIGN:NO", "", "false", 0},
-  {"LinkDelaySign", "DELAYSIGN", "", "true", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0},
-  {"DetectOneDefinitionRule", "ODR", "", "true", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0},
-  {"LinkDLL", "DLL", "", "true", 0},
+  // Bool Properties With Argument
+  { "EnableUAC", "MANIFESTUAC:NO", "", "false", 0 },
+  { "EnableUAC", "MANIFESTUAC:", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateMapFile", "MAP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "MapFileName", "MAP:", "Generate Map File", "",
+    cmVS7FlagTable::UserValueRequired },
 
-  //Bool Properties With Argument
-  {"EnableUAC", "MANIFESTUAC:NO", "", "false", 0},
-  {"EnableUAC", "MANIFESTUAC:", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateMapFile", "MAP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"MapFileName", "MAP:", "Generate Map File", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AddModuleNamesToAssembly", "ASSEMBLYMODULE:",
-   "Add Module to Assembly",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
-   "Embed Managed Resource File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DelayLoadDLLs", "DELAYLOAD:",
-   "Delay Loaded Dlls",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:",
-   "Assembly Link Resource",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-   "Additional Manifest Dependencies",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ManifestInput", "manifestinput:",
-   "Manifest Input",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AddModuleNamesToAssembly", "ASSEMBLYMODULE:", "Add Module to Assembly",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
+    "Embed Managed Resource File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DelayLoadDLLs", "DELAYLOAD:", "Delay Loaded Dlls", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
+    "Additional Manifest Dependencies", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ManifestInput", "manifestinput:", "Manifest Input", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"Version", "VERSION:",
-   "Version",
-   "", cmVS7FlagTable::UserValue},
-  {"SpecifySectionAttributes", "SECTION:",
-   "Specify Section Attributes",
-   "", cmVS7FlagTable::UserValue},
-  {"MSDOSStubFileName", "STUB:",
-   "MS-DOS Stub File Name",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "Version", "VERSION:", "Version", "", cmVS7FlagTable::UserValue },
+  { "SpecifySectionAttributes", "SECTION:", "Specify Section Attributes", "",
+    cmVS7FlagTable::UserValue },
+  { "MSDOSStubFileName", "STUB:", "MS-DOS Stub File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File",
-   "", cmVS7FlagTable::UserValue},
-  {"ManifestFile", "ManifestFile:",
-   "Manifest File",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDatabaseFile", "PDB:",
-   "Generate Program Database File",
-   "", cmVS7FlagTable::UserValue},
-  {"StripPrivateSymbols", "PDBSTRIPPED:",
-   "Strip Private Symbols",
-   "", cmVS7FlagTable::UserValue},
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File", "",
+    cmVS7FlagTable::UserValue },
+  { "ManifestFile", "ManifestFile:", "Manifest File", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDatabaseFile", "PDB:", "Generate Program Database File", "",
+    cmVS7FlagTable::UserValue },
+  { "StripPrivateSymbols", "PDBSTRIPPED:", "Strip Private Symbols", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MapFileName] - no command line Switch.
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"HeapReserveSize", "HEAP:",
-   "Heap Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "HeapReserveSize", "HEAP:", "Heap Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [HeapCommitSize] - no command line Switch.
-  {"StackReserveSize", "STACK:",
-   "Stack Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "StackReserveSize", "STACK:", "Stack Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [StackCommitSize] - no command line Switch.
-  {"FunctionOrder", "ORDER:@",
-   "Function Order",
-   "", cmVS7FlagTable::UserValue},
-  {"ProfileGuidedDatabase", "PGD:",
-   "Profile Guided Database",
-   "", cmVS7FlagTable::UserValue},
-  {"MidlCommandFile", "MIDL:@",
-   "MIDL Commands",
-   "", cmVS7FlagTable::UserValue},
-  {"MergedIDLBaseFileName", "IDLOUT:",
-   "Merged IDL Base File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"TypeLibraryFile", "TLBOUT:",
-   "Type Library",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataFile", "WINMDFILE:",
-   "Windows Metadata File",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataLinkKeyFile", "WINMDKEYFILE:",
-   "Windows Metadata Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataKeyContainer", "WINMDKEYCONTAINER:",
-   "Windows Metadata Key Container",
-   "", cmVS7FlagTable::UserValue},
-  {"EntryPointSymbol", "ENTRY:",
-   "Entry Point",
-   "", cmVS7FlagTable::UserValue},
-  {"BaseAddress", "BASE:",
-   "Base Address",
-   "", cmVS7FlagTable::UserValue},
-  {"ImportLibrary", "IMPLIB:",
-   "Import Library",
-   "", cmVS7FlagTable::UserValue},
-  {"MergeSections", "MERGE:",
-   "Merge Sections",
-   "", cmVS7FlagTable::UserValue},
-  {"LinkKeyFile", "KEYFILE:",
-   "Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"KeyContainer", "KEYCONTAINER:",
-   "Key Container",
-   "", cmVS7FlagTable::UserValue},
+  { "FunctionOrder", "ORDER:@", "Function Order", "",
+    cmVS7FlagTable::UserValue },
+  { "ProfileGuidedDatabase", "PGD:", "Profile Guided Database", "",
+    cmVS7FlagTable::UserValue },
+  { "MidlCommandFile", "MIDL:@", "MIDL Commands", "",
+    cmVS7FlagTable::UserValue },
+  { "MergedIDLBaseFileName", "IDLOUT:", "Merged IDL Base File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "TypeLibraryFile", "TLBOUT:", "Type Library", "",
+    cmVS7FlagTable::UserValue },
+  { "WindowsMetadataFile", "WINMDFILE:", "Windows Metadata File", "",
+    cmVS7FlagTable::UserValue },
+  { "WindowsMetadataLinkKeyFile", "WINMDKEYFILE:", "Windows Metadata Key File",
+    "", cmVS7FlagTable::UserValue },
+  { "WindowsMetadataKeyContainer", "WINMDKEYCONTAINER:",
+    "Windows Metadata Key Container", "", cmVS7FlagTable::UserValue },
+  { "EntryPointSymbol", "ENTRY:", "Entry Point", "",
+    cmVS7FlagTable::UserValue },
+  { "BaseAddress", "BASE:", "Base Address", "", cmVS7FlagTable::UserValue },
+  { "ImportLibrary", "IMPLIB:", "Import Library", "",
+    cmVS7FlagTable::UserValue },
+  { "MergeSections", "MERGE:", "Merge Sections", "",
+    cmVS7FlagTable::UserValue },
+  { "LinkKeyFile", "KEYFILE:", "Key File", "", cmVS7FlagTable::UserValue },
+  { "KeyContainer", "KEYCONTAINER:", "Key Container", "",
+    cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS12MASMFlagTable.h b/Source/cmVS12MASMFlagTable.h
index 74d529c..a7e4a80 100644
--- a/Source/cmVS12MASMFlagTable.h
+++ b/Source/cmVS12MASMFlagTable.h
@@ -1,96 +1,78 @@
-static cmVS7FlagTable cmVS12MASMFlagTable[] =
-{
+static cmVS7FlagTable cmVS12MASMFlagTable[] = {
 
-  //Enum Properties
-  {"PreserveIdentifierCase", "",
-   "Default", "0", 0},
-  {"PreserveIdentifierCase", "/Cp",
-   "Preserves Identifier Case (/Cp)", "1", 0},
-  {"PreserveIdentifierCase", "/Cu",
-   "Maps all identifiers to upper case. (/Cu)", "2", 0},
-  {"PreserveIdentifierCase", "/Cx",
-   "Preserves case in public and extern symbols. (/Cx)", "3", 0},
+  // Enum Properties
+  { "PreserveIdentifierCase", "", "Default", "0", 0 },
+  { "PreserveIdentifierCase", "/Cp", "Preserves Identifier Case (/Cp)", "1",
+    0 },
+  { "PreserveIdentifierCase", "/Cu",
+    "Maps all identifiers to upper case. (/Cu)", "2", 0 },
+  { "PreserveIdentifierCase", "/Cx",
+    "Preserves case in public and extern symbols. (/Cx)", "3", 0 },
 
-  {"WarningLevel", "/W0",
-   "Warning Level 0 (/W0)", "0", 0},
-  {"WarningLevel", "/W1",
-   "Warning Level 1 (/W1)", "1", 0},
-  {"WarningLevel", "/W2",
-   "Warning Level 2 (/W2)", "2", 0},
-  {"WarningLevel", "/W3",
-   "Warning Level 3 (/W3)", "3", 0},
+  { "WarningLevel", "/W0", "Warning Level 0 (/W0)", "0", 0 },
+  { "WarningLevel", "/W1", "Warning Level 1 (/W1)", "1", 0 },
+  { "WarningLevel", "/W2", "Warning Level 2 (/W2)", "2", 0 },
+  { "WarningLevel", "/W3", "Warning Level 3 (/W3)", "3", 0 },
 
-  {"PackAlignmentBoundary", "",
-   "Default", "0", 0},
-  {"PackAlignmentBoundary", "/Zp1",
-   "One Byte Boundary (/Zp1)", "1", 0},
-  {"PackAlignmentBoundary", "/Zp2",
-   "Two Byte Boundary (/Zp2)", "2", 0},
-  {"PackAlignmentBoundary", "/Zp4",
-   "Four Byte Boundary (/Zp4)", "3", 0},
-  {"PackAlignmentBoundary", "/Zp8",
-   "Eight Byte Boundary (/Zp8)", "4", 0},
-  {"PackAlignmentBoundary", "/Zp16",
-   "Sixteen Byte Boundary (/Zp16)", "5", 0},
+  { "PackAlignmentBoundary", "", "Default", "0", 0 },
+  { "PackAlignmentBoundary", "/Zp1", "One Byte Boundary (/Zp1)", "1", 0 },
+  { "PackAlignmentBoundary", "/Zp2", "Two Byte Boundary (/Zp2)", "2", 0 },
+  { "PackAlignmentBoundary", "/Zp4", "Four Byte Boundary (/Zp4)", "3", 0 },
+  { "PackAlignmentBoundary", "/Zp8", "Eight Byte Boundary (/Zp8)", "4", 0 },
+  { "PackAlignmentBoundary", "/Zp16", "Sixteen Byte Boundary (/Zp16)", "5",
+    0 },
 
-  {"CallingConvention", "",
-   "Default", "0", 0},
-  {"CallingConvention", "/Gd",
-   "Use C-style Calling Convention (/Gd)", "1", 0},
-  {"CallingConvention", "/Gz",
-   "Use stdcall Calling Convention (/Gz)", "2", 0},
-  {"CallingConvention", "/Gc",
-   "Use Pascal Calling Convention (/Gc)", "3", 0},
+  { "CallingConvention", "", "Default", "0", 0 },
+  { "CallingConvention", "/Gd", "Use C-style Calling Convention (/Gd)", "1",
+    0 },
+  { "CallingConvention", "/Gz", "Use stdcall Calling Convention (/Gz)", "2",
+    0 },
+  { "CallingConvention", "/Gc", "Use Pascal Calling Convention (/Gc)", "3",
+    0 },
 
-  {"ErrorReporting", "/errorReport:prompt",
-   "Prompt to send report immediately (/errorReport:prompt)", "0", 0},
-  {"ErrorReporting", "/errorReport:queue",
-   "Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
-  {"ErrorReporting", "/errorReport:send",
-   "Automatically send report (/errorReport:send)", "2", 0},
-  {"ErrorReporting", "/errorReport:none",
-   "Do not send report (/errorReport:none)", "3", 0},
+  { "ErrorReporting", "/errorReport:prompt",
+    "Prompt to send report immediately (/errorReport:prompt)", "0", 0 },
+  { "ErrorReporting", "/errorReport:queue",
+    "Prompt to send report at the next logon (/errorReport:queue)", "1", 0 },
+  { "ErrorReporting", "/errorReport:send",
+    "Automatically send report (/errorReport:send)", "2", 0 },
+  { "ErrorReporting", "/errorReport:none",
+    "Do not send report (/errorReport:none)", "3", 0 },
 
+  // Bool Properties
+  { "NoLogo", "/nologo", "", "true", 0 },
+  { "GeneratePreprocessedSourceListing", "/EP", "", "true", 0 },
+  { "ListAllAvailableInformation", "/Sa", "", "true", 0 },
+  { "UseSafeExceptionHandlers", "/safeseh", "", "true", 0 },
+  { "AddFirstPassListing", "/Sf", "", "true", 0 },
+  { "EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0 },
+  { "DisableSymbolTable", "/Sn", "", "true", 0 },
+  { "EnableFalseConditionalsInListing", "/Sx", "", "true", 0 },
+  { "TreatWarningsAsErrors", "/WX", "", "true", 0 },
+  { "MakeAllSymbolsPublic", "/Zf", "", "true", 0 },
+  { "GenerateDebugInformation", "/Zi", "", "true", 0 },
+  { "EnableMASM51Compatibility", "/Zm", "", "true", 0 },
+  { "PerformSyntaxCheckOnly", "/Zs", "", "true", 0 },
 
-  //Bool Properties
-  {"NoLogo", "/nologo", "", "true", 0},
-  {"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
-  {"ListAllAvailableInformation", "/Sa", "", "true", 0},
-  {"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
-  {"AddFirstPassListing", "/Sf", "", "true", 0},
-  {"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
-  {"DisableSymbolTable", "/Sn", "", "true", 0},
-  {"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
-  {"TreatWarningsAsErrors", "/WX", "", "true", 0},
-  {"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
-  {"GenerateDebugInformation", "/Zi", "", "true", 0},
-  {"EnableMASM51Compatibility", "/Zm", "", "true", 0},
-  {"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
-  {"PreprocessorDefinitions", "/D",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IncludePaths", "/I",
-   "Include Paths",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"BrowseFile", "/FR",
-   "Generate Browse Information File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "PreprocessorDefinitions", "/D", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IncludePaths", "/I", "Include Paths", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "BrowseFile", "/FR", "Generate Browse Information File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
 
-  //String Properties
+  // String Properties
   // Skip [Inputs] - no command line Switch.
-  {"ObjectFileName", "/Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"AssembledCodeListingFile", "/Fl",
-   "Assembled Code Listing File",
-   "", cmVS7FlagTable::UserValue},
+  { "ObjectFileName", "/Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "AssembledCodeListingFile", "/Fl", "Assembled Code Listing File", "",
+    cmVS7FlagTable::UserValue },
   // Skip [CommandLineTemplate] - no command line Switch.
   // Skip [ExecutionDescription] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS12RCFlagTable.h b/Source/cmVS12RCFlagTable.h
index 1551c66..d047f824 100644
--- a/Source/cmVS12RCFlagTable.h
+++ b/Source/cmVS12RCFlagTable.h
@@ -1,7 +1,6 @@
-static cmVS7FlagTable cmVS12RCFlagTable[] =
-{
-  //Bool Properties
-  {"NullTerminateStrings", "n", "", "true", 0},
+static cmVS7FlagTable cmVS12RCFlagTable[] = {
+  // Bool Properties
+  { "NullTerminateStrings", "n", "", "true", 0 },
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS14CLFlagTable.h b/Source/cmVS14CLFlagTable.h
index 173f624..4243f30 100644
--- a/Source/cmVS14CLFlagTable.h
+++ b/Source/cmVS14CLFlagTable.h
@@ -1,316 +1,238 @@
-static cmVS7FlagTable cmVS14CLFlagTable[] =
-{
-
-  //Enum Properties
-  {"DebugInformationFormat", "",
-   "None", "None", 0},
-  {"DebugInformationFormat", "Z7",
-   "C7 compatible", "OldStyle", 0},
-  {"DebugInformationFormat", "Zi",
-   "Program Database", "ProgramDatabase", 0},
-  {"DebugInformationFormat", "ZI",
-   "Program Database for Edit And Continue", "EditAndContinue", 0},
-
-  {"WarningLevel", "W0",
-   "Turn Off All Warnings", "TurnOffAllWarnings", 0},
-  {"WarningLevel", "W1",
-   "Level1", "Level1", 0},
-  {"WarningLevel", "W2",
-   "Level2", "Level2", 0},
-  {"WarningLevel", "W3",
-   "Level3", "Level3", 0},
-  {"WarningLevel", "W4",
-   "Level4", "Level4", 0},
-  {"WarningLevel", "Wall",
-   "EnableAllWarnings", "EnableAllWarnings", 0},
-
-  {"Optimization", "",
-   "Custom", "Custom", 0},
-  {"Optimization", "Od",
-   "Disabled", "Disabled", 0},
-  {"Optimization", "Os",
-   "Minimize Size", "MinSize", 0},
-  {"Optimization", "O1",
-   "Minimize Size", "MinSpace", 0},
-  {"Optimization", "O2",
-   "Maximize Speed", "MaxSpeed", 0},
-  {"Optimization", "Ox",
-   "Full Optimization", "Full", 0},
-
-  {"InlineFunctionExpansion", "",
-   "Default", "Default", 0},
-  {"InlineFunctionExpansion", "Ob0",
-   "Disabled", "Disabled", 0},
-  {"InlineFunctionExpansion", "Ob1",
-   "Only __inline", "OnlyExplicitInline", 0},
-  {"InlineFunctionExpansion", "Ob2",
-   "Any Suitable", "AnySuitable", 0},
-
-  {"FavorSizeOrSpeed", "Os",
-   "Favor small code", "Size", 0},
-  {"FavorSizeOrSpeed", "Ot",
-   "Favor fast code", "Speed", 0},
-  {"FavorSizeOrSpeed", "",
-   "Neither", "Neither", 0},
-
-  {"ExceptionHandling", "EHa",
-   "Yes with SEH Exceptions", "Async", 0},
-  {"ExceptionHandling", "EHsc",
-   "Yes", "Sync", 0},
-  {"ExceptionHandling", "EHs",
-   "Yes with Extern C functions", "SyncCThrow", 0},
-  {"ExceptionHandling", "",
-   "No", "false", 0},
-
-  {"BasicRuntimeChecks", "RTCs",
-   "Stack Frames", "StackFrameRuntimeCheck", 0},
-  {"BasicRuntimeChecks", "RTCu",
-   "Uninitialized variables", "UninitializedLocalUsageCheck", 0},
-  {"BasicRuntimeChecks", "RTC1",
-   "Both (/RTC1, equiv. to /RTCsu)", "EnableFastChecks", 0},
-  {"BasicRuntimeChecks", "",
-   "Default", "Default", 0},
-
-  {"RuntimeLibrary", "MT",
-   "Multi-threaded", "MultiThreaded", 0},
-  {"RuntimeLibrary", "MTd",
-   "Multi-threaded Debug", "MultiThreadedDebug", 0},
-  {"RuntimeLibrary", "MD",
-   "Multi-threaded DLL", "MultiThreadedDLL", 0},
-  {"RuntimeLibrary", "MDd",
-   "Multi-threaded Debug DLL", "MultiThreadedDebugDLL", 0},
-
-  {"StructMemberAlignment", "Zp1",
-   "1 Byte", "1Byte", 0},
-  {"StructMemberAlignment", "Zp2",
-   "2 Bytes", "2Bytes", 0},
-  {"StructMemberAlignment", "Zp4",
-   "4 Byte", "4Bytes", 0},
-  {"StructMemberAlignment", "Zp8",
-   "8 Bytes", "8Bytes", 0},
-  {"StructMemberAlignment", "Zp16",
-   "16 Bytes", "16Bytes", 0},
-  {"StructMemberAlignment", "",
-   "Default", "Default", 0},
-
-  {"BufferSecurityCheck", "GS-",
-   "Disable Security Check", "false", 0},
-  {"BufferSecurityCheck", "GS",
-   "Enable Security Check", "true", 0},
-
-  {"EnableEnhancedInstructionSet", "arch:SSE",
-   "Streaming SIMD Extensions", "StreamingSIMDExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:SSE2",
-   "Streaming SIMD Extensions 2", "StreamingSIMDExtensions2", 0},
-  {"EnableEnhancedInstructionSet", "arch:AVX",
-   "Advanced Vector Extensions", "AdvancedVectorExtensions", 0},
-  {"EnableEnhancedInstructionSet", "arch:AVX2",
-   "Advanced Vector Extensions 2", "AdvancedVectorExtensions2", 0},
-  {"EnableEnhancedInstructionSet", "arch:IA32",
-   "No Enhanced Instructions", "NoExtensions", 0},
-  {"EnableEnhancedInstructionSet", "",
-   "Not Set", "NotSet", 0},
-
-  {"FloatingPointModel", "fp:precise",
-   "Precise", "Precise", 0},
-  {"FloatingPointModel", "fp:strict",
-   "Strict", "Strict", 0},
-  {"FloatingPointModel", "fp:fast",
-   "Fast", "Fast", 0},
-
-  {"PrecompiledHeader", "Yc",
-   "Create", "Create",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "Yu",
-   "Use", "Use",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"PrecompiledHeader", "",
-   "Not Using Precompiled Headers", "NotUsing", 0},
-
-  {"AssemblerOutput", "",
-   "No Listing", "NoListing", 0},
-  {"AssemblerOutput", "FA",
-   "Assembly-Only Listing", "AssemblyCode", 0},
-  {"AssemblerOutput", "FAc",
-   "Assembly With Machine Code", "AssemblyAndMachineCode", 0},
-  {"AssemblerOutput", "FAs",
-   "Assembly With Source Code", "AssemblyAndSourceCode", 0},
-  {"AssemblerOutput", "FAcs",
-   "Assembly, Machine Code and Source", "All", 0},
-
-  {"CallingConvention", "Gd",
-   "__cdecl", "Cdecl", 0},
-  {"CallingConvention", "Gr",
-   "__fastcall", "FastCall", 0},
-  {"CallingConvention", "Gz",
-   "__stdcall", "StdCall", 0},
-  {"CallingConvention", "Gv",
-   "__vectorcall", "VectorCall", 0},
-
-  {"CompileAs", "",
-   "Default", "Default", 0},
-  {"CompileAs", "TC",
-   "Compile as C Code", "CompileAsC", 0},
-  {"CompileAs", "TP",
-   "Compile as C++ Code", "CompileAsCpp", 0},
-
-  {"ErrorReporting", "errorReport:none",
-   "Do Not Send Report", "None", 0},
-  {"ErrorReporting", "errorReport:prompt",
-   "Prompt Immediately", "Prompt", 0},
-  {"ErrorReporting", "errorReport:queue",
-   "Queue For Next Login", "Queue", 0},
-  {"ErrorReporting", "errorReport:send",
-   "Send Automatically", "Send", 0},
-
-  {"CompileAsManaged", "",
-   "No Common Language RunTime Support", "false", 0},
-  {"CompileAsManaged", "clr",
-   "Common Language RunTime Support", "true", 0},
-  {"CompileAsManaged", "clr:pure",
-   "Pure MSIL Common Language RunTime Support", "Pure", 0},
-  {"CompileAsManaged", "clr:safe",
-   "Safe MSIL Common Language RunTime Support", "Safe", 0},
-  {"CompileAsManaged", "clr:oldSyntax",
-   "Common Language RunTime Support, Old Syntax", "OldSyntax", 0},
-
-  {"CppLanguageStandard", "",
-   "Default", "Default", 0},
-  {"CppLanguageStandard", "std=c++98",
-   "C++03", "c++98", 0},
-  {"CppLanguageStandard", "std=c++11",
-   "C++11", "c++11", 0},
-  {"CppLanguageStandard", "std=c++1y",
-   "C++14", "c++1y", 0 },
-  {"CppLanguageStandard", "std=c++14",
-   "C++14", "c++1y", 0 },
-  {"CppLanguageStandard", "std=gnu++98",
-   "C++03 (GNU Dialect)", "gnu++98", 0},
-  {"CppLanguageStandard", "std=gnu++11",
-   "C++11 (GNU Dialect)", "gnu++11", 0},
-  {"CppLanguageStandard", "std=gnu++1y",
-   "C++14 (GNU Dialect)", "gnu++1y", 0},
-  {"CppLanguageStandard", "std=gnu++14",
-   "C++14 (GNU Dialect)", "gnu++1y", 0},
-
-  //Bool Properties
-  {"CompileAsWinRT", "ZW", "", "true", 0},
-  {"WinRTNoStdLib", "ZW:nostdlib", "", "true", 0},
-  {"SuppressStartupBanner", "nologo", "", "true", 0},
-  {"TreatWarningAsError", "WX-", "", "false", 0},
-  {"TreatWarningAsError", "WX", "", "true", 0},
-  {"SDLCheck", "sdl-", "", "false", 0},
-  {"SDLCheck", "sdl", "", "true", 0},
-  {"IntrinsicFunctions", "Oi", "", "true", 0},
-  {"OmitFramePointers", "Oy-", "", "false", 0},
-  {"OmitFramePointers", "Oy", "", "true", 0},
-  {"EnableFiberSafeOptimizations", "GT", "", "true", 0},
-  {"WholeProgramOptimization", "GL", "", "true", 0},
-  {"UndefineAllPreprocessorDefinitions", "u", "", "true", 0},
-  {"IgnoreStandardIncludePath", "X", "", "true", 0},
-  {"PreprocessToFile", "P", "", "true", 0},
-  {"PreprocessSuppressLineNumbers", "EP", "", "true", 0},
-  {"PreprocessKeepComments", "C", "", "true", 0},
-  {"StringPooling", "GF-", "", "false", 0},
-  {"StringPooling", "GF", "", "true", 0},
-  {"MinimalRebuild", "Gm-", "", "false", 0},
-  {"MinimalRebuild", "Gm", "", "true", 0},
-  {"SmallerTypeCheck", "RTCc", "", "true", 0},
-  {"FunctionLevelLinking", "Gy-", "", "false", 0},
-  {"FunctionLevelLinking", "Gy", "", "true", 0},
-  {"EnableParallelCodeGeneration", "Qpar-", "", "false", 0},
-  {"EnableParallelCodeGeneration", "Qpar", "", "true", 0},
-  {"FloatingPointExceptions", "fp:except-", "", "false", 0},
-  {"FloatingPointExceptions", "fp:except", "", "true", 0},
-  {"CreateHotpatchableImage", "hotpatch", "", "true", 0},
-  {"DisableLanguageExtensions", "Za", "", "true", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0},
-  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0},
-  {"ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0},
-  {"RuntimeTypeInfo", "GR-", "", "false", 0},
-  {"RuntimeTypeInfo", "GR", "", "true", 0},
-  {"OpenMPSupport", "openmp-", "", "false", 0},
-  {"OpenMPSupport", "openmp", "", "true", 0},
-  {"ExpandAttributedSource", "Fx", "", "true", 0},
-  {"UseUnicodeForAssemblerListing", "FAu", "", "true", 0},
-  {"ShowIncludes", "showIncludes", "", "true", 0},
-  {"EnablePREfast", "analyze-", "", "false", 0},
-  {"EnablePREfast", "analyze", "", "true", 0},
-  {"UseFullPaths", "FC", "", "true", 0},
-  {"OmitDefaultLibName", "Zl", "", "true", 0},
-
-  //Bool Properties With Argument
-  {"MultiProcessorCompilation", "MP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"ProcessorNumber", "MP", "Multi-processor Compilation", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateXMLDocumentationFiles", "doc", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"BrowseInformation", "FR", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"BrowseInformationFile", "FR", "Enable Browse Information", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalIncludeDirectories", "I",
-   "Additional Include Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalUsingDirectories", "AI",
-   "Additional #using Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PreprocessorDefinitions", "D ",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"UndefinePreprocessorDefinitions", "U",
-   "Undefine Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DisableSpecificWarnings", "wd",
-   "Disable Specific Warnings",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedIncludeFiles", "FI",
-   "Forced Include File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForcedUsingFiles", "FU",
-   "Forced #using File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"PREfastLog", "analyze:log",
-   "Code Analysis Log",
-   "", cmVS7FlagTable::UserFollowing},
-  {"PREfastAdditionalPlugins", "analyze:plugin",
-   "Additional Code Analysis Native plugins",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"TreatSpecificWarningsAsErrors", "we",
-   "Treat Specific Warnings As Errors",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-
-  //String Properties
+static cmVS7FlagTable cmVS14CLFlagTable[] = {
+
+  // Enum Properties
+  { "DebugInformationFormat", "", "None", "None", 0 },
+  { "DebugInformationFormat", "Z7", "C7 compatible", "OldStyle", 0 },
+  { "DebugInformationFormat", "Zi", "Program Database", "ProgramDatabase", 0 },
+  { "DebugInformationFormat", "ZI", "Program Database for Edit And Continue",
+    "EditAndContinue", 0 },
+
+  { "WarningLevel", "W0", "Turn Off All Warnings", "TurnOffAllWarnings", 0 },
+  { "WarningLevel", "W1", "Level1", "Level1", 0 },
+  { "WarningLevel", "W2", "Level2", "Level2", 0 },
+  { "WarningLevel", "W3", "Level3", "Level3", 0 },
+  { "WarningLevel", "W4", "Level4", "Level4", 0 },
+  { "WarningLevel", "Wall", "EnableAllWarnings", "EnableAllWarnings", 0 },
+
+  { "Optimization", "", "Custom", "Custom", 0 },
+  { "Optimization", "Od", "Disabled", "Disabled", 0 },
+  { "Optimization", "Os", "Minimize Size", "MinSize", 0 },
+  { "Optimization", "O1", "Minimize Size", "MinSpace", 0 },
+  { "Optimization", "O2", "Maximize Speed", "MaxSpeed", 0 },
+  { "Optimization", "Ox", "Full Optimization", "Full", 0 },
+
+  { "InlineFunctionExpansion", "", "Default", "Default", 0 },
+  { "InlineFunctionExpansion", "Ob0", "Disabled", "Disabled", 0 },
+  { "InlineFunctionExpansion", "Ob1", "Only __inline", "OnlyExplicitInline",
+    0 },
+  { "InlineFunctionExpansion", "Ob2", "Any Suitable", "AnySuitable", 0 },
+
+  { "FavorSizeOrSpeed", "Os", "Favor small code", "Size", 0 },
+  { "FavorSizeOrSpeed", "Ot", "Favor fast code", "Speed", 0 },
+  { "FavorSizeOrSpeed", "", "Neither", "Neither", 0 },
+
+  { "ExceptionHandling", "EHa", "Yes with SEH Exceptions", "Async", 0 },
+  { "ExceptionHandling", "EHsc", "Yes", "Sync", 0 },
+  { "ExceptionHandling", "EHs", "Yes with Extern C functions", "SyncCThrow",
+    0 },
+  { "ExceptionHandling", "", "No", "false", 0 },
+
+  { "BasicRuntimeChecks", "RTCs", "Stack Frames", "StackFrameRuntimeCheck",
+    0 },
+  { "BasicRuntimeChecks", "RTCu", "Uninitialized variables",
+    "UninitializedLocalUsageCheck", 0 },
+  { "BasicRuntimeChecks", "RTC1", "Both (/RTC1, equiv. to /RTCsu)",
+    "EnableFastChecks", 0 },
+  { "BasicRuntimeChecks", "", "Default", "Default", 0 },
+
+  { "RuntimeLibrary", "MT", "Multi-threaded", "MultiThreaded", 0 },
+  { "RuntimeLibrary", "MTd", "Multi-threaded Debug", "MultiThreadedDebug", 0 },
+  { "RuntimeLibrary", "MD", "Multi-threaded DLL", "MultiThreadedDLL", 0 },
+  { "RuntimeLibrary", "MDd", "Multi-threaded Debug DLL",
+    "MultiThreadedDebugDLL", 0 },
+
+  { "StructMemberAlignment", "Zp1", "1 Byte", "1Byte", 0 },
+  { "StructMemberAlignment", "Zp2", "2 Bytes", "2Bytes", 0 },
+  { "StructMemberAlignment", "Zp4", "4 Byte", "4Bytes", 0 },
+  { "StructMemberAlignment", "Zp8", "8 Bytes", "8Bytes", 0 },
+  { "StructMemberAlignment", "Zp16", "16 Bytes", "16Bytes", 0 },
+  { "StructMemberAlignment", "", "Default", "Default", 0 },
+
+  { "BufferSecurityCheck", "GS-", "Disable Security Check", "false", 0 },
+  { "BufferSecurityCheck", "GS", "Enable Security Check", "true", 0 },
+
+  { "EnableEnhancedInstructionSet", "arch:SSE", "Streaming SIMD Extensions",
+    "StreamingSIMDExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:SSE2", "Streaming SIMD Extensions 2",
+    "StreamingSIMDExtensions2", 0 },
+  { "EnableEnhancedInstructionSet", "arch:AVX", "Advanced Vector Extensions",
+    "AdvancedVectorExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "arch:AVX2",
+    "Advanced Vector Extensions 2", "AdvancedVectorExtensions2", 0 },
+  { "EnableEnhancedInstructionSet", "arch:IA32", "No Enhanced Instructions",
+    "NoExtensions", 0 },
+  { "EnableEnhancedInstructionSet", "", "Not Set", "NotSet", 0 },
+
+  { "FloatingPointModel", "fp:precise", "Precise", "Precise", 0 },
+  { "FloatingPointModel", "fp:strict", "Strict", "Strict", 0 },
+  { "FloatingPointModel", "fp:fast", "Fast", "Fast", 0 },
+
+  { "PrecompiledHeader", "Yc", "Create", "Create",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "Yu", "Use", "Use",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "PrecompiledHeader", "", "Not Using Precompiled Headers", "NotUsing", 0 },
+
+  { "AssemblerOutput", "", "No Listing", "NoListing", 0 },
+  { "AssemblerOutput", "FA", "Assembly-Only Listing", "AssemblyCode", 0 },
+  { "AssemblerOutput", "FAc", "Assembly With Machine Code",
+    "AssemblyAndMachineCode", 0 },
+  { "AssemblerOutput", "FAs", "Assembly With Source Code",
+    "AssemblyAndSourceCode", 0 },
+  { "AssemblerOutput", "FAcs", "Assembly, Machine Code and Source", "All", 0 },
+
+  { "CallingConvention", "Gd", "__cdecl", "Cdecl", 0 },
+  { "CallingConvention", "Gr", "__fastcall", "FastCall", 0 },
+  { "CallingConvention", "Gz", "__stdcall", "StdCall", 0 },
+  { "CallingConvention", "Gv", "__vectorcall", "VectorCall", 0 },
+
+  { "CompileAs", "", "Default", "Default", 0 },
+  { "CompileAs", "TC", "Compile as C Code", "CompileAsC", 0 },
+  { "CompileAs", "TP", "Compile as C++ Code", "CompileAsCpp", 0 },
+
+  { "ErrorReporting", "errorReport:none", "Do Not Send Report", "None", 0 },
+  { "ErrorReporting", "errorReport:prompt", "Prompt Immediately", "Prompt",
+    0 },
+  { "ErrorReporting", "errorReport:queue", "Queue For Next Login", "Queue",
+    0 },
+  { "ErrorReporting", "errorReport:send", "Send Automatically", "Send", 0 },
+
+  { "CompileAsManaged", "", "No Common Language RunTime Support", "false", 0 },
+  { "CompileAsManaged", "clr", "Common Language RunTime Support", "true", 0 },
+  { "CompileAsManaged", "clr:pure",
+    "Pure MSIL Common Language RunTime Support", "Pure", 0 },
+  { "CompileAsManaged", "clr:safe",
+    "Safe MSIL Common Language RunTime Support", "Safe", 0 },
+  { "CompileAsManaged", "clr:oldSyntax",
+    "Common Language RunTime Support, Old Syntax", "OldSyntax", 0 },
+
+  { "CppLanguageStandard", "", "Default", "Default", 0 },
+  { "CppLanguageStandard", "std=c++98", "C++03", "c++98", 0 },
+  { "CppLanguageStandard", "std=c++11", "C++11", "c++11", 0 },
+  { "CppLanguageStandard", "std=c++1y", "C++14", "c++1y", 0 },
+  { "CppLanguageStandard", "std=c++14", "C++14", "c++1y", 0 },
+  { "CppLanguageStandard", "std=gnu++98", "C++03 (GNU Dialect)", "gnu++98",
+    0 },
+  { "CppLanguageStandard", "std=gnu++11", "C++11 (GNU Dialect)", "gnu++11",
+    0 },
+  { "CppLanguageStandard", "std=gnu++1y", "C++14 (GNU Dialect)", "gnu++1y",
+    0 },
+  { "CppLanguageStandard", "std=gnu++14", "C++14 (GNU Dialect)", "gnu++1y",
+    0 },
+
+  // Bool Properties
+  { "CompileAsWinRT", "ZW", "", "true", 0 },
+  { "WinRTNoStdLib", "ZW:nostdlib", "", "true", 0 },
+  { "SuppressStartupBanner", "nologo", "", "true", 0 },
+  { "TreatWarningAsError", "WX-", "", "false", 0 },
+  { "TreatWarningAsError", "WX", "", "true", 0 },
+  { "SDLCheck", "sdl-", "", "false", 0 },
+  { "SDLCheck", "sdl", "", "true", 0 },
+  { "IntrinsicFunctions", "Oi", "", "true", 0 },
+  { "OmitFramePointers", "Oy-", "", "false", 0 },
+  { "OmitFramePointers", "Oy", "", "true", 0 },
+  { "EnableFiberSafeOptimizations", "GT", "", "true", 0 },
+  { "WholeProgramOptimization", "GL", "", "true", 0 },
+  { "UndefineAllPreprocessorDefinitions", "u", "", "true", 0 },
+  { "IgnoreStandardIncludePath", "X", "", "true", 0 },
+  { "PreprocessToFile", "P", "", "true", 0 },
+  { "PreprocessSuppressLineNumbers", "EP", "", "true", 0 },
+  { "PreprocessKeepComments", "C", "", "true", 0 },
+  { "StringPooling", "GF-", "", "false", 0 },
+  { "StringPooling", "GF", "", "true", 0 },
+  { "MinimalRebuild", "Gm-", "", "false", 0 },
+  { "MinimalRebuild", "Gm", "", "true", 0 },
+  { "SmallerTypeCheck", "RTCc", "", "true", 0 },
+  { "FunctionLevelLinking", "Gy-", "", "false", 0 },
+  { "FunctionLevelLinking", "Gy", "", "true", 0 },
+  { "EnableParallelCodeGeneration", "Qpar-", "", "false", 0 },
+  { "EnableParallelCodeGeneration", "Qpar", "", "true", 0 },
+  { "FloatingPointExceptions", "fp:except-", "", "false", 0 },
+  { "FloatingPointExceptions", "fp:except", "", "true", 0 },
+  { "CreateHotpatchableImage", "hotpatch", "", "true", 0 },
+  { "DisableLanguageExtensions", "Za", "", "true", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0 },
+  { "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0 },
+  { "ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0 },
+  { "RuntimeTypeInfo", "GR-", "", "false", 0 },
+  { "RuntimeTypeInfo", "GR", "", "true", 0 },
+  { "OpenMPSupport", "openmp-", "", "false", 0 },
+  { "OpenMPSupport", "openmp", "", "true", 0 },
+  { "ExpandAttributedSource", "Fx", "", "true", 0 },
+  { "UseUnicodeForAssemblerListing", "FAu", "", "true", 0 },
+  { "ShowIncludes", "showIncludes", "", "true", 0 },
+  { "EnablePREfast", "analyze-", "", "false", 0 },
+  { "EnablePREfast", "analyze", "", "true", 0 },
+  { "UseFullPaths", "FC", "", "true", 0 },
+  { "OmitDefaultLibName", "Zl", "", "true", 0 },
+
+  // Bool Properties With Argument
+  { "MultiProcessorCompilation", "MP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "ProcessorNumber", "MP", "Multi-processor Compilation", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateXMLDocumentationFiles", "doc", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "BrowseInformation", "FR", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "BrowseInformationFile", "FR", "Enable Browse Information", "",
+    cmVS7FlagTable::UserValueRequired },
+
+  // String List Properties
+  { "AdditionalIncludeDirectories", "I", "Additional Include Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalUsingDirectories", "AI", "Additional #using Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PreprocessorDefinitions", "D ", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "UndefinePreprocessorDefinitions", "U",
+    "Undefine Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DisableSpecificWarnings", "wd", "Disable Specific Warnings", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedIncludeFiles", "FI", "Forced Include File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForcedUsingFiles", "FU", "Forced #using File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "PREfastLog", "analyze:log", "Code Analysis Log", "",
+    cmVS7FlagTable::UserFollowing },
+  { "PREfastAdditionalPlugins", "analyze:plugin",
+    "Additional Code Analysis Native plugins", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "TreatSpecificWarningsAsErrors", "we", "Treat Specific Warnings As Errors",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+
+  // String Properties
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"PreprocessOutputPath", "Fi",
-   "Preprocess Output Path",
-   "", cmVS7FlagTable::UserValue},
-  {"PrecompiledHeaderFile", "Yc",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderFile", "Yu",
-   "Precompiled Header Name",
-   "", cmVS7FlagTable::UserValueRequired},
-  {"PrecompiledHeaderOutputFile", "Fp",
-   "Precompiled Header Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"AssemblerListingLocation", "Fa",
-   "ASM List Location",
-   "", cmVS7FlagTable::UserValue},
-  {"ObjectFileName", "Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDataBaseFileName", "Fd",
-   "Program Database File Name",
-   "", cmVS7FlagTable::UserValue},
+  { "PreprocessOutputPath", "Fi", "Preprocess Output Path", "",
+    cmVS7FlagTable::UserValue },
+  { "PrecompiledHeaderFile", "Yc", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderFile", "Yu", "Precompiled Header Name", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "PrecompiledHeaderOutputFile", "Fp", "Precompiled Header Output File", "",
+    cmVS7FlagTable::UserValue },
+  { "AssemblerListingLocation", "Fa", "ASM List Location", "",
+    cmVS7FlagTable::UserValue },
+  { "ObjectFileName", "Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDataBaseFileName", "Fd", "Program Database File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [XMLDocumentationFileName] - no command line Switch.
   // Skip [BrowseInformationFile] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS14LibFlagTable.h b/Source/cmVS14LibFlagTable.h
index a33f273..7fa7138 100644
--- a/Source/cmVS14LibFlagTable.h
+++ b/Source/cmVS14LibFlagTable.h
@@ -1,102 +1,76 @@
-static cmVS7FlagTable cmVS14LibFlagTable[] =
-{
+static cmVS7FlagTable cmVS14LibFlagTable[] = {
 
-  //Enum Properties
-  {"ErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"ErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"ErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"ErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  // Enum Properties
+  { "ErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "ErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "ErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "ErrorReporting", "ERRORREPORT:NONE", "No Error Report", "NoErrorReport",
+    0 },
 
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWSCE",
-   "WindowsCE", "WindowsCE", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
+  // Bool Properties
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "TreatLibWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLibWarningAsErrors", "WX", "", "true", 0 },
+  { "Verbose", "VERBOSE", "", "true", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "", "true", 0 },
 
-  //Bool Properties
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"TreatLibWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLibWarningAsErrors", "WX", "", "true", 0},
-  {"Verbose", "VERBOSE", "", "true", 0},
-  {"LinkTimeCodeGeneration", "LTCG", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
+  // String List Properties
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ExportNamedFunctions", "EXPORT:",
-   "Export Named Functions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"RemoveObjects", "REMOVE:",
-   "Remove Objects",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ExportNamedFunctions", "EXPORT:", "Export Named Functions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "RemoveObjects", "REMOVE:", "Remove Objects", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue},
-  {"DisplayLibrary", "LIST:",
-   "Display Library to standard output",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue },
+  { "DisplayLibrary", "LIST:", "Display Library to standard output", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"Name", "NAME:",
-   "Name",
-   "", cmVS7FlagTable::UserValue},
+  { "Name", "NAME:", "Name", "", cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS14LinkFlagTable.h b/Source/cmVS14LinkFlagTable.h
index 29e3d86..6e56422 100644
--- a/Source/cmVS14LinkFlagTable.h
+++ b/Source/cmVS14LinkFlagTable.h
@@ -1,343 +1,271 @@
-static cmVS7FlagTable cmVS14LinkFlagTable[] =
-{
+static cmVS7FlagTable cmVS14LinkFlagTable[] = {
 
-  //Enum Properties
-  {"ShowProgress", "",
-   "Not Set", "NotSet", 0},
-  {"ShowProgress", "VERBOSE",
-   "Display all progress messages", "LinkVerbose", 0},
-  {"ShowProgress", "VERBOSE:Lib",
-   "For Libraries Searched", "LinkVerboseLib", 0},
-  {"ShowProgress", "VERBOSE:ICF",
-   "About COMDAT folding during optimized linking", "LinkVerboseICF", 0},
-  {"ShowProgress", "VERBOSE:REF",
-   "About data removed during optimized linking", "LinkVerboseREF", 0},
-  {"ShowProgress", "VERBOSE:SAFESEH",
-   "About Modules incompatible with SEH", "LinkVerboseSAFESEH", 0},
-  {"ShowProgress", "VERBOSE:CLR",
-   "About linker activity related to managed code", "LinkVerboseCLR", 0},
+  // Enum Properties
+  { "ShowProgress", "", "Not Set", "NotSet", 0 },
+  { "ShowProgress", "VERBOSE", "Display all progress messages", "LinkVerbose",
+    0 },
+  { "ShowProgress", "VERBOSE:Lib", "For Libraries Searched", "LinkVerboseLib",
+    0 },
+  { "ShowProgress", "VERBOSE:ICF",
+    "About COMDAT folding during optimized linking", "LinkVerboseICF", 0 },
+  { "ShowProgress", "VERBOSE:REF",
+    "About data removed during optimized linking", "LinkVerboseREF", 0 },
+  { "ShowProgress", "VERBOSE:SAFESEH", "About Modules incompatible with SEH",
+    "LinkVerboseSAFESEH", 0 },
+  { "ShowProgress", "VERBOSE:CLR",
+    "About linker activity related to managed code", "LinkVerboseCLR", 0 },
 
-  {"ForceFileOutput", "FORCE",
-   "Enabled", "Enabled", 0},
-  {"ForceFileOutput", "FORCE:MULTIPLE",
-   "Multiply Defined Symbol Only", "MultiplyDefinedSymbolOnly", 0},
-  {"ForceFileOutput", "FORCE:UNRESOLVED",
-   "Undefined Symbol Only", "UndefinedSymbolOnly", 0},
+  { "ForceFileOutput", "FORCE", "Enabled", "Enabled", 0 },
+  { "ForceFileOutput", "FORCE:MULTIPLE", "Multiply Defined Symbol Only",
+    "MultiplyDefinedSymbolOnly", 0 },
+  { "ForceFileOutput", "FORCE:UNRESOLVED", "Undefined Symbol Only",
+    "UndefinedSymbolOnly", 0 },
 
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN",
-   "Enabled", "Enabled", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:5",
-   "X86 Image Only", "X86Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:6",
-   "X64 Image Only", "X64Image", 0},
-  {"CreateHotPatchableImage", "FUNCTIONPADMIN:16",
-   "Itanium Image Only", "ItaniumImage", 0},
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN", "Enabled", "Enabled", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:5", "X86 Image Only",
+    "X86Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:6", "X64 Image Only",
+    "X64Image", 0 },
+  { "CreateHotPatchableImage", "FUNCTIONPADMIN:16", "Itanium Image Only",
+    "ItaniumImage", 0 },
 
-  {"UACExecutionLevel", "level='asInvoker'",
-   "asInvoker", "AsInvoker", 0},
-  {"UACExecutionLevel", "level='highestAvailable'",
-   "highestAvailable", "HighestAvailable", 0},
-  {"UACExecutionLevel", "level='requireAdministrator'",
-   "requireAdministrator", "RequireAdministrator", 0},
+  { "UACExecutionLevel", "level='asInvoker'", "asInvoker", "AsInvoker", 0 },
+  { "UACExecutionLevel", "level='highestAvailable'", "highestAvailable",
+    "HighestAvailable", 0 },
+  { "UACExecutionLevel", "level='requireAdministrator'",
+    "requireAdministrator", "RequireAdministrator", 0 },
 
-  {"SubSystem", "",
-   "Not Set", "NotSet", 0},
-  {"SubSystem", "SUBSYSTEM:CONSOLE",
-   "Console", "Console", 0},
-  {"SubSystem", "SUBSYSTEM:WINDOWS",
-   "Windows", "Windows", 0},
-  {"SubSystem", "SUBSYSTEM:NATIVE",
-   "Native", "Native", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_APPLICATION",
-   "EFI Application", "EFI Application", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
-   "EFI Boot Service Driver", "EFI Boot Service Driver", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_ROM",
-   "EFI ROM", "EFI ROM", 0},
-  {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER",
-   "EFI Runtime", "EFI Runtime", 0},
-  {"SubSystem", "SUBSYSTEM:POSIX",
-   "POSIX", "POSIX", 0},
+  { "SubSystem", "", "Not Set", "NotSet", 0 },
+  { "SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0 },
+  { "SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0 },
+  { "SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application",
+    "EFI Application", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER",
+    "EFI Boot Service Driver", "EFI Boot Service Driver", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0 },
+  { "SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime",
+    0 },
+  { "SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0 },
 
-  {"Driver", "",
-   "Not Set", "NotSet", 0},
-  {"Driver", "Driver",
-   "Driver", "Driver", 0},
-  {"Driver", "DRIVER:UPONLY",
-   "UP Only", "UpOnly", 0},
-  {"Driver", "DRIVER:WDM",
-   "WDM", "WDM", 0},
+  { "Driver", "", "Not Set", "NotSet", 0 },
+  { "Driver", "Driver", "Driver", "Driver", 0 },
+  { "Driver", "DRIVER:UPONLY", "UP Only", "UpOnly", 0 },
+  { "Driver", "DRIVER:WDM", "WDM", "WDM", 0 },
 
-  {"LinkTimeCodeGeneration", "",
-   "Default", "Default", 0},
-  {"LinkTimeCodeGeneration", "LTCG",
-   "Use Link Time Code Generation", "UseLinkTimeCodeGeneration", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGInstrument",
-   "Profile Guided Optimization - Instrument", "PGInstrument", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGOptimize",
-   "Profile Guided Optimization - Optimization", "PGOptimization", 0},
-  {"LinkTimeCodeGeneration", "LTCG:PGUpdate",
-   "Profile Guided Optimization - Update", "PGUpdate", 0},
+  { "LinkTimeCodeGeneration", "", "Default", "Default", 0 },
+  { "LinkTimeCodeGeneration", "LTCG", "Use Link Time Code Generation",
+    "UseLinkTimeCodeGeneration", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGInstrument",
+    "Profile Guided Optimization - Instrument", "PGInstrument", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGOptimize",
+    "Profile Guided Optimization - Optimization", "PGOptimization", 0 },
+  { "LinkTimeCodeGeneration", "LTCG:PGUpdate",
+    "Profile Guided Optimization - Update", "PGUpdate", 0 },
 
-  {"GenerateWindowsMetadata", "WINMD",
-   "Yes", "true", 0},
-  {"GenerateWindowsMetadata", "WINMD:NO",
-   "No", "false", 0},
+  { "GenerateWindowsMetadata", "WINMD", "Yes", "true", 0 },
+  { "GenerateWindowsMetadata", "WINMD:NO", "No", "false", 0 },
 
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA1",
-   "SHA1", "SHA1", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA256",
-   "SHA256", "SHA256", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA384",
-   "SHA384", "SHA384", 0},
-  {"WindowsMetadataSignHash", "WINMDSIGNHASH:SHA512",
-   "SHA512", "SHA512", 0},
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA1", "SHA1", "SHA1", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA256", "SHA256", "SHA256", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA384", "SHA384", "SHA384", 0 },
+  { "WindowsMetadataSignHash", "WINMDSIGNHASH:SHA512", "SHA512", "SHA512", 0 },
 
-  {"TargetMachine", "",
-   "Not Set", "NotSet", 0},
-  {"TargetMachine", "MACHINE:ARM",
-   "MachineARM", "MachineARM", 0},
-  {"TargetMachine", "MACHINE:EBC",
-   "MachineEBC", "MachineEBC", 0},
-  {"TargetMachine", "MACHINE:IA64",
-   "MachineIA64", "MachineIA64", 0},
-  {"TargetMachine", "MACHINE:MIPS",
-   "MachineMIPS", "MachineMIPS", 0},
-  {"TargetMachine", "MACHINE:MIPS16",
-   "MachineMIPS16", "MachineMIPS16", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU",
-   "MachineMIPSFPU", "MachineMIPSFPU", 0},
-  {"TargetMachine", "MACHINE:MIPSFPU16",
-   "MachineMIPSFPU16", "MachineMIPSFPU16", 0},
-  {"TargetMachine", "MACHINE:SH4",
-   "MachineSH4", "MachineSH4", 0},
-  {"TargetMachine", "MACHINE:THUMB",
-   "MachineTHUMB", "MachineTHUMB", 0},
-  {"TargetMachine", "MACHINE:X64",
-   "MachineX64", "MachineX64", 0},
-  {"TargetMachine", "MACHINE:X86",
-   "MachineX86", "MachineX86", 0},
+  { "TargetMachine", "", "Not Set", "NotSet", 0 },
+  { "TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0 },
+  { "TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0 },
+  { "TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0 },
+  { "TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0 },
+  { "TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0 },
+  { "TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU",
+    0 },
+  { "TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16",
+    "MachineMIPSFPU16", 0 },
+  { "TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0 },
+  { "TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0 },
+  { "TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0 },
+  { "TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0 },
 
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA",
-   "MTA threading attribute", "MTAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA",
-   "STA threading attribute", "STAThreadingAttribute", 0},
-  {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
-   "Default threading attribute", "DefaultThreadingAttribute", 0},
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA", "MTA threading attribute",
+    "MTAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA", "STA threading attribute",
+    "STAThreadingAttribute", 0 },
+  { "CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE",
+    "Default threading attribute", "DefaultThreadingAttribute", 0 },
 
-  {"CLRImageType", "CLRIMAGETYPE:IJW",
-   "Force IJW image", "ForceIJWImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:PURE",
-   "Force Pure IL Image", "ForcePureILImage", 0},
-  {"CLRImageType", "CLRIMAGETYPE:SAFE",
-   "Force Safe IL Image", "ForceSafeILImage", 0},
-  {"CLRImageType", "",
-   "Default image type", "Default", 0},
+  { "CLRImageType", "CLRIMAGETYPE:IJW", "Force IJW image", "ForceIJWImage",
+    0 },
+  { "CLRImageType", "CLRIMAGETYPE:PURE", "Force Pure IL Image",
+    "ForcePureILImage", 0 },
+  { "CLRImageType", "CLRIMAGETYPE:SAFE", "Force Safe IL Image",
+    "ForceSafeILImage", 0 },
+  { "CLRImageType", "", "Default image type", "Default", 0 },
 
-  {"SignHash", "CLRSIGNHASH:SHA1",
-   "SHA1", "SHA1", 0},
-  {"SignHash", "CLRSIGNHASH:SHA256",
-   "SHA256", "SHA256", 0},
-  {"SignHash", "CLRSIGNHASH:SHA384",
-   "SHA384", "SHA384", 0},
-  {"SignHash", "CLRSIGNHASH:SHA512",
-   "SHA512", "SHA512", 0},
+  { "SignHash", "CLRSIGNHASH:SHA1", "SHA1", "SHA1", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA256", "SHA256", "SHA256", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA384", "SHA384", "SHA384", 0 },
+  { "SignHash", "CLRSIGNHASH:SHA512", "SHA512", "SHA512", 0 },
 
-  {"LinkErrorReporting", "ERRORREPORT:PROMPT",
-   "PromptImmediately", "PromptImmediately", 0},
-  {"LinkErrorReporting", "ERRORREPORT:QUEUE",
-   "Queue For Next Login", "QueueForNextLogin", 0},
-  {"LinkErrorReporting", "ERRORREPORT:SEND",
-   "Send Error Report", "SendErrorReport", 0},
-  {"LinkErrorReporting", "ERRORREPORT:NONE",
-   "No Error Report", "NoErrorReport", 0},
+  { "LinkErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately",
+    "PromptImmediately", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login",
+    "QueueForNextLogin", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:SEND", "Send Error Report",
+    "SendErrorReport", 0 },
+  { "LinkErrorReporting", "ERRORREPORT:NONE", "No Error Report",
+    "NoErrorReport", 0 },
 
-  {"CLRSupportLastError", "CLRSupportLastError",
-   "Enabled", "Enabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:NO",
-   "Disabled", "Disabled", 0},
-  {"CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL",
-   "System Dlls Only", "SystemDlls", 0},
+  { "CLRSupportLastError", "CLRSupportLastError", "Enabled", "Enabled", 0 },
+  { "CLRSupportLastError", "CLRSupportLastError:NO", "Disabled", "Disabled",
+    0 },
+  { "CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL", "System Dlls Only",
+    "SystemDlls", 0 },
 
+  // Bool Properties
+  { "LinkIncremental", "INCREMENTAL:NO", "", "false", 0 },
+  { "LinkIncremental", "INCREMENTAL", "", "true", 0 },
+  { "SuppressStartupBanner", "NOLOGO", "", "true", 0 },
+  { "LinkStatus", "LTCG:NOSTATUS", "", "false", 0 },
+  { "LinkStatus", "LTCG:STATUS", "", "true", 0 },
+  { "PreventDllBinding", "ALLOWBIND:NO", "", "false", 0 },
+  { "PreventDllBinding", "ALLOWBIND", "", "true", 0 },
+  { "TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0 },
+  { "TreatLinkerWarningAsErrors", "WX", "", "true", 0 },
+  { "IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0 },
+  { "GenerateManifest", "MANIFEST:NO", "", "false", 0 },
+  { "GenerateManifest", "MANIFEST", "", "true", 0 },
+  { "AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='false'", "", "false", 0 },
+  { "UACUIAccess", "uiAccess='true'", "", "true", 0 },
+  { "ManifestEmbed", "manifest:embed", "", "true", 0 },
+  { "GenerateDebugInformation", "DEBUG:FASTLINK", "", "DebugFastLink",
+    cmVS7FlagTable::CaseInsensitive },
+  { "GenerateDebugInformation", "DEBUG", "", "Debug",
+    cmVS7FlagTable::CaseInsensitive },
+  { "MapExports", "MAPINFO:EXPORTS", "", "true", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0 },
+  { "AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0 },
+  { "LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0 },
+  { "TerminalServerAware", "TSAWARE:NO", "", "false", 0 },
+  { "TerminalServerAware", "TSAWARE", "", "true", 0 },
+  { "SwapRunFromCD", "SWAPRUN:CD", "", "true", 0 },
+  { "SwapRunFromNET", "SWAPRUN:NET", "", "true", 0 },
+  { "OptimizeReferences", "OPT:NOREF", "", "false", 0 },
+  { "OptimizeReferences", "OPT:REF", "", "true", 0 },
+  { "EnableCOMDATFolding", "OPT:NOICF", "", "false", 0 },
+  { "EnableCOMDATFolding", "OPT:ICF", "", "true", 0 },
+  { "IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0 },
+  { "AppContainer", "APPCONTAINER", "", "true", 0 },
+  { "WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN:NO", "", "false", 0 },
+  { "WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN", "", "true", 0 },
+  { "NoEntryPoint", "NOENTRY", "", "true", 0 },
+  { "SetChecksum", "RELEASE", "", "true", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0 },
+  { "RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0 },
+  { "FixedBaseAddress", "FIXED:NO", "", "false", 0 },
+  { "FixedBaseAddress", "FIXED", "", "true", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0 },
+  { "DataExecutionPrevention", "NXCOMPAT", "", "true", 0 },
+  { "TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0 },
+  { "SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0 },
+  { "SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0 },
+  { "Profile", "PROFILE", "", "true", 0 },
+  { "LinkDelaySign", "DELAYSIGN:NO", "", "false", 0 },
+  { "LinkDelaySign", "DELAYSIGN", "", "true", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0 },
+  { "CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0 },
+  { "DetectOneDefinitionRule", "ODR", "", "true", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0 },
+  { "ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0 },
+  { "LinkDLL", "DLL", "", "true", 0 },
 
-  //Bool Properties
-  {"LinkIncremental", "INCREMENTAL:NO", "", "false", 0},
-  {"LinkIncremental", "INCREMENTAL", "", "true", 0},
-  {"SuppressStartupBanner", "NOLOGO", "", "true", 0},
-  {"LinkStatus", "LTCG:NOSTATUS", "", "false", 0},
-  {"LinkStatus", "LTCG:STATUS", "", "true", 0},
-  {"PreventDllBinding", "ALLOWBIND:NO", "", "false", 0},
-  {"PreventDllBinding", "ALLOWBIND", "", "true", 0},
-  {"TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0},
-  {"TreatLinkerWarningAsErrors", "WX", "", "true", 0},
-  {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0},
-  {"GenerateManifest", "MANIFEST:NO", "", "false", 0},
-  {"GenerateManifest", "MANIFEST", "", "true", 0},
-  {"AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0},
-  {"UACUIAccess", "uiAccess='false'", "", "false", 0},
-  {"UACUIAccess", "uiAccess='true'", "", "true", 0},
-  {"ManifestEmbed", "manifest:embed", "", "true", 0},
-  {"GenerateDebugInformation", "DEBUG:FASTLINK", "", "DebugFastLink",
-   cmVS7FlagTable::CaseInsensitive},
-  {"GenerateDebugInformation", "DEBUG", "", "Debug",
-   cmVS7FlagTable::CaseInsensitive},
-  {"MapExports", "MAPINFO:EXPORTS", "", "true", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0},
-  {"AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0},
-  {"LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0},
-  {"TerminalServerAware", "TSAWARE:NO", "", "false", 0},
-  {"TerminalServerAware", "TSAWARE", "", "true", 0},
-  {"SwapRunFromCD", "SWAPRUN:CD", "", "true", 0},
-  {"SwapRunFromNET", "SWAPRUN:NET", "", "true", 0},
-  {"OptimizeReferences", "OPT:NOREF", "", "false", 0},
-  {"OptimizeReferences", "OPT:REF", "", "true", 0},
-  {"EnableCOMDATFolding", "OPT:NOICF", "", "false", 0},
-  {"EnableCOMDATFolding", "OPT:ICF", "", "true", 0},
-  {"IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0},
-  {"AppContainer", "APPCONTAINER", "", "true", 0},
-  {"WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN:NO", "", "false", 0},
-  {"WindowsMetadataLinkDelaySign", "WINMDDELAYSIGN", "", "true", 0},
-  {"NoEntryPoint", "NOENTRY", "", "true", 0},
-  {"SetChecksum", "RELEASE", "", "true", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0},
-  {"RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0},
-  {"FixedBaseAddress", "FIXED:NO", "", "false", 0},
-  {"FixedBaseAddress", "FIXED", "", "true", 0},
-  {"DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0},
-  {"DataExecutionPrevention", "NXCOMPAT", "", "true", 0},
-  {"TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0},
-  {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0},
-  {"SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0},
-  {"Profile", "PROFILE", "", "true", 0},
-  {"LinkDelaySign", "DELAYSIGN:NO", "", "false", 0},
-  {"LinkDelaySign", "DELAYSIGN", "", "true", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0},
-  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0},
-  {"DetectOneDefinitionRule", "ODR", "", "true", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0},
-  {"ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0},
-  {"LinkDLL", "DLL", "", "true", 0},
+  // Bool Properties With Argument
+  { "EnableUAC", "MANIFESTUAC:NO", "", "false", 0 },
+  { "EnableUAC", "MANIFESTUAC:", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
+    cmVS7FlagTable::UserValueRequired },
+  { "GenerateMapFile", "MAP", "", "true",
+    cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue },
+  { "MapFileName", "MAP:", "Generate Map File", "",
+    cmVS7FlagTable::UserValueRequired },
 
-  //Bool Properties With Argument
-  {"EnableUAC", "MANIFESTUAC:NO", "", "false", 0},
-  {"EnableUAC", "MANIFESTUAC:", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "",
-   cmVS7FlagTable::UserValueRequired},
-  {"GenerateMapFile", "MAP", "", "true",
-   cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
-  {"MapFileName", "MAP:", "Generate Map File", "",
-   cmVS7FlagTable::UserValueRequired},
-
-  //String List Properties
-  {"AdditionalLibraryDirectories", "LIBPATH:",
-   "Additional Library Directories",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "AdditionalLibraryDirectories", "LIBPATH:",
+    "Additional Library Directories", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
-  {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
-   "Ignore Specific Default Libraries",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AddModuleNamesToAssembly", "ASSEMBLYMODULE:",
-   "Add Module to Assembly",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
-   "Embed Managed Resource File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ForceSymbolReferences", "INCLUDE:",
-   "Force Symbol References",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"DelayLoadDLLs", "DELAYLOAD:",
-   "Delay Loaded Dlls",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:",
-   "Assembly Link Resource",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
-   "Additional Manifest Dependencies",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"ManifestInput", "manifestinput:",
-   "Manifest Input",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  { "IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:",
+    "Ignore Specific Default Libraries", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AddModuleNamesToAssembly", "ASSEMBLYMODULE:", "Add Module to Assembly",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "EmbedManagedResourceFile", "ASSEMBLYRESOURCE:",
+    "Embed Managed Resource File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "DelayLoadDLLs", "DELAYLOAD:", "Delay Loaded Dlls", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource",
+    "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "AdditionalManifestDependencies", "MANIFESTDEPENDENCY:",
+    "Additional Manifest Dependencies", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "ManifestInput", "manifestinput:", "Manifest Input", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
 
-  //String Properties
-  {"OutputFile", "OUT:",
-   "Output File",
-   "", cmVS7FlagTable::UserValue},
-  {"Version", "VERSION:",
-   "Version",
-   "", cmVS7FlagTable::UserValue},
-  {"SpecifySectionAttributes", "SECTION:",
-   "Specify Section Attributes",
-   "", cmVS7FlagTable::UserValue},
-  {"MSDOSStubFileName", "STUB:",
-   "MS-DOS Stub File Name",
-   "", cmVS7FlagTable::UserValue},
+  // String Properties
+  { "OutputFile", "OUT:", "Output File", "", cmVS7FlagTable::UserValue },
+  { "Version", "VERSION:", "Version", "", cmVS7FlagTable::UserValue },
+  { "SpecifySectionAttributes", "SECTION:", "Specify Section Attributes", "",
+    cmVS7FlagTable::UserValue },
+  { "MSDOSStubFileName", "STUB:", "MS-DOS Stub File Name", "",
+    cmVS7FlagTable::UserValue },
   // Skip [TrackerLogDirectory] - no command line Switch.
-  {"ModuleDefinitionFile", "DEF:",
-   "Module Definition File",
-   "", cmVS7FlagTable::UserValue},
-  {"ManifestFile", "ManifestFile:",
-   "Manifest File",
-   "", cmVS7FlagTable::UserValue},
-  {"ProgramDatabaseFile", "PDB:",
-   "Generate Program Database File",
-   "", cmVS7FlagTable::UserValue},
-  {"StripPrivateSymbols", "PDBSTRIPPED:",
-   "Strip Private Symbols",
-   "", cmVS7FlagTable::UserValue},
+  { "ModuleDefinitionFile", "DEF:", "Module Definition File", "",
+    cmVS7FlagTable::UserValue },
+  { "ManifestFile", "ManifestFile:", "Manifest File", "",
+    cmVS7FlagTable::UserValue },
+  { "ProgramDatabaseFile", "PDB:", "Generate Program Database File", "",
+    cmVS7FlagTable::UserValue },
+  { "StripPrivateSymbols", "PDBSTRIPPED:", "Strip Private Symbols", "",
+    cmVS7FlagTable::UserValue },
   // Skip [MapFileName] - no command line Switch.
   // Skip [MinimumRequiredVersion] - no command line Switch.
-  {"HeapReserveSize", "HEAP:",
-   "Heap Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "HeapReserveSize", "HEAP:", "Heap Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [HeapCommitSize] - no command line Switch.
-  {"StackReserveSize", "STACK:",
-   "Stack Reserve Size",
-   "", cmVS7FlagTable::UserValue},
+  { "StackReserveSize", "STACK:", "Stack Reserve Size", "",
+    cmVS7FlagTable::UserValue },
   // Skip [StackCommitSize] - no command line Switch.
-  {"FunctionOrder", "ORDER:@",
-   "Function Order",
-   "", cmVS7FlagTable::UserValue},
-  {"ProfileGuidedDatabase", "PGD:",
-   "Profile Guided Database",
-   "", cmVS7FlagTable::UserValue},
-  {"MidlCommandFile", "MIDL:@",
-   "MIDL Commands",
-   "", cmVS7FlagTable::UserValue},
-  {"MergedIDLBaseFileName", "IDLOUT:",
-   "Merged IDL Base File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"TypeLibraryFile", "TLBOUT:",
-   "Type Library",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataFile", "WINMDFILE:",
-   "Windows Metadata File",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataLinkKeyFile", "WINMDKEYFILE:",
-   "Windows Metadata Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"WindowsMetadataKeyContainer", "WINMDKEYCONTAINER:",
-   "Windows Metadata Key Container",
-   "", cmVS7FlagTable::UserValue},
-  {"EntryPointSymbol", "ENTRY:",
-   "Entry Point",
-   "", cmVS7FlagTable::UserValue},
-  {"BaseAddress", "BASE:",
-   "Base Address",
-   "", cmVS7FlagTable::UserValue},
-  {"ImportLibrary", "IMPLIB:",
-   "Import Library",
-   "", cmVS7FlagTable::UserValue},
-  {"MergeSections", "MERGE:",
-   "Merge Sections",
-   "", cmVS7FlagTable::UserValue},
-  {"LinkKeyFile", "KEYFILE:",
-   "Key File",
-   "", cmVS7FlagTable::UserValue},
-  {"KeyContainer", "KEYCONTAINER:",
-   "Key Container",
-   "", cmVS7FlagTable::UserValue},
+  { "FunctionOrder", "ORDER:@", "Function Order", "",
+    cmVS7FlagTable::UserValue },
+  { "ProfileGuidedDatabase", "PGD:", "Profile Guided Database", "",
+    cmVS7FlagTable::UserValue },
+  { "MidlCommandFile", "MIDL:@", "MIDL Commands", "",
+    cmVS7FlagTable::UserValue },
+  { "MergedIDLBaseFileName", "IDLOUT:", "Merged IDL Base File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "TypeLibraryFile", "TLBOUT:", "Type Library", "",
+    cmVS7FlagTable::UserValue },
+  { "WindowsMetadataFile", "WINMDFILE:", "Windows Metadata File", "",
+    cmVS7FlagTable::UserValue },
+  { "WindowsMetadataLinkKeyFile", "WINMDKEYFILE:", "Windows Metadata Key File",
+    "", cmVS7FlagTable::UserValue },
+  { "WindowsMetadataKeyContainer", "WINMDKEYCONTAINER:",
+    "Windows Metadata Key Container", "", cmVS7FlagTable::UserValue },
+  { "EntryPointSymbol", "ENTRY:", "Entry Point", "",
+    cmVS7FlagTable::UserValue },
+  { "BaseAddress", "BASE:", "Base Address", "", cmVS7FlagTable::UserValue },
+  { "ImportLibrary", "IMPLIB:", "Import Library", "",
+    cmVS7FlagTable::UserValue },
+  { "MergeSections", "MERGE:", "Merge Sections", "",
+    cmVS7FlagTable::UserValue },
+  { "LinkKeyFile", "KEYFILE:", "Key File", "", cmVS7FlagTable::UserValue },
+  { "KeyContainer", "KEYCONTAINER:", "Key Container", "",
+    cmVS7FlagTable::UserValue },
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS14MASMFlagTable.h b/Source/cmVS14MASMFlagTable.h
index dce846f..c4e5e1e 100644
--- a/Source/cmVS14MASMFlagTable.h
+++ b/Source/cmVS14MASMFlagTable.h
@@ -1,96 +1,78 @@
-static cmVS7FlagTable cmVS14MASMFlagTable[] =
-{
+static cmVS7FlagTable cmVS14MASMFlagTable[] = {
 
-  //Enum Properties
-  {"PreserveIdentifierCase", "",
-   "Default", "0", 0},
-  {"PreserveIdentifierCase", "/Cp",
-   "Preserves Identifier Case (/Cp)", "1", 0},
-  {"PreserveIdentifierCase", "/Cu",
-   "Maps all identifiers to upper case. (/Cu)", "2", 0},
-  {"PreserveIdentifierCase", "/Cx",
-   "Preserves case in public and extern symbols. (/Cx)", "3", 0},
+  // Enum Properties
+  { "PreserveIdentifierCase", "", "Default", "0", 0 },
+  { "PreserveIdentifierCase", "/Cp", "Preserves Identifier Case (/Cp)", "1",
+    0 },
+  { "PreserveIdentifierCase", "/Cu",
+    "Maps all identifiers to upper case. (/Cu)", "2", 0 },
+  { "PreserveIdentifierCase", "/Cx",
+    "Preserves case in public and extern symbols. (/Cx)", "3", 0 },
 
-  {"WarningLevel", "/W0",
-   "Warning Level 0 (/W0)", "0", 0},
-  {"WarningLevel", "/W1",
-   "Warning Level 1 (/W1)", "1", 0},
-  {"WarningLevel", "/W2",
-   "Warning Level 2 (/W2)", "2", 0},
-  {"WarningLevel", "/W3",
-   "Warning Level 3 (/W3)", "3", 0},
+  { "WarningLevel", "/W0", "Warning Level 0 (/W0)", "0", 0 },
+  { "WarningLevel", "/W1", "Warning Level 1 (/W1)", "1", 0 },
+  { "WarningLevel", "/W2", "Warning Level 2 (/W2)", "2", 0 },
+  { "WarningLevel", "/W3", "Warning Level 3 (/W3)", "3", 0 },
 
-  {"PackAlignmentBoundary", "",
-   "Default", "0", 0},
-  {"PackAlignmentBoundary", "/Zp1",
-   "One Byte Boundary (/Zp1)", "1", 0},
-  {"PackAlignmentBoundary", "/Zp2",
-   "Two Byte Boundary (/Zp2)", "2", 0},
-  {"PackAlignmentBoundary", "/Zp4",
-   "Four Byte Boundary (/Zp4)", "3", 0},
-  {"PackAlignmentBoundary", "/Zp8",
-   "Eight Byte Boundary (/Zp8)", "4", 0},
-  {"PackAlignmentBoundary", "/Zp16",
-   "Sixteen Byte Boundary (/Zp16)", "5", 0},
+  { "PackAlignmentBoundary", "", "Default", "0", 0 },
+  { "PackAlignmentBoundary", "/Zp1", "One Byte Boundary (/Zp1)", "1", 0 },
+  { "PackAlignmentBoundary", "/Zp2", "Two Byte Boundary (/Zp2)", "2", 0 },
+  { "PackAlignmentBoundary", "/Zp4", "Four Byte Boundary (/Zp4)", "3", 0 },
+  { "PackAlignmentBoundary", "/Zp8", "Eight Byte Boundary (/Zp8)", "4", 0 },
+  { "PackAlignmentBoundary", "/Zp16", "Sixteen Byte Boundary (/Zp16)", "5",
+    0 },
 
-  {"CallingConvention", "",
-   "Default", "0", 0},
-  {"CallingConvention", "/Gd",
-   "Use C-style Calling Convention (/Gd)", "1", 0},
-  {"CallingConvention", "/Gz",
-   "Use stdcall Calling Convention (/Gz)", "2", 0},
-  {"CallingConvention", "/Gc",
-   "Use Pascal Calling Convention (/Gc)", "3", 0},
+  { "CallingConvention", "", "Default", "0", 0 },
+  { "CallingConvention", "/Gd", "Use C-style Calling Convention (/Gd)", "1",
+    0 },
+  { "CallingConvention", "/Gz", "Use stdcall Calling Convention (/Gz)", "2",
+    0 },
+  { "CallingConvention", "/Gc", "Use Pascal Calling Convention (/Gc)", "3",
+    0 },
 
-  {"ErrorReporting", "/errorReport:prompt",
-   "Prompt to send report immediately (/errorReport:prompt)", "0", 0},
-  {"ErrorReporting", "/errorReport:queue",
-   "Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
-  {"ErrorReporting", "/errorReport:send",
-   "Automatically send report (/errorReport:send)", "2", 0},
-  {"ErrorReporting", "/errorReport:none",
-   "Do not send report (/errorReport:none)", "3", 0},
+  { "ErrorReporting", "/errorReport:prompt",
+    "Prompt to send report immediately (/errorReport:prompt)", "0", 0 },
+  { "ErrorReporting", "/errorReport:queue",
+    "Prompt to send report at the next logon (/errorReport:queue)", "1", 0 },
+  { "ErrorReporting", "/errorReport:send",
+    "Automatically send report (/errorReport:send)", "2", 0 },
+  { "ErrorReporting", "/errorReport:none",
+    "Do not send report (/errorReport:none)", "3", 0 },
 
+  // Bool Properties
+  { "NoLogo", "/nologo", "", "true", 0 },
+  { "GeneratePreprocessedSourceListing", "/EP", "", "true", 0 },
+  { "ListAllAvailableInformation", "/Sa", "", "true", 0 },
+  { "UseSafeExceptionHandlers", "/safeseh", "", "true", 0 },
+  { "AddFirstPassListing", "/Sf", "", "true", 0 },
+  { "EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0 },
+  { "DisableSymbolTable", "/Sn", "", "true", 0 },
+  { "EnableFalseConditionalsInListing", "/Sx", "", "true", 0 },
+  { "TreatWarningsAsErrors", "/WX", "", "true", 0 },
+  { "MakeAllSymbolsPublic", "/Zf", "", "true", 0 },
+  { "GenerateDebugInformation", "/Zi", "", "true", 0 },
+  { "EnableMASM51Compatibility", "/Zm", "", "true", 0 },
+  { "PerformSyntaxCheckOnly", "/Zs", "", "true", 0 },
 
-  //Bool Properties
-  {"NoLogo", "/nologo", "", "true", 0},
-  {"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
-  {"ListAllAvailableInformation", "/Sa", "", "true", 0},
-  {"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
-  {"AddFirstPassListing", "/Sf", "", "true", 0},
-  {"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
-  {"DisableSymbolTable", "/Sn", "", "true", 0},
-  {"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
-  {"TreatWarningsAsErrors", "/WX", "", "true", 0},
-  {"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
-  {"GenerateDebugInformation", "/Zi", "", "true", 0},
-  {"EnableMASM51Compatibility", "/Zm", "", "true", 0},
-  {"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
+  // Bool Properties With Argument
 
-  //Bool Properties With Argument
-
-  //String List Properties
-  {"PreprocessorDefinitions", "/D",
-   "Preprocessor Definitions",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"IncludePaths", "/I",
-   "Include Paths",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
-  {"BrowseFile", "/FR",
-   "Generate Browse Information File",
-   "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
+  // String List Properties
+  { "PreprocessorDefinitions", "/D", "Preprocessor Definitions", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "IncludePaths", "/I", "Include Paths", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
+  { "BrowseFile", "/FR", "Generate Browse Information File", "",
+    cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable },
   // Skip [AdditionalDependencies] - no command line Switch.
 
-  //String Properties
+  // String Properties
   // Skip [Inputs] - no command line Switch.
-  {"ObjectFileName", "/Fo",
-   "Object File Name",
-   "", cmVS7FlagTable::UserValue},
-  {"AssembledCodeListingFile", "/Fl",
-   "Assembled Code Listing File",
-   "", cmVS7FlagTable::UserValue},
+  { "ObjectFileName", "/Fo", "Object File Name", "",
+    cmVS7FlagTable::UserValue },
+  { "AssembledCodeListingFile", "/Fl", "Assembled Code Listing File", "",
+    cmVS7FlagTable::UserValue },
   // Skip [CommandLineTemplate] - no command line Switch.
   // Skip [ExecutionDescription] - no command line Switch.
   // Skip [AdditionalOptions] - no command line Switch.
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVS14RCFlagTable.h b/Source/cmVS14RCFlagTable.h
index ebd8d65..11e00d5 100644
--- a/Source/cmVS14RCFlagTable.h
+++ b/Source/cmVS14RCFlagTable.h
@@ -1,7 +1,6 @@
-static cmVS7FlagTable cmVS14RCFlagTable[] =
-{
-  //Bool Properties
-  {"NullTerminateStrings", "n", "", "true", 0},
+static cmVS7FlagTable cmVS14RCFlagTable[] = {
+  // Bool Properties
+  { "NullTerminateStrings", "n", "", "true", 0 },
 
-  {0,0,0,0,0}
+  { 0, 0, 0, 0, 0 }
 };
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index a830842..8d55b0e 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -14,67 +14,61 @@
 #include "cmState.h"
 
 // cmLibraryCommand
-bool cmVariableRequiresCommand
-::InitialPass(std::vector<std::string>const& args, cmExecutionStatus &)
+bool cmVariableRequiresCommand::InitialPass(
+  std::vector<std::string> const& args, cmExecutionStatus&)
 {
-  if(this->Disallowed(cmPolicies::CMP0035,
-      "The variable_requires command should not be called; see CMP0035."))
-    { return true; }
-  if(args.size() < 3 )
-    {
+  if (this->Disallowed(
+        cmPolicies::CMP0035,
+        "The variable_requires command should not be called; see CMP0035.")) {
+    return true;
+  }
+  if (args.size() < 3) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   std::string testVariable = args[0];
-  if(!this->Makefile->IsOn(testVariable))
-    {
+  if (!this->Makefile->IsOn(testVariable)) {
     return true;
-    }
+  }
   std::string resultVariable = args[1];
   bool requirementsMet = true;
   std::string notSet;
   bool hasAdvanced = false;
   cmState* state = this->Makefile->GetState();
-  for(unsigned int i = 2; i < args.size(); ++i)
-    {
-    if(!this->Makefile->IsOn(args[i]))
-      {
+  for (unsigned int i = 2; i < args.size(); ++i) {
+    if (!this->Makefile->IsOn(args[i])) {
       requirementsMet = false;
       notSet += args[i];
       notSet += "\n";
-      if(state->GetCacheEntryValue(args[i]) &&
-          state->GetCacheEntryPropertyAsBool(args[i], "ADVANCED"))
-        {
+      if (state->GetCacheEntryValue(args[i]) &&
+          state->GetCacheEntryPropertyAsBool(args[i], "ADVANCED")) {
         hasAdvanced = true;
-        }
       }
     }
+  }
   const char* reqVar = this->Makefile->GetDefinition(resultVariable);
   // if reqVar is unset, then set it to requirementsMet
   // if reqVar is set to true, but requirementsMet is false , then
   // set reqVar to false.
-  if(!reqVar || (!requirementsMet && this->Makefile->IsOn(reqVar)))
-    {
+  if (!reqVar || (!requirementsMet && this->Makefile->IsOn(reqVar))) {
     this->Makefile->AddDefinition(resultVariable, requirementsMet);
-    }
+  }
 
-  if(!requirementsMet)
-    {
+  if (!requirementsMet) {
     std::string message = "Variable assertion failed:\n";
-    message += testVariable +
-      " Requires that the following unset variables are set:\n";
+    message +=
+      testVariable + " Requires that the following unset variables are set:\n";
     message += notSet;
     message += "\nPlease set them, or set ";
     message += testVariable + " to false, and re-configure.\n";
-    if(hasAdvanced)
-      {
+    if (hasAdvanced) {
       message +=
         "One or more of the required variables is advanced."
         "  To set the variable, you must turn on advanced mode in cmake.";
-      }
-    cmSystemTools::Error(message.c_str());
     }
+    cmSystemTools::Error(message.c_str());
+  }
 
   return true;
 }
diff --git a/Source/cmVariableRequiresCommand.h b/Source/cmVariableRequiresCommand.h
index 5b0477f..b83f615 100644
--- a/Source/cmVariableRequiresCommand.h
+++ b/Source/cmVariableRequiresCommand.h
@@ -20,9 +20,8 @@ public:
   cmTypeMacro(cmVariableRequiresCommand, cmCommand);
   virtual cmCommand* Clone() { return new cmVariableRequiresCommand; }
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
-  virtual std::string GetName() const { return "variable_requires";}
+                           cmExecutionStatus& status);
+  virtual std::string GetName() const { return "variable_requires"; }
 };
 
-
 #endif
diff --git a/Source/cmVariableWatch.cxx b/Source/cmVariableWatch.cxx
index a200718..ac2f2fa 100644
--- a/Source/cmVariableWatch.cxx
+++ b/Source/cmVariableWatch.cxx
@@ -13,22 +13,16 @@
 
 #include "cmAlgorithms.h"
 
-static const char* const cmVariableWatchAccessStrings[] =
-{
-    "READ_ACCESS",
-    "UNKNOWN_READ_ACCESS",
-    "UNKNOWN_DEFINED_ACCESS",
-    "MODIFIED_ACCESS",
-    "REMOVED_ACCESS",
-    "NO_ACCESS"
+static const char* const cmVariableWatchAccessStrings[] = {
+  "READ_ACCESS",     "UNKNOWN_READ_ACCESS", "UNKNOWN_DEFINED_ACCESS",
+  "MODIFIED_ACCESS", "REMOVED_ACCESS",      "NO_ACCESS"
 };
 
 const char* cmVariableWatch::GetAccessAsString(int access_type)
 {
-  if ( access_type < 0 || access_type >= cmVariableWatch::NO_ACCESS )
-    {
+  if (access_type < 0 || access_type >= cmVariableWatch::NO_ACCESS) {
     return "NO_ACCESS";
-    }
+  }
   return cmVariableWatchAccessStrings[access_type];
 }
 
@@ -36,7 +30,7 @@ cmVariableWatch::cmVariableWatch()
 {
 }
 
-template<typename C>
+template <typename C>
 void deleteAllSecond(typename C::value_type it)
 {
   cmDeleteAll(it.second);
@@ -48,8 +42,8 @@ cmVariableWatch::~cmVariableWatch()
                 deleteAllSecond<cmVariableWatch::StringToVectorOfPairs>);
 }
 
-bool cmVariableWatch::AddWatch(const std::string& variable,
-                               WatchMethod method, void* client_data /*=0*/,
+bool cmVariableWatch::AddWatch(const std::string& variable, WatchMethod method,
+                               void* client_data /*=0*/,
                                DeleteData delete_data /*=0*/)
 {
   cmVariableWatch::Pair* p = new cmVariableWatch::Pair;
@@ -58,61 +52,51 @@ bool cmVariableWatch::AddWatch(const std::string& variable,
   p->DeleteDataCall = delete_data;
   cmVariableWatch::VectorOfPairs* vp = &this->WatchMap[variable];
   cmVariableWatch::VectorOfPairs::size_type cc;
-  for ( cc = 0; cc < vp->size(); cc ++ )
-    {
+  for (cc = 0; cc < vp->size(); cc++) {
     cmVariableWatch::Pair* pair = (*vp)[cc];
-    if ( pair->Method == method &&
-         client_data && client_data == pair->ClientData)
-      {
+    if (pair->Method == method && client_data &&
+        client_data == pair->ClientData) {
       // Callback already exists
       return false;
-      }
     }
+  }
   vp->push_back(p);
   return true;
 }
 
 void cmVariableWatch::RemoveWatch(const std::string& variable,
-                                  WatchMethod method,
-                                  void* client_data /*=0*/)
+                                  WatchMethod method, void* client_data /*=0*/)
 {
-  if ( !this->WatchMap.count(variable) )
-    {
+  if (!this->WatchMap.count(variable)) {
     return;
-    }
+  }
   cmVariableWatch::VectorOfPairs* vp = &this->WatchMap[variable];
   cmVariableWatch::VectorOfPairs::iterator it;
-  for ( it = vp->begin(); it != vp->end(); ++it )
-    {
-    if ( (*it)->Method == method &&
-         // If client_data is NULL, we want to disconnect all watches against
-         // the given method; otherwise match ClientData as well.
-         (!client_data || (client_data == (*it)->ClientData)))
-      {
+  for (it = vp->begin(); it != vp->end(); ++it) {
+    if ((*it)->Method == method &&
+        // If client_data is NULL, we want to disconnect all watches against
+        // the given method; otherwise match ClientData as well.
+        (!client_data || (client_data == (*it)->ClientData))) {
       delete *it;
       vp->erase(it);
       return;
-      }
     }
+  }
 }
 
-bool  cmVariableWatch::VariableAccessed(const std::string& variable,
-                                        int access_type,
-                                        const char* newValue,
-                                        const cmMakefile* mf) const
+bool cmVariableWatch::VariableAccessed(const std::string& variable,
+                                       int access_type, const char* newValue,
+                                       const cmMakefile* mf) const
 {
   cmVariableWatch::StringToVectorOfPairs::const_iterator mit =
     this->WatchMap.find(variable);
-  if ( mit  != this->WatchMap.end() )
-    {
+  if (mit != this->WatchMap.end()) {
     const cmVariableWatch::VectorOfPairs* vp = &mit->second;
     cmVariableWatch::VectorOfPairs::const_iterator it;
-    for ( it = vp->begin(); it != vp->end(); it ++ )
-      {
-      (*it)->Method(variable, access_type, (*it)->ClientData,
-        newValue, mf);
-      }
-    return true;
+    for (it = vp->begin(); it != vp->end(); it++) {
+      (*it)->Method(variable, access_type, (*it)->ClientData, newValue, mf);
     }
+    return true;
+  }
   return false;
 }
diff --git a/Source/cmVariableWatch.h b/Source/cmVariableWatch.h
index 2f082af..be8f72f 100644
--- a/Source/cmVariableWatch.h
+++ b/Source/cmVariableWatch.h
@@ -25,7 +25,8 @@ class cmVariableWatch
 {
 public:
   typedef void (*WatchMethod)(const std::string& variable, int access_type,
-    void* client_data, const char* newValue, const cmMakefile* mf);
+                              void* client_data, const char* newValue,
+                              const cmMakefile* mf);
   typedef void (*DeleteData)(void* client_data);
 
   cmVariableWatch();
@@ -35,28 +36,28 @@ public:
    * Add watch to the variable
    */
   bool AddWatch(const std::string& variable, WatchMethod method,
-                void* client_data=0, DeleteData delete_data=0);
+                void* client_data = 0, DeleteData delete_data = 0);
   void RemoveWatch(const std::string& variable, WatchMethod method,
-                   void* client_data=0);
+                   void* client_data = 0);
 
   /**
    * This method is called when variable is accessed
    */
   bool VariableAccessed(const std::string& variable, int access_type,
-    const char* newValue, const cmMakefile* mf) const;
+                        const char* newValue, const cmMakefile* mf) const;
 
   /**
    * Different access types.
    */
   enum
-    {
+  {
     VARIABLE_READ_ACCESS = 0,
     UNKNOWN_VARIABLE_READ_ACCESS,
     UNKNOWN_VARIABLE_DEFINED_ACCESS,
     VARIABLE_MODIFIED_ACCESS,
     VARIABLE_REMOVED_ACCESS,
     NO_ACCESS
-    };
+  };
 
   /**
    * Return the access as string
@@ -67,23 +68,26 @@ protected:
   struct Pair
   {
     WatchMethod Method;
-    void*        ClientData;
-    DeleteData   DeleteDataCall;
-    Pair() : Method(0), ClientData(0), DeleteDataCall(0) {}
+    void* ClientData;
+    DeleteData DeleteDataCall;
+    Pair()
+      : Method(0)
+      , ClientData(0)
+      , DeleteDataCall(0)
+    {
+    }
     ~Pair()
-      {
-      if (this->DeleteDataCall && this->ClientData)
-        {
+    {
+      if (this->DeleteDataCall && this->ClientData) {
         this->DeleteDataCall(this->ClientData);
-        }
       }
+    }
   };
 
-  typedef std::vector< Pair* > VectorOfPairs;
-  typedef std::map<std::string, VectorOfPairs > StringToVectorOfPairs;
+  typedef std::vector<Pair*> VectorOfPairs;
+  typedef std::map<std::string, VectorOfPairs> StringToVectorOfPairs;
 
   StringToVectorOfPairs WatchMap;
 };
 
-
 #endif
diff --git a/Source/cmVariableWatchCommand.cxx b/Source/cmVariableWatchCommand.cxx
index b776626..f30ffe8 100644
--- a/Source/cmVariableWatchCommand.cxx
+++ b/Source/cmVariableWatchCommand.cxx
@@ -19,17 +19,18 @@ struct cmVariableWatchCallbackData
   std::string Command;
 };
 
-static void cmVariableWatchCommandVariableAccessed(
-  const std::string& variable, int access_type, void* client_data,
-  const char* newValue, const cmMakefile* mf)
+static void cmVariableWatchCommandVariableAccessed(const std::string& variable,
+                                                   int access_type,
+                                                   void* client_data,
+                                                   const char* newValue,
+                                                   const cmMakefile* mf)
 {
-  cmVariableWatchCallbackData* data
-    = static_cast<cmVariableWatchCallbackData*>(client_data);
+  cmVariableWatchCallbackData* data =
+    static_cast<cmVariableWatchCallbackData*>(client_data);
 
-  if ( data->InCallback )
-    {
+  if (data->InCallback) {
     return;
-    }
+  }
   data->InCallback = true;
 
   cmListFileFunction newLFF;
@@ -42,54 +43,47 @@ static void cmVariableWatchCommandVariableAccessed(
   cmMakefile* makefile = const_cast<cmMakefile*>(mf);
 
   std::string stack = makefile->GetProperty("LISTFILE_STACK");
-  if ( !data->Command.empty() )
-    {
+  if (!data->Command.empty()) {
     newLFF.Arguments.clear();
     newLFF.Arguments.push_back(
-      cmListFileArgument(variable, cmListFileArgument::Quoted,
-                         9999));
-    newLFF.Arguments.push_back(
-      cmListFileArgument(accessString, cmListFileArgument::Quoted,
-                         9999));
+      cmListFileArgument(variable, cmListFileArgument::Quoted, 9999));
     newLFF.Arguments.push_back(
-      cmListFileArgument(newValue?newValue:"", cmListFileArgument::Quoted,
-                         9999));
+      cmListFileArgument(accessString, cmListFileArgument::Quoted, 9999));
+    newLFF.Arguments.push_back(cmListFileArgument(
+      newValue ? newValue : "", cmListFileArgument::Quoted, 9999));
     newLFF.Arguments.push_back(
-      cmListFileArgument(currentListFile, cmListFileArgument::Quoted,
-                         9999));
+      cmListFileArgument(currentListFile, cmListFileArgument::Quoted, 9999));
     newLFF.Arguments.push_back(
-      cmListFileArgument(stack, cmListFileArgument::Quoted,
-                         9999));
+      cmListFileArgument(stack, cmListFileArgument::Quoted, 9999));
     newLFF.Name = data->Command;
     newLFF.Line = 9999;
     cmExecutionStatus status;
-    if(!makefile->ExecuteCommand(newLFF,status))
-      {
+    if (!makefile->ExecuteCommand(newLFF, status)) {
       std::ostringstream error;
       error << "Error in cmake code at\nUnknown:0:\n"
-        << "A command failed during the invocation of callback \""
-        << data->Command << "\".";
+            << "A command failed during the invocation of callback \""
+            << data->Command << "\".";
       cmSystemTools::Error(error.str().c_str());
       data->InCallback = false;
       return;
-      }
-    processed = true;
     }
-  if ( !processed )
-    {
+    processed = true;
+  }
+  if (!processed) {
     std::ostringstream msg;
     msg << "Variable \"" << variable << "\" was accessed using "
-        << accessString << " with value \"" << (newValue?newValue:"") << "\".";
+        << accessString << " with value \"" << (newValue ? newValue : "")
+        << "\".";
     makefile->IssueMessage(cmake::LOG, msg.str());
-    }
+  }
 
   data->InCallback = false;
 }
 
 static void deleteVariableWatchCallbackData(void* client_data)
 {
-  cmVariableWatchCallbackData* data
-    = static_cast<cmVariableWatchCallbackData*>(client_data);
+  cmVariableWatchCallbackData* data =
+    static_cast<cmVariableWatchCallbackData*>(client_data);
   delete data;
 }
 
@@ -100,36 +94,31 @@ cmVariableWatchCommand::cmVariableWatchCommand()
 cmVariableWatchCommand::~cmVariableWatchCommand()
 {
   std::set<std::string>::const_iterator it;
-  for ( it = this->WatchedVariables.begin();
-        it != this->WatchedVariables.end();
-        ++it )
-    {
+  for (it = this->WatchedVariables.begin(); it != this->WatchedVariables.end();
+       ++it) {
     this->Makefile->GetCMakeInstance()->GetVariableWatch()->RemoveWatch(
       *it, cmVariableWatchCommandVariableAccessed);
-    }
+  }
 }
 
-bool cmVariableWatchCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmVariableWatchCommand::InitialPass(std::vector<std::string> const& args,
+                                         cmExecutionStatus&)
 {
-  if ( args.size() < 1 )
-    {
+  if (args.size() < 1) {
     this->SetError("must be called with at least one argument.");
     return false;
-    }
+  }
   std::string variable = args[0];
   std::string command;
-  if ( args.size() > 1 )
-    {
+  if (args.size() > 1) {
     command = args[1];
-    }
-  if ( variable == "CMAKE_CURRENT_LIST_FILE" )
-    {
+  }
+  if (variable == "CMAKE_CURRENT_LIST_FILE") {
     std::ostringstream ostr;
     ostr << "cannot be set on the variable: " << variable;
     this->SetError(ostr.str());
     return false;
-    }
+  }
 
   cmVariableWatchCallbackData* data = new cmVariableWatchCallbackData;
 
@@ -137,13 +126,12 @@ bool cmVariableWatchCommand
   data->Command = command;
 
   this->WatchedVariables.insert(variable);
-  if ( !this->Makefile->GetCMakeInstance()->GetVariableWatch()->AddWatch(
-          variable, cmVariableWatchCommandVariableAccessed,
-          data, deleteVariableWatchCallbackData) )
-    {
+  if (!this->Makefile->GetCMakeInstance()->GetVariableWatch()->AddWatch(
+        variable, cmVariableWatchCommandVariableAccessed, data,
+        deleteVariableWatchCallbackData)) {
     deleteVariableWatchCallbackData(data);
     return false;
-    }
+  }
 
   return true;
 }
diff --git a/Source/cmVariableWatchCommand.h b/Source/cmVariableWatchCommand.h
index c1ee9b1..aad53cb 100644
--- a/Source/cmVariableWatchCommand.h
+++ b/Source/cmVariableWatchCommand.h
@@ -24,10 +24,7 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmVariableWatchCommand;
-    }
+  virtual cmCommand* Clone() { return new cmVariableWatchCommand; }
 
   //! Default constructor
   cmVariableWatchCommand();
@@ -40,7 +37,7 @@ public:
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -54,7 +51,7 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "variable_watch";}
+  virtual std::string GetName() const { return "variable_watch"; }
 
   cmTypeMacro(cmVariableWatchCommand, cmCommand);
 
@@ -62,7 +59,4 @@ protected:
   std::set<std::string> WatchedVariables;
 };
 
-
 #endif
-
-
diff --git a/Source/cmVersion.cxx b/Source/cmVersion.cxx
index 9cb0cd6..4c2e4ce 100644
--- a/Source/cmVersion.cxx
+++ b/Source/cmVersion.cxx
@@ -13,10 +13,22 @@
 
 #include "cmVersionMacros.h"
 
-unsigned int cmVersion::GetMajorVersion() { return CMake_VERSION_MAJOR; }
-unsigned int cmVersion::GetMinorVersion() { return CMake_VERSION_MINOR; }
-unsigned int cmVersion::GetPatchVersion() { return CMake_VERSION_PATCH; }
-unsigned int cmVersion::GetTweakVersion() { return 0; }
+unsigned int cmVersion::GetMajorVersion()
+{
+  return CMake_VERSION_MAJOR;
+}
+unsigned int cmVersion::GetMinorVersion()
+{
+  return CMake_VERSION_MINOR;
+}
+unsigned int cmVersion::GetPatchVersion()
+{
+  return CMake_VERSION_PATCH;
+}
+unsigned int cmVersion::GetTweakVersion()
+{
+  return 0;
+}
 
 const char* cmVersion::GetCMakeVersion()
 {
diff --git a/Source/cmVersion.h b/Source/cmVersion.h
index 84f750f..46fd5a6 100644
--- a/Source/cmVersion.h
+++ b/Source/cmVersion.h
@@ -35,10 +35,9 @@ public:
 /* Encode with room for up to 1000 minor releases between major releases
    and to encode dates until the year 10000 in the patch level.  */
 #define CMake_VERSION_ENCODE__BASE KWIML_INT_UINT64_C(100000000)
-#define CMake_VERSION_ENCODE(major, minor, patch) \
-  ((((major) * 1000u) * CMake_VERSION_ENCODE__BASE) + \
-   (((minor) % 1000u) * CMake_VERSION_ENCODE__BASE) + \
-   (((patch)          % CMake_VERSION_ENCODE__BASE)))
+#define CMake_VERSION_ENCODE(major, minor, patch)                             \
+  ((((major)*1000u) * CMake_VERSION_ENCODE__BASE) +                           \
+   (((minor) % 1000u) * CMake_VERSION_ENCODE__BASE) +                         \
+   (((patch) % CMake_VERSION_ENCODE__BASE)))
 
 #endif
-
diff --git a/Source/cmVersionMacros.h b/Source/cmVersionMacros.h
index cf7f678..a2dcce4 100644
--- a/Source/cmVersionMacros.h
+++ b/Source/cmVersionMacros.h
@@ -16,7 +16,7 @@
 
 #define CMake_VERSION_PATCH_IS_RELEASE(patch) ((patch) < 20000000)
 #if CMake_VERSION_PATCH_IS_RELEASE(CMake_VERSION_PATCH)
-# define CMake_VERSION_IS_RELEASE 1
+#define CMake_VERSION_IS_RELEASE 1
 #endif
 
 #endif
diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index 51e7999..3d93e69 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -46,91 +46,91 @@
 
 cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetClFlagTable() const
 {
-  if(this->MSTools)
-    {
-    cmGlobalVisualStudioGenerator::VSVersion
-      v = this->LocalGenerator->GetVersion();
-    if(v >= cmGlobalVisualStudioGenerator::VS14)
-      { return cmVS14CLFlagTable; }
-    else if(v >= cmGlobalVisualStudioGenerator::VS12)
-      { return cmVS12CLFlagTable; }
-    else if(v == cmGlobalVisualStudioGenerator::VS11)
-      { return cmVS11CLFlagTable; }
-    else
-      { return cmVS10CLFlagTable; }
+  if (this->MSTools) {
+    cmGlobalVisualStudioGenerator::VSVersion v =
+      this->LocalGenerator->GetVersion();
+    if (v >= cmGlobalVisualStudioGenerator::VS14) {
+      return cmVS14CLFlagTable;
+    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
+      return cmVS12CLFlagTable;
+    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
+      return cmVS11CLFlagTable;
+    } else {
+      return cmVS10CLFlagTable;
     }
+  }
   return 0;
 }
 
 cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetRcFlagTable() const
 {
-  if(this->MSTools)
-    {
-    cmGlobalVisualStudioGenerator::VSVersion
-      v = this->LocalGenerator->GetVersion();
-    if(v >= cmGlobalVisualStudioGenerator::VS14)
-      { return cmVS14RCFlagTable; }
-    else if(v >= cmGlobalVisualStudioGenerator::VS12)
-      { return cmVS12RCFlagTable; }
-    else if(v == cmGlobalVisualStudioGenerator::VS11)
-      { return cmVS11RCFlagTable; }
-    else
-      { return cmVS10RCFlagTable; }
+  if (this->MSTools) {
+    cmGlobalVisualStudioGenerator::VSVersion v =
+      this->LocalGenerator->GetVersion();
+    if (v >= cmGlobalVisualStudioGenerator::VS14) {
+      return cmVS14RCFlagTable;
+    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
+      return cmVS12RCFlagTable;
+    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
+      return cmVS11RCFlagTable;
+    } else {
+      return cmVS10RCFlagTable;
     }
+  }
   return 0;
 }
 
 cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLibFlagTable() const
 {
-  if(this->MSTools)
-    {
-    cmGlobalVisualStudioGenerator::VSVersion
-      v = this->LocalGenerator->GetVersion();
-    if(v >= cmGlobalVisualStudioGenerator::VS14)
-      { return cmVS14LibFlagTable; }
-    else if(v >= cmGlobalVisualStudioGenerator::VS12)
-      { return cmVS12LibFlagTable; }
-    else if(v == cmGlobalVisualStudioGenerator::VS11)
-      { return cmVS11LibFlagTable; }
-    else
-      { return cmVS10LibFlagTable; }
+  if (this->MSTools) {
+    cmGlobalVisualStudioGenerator::VSVersion v =
+      this->LocalGenerator->GetVersion();
+    if (v >= cmGlobalVisualStudioGenerator::VS14) {
+      return cmVS14LibFlagTable;
+    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
+      return cmVS12LibFlagTable;
+    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
+      return cmVS11LibFlagTable;
+    } else {
+      return cmVS10LibFlagTable;
     }
+  }
   return 0;
 }
 
 cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLinkFlagTable() const
 {
-  if(this->MSTools)
-    {
-    cmGlobalVisualStudioGenerator::VSVersion
-      v = this->LocalGenerator->GetVersion();
-    if(v >= cmGlobalVisualStudioGenerator::VS14)
-      { return cmVS14LinkFlagTable; }
-    else if(v >= cmGlobalVisualStudioGenerator::VS12)
-      { return cmVS12LinkFlagTable; }
-    else if(v == cmGlobalVisualStudioGenerator::VS11)
-      { return cmVS11LinkFlagTable; }
-    else
-      { return cmVS10LinkFlagTable; }
+  if (this->MSTools) {
+    cmGlobalVisualStudioGenerator::VSVersion v =
+      this->LocalGenerator->GetVersion();
+    if (v >= cmGlobalVisualStudioGenerator::VS14) {
+      return cmVS14LinkFlagTable;
+    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
+      return cmVS12LinkFlagTable;
+    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
+      return cmVS11LinkFlagTable;
+    } else {
+      return cmVS10LinkFlagTable;
     }
+  }
   return 0;
 }
 
 cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetMasmFlagTable() const
 {
-  if(this->MSTools)
-    {
-    cmGlobalVisualStudioGenerator::VSVersion
-      v = this->LocalGenerator->GetVersion();
-    if(v >= cmGlobalVisualStudioGenerator::VS14)
-      { return cmVS14MASMFlagTable; }
-    else if(v >= cmGlobalVisualStudioGenerator::VS12)
-      { return cmVS12MASMFlagTable; }
-    else if(v == cmGlobalVisualStudioGenerator::VS11)
-      { return cmVS11MASMFlagTable; }
-    else
-      { return cmVS10MASMFlagTable; }
+  if (this->MSTools) {
+    cmGlobalVisualStudioGenerator::VSVersion v =
+      this->LocalGenerator->GetVersion();
+    if (v >= cmGlobalVisualStudioGenerator::VS14) {
+      return cmVS14MASMFlagTable;
+    } else if (v >= cmGlobalVisualStudioGenerator::VS12) {
+      return cmVS12MASMFlagTable;
+    } else if (v == cmGlobalVisualStudioGenerator::VS11) {
+      return cmVS11MASMFlagTable;
+    } else {
+      return cmVS10MASMFlagTable;
     }
+  }
   return 0;
 }
 
@@ -148,47 +148,48 @@ static std::string cmVS10EscapeComment(std::string comment)
   // does "echo $CDATA" with no escapes.  We must encode the string.
   // http://technet.microsoft.com/en-us/library/cc772462%28WS.10%29.aspx
   std::string echoable;
-  for(std::string::iterator c = comment.begin(); c != comment.end(); ++c)
-    {
-    switch (*c)
-      {
-      case '\r': break;
-      case '\n': echoable += '\t'; break;
+  for (std::string::iterator c = comment.begin(); c != comment.end(); ++c) {
+    switch (*c) {
+      case '\r':
+        break;
+      case '\n':
+        echoable += '\t';
+        break;
       case '"': /* no break */
       case '|': /* no break */
       case '&': /* no break */
       case '<': /* no break */
       case '>': /* no break */
-      case '^': echoable += '^'; /* no break */
-      default:  echoable += *c; break;
-      }
+      case '^':
+        echoable += '^'; /* no break */
+      default:
+        echoable += *c;
+        break;
     }
+  }
   return echoable;
 }
 
-cmVisualStudio10TargetGenerator::
-cmVisualStudio10TargetGenerator(cmGeneratorTarget* target,
-                                cmGlobalVisualStudio10Generator* gg)
+cmVisualStudio10TargetGenerator::cmVisualStudio10TargetGenerator(
+  cmGeneratorTarget* target, cmGlobalVisualStudio10Generator* gg)
 {
   this->GlobalGenerator = gg;
   this->GeneratorTarget = target;
   this->Makefile = target->Target->GetMakefile();
   this->Makefile->GetConfigurations(this->Configurations);
   this->LocalGenerator =
-    (cmLocalVisualStudio7Generator*)
-    this->GeneratorTarget->GetLocalGenerator();
+    (cmLocalVisualStudio7Generator*)this->GeneratorTarget->GetLocalGenerator();
   this->Name = this->GeneratorTarget->GetName();
   this->GUID = this->GlobalGenerator->GetGUID(this->Name.c_str());
   this->Platform = gg->GetPlatformName();
   this->NsightTegra = gg->IsNsightTegra();
-  for(int i =
-        sscanf(gg->GetNsightTegraVersion().c_str(), "%u.%u.%u.%u",
-               &this->NsightTegraVersion[0], &this->NsightTegraVersion[1],
-               &this->NsightTegraVersion[2], &this->NsightTegraVersion[3]);
-      i < 4; ++i)
-    {
+  for (int i =
+         sscanf(gg->GetNsightTegraVersion().c_str(), "%u.%u.%u.%u",
+                &this->NsightTegraVersion[0], &this->NsightTegraVersion[1],
+                &this->NsightTegraVersion[2], &this->NsightTegraVersion[3]);
+       i < 4; ++i) {
     this->NsightTegraVersion[i] = 0;
-    }
+  }
   this->MSTools = !this->NsightTegra;
   this->TargetCompileAsWinRT = false;
   this->BuildFileStream = 0;
@@ -200,67 +201,54 @@ cmVisualStudio10TargetGenerator(cmGeneratorTarget* target,
 
 cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator()
 {
-  for(OptionsMap::iterator i = this->ClOptions.begin();
-      i != this->ClOptions.end(); ++i)
-    {
+  for (OptionsMap::iterator i = this->ClOptions.begin();
+       i != this->ClOptions.end(); ++i) {
     delete i->second;
-    }
-  for(OptionsMap::iterator i = this->LinkOptions.begin();
-      i != this->LinkOptions.end(); ++i)
-    {
+  }
+  for (OptionsMap::iterator i = this->LinkOptions.begin();
+       i != this->LinkOptions.end(); ++i) {
     delete i->second;
-    }
-  if(!this->BuildFileStream)
-    {
+  }
+  if (!this->BuildFileStream) {
     return;
-    }
-  if (this->BuildFileStream->Close())
-    {
-    this->GlobalGenerator
-      ->FileReplacedDuringGenerate(this->PathToVcxproj);
-    }
+  }
+  if (this->BuildFileStream->Close()) {
+    this->GlobalGenerator->FileReplacedDuringGenerate(this->PathToVcxproj);
+  }
   delete this->BuildFileStream;
 }
 
 void cmVisualStudio10TargetGenerator::WritePlatformConfigTag(
-  const char* tag,
-  const std::string& config,
-  int indentLevel,
-  const char* attribute,
-  const char* end,
-  std::ostream* stream)
+  const char* tag, const std::string& config, int indentLevel,
+  const char* attribute, const char* end, std::ostream* stream)
 
 {
-  if(!stream)
-    {
+  if (!stream) {
     stream = this->BuildFileStream;
-    }
+  }
   stream->fill(' ');
-  stream->width(indentLevel*2 );
-  (*stream ) << "";
-  (*stream ) << "<" << tag
-             << " Condition=\"'$(Configuration)|$(Platform)'=='";
-  (*stream ) << config << "|" << this->Platform << "'\"";
-  if(attribute)
-    {
-    (*stream ) << attribute;
-    }
+  stream->width(indentLevel * 2);
+  (*stream) << "";
+  (*stream) << "<" << tag << " Condition=\"'$(Configuration)|$(Platform)'=='";
+  (*stream) << config << "|" << this->Platform << "'\"";
+  if (attribute) {
+    (*stream) << attribute;
+  }
   // close the tag
-  (*stream ) << ">";
-  if(end)
-    {
-    (*stream ) << end;
-    }
+  (*stream) << ">";
+  if (end) {
+    (*stream) << end;
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteString(const char* line,
                                                   int indentLevel)
 {
   this->BuildFileStream->fill(' ');
-  this->BuildFileStream->width(indentLevel*2 );
+  this->BuildFileStream->width(indentLevel * 2);
   // write an empty string to get the fill level indent to print
-  (*this->BuildFileStream ) << "";
-  (*this->BuildFileStream ) << line;
+  (*this->BuildFileStream) << "";
+  (*this->BuildFileStream) << line;
 }
 
 #define VS10_USER_PROPS "$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props"
@@ -268,212 +256,183 @@ void cmVisualStudio10TargetGenerator::WriteString(const char* line,
 void cmVisualStudio10TargetGenerator::Generate()
 {
   // do not generate external ms projects
-  if(this->GeneratorTarget->GetType() == cmState::INTERFACE_LIBRARY
-      || this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT"))
-    {
+  if (this->GeneratorTarget->GetType() == cmState::INTERFACE_LIBRARY ||
+      this->GeneratorTarget->GetProperty("EXTERNAL_MSPROJECT")) {
     return;
-    }
+  }
   // Tell the global generator the name of the project file
-  this->GeneratorTarget->Target
-      ->SetProperty("GENERATOR_FILE_NAME",this->Name.c_str());
+  this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME",
+                                             this->Name.c_str());
   this->GeneratorTarget->Target->SetProperty("GENERATOR_FILE_NAME_EXT",
-                            ".vcxproj");
-  if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
-    {
-    if(!this->ComputeClOptions())
-      {
+                                             ".vcxproj");
+  if (this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) {
+    if (!this->ComputeClOptions()) {
       return;
-      }
-    if(!this->ComputeRcOptions())
-      {
+    }
+    if (!this->ComputeRcOptions()) {
       return;
-      }
-    if(!this->ComputeMasmOptions())
-      {
+    }
+    if (!this->ComputeMasmOptions()) {
       return;
-      }
-    if(!this->ComputeLinkOptions())
-      {
+    }
+    if (!this->ComputeLinkOptions()) {
       return;
-      }
     }
-  std::string path =  this->LocalGenerator->GetCurrentBinaryDirectory();
+  }
+  std::string path = this->LocalGenerator->GetCurrentBinaryDirectory();
   path += "/";
   path += this->Name;
   path += ".vcxproj";
-  this->BuildFileStream =
-    new cmGeneratedFileStream(path.c_str());
+  this->BuildFileStream = new cmGeneratedFileStream(path.c_str());
   this->PathToVcxproj = path;
   this->BuildFileStream->SetCopyIfDifferent(true);
 
   // Write the encoding header into the file
-  char magic[] = {char(0xEF), char(0xBB), char(0xBF)};
+  char magic[] = { char(0xEF), char(0xBB), char(0xBF) };
   this->BuildFileStream->write(magic, 3);
 
-  //get the tools version to use
+  // get the tools version to use
   const std::string toolsVer(this->GlobalGenerator->GetToolsVersion());
-  std::string project_defaults=
-    "<?xml version=\"1.0\" encoding=\"" +
+  std::string project_defaults = "<?xml version=\"1.0\" encoding=\"" +
     this->GlobalGenerator->Encoding() + "\"?>\n";
   project_defaults.append("<Project DefaultTargets=\"Build\" ToolsVersion=\"");
-  project_defaults.append(toolsVer +"\" ");
+  project_defaults.append(toolsVer + "\" ");
   project_defaults.append(
-          "xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
-  this->WriteString(project_defaults.c_str(),0);
+    "xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
+  this->WriteString(project_defaults.c_str(), 0);
 
-  if(this->NsightTegra)
-    {
+  if (this->NsightTegra) {
     this->WriteString("<PropertyGroup Label=\"NsightTegraProject\">\n", 1);
     const int nsightTegraMajorVersion = this->NsightTegraVersion[0];
     const int nsightTegraMinorVersion = this->NsightTegraVersion[1];
-    if (nsightTegraMajorVersion >= 2)
-      {
+    if (nsightTegraMajorVersion >= 2) {
       this->WriteString("<NsightTegraProjectRevisionNumber>", 2);
       if (nsightTegraMajorVersion > 3 ||
-          (nsightTegraMajorVersion == 3 && nsightTegraMinorVersion >= 1))
-        {
+          (nsightTegraMajorVersion == 3 && nsightTegraMinorVersion >= 1)) {
         (*this->BuildFileStream) << "11";
-        }
-      else
-        {
+      } else {
         // Nsight Tegra 2.0 uses project revision 9.
         (*this->BuildFileStream) << "9";
-        }
+      }
       (*this->BuildFileStream) << "</NsightTegraProjectRevisionNumber>\n";
       // Tell newer versions to upgrade silently when loading.
       this->WriteString("<NsightTegraUpgradeOnceWithoutPrompt>"
                         "true"
-                        "</NsightTegraUpgradeOnceWithoutPrompt>\n", 2);
-      }
-    else
-      {
+                        "</NsightTegraUpgradeOnceWithoutPrompt>\n",
+                        2);
+    } else {
       // Require Nsight Tegra 1.6 for JCompile support.
       this->WriteString("<NsightTegraProjectRevisionNumber>"
                         "7"
-                        "</NsightTegraProjectRevisionNumber>\n", 2);
-      }
-    this->WriteString("</PropertyGroup>\n", 1);
+                        "</NsightTegraProjectRevisionNumber>\n",
+                        2);
     }
+    this->WriteString("</PropertyGroup>\n", 1);
+  }
 
   this->WriteProjectConfigurations();
   this->WriteString("<PropertyGroup Label=\"Globals\">\n", 1);
   this->WriteString("<ProjectGUID>", 2);
-  (*this->BuildFileStream) <<  "{" << this->GUID << "}</ProjectGUID>\n";
+  (*this->BuildFileStream) << "{" << this->GUID << "}</ProjectGUID>\n";
 
-  if(this->MSTools
-     && this->GeneratorTarget->GetType() <= cmState::GLOBAL_TARGET)
-    {
+  if (this->MSTools &&
+      this->GeneratorTarget->GetType() <= cmState::GLOBAL_TARGET) {
     this->WriteApplicationTypeSettings();
     this->VerifyNecessaryFiles();
-    }
+  }
 
   const char* vsProjectTypes =
     this->GeneratorTarget->GetProperty("VS_GLOBAL_PROJECT_TYPES");
-  if(vsProjectTypes)
-    {
+  if (vsProjectTypes) {
     this->WriteString("<ProjectTypes>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsProjectTypes) <<
-      "</ProjectTypes>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(vsProjectTypes)
+                             << "</ProjectTypes>\n";
+  }
 
   const char* vsProjectName =
-      this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME");
+    this->GeneratorTarget->GetProperty("VS_SCC_PROJECTNAME");
   const char* vsLocalPath =
-      this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH");
+    this->GeneratorTarget->GetProperty("VS_SCC_LOCALPATH");
   const char* vsProvider =
-      this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER");
+    this->GeneratorTarget->GetProperty("VS_SCC_PROVIDER");
 
-  if( vsProjectName && vsLocalPath && vsProvider )
-    {
+  if (vsProjectName && vsLocalPath && vsProvider) {
     this->WriteString("<SccProjectName>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsProjectName) <<
-      "</SccProjectName>\n";
+    (*this->BuildFileStream) << cmVS10EscapeXML(vsProjectName)
+                             << "</SccProjectName>\n";
     this->WriteString("<SccLocalPath>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsLocalPath) <<
-      "</SccLocalPath>\n";
+    (*this->BuildFileStream) << cmVS10EscapeXML(vsLocalPath)
+                             << "</SccLocalPath>\n";
     this->WriteString("<SccProvider>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsProvider) <<
-      "</SccProvider>\n";
+    (*this->BuildFileStream) << cmVS10EscapeXML(vsProvider)
+                             << "</SccProvider>\n";
 
     const char* vsAuxPath =
-        this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH");
-    if( vsAuxPath )
-      {
+      this->GeneratorTarget->GetProperty("VS_SCC_AUXPATH");
+    if (vsAuxPath) {
       this->WriteString("<SccAuxPath>", 2);
-       (*this->BuildFileStream) << cmVS10EscapeXML(vsAuxPath) <<
-         "</SccAuxPath>\n";
-      }
+      (*this->BuildFileStream) << cmVS10EscapeXML(vsAuxPath)
+                               << "</SccAuxPath>\n";
     }
+  }
 
-  if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT"))
-    {
+  if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) {
     this->WriteString("<WinMDAssembly>true</WinMDAssembly>\n", 2);
-    }
+  }
 
   const char* vsGlobalKeyword =
     this->GeneratorTarget->GetProperty("VS_GLOBAL_KEYWORD");
-  if(!vsGlobalKeyword)
-    {
+  if (!vsGlobalKeyword) {
     this->WriteString("<Keyword>Win32Proj</Keyword>\n", 2);
-    }
-  else
-    {
+  } else {
     this->WriteString("<Keyword>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalKeyword) <<
-      "</Keyword>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalKeyword)
+                             << "</Keyword>\n";
+  }
 
   const char* vsGlobalRootNamespace =
     this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE");
-  if(vsGlobalRootNamespace)
-    {
+  if (vsGlobalRootNamespace) {
     this->WriteString("<RootNamespace>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalRootNamespace) <<
-      "</RootNamespace>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(vsGlobalRootNamespace)
+                             << "</RootNamespace>\n";
+  }
 
   this->WriteString("<Platform>", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(this->Platform)
                            << "</Platform>\n";
   const char* projLabel = this->GeneratorTarget->GetProperty("PROJECT_LABEL");
-  if(!projLabel)
-    {
+  if (!projLabel) {
     projLabel = this->Name.c_str();
-    }
+  }
   this->WriteString("<ProjectName>", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(projLabel) << "</ProjectName>\n";
-  if(const char* targetFrameworkVersion = this->GeneratorTarget->GetProperty(
-       "VS_DOTNET_TARGET_FRAMEWORK_VERSION"))
-    {
+  if (const char* targetFrameworkVersion = this->GeneratorTarget->GetProperty(
+        "VS_DOTNET_TARGET_FRAMEWORK_VERSION")) {
     this->WriteString("<TargetFrameworkVersion>", 2);
     (*this->BuildFileStream) << cmVS10EscapeXML(targetFrameworkVersion)
                              << "</TargetFrameworkVersion>\n";
-    }
+  }
 
   std::vector<std::string> keys = this->GeneratorTarget->GetPropertyKeys();
-  for(std::vector<std::string>::const_iterator keyIt = keys.begin();
-      keyIt != keys.end(); ++keyIt)
-    {
+  for (std::vector<std::string>::const_iterator keyIt = keys.begin();
+       keyIt != keys.end(); ++keyIt) {
     static const char* prefix = "VS_GLOBAL_";
-    if(keyIt->find(prefix) != 0)
+    if (keyIt->find(prefix) != 0)
       continue;
     std::string globalKey = keyIt->substr(strlen(prefix));
     // Skip invalid or separately-handled properties.
-    if(globalKey == "" ||
-       globalKey == "PROJECT_TYPES" ||
-       globalKey == "ROOTNAMESPACE" ||
-       globalKey == "KEYWORD")
-      {
+    if (globalKey == "" || globalKey == "PROJECT_TYPES" ||
+        globalKey == "ROOTNAMESPACE" || globalKey == "KEYWORD") {
       continue;
-      }
+    }
     const char* value = this->GeneratorTarget->GetProperty(keyIt->c_str());
     if (!value)
       continue;
     this->WriteString("<", 2);
-    (*this->BuildFileStream) << globalKey << ">"
-                             << cmVS10EscapeXML(value)
+    (*this->BuildFileStream) << globalKey << ">" << cmVS10EscapeXML(value)
                              << "</" << globalKey << ">\n";
-    }
+  }
 
   this->WriteString("</PropertyGroup>\n", 1);
   this->WriteString("<Import Project="
@@ -483,16 +442,17 @@ void cmVisualStudio10TargetGenerator::Generate()
   this->WriteString(
     "<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.props\" />\n", 1);
   this->WriteString("<ImportGroup Label=\"ExtensionSettings\">\n", 1);
-  if (this->GlobalGenerator->IsMasmEnabled())
-    {
+  if (this->GlobalGenerator->IsMasmEnabled()) {
     this->WriteString("<Import Project=\"$(VCTargetsPath)\\"
-                      "BuildCustomizations\\masm.props\" />\n", 2);
-    }
+                      "BuildCustomizations\\masm.props\" />\n",
+                      2);
+  }
   this->WriteString("</ImportGroup>\n", 1);
   this->WriteString("<ImportGroup Label=\"PropertySheets\">\n", 1);
   this->WriteString("<Import Project=\"" VS10_USER_PROPS "\""
                     " Condition=\"exists('" VS10_USER_PROPS "')\""
-                    " Label=\"LocalAppDataPlatform\" />\n", 2);
+                    " Label=\"LocalAppDataPlatform\" />\n",
+                    2);
   this->WritePlatformExtensions();
   this->WriteString("</ImportGroup>\n", 1);
   this->WriteString("<PropertyGroup Label=\"UserMacros\" />\n", 1);
@@ -509,14 +469,15 @@ void cmVisualStudio10TargetGenerator::Generate()
   this->WriteSDKReferences();
   this->WriteString(
     "<Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\""
-    " />\n", 1);
+    " />\n",
+    1);
   this->WriteTargetSpecificReferences();
   this->WriteString("<ImportGroup Label=\"ExtensionTargets\">\n", 1);
-  if (this->GlobalGenerator->IsMasmEnabled())
-    {
+  if (this->GlobalGenerator->IsMasmEnabled()) {
     this->WriteString("<Import Project=\"$(VCTargetsPath)\\"
-                      "BuildCustomizations\\masm.targets\" />\n", 2);
-    }
+                      "BuildCustomizations\\masm.targets\" />\n",
+                      2);
+  }
   this->WriteString("</ImportGroup>\n", 1);
   this->WriteString("</Project>", 0);
   // The groups are stored in a separate file for VS 10
@@ -526,144 +487,129 @@ void cmVisualStudio10TargetGenerator::Generate()
 void cmVisualStudio10TargetGenerator::WriteDotNetReferences()
 {
   std::vector<std::string> references;
-  if(const char* vsDotNetReferences =
-     this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES"))
-    {
+  if (const char* vsDotNetReferences =
+        this->GeneratorTarget->GetProperty("VS_DOTNET_REFERENCES")) {
     cmSystemTools::ExpandListArgument(vsDotNetReferences, references);
-    }
-  if(!references.empty())
-    {
+  }
+  if (!references.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for(std::vector<std::string>::iterator ri = references.begin();
-        ri != references.end(); ++ri)
-      {
+    for (std::vector<std::string>::iterator ri = references.begin();
+         ri != references.end(); ++ri) {
       this->WriteString("<Reference Include=\"", 2);
       (*this->BuildFileStream) << cmVS10EscapeXML(*ri) << "\">\n";
       this->WriteString("<CopyLocalSatelliteAssemblies>true"
-                        "</CopyLocalSatelliteAssemblies>\n", 3);
+                        "</CopyLocalSatelliteAssemblies>\n",
+                        3);
       this->WriteString("<ReferenceOutputAssembly>true"
-                        "</ReferenceOutputAssembly>\n", 3);
+                        "</ReferenceOutputAssembly>\n",
+                        3);
       this->WriteString("</Reference>\n", 2);
-      }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteEmbeddedResourceGroup()
 {
   std::vector<cmSourceFile const*> resxObjs;
-    this->GeneratorTarget->GetResxSources(resxObjs, "");
-  if(!resxObjs.empty())
-    {
+  this->GeneratorTarget->GetResxSources(resxObjs, "");
+  if (!resxObjs.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for(std::vector<cmSourceFile const*>::const_iterator oi = resxObjs.begin();
-        oi != resxObjs.end(); ++oi)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator oi =
+           resxObjs.begin();
+         oi != resxObjs.end(); ++oi) {
       std::string obj = (*oi)->GetFullPath();
       this->WriteString("<EmbeddedResource Include=\"", 2);
       this->ConvertToWindowsSlash(obj);
-      (*this->BuildFileStream ) << obj << "\">\n";
+      (*this->BuildFileStream) << obj << "\">\n";
 
       this->WriteString("<DependentUpon>", 3);
       std::string hFileName = obj.substr(0, obj.find_last_of(".")) + ".h";
       (*this->BuildFileStream) << hFileName << "</DependentUpon>\n";
 
-      for(std::vector<std::string>::const_iterator
-            i = this->Configurations.begin();
-          i != this->Configurations.end(); ++i)
-        {
+      for (std::vector<std::string>::const_iterator i =
+             this->Configurations.begin();
+           i != this->Configurations.end(); ++i) {
         this->WritePlatformConfigTag("LogicalName", i->c_str(), 3);
-        if(this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE"))
-          {
-          (*this->BuildFileStream ) << "$(RootNamespace).";
-          }
-        (*this->BuildFileStream ) << "%(Filename)";
-        (*this->BuildFileStream ) << ".resources";
-        (*this->BuildFileStream ) << "</LogicalName>\n";
+        if (this->GeneratorTarget->GetProperty("VS_GLOBAL_ROOTNAMESPACE")) {
+          (*this->BuildFileStream) << "$(RootNamespace).";
         }
+        (*this->BuildFileStream) << "%(Filename)";
+        (*this->BuildFileStream) << ".resources";
+        (*this->BuildFileStream) << "</LogicalName>\n";
+      }
 
       this->WriteString("</EmbeddedResource>\n", 2);
-      }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteXamlFilesGroup()
 {
   std::vector<cmSourceFile const*> xamlObjs;
   this->GeneratorTarget->GetXamlSources(xamlObjs, "");
-  if (!xamlObjs.empty())
-    {
+  if (!xamlObjs.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for (std::vector<cmSourceFile const*>::const_iterator
-           oi = xamlObjs.begin(); oi != xamlObjs.end(); ++oi)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator oi =
+           xamlObjs.begin();
+         oi != xamlObjs.end(); ++oi) {
       std::string obj = (*oi)->GetFullPath();
       std::string xamlType;
-      const char * xamlTypeProperty = (*oi)->GetProperty("VS_XAML_TYPE");
-      if (xamlTypeProperty)
-        {
+      const char* xamlTypeProperty = (*oi)->GetProperty("VS_XAML_TYPE");
+      if (xamlTypeProperty) {
         xamlType = xamlTypeProperty;
-        }
-      else
-        {
+      } else {
         xamlType = "Page";
-        }
+      }
 
       this->WriteSource(xamlType, *oi, ">\n");
       this->WriteString("<SubType>Designer</SubType>\n", 3);
       this->WriteString("</", 2);
       (*this->BuildFileStream) << xamlType << ">\n";
-
-      }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteTargetSpecificReferences()
 {
-  if(this->MSTools)
-    {
-    if(this->GlobalGenerator->TargetsWindowsPhone() &&
-       this->GlobalGenerator->GetSystemVersion() == "8.0")
-      {
-      this->WriteString(
-        "<Import Project=\""
-        "$(MSBuildExtensionsPath)\\Microsoft\\WindowsPhone\\v"
-        "$(TargetPlatformVersion)\\Microsoft.Cpp.WindowsPhone."
-        "$(TargetPlatformVersion).targets\" />\n", 1);
-      }
+  if (this->MSTools) {
+    if (this->GlobalGenerator->TargetsWindowsPhone() &&
+        this->GlobalGenerator->GetSystemVersion() == "8.0") {
+      this->WriteString("<Import Project=\""
+                        "$(MSBuildExtensionsPath)\\Microsoft\\WindowsPhone\\v"
+                        "$(TargetPlatformVersion)\\Microsoft.Cpp.WindowsPhone."
+                        "$(TargetPlatformVersion).targets\" />\n",
+                        1);
     }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteWinRTReferences()
 {
   std::vector<std::string> references;
-  if(const char* vsWinRTReferences =
-     this->GeneratorTarget->GetProperty("VS_WINRT_REFERENCES"))
-    {
+  if (const char* vsWinRTReferences =
+        this->GeneratorTarget->GetProperty("VS_WINRT_REFERENCES")) {
     cmSystemTools::ExpandListArgument(vsWinRTReferences, references);
-    }
+  }
 
-  if(this->GlobalGenerator->TargetsWindowsPhone() &&
-     this->GlobalGenerator->GetSystemVersion() == "8.0" &&
-     references.empty())
-    {
+  if (this->GlobalGenerator->TargetsWindowsPhone() &&
+      this->GlobalGenerator->GetSystemVersion() == "8.0" &&
+      references.empty()) {
     references.push_back("platform.winmd");
-    }
-  if(!references.empty())
-    {
+  }
+  if (!references.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for(std::vector<std::string>::iterator ri = references.begin();
-        ri != references.end(); ++ri)
-      {
+    for (std::vector<std::string>::iterator ri = references.begin();
+         ri != references.end(); ++ri) {
       this->WriteString("<Reference Include=\"", 2);
       (*this->BuildFileStream) << cmVS10EscapeXML(*ri) << "\">\n";
       this->WriteString("<IsWinMDFile>true</IsWinMDFile>\n", 3);
       this->WriteString("</Reference>\n", 2);
-      }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 }
 
 // ConfigurationType Application, Utility StaticLibrary DynamicLibrary
@@ -671,41 +617,34 @@ void cmVisualStudio10TargetGenerator::WriteWinRTReferences()
 void cmVisualStudio10TargetGenerator::WriteProjectConfigurations()
 {
   this->WriteString("<ItemGroup Label=\"ProjectConfigurations\">\n", 1);
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
     this->WriteString("<ProjectConfiguration Include=\"", 2);
-    (*this->BuildFileStream ) <<  *i << "|" << this->Platform << "\">\n";
+    (*this->BuildFileStream) << *i << "|" << this->Platform << "\">\n";
     this->WriteString("<Configuration>", 3);
-    (*this->BuildFileStream ) <<  *i << "</Configuration>\n";
+    (*this->BuildFileStream) << *i << "</Configuration>\n";
     this->WriteString("<Platform>", 3);
     (*this->BuildFileStream) << cmVS10EscapeXML(this->Platform)
                              << "</Platform>\n";
     this->WriteString("</ProjectConfiguration>\n", 2);
-    }
+  }
   this->WriteString("</ItemGroup>\n", 1);
 }
 
 void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
 {
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
-    this->WritePlatformConfigTag("PropertyGroup",
-                                 i->c_str(),
-                                 1, " Label=\"Configuration\"", "\n");
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
+    this->WritePlatformConfigTag("PropertyGroup", i->c_str(), 1,
+                                 " Label=\"Configuration\"", "\n");
     std::string configType = "<ConfigurationType>";
     if (const char* vsConfigurationType =
-        this->GeneratorTarget->GetProperty("VS_CONFIGURATION_TYPE"))
-      {
+          this->GeneratorTarget->GetProperty("VS_CONFIGURATION_TYPE")) {
       configType += cmVS10EscapeXML(vsConfigurationType);
-      }
-    else
-      {
-      switch(this->GeneratorTarget->GetType())
-        {
+    } else {
+      switch (this->GeneratorTarget->GetType()) {
         case cmState::SHARED_LIBRARY:
         case cmState::MODULE_LIBRARY:
           configType += "DynamicLibrary";
@@ -715,147 +654,124 @@ void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues()
           configType += "StaticLibrary";
           break;
         case cmState::EXECUTABLE:
-          if(this->NsightTegra &&
-             !this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI"))
-            {
+          if (this->NsightTegra &&
+              !this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) {
             // Android executables are .so too.
             configType += "DynamicLibrary";
-            }
-          else
-            {
+          } else {
             configType += "Application";
-            }
+          }
           break;
         case cmState::UTILITY:
         case cmState::GLOBAL_TARGET:
-          if(this->NsightTegra)
-            {
+          if (this->NsightTegra) {
             // Tegra-Android platform does not understand "Utility".
             configType += "StaticLibrary";
-            }
-          else
-            {
+          } else {
             configType += "Utility";
-            }
+          }
           break;
         case cmState::UNKNOWN_LIBRARY:
         case cmState::INTERFACE_LIBRARY:
           break;
-        }
       }
+    }
     configType += "</ConfigurationType>\n";
     this->WriteString(configType.c_str(), 2);
 
-    if(this->MSTools)
-      {
+    if (this->MSTools) {
       this->WriteMSToolConfigurationValues(*i);
-      }
-    else if(this->NsightTegra)
-      {
+    } else if (this->NsightTegra) {
       this->WriteNsightTegraConfigurationValues(*i);
-      }
+    }
 
     this->WriteString("</PropertyGroup>\n", 1);
-    }
+  }
 }
 
-void cmVisualStudio10TargetGenerator
-::WriteMSToolConfigurationValues(std::string const& config)
+void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValues(
+  std::string const& config)
 {
   cmGlobalVisualStudio10Generator* gg =
     static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
   const char* mfcFlag =
-    this->GeneratorTarget->
-      Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG");
+    this->GeneratorTarget->Target->GetMakefile()->GetDefinition(
+      "CMAKE_MFC_FLAG");
   std::string mfcFlagValue = mfcFlag ? mfcFlag : "0";
 
   std::string useOfMfcValue = "false";
-  if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
-    {
-    if(mfcFlagValue == "1")
-      {
+  if (this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) {
+    if (mfcFlagValue == "1") {
       useOfMfcValue = "Static";
-      }
-    else if(mfcFlagValue == "2")
-      {
+    } else if (mfcFlagValue == "2") {
       useOfMfcValue = "Dynamic";
-      }
     }
+  }
   std::string mfcLine = "<UseOfMfc>";
   mfcLine += useOfMfcValue + "</UseOfMfc>\n";
   this->WriteString(mfcLine.c_str(), 2);
 
-  if((this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY &&
-      this->ClOptions[config]->UsingUnicode()) ||
-     this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
-     this->GlobalGenerator->TargetsWindowsPhone() ||
-     this->GlobalGenerator->TargetsWindowsStore() ||
-     this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
-    {
+  if ((this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY &&
+       this->ClOptions[config]->UsingUnicode()) ||
+      this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
+      this->GlobalGenerator->TargetsWindowsPhone() ||
+      this->GlobalGenerator->TargetsWindowsStore() ||
+      this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) {
     this->WriteString("<CharacterSet>Unicode</CharacterSet>\n", 2);
-    }
-  else if (this->GeneratorTarget->GetType() <= cmState::MODULE_LIBRARY &&
-           this->ClOptions[config]->UsingSBCS())
-    {
+  } else if (this->GeneratorTarget->GetType() <= cmState::MODULE_LIBRARY &&
+             this->ClOptions[config]->UsingSBCS()) {
     this->WriteString("<CharacterSet>NotSet</CharacterSet>\n", 2);
-    }
-  else
-    {
+  } else {
     this->WriteString("<CharacterSet>MultiByte</CharacterSet>\n", 2);
-    }
-  if(const char* toolset = gg->GetPlatformToolset())
-    {
+  }
+  if (const char* toolset = gg->GetPlatformToolset()) {
     std::string pts = "<PlatformToolset>";
     pts += toolset;
     pts += "</PlatformToolset>\n";
     this->WriteString(pts.c_str(), 2);
-    }
-  if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
-     this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS"))
-    {
+  }
+  if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") ||
+      this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_EXTENSIONS")) {
     this->WriteString("<WindowsAppContainer>true"
-                      "</WindowsAppContainer>\n", 2);
-    }
+                      "</WindowsAppContainer>\n",
+                      2);
+  }
 }
 
-void cmVisualStudio10TargetGenerator
-::WriteNsightTegraConfigurationValues(std::string const&)
+void cmVisualStudio10TargetGenerator::WriteNsightTegraConfigurationValues(
+  std::string const&)
 {
   cmGlobalVisualStudio10Generator* gg =
     static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
   const char* toolset = gg->GetPlatformToolset();
   std::string ntv = "<NdkToolchainVersion>";
-  ntv += toolset? toolset : "Default";
+  ntv += toolset ? toolset : "Default";
   ntv += "</NdkToolchainVersion>\n";
   this->WriteString(ntv.c_str(), 2);
-  if(const char* minApi =
-     this->GeneratorTarget->GetProperty("ANDROID_API_MIN"))
-    {
+  if (const char* minApi =
+        this->GeneratorTarget->GetProperty("ANDROID_API_MIN")) {
     this->WriteString("<AndroidMinAPI>", 2);
-    (*this->BuildFileStream ) <<
-      "android-" << cmVS10EscapeXML(minApi) << "</AndroidMinAPI>\n";
-    }
-  if(const char* api = this->GeneratorTarget->GetProperty("ANDROID_API"))
-    {
+    (*this->BuildFileStream) << "android-" << cmVS10EscapeXML(minApi)
+                             << "</AndroidMinAPI>\n";
+  }
+  if (const char* api = this->GeneratorTarget->GetProperty("ANDROID_API")) {
     this->WriteString("<AndroidTargetAPI>", 2);
-    (*this->BuildFileStream ) <<
-      "android-" << cmVS10EscapeXML(api) << "</AndroidTargetAPI>\n";
-    }
+    (*this->BuildFileStream) << "android-" << cmVS10EscapeXML(api)
+                             << "</AndroidTargetAPI>\n";
+  }
 
-  if(const char* cpuArch = this->GeneratorTarget->GetProperty("ANDROID_ARCH"))
-    {
+  if (const char* cpuArch =
+        this->GeneratorTarget->GetProperty("ANDROID_ARCH")) {
     this->WriteString("<AndroidArch>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) <<
-      "</AndroidArch>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(cpuArch) << "</AndroidArch>\n";
+  }
 
-  if(const char* stlType =
-     this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE"))
-    {
+  if (const char* stlType =
+        this->GeneratorTarget->GetProperty("ANDROID_STL_TYPE")) {
     this->WriteString("<AndroidStlType>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(stlType) <<
-      "</AndroidStlType>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(stlType)
+                             << "</AndroidStlType>\n";
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteCustomCommands()
@@ -863,136 +779,114 @@ void cmVisualStudio10TargetGenerator::WriteCustomCommands()
   this->SourcesVisited.clear();
   std::vector<cmSourceFile const*> customCommands;
   this->GeneratorTarget->GetCustomCommands(customCommands, "");
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = customCommands.begin();
-      si != customCommands.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         customCommands.begin();
+       si != customCommands.end(); ++si) {
     this->WriteCustomCommand(*si);
-    }
+  }
 }
 
-void cmVisualStudio10TargetGenerator
-::WriteCustomCommand(cmSourceFile const* sf)
+void cmVisualStudio10TargetGenerator::WriteCustomCommand(
+  cmSourceFile const* sf)
 {
-  if(this->SourcesVisited.insert(sf).second)
-    {
-    if(std::vector<cmSourceFile*> const* depends =
-       this->GeneratorTarget->GetSourceDepends(sf))
-      {
-      for(std::vector<cmSourceFile*>::const_iterator di = depends->begin();
-          di != depends->end(); ++di)
-        {
+  if (this->SourcesVisited.insert(sf).second) {
+    if (std::vector<cmSourceFile*> const* depends =
+          this->GeneratorTarget->GetSourceDepends(sf)) {
+      for (std::vector<cmSourceFile*>::const_iterator di = depends->begin();
+           di != depends->end(); ++di) {
         this->WriteCustomCommand(*di);
-        }
       }
-    if(cmCustomCommand const* command = sf->GetCustomCommand())
-      {
+    }
+    if (cmCustomCommand const* command = sf->GetCustomCommand()) {
       this->WriteString("<ItemGroup>\n", 1);
       this->WriteCustomRule(sf, *command);
       this->WriteString("</ItemGroup>\n", 1);
-      }
     }
+  }
 }
 
-void
-cmVisualStudio10TargetGenerator::WriteCustomRule(cmSourceFile const* source,
-                                                 cmCustomCommand const &
-                                                 command)
+void cmVisualStudio10TargetGenerator::WriteCustomRule(
+  cmSourceFile const* source, cmCustomCommand const& command)
 {
   std::string sourcePath = source->GetFullPath();
   // VS 10 will always rebuild a custom command attached to a .rule
   // file that doesn't exist so create the file explicitly.
-  if (source->GetPropertyAsBool("__CMAKE_RULE"))
-    {
-    if(!cmSystemTools::FileExists(sourcePath.c_str()))
-      {
+  if (source->GetPropertyAsBool("__CMAKE_RULE")) {
+    if (!cmSystemTools::FileExists(sourcePath.c_str())) {
       // Make sure the path exists for the file
       std::string path = cmSystemTools::GetFilenamePath(sourcePath);
       cmSystemTools::MakeDirectory(path.c_str());
       cmsys::ofstream fout(sourcePath.c_str());
-      if(fout)
-        {
+      if (fout) {
         fout << "# generated from CMake\n";
         fout.flush();
         fout.close();
         // Force given file to have a very old timestamp, thus
         // preventing dependent rebuilds.
         this->ForceOld(sourcePath);
-        }
-      else
-        {
+      } else {
         std::string error = "Could not create file: [";
-        error +=  sourcePath;
+        error += sourcePath;
         error += "]  ";
-        cmSystemTools::Error
-          (error.c_str(), cmSystemTools::GetLastSystemError().c_str());
-        }
+        cmSystemTools::Error(error.c_str(),
+                             cmSystemTools::GetLastSystemError().c_str());
       }
     }
+  }
   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
 
   this->WriteSource("CustomBuild", source, ">\n");
 
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
     cmCustomCommandGenerator ccg(command, *i, this->LocalGenerator);
     std::string comment = lg->ConstructComment(ccg);
     comment = cmVS10EscapeComment(comment);
-    std::string script =
-      cmVS10EscapeXML(lg->ConstructScript(ccg));
-    this->WritePlatformConfigTag("Message",i->c_str(), 3);
-    (*this->BuildFileStream ) << cmVS10EscapeXML(comment) << "</Message>\n";
+    std::string script = cmVS10EscapeXML(lg->ConstructScript(ccg));
+    this->WritePlatformConfigTag("Message", i->c_str(), 3);
+    (*this->BuildFileStream) << cmVS10EscapeXML(comment) << "</Message>\n";
     this->WritePlatformConfigTag("Command", i->c_str(), 3);
-    (*this->BuildFileStream ) << script << "</Command>\n";
+    (*this->BuildFileStream) << script << "</Command>\n";
     this->WritePlatformConfigTag("AdditionalInputs", i->c_str(), 3);
 
-    (*this->BuildFileStream ) << cmVS10EscapeXML(source->GetFullPath());
-    for(std::vector<std::string>::const_iterator d =
-          ccg.GetDepends().begin();
-        d != ccg.GetDepends().end();
-        ++d)
-      {
+    (*this->BuildFileStream) << cmVS10EscapeXML(source->GetFullPath());
+    for (std::vector<std::string>::const_iterator d = ccg.GetDepends().begin();
+         d != ccg.GetDepends().end(); ++d) {
       std::string dep;
-      if(this->LocalGenerator->GetRealDependency(d->c_str(), i->c_str(), dep))
-        {
+      if (this->LocalGenerator->GetRealDependency(d->c_str(), i->c_str(),
+                                                  dep)) {
         this->ConvertToWindowsSlash(dep);
-        (*this->BuildFileStream ) << ";" << cmVS10EscapeXML(dep);
-        }
+        (*this->BuildFileStream) << ";" << cmVS10EscapeXML(dep);
       }
-    (*this->BuildFileStream ) << ";%(AdditionalInputs)</AdditionalInputs>\n";
+    }
+    (*this->BuildFileStream) << ";%(AdditionalInputs)</AdditionalInputs>\n";
     this->WritePlatformConfigTag("Outputs", i->c_str(), 3);
     const char* sep = "";
-    for(std::vector<std::string>::const_iterator o =
-          ccg.GetOutputs().begin();
-        o != ccg.GetOutputs().end();
-        ++o)
-      {
+    for (std::vector<std::string>::const_iterator o = ccg.GetOutputs().begin();
+         o != ccg.GetOutputs().end(); ++o) {
       std::string out = *o;
       this->ConvertToWindowsSlash(out);
-      (*this->BuildFileStream ) << sep << cmVS10EscapeXML(out);
+      (*this->BuildFileStream) << sep << cmVS10EscapeXML(out);
       sep = ";";
-      }
-    (*this->BuildFileStream ) << "</Outputs>\n";
-    if(this->LocalGenerator->GetVersion()
-                                        > cmGlobalVisualStudioGenerator::VS10)
-      {
+    }
+    (*this->BuildFileStream) << "</Outputs>\n";
+    if (this->LocalGenerator->GetVersion() >
+        cmGlobalVisualStudioGenerator::VS10) {
       // VS >= 11 let us turn off linking of custom command outputs.
       this->WritePlatformConfigTag("LinkObjects", i->c_str(), 3);
-      (*this->BuildFileStream ) << "false</LinkObjects>\n";
-      }
+      (*this->BuildFileStream) << "false</LinkObjects>\n";
     }
+  }
   this->WriteString("</CustomBuild>\n", 2);
 }
 
-std::string
-cmVisualStudio10TargetGenerator::ConvertPath(std::string const& path,
-                                             bool forceRelative)
+std::string cmVisualStudio10TargetGenerator::ConvertPath(
+  std::string const& path, bool forceRelative)
 {
   return forceRelative
     ? cmSystemTools::RelativePath(
-      this->LocalGenerator->GetCurrentBinaryDirectory(), path.c_str())
+        this->LocalGenerator->GetCurrentBinaryDirectory(), path.c_str())
     : path.c_str();
 }
 
@@ -1000,186 +894,159 @@ void cmVisualStudio10TargetGenerator::ConvertToWindowsSlash(std::string& s)
 {
   // first convert all of the slashes
   std::string::size_type pos = 0;
-  while((pos = s.find('/', pos)) != std::string::npos)
-    {
+  while ((pos = s.find('/', pos)) != std::string::npos) {
     s[pos] = '\\';
     pos++;
-    }
+  }
 }
 void cmVisualStudio10TargetGenerator::WriteGroups()
 {
   // collect up group information
-  std::vector<cmSourceGroup> sourceGroups =
-    this->Makefile->GetSourceGroups();
+  std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
   std::vector<cmSourceFile*> classes;
-  if (!this->GeneratorTarget->GetConfigCommonSourceFiles(classes))
-    {
+  if (!this->GeneratorTarget->GetConfigCommonSourceFiles(classes)) {
     return;
-    }
+  }
 
   std::set<cmSourceGroup*> groupsUsed;
-  for(std::vector<cmSourceFile*>::const_iterator s = classes.begin();
-      s != classes.end(); s++)
-    {
+  for (std::vector<cmSourceFile*>::const_iterator s = classes.begin();
+       s != classes.end(); s++) {
     cmSourceFile* sf = *s;
     std::string const& source = sf->GetFullPath();
     cmSourceGroup* sourceGroup =
       this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
     groupsUsed.insert(sourceGroup);
-    }
+  }
 
   this->AddMissingSourceGroups(groupsUsed, sourceGroups);
 
   // Write out group file
-  std::string path =  this->LocalGenerator->GetCurrentBinaryDirectory();
+  std::string path = this->LocalGenerator->GetCurrentBinaryDirectory();
   path += "/";
   path += this->Name;
   path += ".vcxproj.filters";
   cmGeneratedFileStream fout(path.c_str());
   fout.SetCopyIfDifferent(true);
-  char magic[] = {char(0xEF), char(0xBB), char(0xBF)};
+  char magic[] = { char(0xEF), char(0xBB), char(0xBF) };
   fout.write(magic, 3);
   cmGeneratedFileStream* save = this->BuildFileStream;
-  this->BuildFileStream = & fout;
+  this->BuildFileStream = &fout;
 
-  //get the tools version to use
+  // get the tools version to use
   const std::string toolsVer(this->GlobalGenerator->GetToolsVersion());
-  std::string project_defaults=
-    "<?xml version=\"1.0\" encoding=\"" +
+  std::string project_defaults = "<?xml version=\"1.0\" encoding=\"" +
     this->GlobalGenerator->Encoding() + "\"?>\n";
   project_defaults.append("<Project ToolsVersion=\"");
-  project_defaults.append(toolsVer +"\" ");
+  project_defaults.append(toolsVer + "\" ");
   project_defaults.append(
-        "xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
-  this->WriteString(project_defaults.c_str(),0);
+    "xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\n");
+  this->WriteString(project_defaults.c_str(), 0);
 
-  for(ToolSourceMap::const_iterator ti = this->Tools.begin();
-      ti != this->Tools.end(); ++ti)
-    {
+  for (ToolSourceMap::const_iterator ti = this->Tools.begin();
+       ti != this->Tools.end(); ++ti) {
     this->WriteGroupSources(ti->first.c_str(), ti->second, sourceGroups);
-    }
+  }
 
   // Added files are images and the manifest.
-  if (!this->AddedFiles.empty())
-    {
+  if (!this->AddedFiles.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for(std::vector<std::string>::const_iterator
-          oi = this->AddedFiles.begin(); oi != this->AddedFiles.end(); ++oi)
-      {
-      std::string fileName = cmSystemTools::LowerCase(
-        cmSystemTools::GetFilenameName(*oi));
-      if (fileName == "wmappmanifest.xml")
-        {
+    for (std::vector<std::string>::const_iterator oi =
+           this->AddedFiles.begin();
+         oi != this->AddedFiles.end(); ++oi) {
+      std::string fileName =
+        cmSystemTools::LowerCase(cmSystemTools::GetFilenameName(*oi));
+      if (fileName == "wmappmanifest.xml") {
         this->WriteString("<XML Include=\"", 2);
         (*this->BuildFileStream) << *oi << "\">\n";
         this->WriteString("<Filter>Resource Files</Filter>\n", 3);
         this->WriteString("</XML>\n", 2);
-        }
-      else if(cmSystemTools::GetFilenameExtension(fileName) ==
-              ".appxmanifest")
-        {
+      } else if (cmSystemTools::GetFilenameExtension(fileName) ==
+                 ".appxmanifest") {
         this->WriteString("<AppxManifest Include=\"", 2);
         (*this->BuildFileStream) << *oi << "\">\n";
         this->WriteString("<Filter>Resource Files</Filter>\n", 3);
         this->WriteString("</AppxManifest>\n", 2);
-        }
-      else if(cmSystemTools::GetFilenameExtension(fileName) ==
-              ".pfx")
-        {
+      } else if (cmSystemTools::GetFilenameExtension(fileName) == ".pfx") {
         this->WriteString("<None Include=\"", 2);
         (*this->BuildFileStream) << *oi << "\">\n";
         this->WriteString("<Filter>Resource Files</Filter>\n", 3);
         this->WriteString("</None>\n", 2);
-        }
-      else
-        {
+      } else {
         this->WriteString("<Image Include=\"", 2);
         (*this->BuildFileStream) << *oi << "\">\n";
         this->WriteString("<Filter>Resource Files</Filter>\n", 3);
         this->WriteString("</Image>\n", 2);
-        }
       }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 
   std::vector<cmSourceFile const*> resxObjs;
-    this->GeneratorTarget->GetResxSources(resxObjs, "");
-  if(!resxObjs.empty())
-    {
+  this->GeneratorTarget->GetResxSources(resxObjs, "");
+  if (!resxObjs.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for(std::vector<cmSourceFile const*>::const_iterator oi = resxObjs.begin();
-        oi != resxObjs.end(); ++oi)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator oi =
+           resxObjs.begin();
+         oi != resxObjs.end(); ++oi) {
       std::string obj = (*oi)->GetFullPath();
       this->WriteString("<EmbeddedResource Include=\"", 2);
       this->ConvertToWindowsSlash(obj);
-      (*this->BuildFileStream ) << cmVS10EscapeXML(obj) << "\">\n";
+      (*this->BuildFileStream) << cmVS10EscapeXML(obj) << "\">\n";
       this->WriteString("<Filter>Resource Files</Filter>\n", 3);
       this->WriteString("</EmbeddedResource>\n", 2);
-      }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 
   // Add object library contents as external objects.
   std::vector<std::string> objs;
   this->GeneratorTarget->UseObjectLibraries(objs, "");
-  if(!objs.empty())
-    {
+  if (!objs.empty()) {
     this->WriteString("<ItemGroup>\n", 1);
-    for(std::vector<std::string>::const_iterator
-          oi = objs.begin(); oi != objs.end(); ++oi)
-      {
+    for (std::vector<std::string>::const_iterator oi = objs.begin();
+         oi != objs.end(); ++oi) {
       std::string obj = *oi;
       this->WriteString("<Object Include=\"", 2);
       this->ConvertToWindowsSlash(obj);
-      (*this->BuildFileStream ) << cmVS10EscapeXML(obj) << "\">\n";
+      (*this->BuildFileStream) << cmVS10EscapeXML(obj) << "\">\n";
       this->WriteString("<Filter>Object Libraries</Filter>\n", 3);
       this->WriteString("</Object>\n", 2);
-      }
-    this->WriteString("</ItemGroup>\n", 1);
     }
+    this->WriteString("</ItemGroup>\n", 1);
+  }
 
   this->WriteString("<ItemGroup>\n", 1);
-  for(std::set<cmSourceGroup*>::iterator g = groupsUsed.begin();
-      g != groupsUsed.end(); ++g)
-    {
+  for (std::set<cmSourceGroup*>::iterator g = groupsUsed.begin();
+       g != groupsUsed.end(); ++g) {
     cmSourceGroup* sg = *g;
     const char* name = sg->GetFullName();
-    if(strlen(name) != 0)
-      {
+    if (strlen(name) != 0) {
       this->WriteString("<Filter Include=\"", 2);
       (*this->BuildFileStream) << name << "\">\n";
       std::string guidName = "SG_Filter_";
       guidName += name;
       this->WriteString("<UniqueIdentifier>", 3);
-      std::string guid
-        = this->GlobalGenerator->GetGUID(guidName.c_str());
-      (*this->BuildFileStream)
-        << "{"
-        << guid << "}"
-        << "</UniqueIdentifier>\n";
+      std::string guid = this->GlobalGenerator->GetGUID(guidName.c_str());
+      (*this->BuildFileStream) << "{" << guid << "}"
+                               << "</UniqueIdentifier>\n";
       this->WriteString("</Filter>\n", 2);
-      }
     }
-  if(!objs.empty())
-    {
+  }
+  if (!objs.empty()) {
     this->WriteString("<Filter Include=\"Object Libraries\">\n", 2);
     std::string guidName = "SG_Filter_Object Libraries";
     this->WriteString("<UniqueIdentifier>", 3);
-    std::string guid =
-      this->GlobalGenerator->GetGUID(guidName.c_str());
+    std::string guid = this->GlobalGenerator->GetGUID(guidName.c_str());
     (*this->BuildFileStream) << "{" << guid << "}"
                              << "</UniqueIdentifier>\n";
     this->WriteString("</Filter>\n", 2);
-    }
+  }
 
-  if(!resxObjs.empty() || !this->AddedFiles.empty())
-    {
+  if (!resxObjs.empty() || !this->AddedFiles.empty()) {
     this->WriteString("<Filter Include=\"Resource Files\">\n", 2);
     std::string guidName = "SG_Filter_Resource Files";
     this->WriteString("<UniqueIdentifier>", 3);
-    std::string guid =
-      this->GlobalGenerator->GetGUID(guidName.c_str());
+    std::string guid = this->GlobalGenerator->GetGUID(guidName.c_str());
     (*this->BuildFileStream) << "{" << guid << "}"
                              << "</UniqueIdentifier>\n";
     this->WriteString("<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;", 3);
@@ -1193,68 +1060,56 @@ void cmVisualStudio10TargetGenerator::WriteGroups()
   // restore stream pointer
   this->BuildFileStream = save;
 
-  if (fout.Close())
-    {
+  if (fout.Close()) {
     this->GlobalGenerator->FileReplacedDuringGenerate(path);
-    }
+  }
 }
 
 // Add to groupsUsed empty source groups that have non-empty children.
-void
-cmVisualStudio10TargetGenerator::AddMissingSourceGroups(
+void cmVisualStudio10TargetGenerator::AddMissingSourceGroups(
   std::set<cmSourceGroup*>& groupsUsed,
-  const std::vector<cmSourceGroup>& allGroups
-  )
+  const std::vector<cmSourceGroup>& allGroups)
 {
-  for(std::vector<cmSourceGroup>::const_iterator current = allGroups.begin();
-      current != allGroups.end(); ++current)
-    {
+  for (std::vector<cmSourceGroup>::const_iterator current = allGroups.begin();
+       current != allGroups.end(); ++current) {
     std::vector<cmSourceGroup> const& children = current->GetGroupChildren();
-    if(children.empty())
-      {
+    if (children.empty()) {
       continue; // the group is really empty
-      }
+    }
 
     this->AddMissingSourceGroups(groupsUsed, children);
 
     cmSourceGroup* current_ptr = const_cast<cmSourceGroup*>(&(*current));
-    if(groupsUsed.find(current_ptr) != groupsUsed.end())
-      {
+    if (groupsUsed.find(current_ptr) != groupsUsed.end()) {
       continue; // group has already been added to set
-      }
+    }
 
     // check if it least one of the group's descendants is not empty
     // (at least one child must already have been added)
     std::vector<cmSourceGroup>::const_iterator child_it = children.begin();
-    while(child_it != children.end())
-      {
+    while (child_it != children.end()) {
       cmSourceGroup* child_ptr = const_cast<cmSourceGroup*>(&(*child_it));
-      if(groupsUsed.find(child_ptr) != groupsUsed.end())
-        {
+      if (groupsUsed.find(child_ptr) != groupsUsed.end()) {
         break; // found a child that was already added => add current group too
-        }
-      child_it++;
       }
+      child_it++;
+    }
 
-    if(child_it == children.end())
-      {
+    if (child_it == children.end()) {
       continue; // no descendants have source files => ignore this group
-      }
+    }
 
     groupsUsed.insert(current_ptr);
-    }
+  }
 }
 
-void
-cmVisualStudio10TargetGenerator::
-WriteGroupSources(const char* name,
-                  ToolSources const& sources,
-                  std::vector<cmSourceGroup>& sourceGroups)
+void cmVisualStudio10TargetGenerator::WriteGroupSources(
+  const char* name, ToolSources const& sources,
+  std::vector<cmSourceGroup>& sourceGroups)
 {
   this->WriteString("<ItemGroup>\n", 1);
-  for(ToolSources::const_iterator s = sources.begin();
-      s != sources.end(); ++s)
-    {
+  for (ToolSources::const_iterator s = sources.begin(); s != sources.end();
+       ++s) {
     cmSourceFile const* sf = s->SourceFile;
     std::string const& source = sf->GetFullPath();
     cmSourceGroup* sourceGroup =
@@ -1263,45 +1118,36 @@ WriteGroupSources(const char* name,
     this->WriteString("<", 2);
     std::string path = this->ConvertPath(source, s->RelativePath);
     this->ConvertToWindowsSlash(path);
-    (*this->BuildFileStream) << name << " Include=\""
-                             << cmVS10EscapeXML(path);
-    if(strlen(filter))
-      {
+    (*this->BuildFileStream) << name << " Include=\"" << cmVS10EscapeXML(path);
+    if (strlen(filter)) {
       (*this->BuildFileStream) << "\">\n";
       this->WriteString("<Filter>", 3);
       (*this->BuildFileStream) << filter << "</Filter>\n";
       this->WriteString("</", 2);
       (*this->BuildFileStream) << name << ">\n";
-      }
-    else
-      {
+    } else {
       (*this->BuildFileStream) << "\" />\n";
-      }
     }
+  }
   this->WriteString("</ItemGroup>\n", 1);
 }
 
 void cmVisualStudio10TargetGenerator::WriteHeaderSource(cmSourceFile const* sf)
 {
   std::string const& fileName = sf->GetFullPath();
-  if (this->IsResxHeader(fileName))
-    {
+  if (this->IsResxHeader(fileName)) {
     this->WriteSource("ClInclude", sf, ">\n");
     this->WriteString("<FileType>CppForm</FileType>\n", 3);
     this->WriteString("</ClInclude>\n", 2);
-    }
-  else if (this->IsXamlHeader(fileName))
-    {
+  } else if (this->IsXamlHeader(fileName)) {
     this->WriteSource("ClInclude", sf, ">\n");
     this->WriteString("<DependentUpon>", 3);
     std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
     (*this->BuildFileStream) << xamlFileName << "</DependentUpon>\n";
     this->WriteString("</ClInclude>\n", 2);
-    }
-  else
-    {
+  } else {
     this->WriteSource("ClInclude", sf);
-    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
@@ -1313,163 +1159,130 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
   std::string shaderModel;
   std::string shaderAdditionalFlags;
   std::string ext = cmSystemTools::LowerCase(sf->GetExtension());
-  if(ext == "hlsl")
-    {
+  if (ext == "hlsl") {
     tool = "FXCompile";
     // Figure out the type of shader compiler to use.
-    if(const char* st = sf->GetProperty("VS_SHADER_TYPE"))
-      {
+    if (const char* st = sf->GetProperty("VS_SHADER_TYPE")) {
       shaderType = st;
       toolHasSettings = true;
-      }
+    }
     // Figure out which entry point to use if any
-    if (const char* se = sf->GetProperty("VS_SHADER_ENTRYPOINT"))
-      {
+    if (const char* se = sf->GetProperty("VS_SHADER_ENTRYPOINT")) {
       shaderEntryPoint = se;
       toolHasSettings = true;
-      }
+    }
     // Figure out which shader model to use if any
-    if (const char* sm = sf->GetProperty("VS_SHADER_MODEL"))
-      {
+    if (const char* sm = sf->GetProperty("VS_SHADER_MODEL")) {
       shaderModel = sm;
       toolHasSettings = true;
-      }
+    }
     // Figure out if there's any additional flags to use
-    if (const char* saf = sf->GetProperty("VS_SHADER_FLAGS"))
-      {
+    if (const char* saf = sf->GetProperty("VS_SHADER_FLAGS")) {
       shaderAdditionalFlags = saf;
       toolHasSettings = true;
-      }
     }
-  else if(ext == "jpg" ||
-          ext == "png")
-    {
+  } else if (ext == "jpg" || ext == "png") {
     tool = "Image";
-    }
-  else if(ext == "resw")
-    {
+  } else if (ext == "resw") {
     tool = "PRIResource";
-    }
-  else if(ext == "xml")
-    {
+  } else if (ext == "xml") {
     tool = "XML";
-    }
+  }
 
-  if(this->NsightTegra)
-    {
+  if (this->NsightTegra) {
     // Nsight Tegra needs specific file types to check up-to-dateness.
-    std::string name =
-      cmSystemTools::LowerCase(sf->GetLocation().GetName());
-    if(name == "androidmanifest.xml" ||
-       name == "build.xml" ||
-       name == "proguard.cfg" ||
-       name == "proguard-project.txt" ||
-       ext == "properties")
-      {
+    std::string name = cmSystemTools::LowerCase(sf->GetLocation().GetName());
+    if (name == "androidmanifest.xml" || name == "build.xml" ||
+        name == "proguard.cfg" || name == "proguard-project.txt" ||
+        ext == "properties") {
       tool = "AndroidBuild";
-      }
-    else if(ext == "java")
-      {
+    } else if (ext == "java") {
       tool = "JCompile";
-      }
-    else if(ext == "asm" || ext == "s")
-      {
+    } else if (ext == "asm" || ext == "s") {
       tool = "ClCompile";
-      }
     }
+  }
 
   std::string deployContent;
   std::string deployLocation;
-  if(this->GlobalGenerator->TargetsWindowsPhone() ||
-     this->GlobalGenerator->TargetsWindowsStore())
-    {
+  if (this->GlobalGenerator->TargetsWindowsPhone() ||
+      this->GlobalGenerator->TargetsWindowsStore()) {
     const char* content = sf->GetProperty("VS_DEPLOYMENT_CONTENT");
-    if(content && *content)
-      {
+    if (content && *content) {
       toolHasSettings = true;
       deployContent = content;
 
       const char* location = sf->GetProperty("VS_DEPLOYMENT_LOCATION");
-      if(location && *location)
-        {
+      if (location && *location) {
         deployLocation = location;
-        }
       }
     }
+  }
 
-  if(toolHasSettings)
-    {
+  if (toolHasSettings) {
     this->WriteSource(tool, sf, ">\n");
 
-    if(!deployContent.empty())
-      {
+    if (!deployContent.empty()) {
       cmGeneratorExpression ge;
       cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
         ge.Parse(deployContent);
       // Deployment location cannot be set on a configuration basis
-      if(!deployLocation.empty())
-        {
+      if (!deployLocation.empty()) {
         this->WriteString("<Link>", 3);
         (*this->BuildFileStream) << deployLocation
                                  << "\\%(FileName)%(Extension)";
         this->WriteString("</Link>\n", 0);
-        }
-      for(size_t i = 0; i != this->Configurations.size(); ++i)
-        {
-        if(0 == strcmp(cge->Evaluate(this->LocalGenerator,
-                                     this->Configurations[i]), "1"))
-          {
+      }
+      for (size_t i = 0; i != this->Configurations.size(); ++i) {
+        if (0 == strcmp(cge->Evaluate(this->LocalGenerator,
+                                      this->Configurations[i]),
+                        "1")) {
           this->WriteString("<DeploymentContent Condition=\""
-                            "'$(Configuration)|$(Platform)'=='", 3);
+                            "'$(Configuration)|$(Platform)'=='",
+                            3);
           (*this->BuildFileStream) << this->Configurations[i] << "|"
                                    << this->Platform << "'\">true";
           this->WriteString("</DeploymentContent>\n", 0);
-          }
-        else
-          {
+        } else {
           this->WriteString("<ExcludedFromBuild Condition=\""
-                            "'$(Configuration)|$(Platform)'=='", 3);
+                            "'$(Configuration)|$(Platform)'=='",
+                            3);
           (*this->BuildFileStream) << this->Configurations[i] << "|"
                                    << this->Platform << "'\">true";
           this->WriteString("</ExcludedFromBuild>\n", 0);
-          }
         }
       }
-    if(!shaderType.empty())
-      {
+    }
+    if (!shaderType.empty()) {
       this->WriteString("<ShaderType>", 3);
       (*this->BuildFileStream) << cmVS10EscapeXML(shaderType)
                                << "</ShaderType>\n";
-      }
-    if(!shaderEntryPoint.empty())
-      {
+    }
+    if (!shaderEntryPoint.empty()) {
       this->WriteString("<EntryPointName>", 3);
       (*this->BuildFileStream) << cmVS10EscapeXML(shaderEntryPoint)
                                << "</EntryPointName>\n";
-      }
-    if(!shaderModel.empty())
-      {
+    }
+    if (!shaderModel.empty()) {
       this->WriteString("<ShaderModel>", 3);
       (*this->BuildFileStream) << cmVS10EscapeXML(shaderModel)
                                << "</ShaderModel>\n";
-      }
-    if(!shaderAdditionalFlags.empty())
-      {
+    }
+    if (!shaderAdditionalFlags.empty()) {
       this->WriteString("<AdditionalOptions>", 3);
       (*this->BuildFileStream) << cmVS10EscapeXML(shaderAdditionalFlags)
                                << "</AdditionalOptions>\n";
-      }
+    }
     this->WriteString("</", 2);
     (*this->BuildFileStream) << tool << ">\n";
-    }
-  else
-    {
+  } else {
     this->WriteSource(tool, sf);
-    }
+  }
 }
 
-void cmVisualStudio10TargetGenerator::WriteSource(
-  std::string const& tool, cmSourceFile const* sf, const char* end)
+void cmVisualStudio10TargetGenerator::WriteSource(std::string const& tool,
+                                                  cmSourceFile const* sf,
+                                                  const char* end)
 {
   // Visual Studio tools append relative paths to the current dir, as in:
   //
@@ -1479,9 +1292,9 @@ void cmVisualStudio10TargetGenerator::WriteSource(
   // conversion uses full paths when possible to allow deeper trees.
   bool forceRelative = false;
   std::string sourceFile = this->ConvertPath(sf->GetFullPath(), false);
-  if(this->LocalGenerator->GetVersion() == cmGlobalVisualStudioGenerator::VS10
-     && cmSystemTools::FileIsFullPath(sourceFile.c_str()))
-    {
+  if (this->LocalGenerator->GetVersion() ==
+        cmGlobalVisualStudioGenerator::VS10 &&
+      cmSystemTools::FileIsFullPath(sourceFile.c_str())) {
     // Normal path conversion resulted in a full path.  VS 10 (but not 11)
     // refuses to show the property page in the IDE for a source file with a
     // full path (not starting in a '.' or '/' AFAICT).  CMake <= 2.8.4 used a
@@ -1492,98 +1305,79 @@ void cmVisualStudio10TargetGenerator::WriteSource(
     // when the combined path will not be too long so property pages appear.
     std::string sourceRel = this->ConvertPath(sf->GetFullPath(), true);
     size_t const maxLen = 250;
-    if(sf->GetCustomCommand() ||
-       ((strlen(this->LocalGenerator->GetCurrentBinaryDirectory()) + 1 +
-         sourceRel.length()) <= maxLen))
-      {
+    if (sf->GetCustomCommand() ||
+        ((strlen(this->LocalGenerator->GetCurrentBinaryDirectory()) + 1 +
+          sourceRel.length()) <= maxLen)) {
       forceRelative = true;
       sourceFile = sourceRel;
-      }
-    else
-      {
-      this->GlobalGenerator->PathTooLong(this->GeneratorTarget,
-                                         sf, sourceRel);
-      }
+    } else {
+      this->GlobalGenerator->PathTooLong(this->GeneratorTarget, sf, sourceRel);
     }
+  }
   this->ConvertToWindowsSlash(sourceFile);
   this->WriteString("<", 2);
-  (*this->BuildFileStream ) << tool << " Include=\""
-                            << cmVS10EscapeXML(sourceFile) << "\""
-                            << (end? end : " />\n");
+  (*this->BuildFileStream) << tool << " Include=\""
+                           << cmVS10EscapeXML(sourceFile) << "\""
+                           << (end ? end : " />\n");
 
-  ToolSource toolSource = {sf, forceRelative};
+  ToolSource toolSource = { sf, forceRelative };
   this->Tools[tool].push_back(toolSource);
 }
 
 void cmVisualStudio10TargetGenerator::WriteSources(
   std::string const& tool, std::vector<cmSourceFile const*> const& sources)
 {
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = sources.begin(); si != sources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si = sources.begin();
+       si != sources.end(); ++si) {
     this->WriteSource(tool, *si);
-    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteAllSources()
 {
-  if(this->GeneratorTarget->GetType() > cmState::UTILITY)
-    {
+  if (this->GeneratorTarget->GetType() > cmState::UTILITY) {
     return;
-    }
+  }
   this->WriteString("<ItemGroup>\n", 1);
 
   std::vector<cmSourceFile const*> headerSources;
   this->GeneratorTarget->GetHeaderSources(headerSources, "");
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = headerSources.begin(); si != headerSources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         headerSources.begin();
+       si != headerSources.end(); ++si) {
     this->WriteHeaderSource(*si);
-    }
+  }
   std::vector<cmSourceFile const*> idlSources;
   this->GeneratorTarget->GetIDLSources(idlSources, "");
   this->WriteSources("Midl", idlSources);
 
   std::vector<cmSourceFile const*> objectSources;
   this->GeneratorTarget->GetObjectSources(objectSources, "");
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = objectSources.begin();
-      si != objectSources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         objectSources.begin();
+       si != objectSources.end(); ++si) {
     const std::string& lang = (*si)->GetLanguage();
     std::string tool;
-    if (lang == "C"|| lang == "CXX")
-      {
+    if (lang == "C" || lang == "CXX") {
       tool = "ClCompile";
-      }
-    else if (lang == "ASM_MASM" &&
-             this->GlobalGenerator->IsMasmEnabled())
-      {
+    } else if (lang == "ASM_MASM" && this->GlobalGenerator->IsMasmEnabled()) {
       tool = "MASM";
-      }
-    else if (lang == "RC")
-      {
+    } else if (lang == "RC") {
       tool = "ResourceCompile";
-      }
+    }
 
-    if (!tool.empty())
-      {
+    if (!tool.empty()) {
       this->WriteSource(tool, *si, " ");
-      if (this->OutputSourceSpecificFlags(*si))
-        {
+      if (this->OutputSourceSpecificFlags(*si)) {
         this->WriteString("</", 2);
-        (*this->BuildFileStream ) << tool << ">\n";
-        }
-      else
-        {
-        (*this->BuildFileStream ) << " />\n";
-        }
+        (*this->BuildFileStream) << tool << ">\n";
+      } else {
+        (*this->BuildFileStream) << " />\n";
       }
-    else
-      {
+    } else {
       this->WriteSource("None", *si);
-      }
     }
+  }
 
   std::vector<cmSourceFile const*> manifestSources;
   this->GeneratorTarget->GetAppManifest(manifestSources, "");
@@ -1595,69 +1389,58 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
 
   std::vector<cmSourceFile const*> externalObjects;
   this->GeneratorTarget->GetExternalObjects(externalObjects, "");
-  for(std::vector<cmSourceFile const*>::iterator
-        si = externalObjects.begin();
-      si != externalObjects.end(); )
-    {
-    if (!(*si)->GetObjectLibrary().empty())
-      {
+  for (std::vector<cmSourceFile const*>::iterator si = externalObjects.begin();
+       si != externalObjects.end();) {
+    if (!(*si)->GetObjectLibrary().empty()) {
       si = externalObjects.erase(si);
-      }
-    else
-      {
+    } else {
       ++si;
-      }
     }
-  if(this->LocalGenerator->GetVersion() > cmGlobalVisualStudioGenerator::VS10)
-    {
+  }
+  if (this->LocalGenerator->GetVersion() >
+      cmGlobalVisualStudioGenerator::VS10) {
     // For VS >= 11 we use LinkObjects to avoid linking custom command
     // outputs.  Use Object for all external objects, generated or not.
     this->WriteSources("Object", externalObjects);
-    }
-  else
-    {
+  } else {
     // If an object file is generated in this target, then vs10 will use
     // it in the build, and we have to list it as None instead of Object.
-    for(std::vector<cmSourceFile const*>::const_iterator
-          si = externalObjects.begin();
-        si != externalObjects.end(); ++si)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator si =
+           externalObjects.begin();
+         si != externalObjects.end(); ++si) {
       std::vector<cmSourceFile*> const* d =
-                                this->GeneratorTarget->GetSourceDepends(*si);
-      this->WriteSource((d && !d->empty())? "None":"Object", *si);
-      }
+        this->GeneratorTarget->GetSourceDepends(*si);
+      this->WriteSource((d && !d->empty()) ? "None" : "Object", *si);
     }
+  }
 
   std::vector<cmSourceFile const*> extraSources;
   this->GeneratorTarget->GetExtraSources(extraSources, "");
-  for(std::vector<cmSourceFile const*>::const_iterator
-        si = extraSources.begin(); si != extraSources.end(); ++si)
-    {
+  for (std::vector<cmSourceFile const*>::const_iterator si =
+         extraSources.begin();
+       si != extraSources.end(); ++si) {
     this->WriteExtraSource(*si);
-    }
+  }
 
   // Add object library contents as external objects.
   std::vector<std::string> objs;
   this->GeneratorTarget->UseObjectLibraries(objs, "");
-  for(std::vector<std::string>::const_iterator
-        oi = objs.begin(); oi != objs.end(); ++oi)
-    {
+  for (std::vector<std::string>::const_iterator oi = objs.begin();
+       oi != objs.end(); ++oi) {
     std::string obj = *oi;
     this->WriteString("<Object Include=\"", 2);
     this->ConvertToWindowsSlash(obj);
-    (*this->BuildFileStream ) << cmVS10EscapeXML(obj) << "\" />\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(obj) << "\" />\n";
+  }
 
   if (cmSourceFile const* defsrc =
-      this->GeneratorTarget->GetModuleDefinitionFile(""))
-    {
+        this->GeneratorTarget->GetModuleDefinitionFile("")) {
     this->WriteSource("None", defsrc);
-    }
+  }
 
-  if (this->IsMissingFiles)
-    {
+  if (this->IsMissingFiles) {
     this->WriteMissingFiles();
-    }
+  }
 
   this->WriteString("</ItemGroup>\n", 1);
 }
@@ -1668,118 +1451,98 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
   cmSourceFile const& sf = *source;
 
   std::string objectName;
-  if(this->GeneratorTarget->HasExplicitObjectName(&sf))
-    {
+  if (this->GeneratorTarget->HasExplicitObjectName(&sf)) {
     objectName = this->GeneratorTarget->GetObjectName(&sf);
-    }
+  }
   std::string flags;
   std::string defines;
-  if(const char* cflags = sf.GetProperty("COMPILE_FLAGS"))
-    {
+  if (const char* cflags = sf.GetProperty("COMPILE_FLAGS")) {
     flags += cflags;
-    }
-  if(const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS"))
-    {
+  }
+  if (const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS")) {
     defines += cdefs;
-    }
+  }
   std::string lang =
-    this->GlobalGenerator->GetLanguageFromExtension
-    (sf.GetExtension().c_str());
+    this->GlobalGenerator->GetLanguageFromExtension(sf.GetExtension().c_str());
   std::string sourceLang = this->LocalGenerator->GetSourceFileLanguage(sf);
   const std::string& linkLanguage = this->GeneratorTarget->GetLinkerLanguage();
   bool needForceLang = false;
   // source file does not match its extension language
-  if(lang != sourceLang)
-    {
+  if (lang != sourceLang) {
     needForceLang = true;
     lang = sourceLang;
-    }
+  }
   // if the source file does not match the linker language
   // then force c or c++
   const char* compileAs = 0;
-  if(needForceLang || (linkLanguage != lang))
-    {
-    if(lang == "CXX")
-      {
+  if (needForceLang || (linkLanguage != lang)) {
+    if (lang == "CXX") {
       // force a C++ file type
       compileAs = "CompileAsCpp";
-      }
-    else if(lang == "C")
-      {
+    } else if (lang == "C") {
       // force to c
       compileAs = "CompileAsC";
-      }
     }
+  }
   bool noWinRT = this->TargetCompileAsWinRT && lang == "C";
   bool hasFlags = false;
   // for the first time we need a new line if there is something
   // produced here.
   const char* firstString = ">\n";
-  if(!objectName.empty())
-    {
-    (*this->BuildFileStream ) << firstString;
+  if (!objectName.empty()) {
+    (*this->BuildFileStream) << firstString;
     firstString = "";
     hasFlags = true;
     this->WriteString("<ObjectFileName>", 3);
-    (*this->BuildFileStream )
-      << "$(IntDir)/" << objectName << "</ObjectFileName>\n";
-    }
-  for(std::vector<std::string>::const_iterator
-        config = this->Configurations.begin();
-      config != this->Configurations.end(); ++config)
-    {
+    (*this->BuildFileStream) << "$(IntDir)/" << objectName
+                             << "</ObjectFileName>\n";
+  }
+  for (std::vector<std::string>::const_iterator config =
+         this->Configurations.begin();
+       config != this->Configurations.end(); ++config) {
     std::string configUpper = cmSystemTools::UpperCase(*config);
     std::string configDefines = defines;
     std::string defPropName = "COMPILE_DEFINITIONS_";
     defPropName += configUpper;
-    if(const char* ccdefs = sf.GetProperty(defPropName.c_str()))
-      {
-      if(!configDefines.empty())
-        {
+    if (const char* ccdefs = sf.GetProperty(defPropName.c_str())) {
+      if (!configDefines.empty()) {
         configDefines += ";";
-        }
-      configDefines += ccdefs;
       }
+      configDefines += ccdefs;
+    }
     // if we have flags or defines for this config then
     // use them
-    if(!flags.empty() || !configDefines.empty() || compileAs || noWinRT)
-      {
-      (*this->BuildFileStream ) << firstString;
+    if (!flags.empty() || !configDefines.empty() || compileAs || noWinRT) {
+      (*this->BuildFileStream) << firstString;
       firstString = ""; // only do firstString once
       hasFlags = true;
-      cmVisualStudioGeneratorOptions
-        clOptions(this->LocalGenerator,
-                  cmVisualStudioGeneratorOptions::Compiler,
-                  this->GetClFlagTable(), 0, this);
-      if(compileAs)
-        {
+      cmVisualStudioGeneratorOptions clOptions(
+        this->LocalGenerator, cmVisualStudioGeneratorOptions::Compiler,
+        this->GetClFlagTable(), 0, this);
+      if (compileAs) {
         clOptions.AddFlag("CompileAs", compileAs);
-        }
-      if(noWinRT)
-        {
+      }
+      if (noWinRT) {
         clOptions.AddFlag("CompileAsWinRT", "false");
-        }
+      }
       clOptions.Parse(flags.c_str());
-      if(clOptions.HasFlag("AdditionalIncludeDirectories"))
-        {
+      if (clOptions.HasFlag("AdditionalIncludeDirectories")) {
         clOptions.AppendFlag("AdditionalIncludeDirectories",
                              "%(AdditionalIncludeDirectories)");
-        }
-      if(clOptions.HasFlag("DisableSpecificWarnings"))
-        {
+      }
+      if (clOptions.HasFlag("DisableSpecificWarnings")) {
         clOptions.AppendFlag("DisableSpecificWarnings",
                              "%(DisableSpecificWarnings)");
-        }
+      }
       clOptions.AddDefines(configDefines.c_str());
       clOptions.SetConfiguration((*config).c_str());
       clOptions.OutputAdditionalOptions(*this->BuildFileStream, "      ", "");
       clOptions.OutputFlagMap(*this->BuildFileStream, "      ");
-      clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream,
-                                              "      ", "\n", lang);
-      }
+      clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
+                                              "\n", lang);
     }
-  if (this->IsXamlSource(source->GetFullPath()))
-    {
+  }
+  if (this->IsXamlSource(source->GetFullPath())) {
     (*this->BuildFileStream) << firstString;
     firstString = ""; // only do firstString once
     hasFlags = true;
@@ -1787,60 +1550,51 @@ bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(
     const std::string& fileName = source->GetFullPath();
     std::string xamlFileName = fileName.substr(0, fileName.find_last_of("."));
     (*this->BuildFileStream) << xamlFileName << "</DependentUpon>\n";
-    }
+  }
 
   return hasFlags;
 }
 
-
 void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
 {
   cmState::TargetType ttype = this->GeneratorTarget->GetType();
-  if(ttype > cmState::GLOBAL_TARGET)
-    {
+  if (ttype > cmState::GLOBAL_TARGET) {
     return;
-    }
+  }
 
   this->WriteString("<PropertyGroup>\n", 2);
   this->WriteString("<_ProjectFileVersion>10.0.20506.1"
-                    "</_ProjectFileVersion>\n", 3);
-  for(std::vector<std::string>::const_iterator
-        config = this->Configurations.begin();
-      config != this->Configurations.end(); ++config)
-    {
-    if(ttype >= cmState::UTILITY)
-      {
+                    "</_ProjectFileVersion>\n",
+                    3);
+  for (std::vector<std::string>::const_iterator config =
+         this->Configurations.begin();
+       config != this->Configurations.end(); ++config) {
+    if (ttype >= cmState::UTILITY) {
       this->WritePlatformConfigTag("IntDir", config->c_str(), 3);
       *this->BuildFileStream
         << "$(Platform)\\$(Configuration)\\$(ProjectName)\\"
         << "</IntDir>\n";
-      }
-    else
-      {
-      std::string intermediateDir = this->LocalGenerator->
-        GetTargetDirectory(this->GeneratorTarget);
+    } else {
+      std::string intermediateDir =
+        this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
       intermediateDir += "/";
       intermediateDir += *config;
       intermediateDir += "/";
       std::string outDir;
       std::string targetNameFull;
-      if(ttype == cmState::OBJECT_LIBRARY)
-        {
+      if (ttype == cmState::OBJECT_LIBRARY) {
         outDir = intermediateDir;
         targetNameFull = this->GeneratorTarget->GetName();
         targetNameFull += ".lib";
-        }
-      else
-        {
+      } else {
         outDir = this->GeneratorTarget->GetDirectory(config->c_str()) + "/";
         targetNameFull = this->GeneratorTarget->GetFullName(config->c_str());
-        }
+      }
       this->ConvertToWindowsSlash(intermediateDir);
       this->ConvertToWindowsSlash(outDir);
 
       this->WritePlatformConfigTag("OutDir", config->c_str(), 3);
-      *this->BuildFileStream << cmVS10EscapeXML(outDir)
-                             << "</OutDir>\n";
+      *this->BuildFileStream << cmVS10EscapeXML(outDir) << "</OutDir>\n";
 
       this->WritePlatformConfigTag("IntDir", config->c_str(), 3);
       *this->BuildFileStream << cmVS10EscapeXML(intermediateDir)
@@ -1853,81 +1607,68 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions()
 
       std::string ext =
         cmSystemTools::GetFilenameLastExtension(targetNameFull);
-      if(ext.empty())
-        {
+      if (ext.empty()) {
         // An empty TargetExt causes a default extension to be used.
         // A single "." appears to be treated as an empty extension.
         ext = ".";
-        }
+      }
       this->WritePlatformConfigTag("TargetExt", config->c_str(), 3);
       *this->BuildFileStream << cmVS10EscapeXML(ext) << "</TargetExt>\n";
 
       this->OutputLinkIncremental(*config);
-      }
     }
+  }
   this->WriteString("</PropertyGroup>\n", 2);
 }
 
-
-
-void
-cmVisualStudio10TargetGenerator::
-OutputLinkIncremental(std::string const& configName)
+void cmVisualStudio10TargetGenerator::OutputLinkIncremental(
+  std::string const& configName)
 {
-  if(!this->MSTools)
-    {
+  if (!this->MSTools) {
     return;
-    }
+  }
   // static libraries and things greater than modules do not need
   // to set this option
-  if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY
-     || this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
+      this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY) {
     return;
-    }
+  }
   Options& linkOptions = *(this->LinkOptions[configName]);
 
   const char* incremental = linkOptions.GetFlag("LinkIncremental");
   this->WritePlatformConfigTag("LinkIncremental", configName.c_str(), 3);
-  *this->BuildFileStream << (incremental?incremental:"true")
+  *this->BuildFileStream << (incremental ? incremental : "true")
                          << "</LinkIncremental>\n";
   linkOptions.RemoveFlag("LinkIncremental");
 
   const char* manifest = linkOptions.GetFlag("GenerateManifest");
   this->WritePlatformConfigTag("GenerateManifest", configName.c_str(), 3);
-  *this->BuildFileStream << (manifest?manifest:"true")
+  *this->BuildFileStream << (manifest ? manifest : "true")
                          << "</GenerateManifest>\n";
   linkOptions.RemoveFlag("GenerateManifest");
 
   // Some link options belong here.  Use them now and remove them so that
   // WriteLinkOptions does not use them.
-  const char* flags[] = {
-    "LinkDelaySign",
-    "LinkKeyFile",
-    0};
-  for(const char** f = flags; *f; ++f)
-    {
+  const char* flags[] = { "LinkDelaySign", "LinkKeyFile", 0 };
+  for (const char** f = flags; *f; ++f) {
     const char* flag = *f;
-    if(const char* value = linkOptions.GetFlag(flag))
-      {
+    if (const char* value = linkOptions.GetFlag(flag)) {
       this->WritePlatformConfigTag(flag, configName.c_str(), 3);
       *this->BuildFileStream << value << "</" << flag << ">\n";
       linkOptions.RemoveFlag(flag);
-      }
     }
+  }
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeClOptions()
 {
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
-    if(!this->ComputeClOptions(*i))
-      {
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
+    if (!this->ComputeClOptions(*i)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -1938,117 +1679,101 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
   // copied from cmLocalVisualStudio7Generator.cxx 805
   // TODO: Integrate code below with cmLocalVisualStudio7Generator.
 
-  cmsys::auto_ptr<Options> pOptions(
-    new Options(this->LocalGenerator, Options::Compiler,
-                this->GetClFlagTable()));
+  cmsys::auto_ptr<Options> pOptions(new Options(
+    this->LocalGenerator, Options::Compiler, this->GetClFlagTable()));
   Options& clOptions = *pOptions;
 
   std::string flags;
   const std::string& linkLanguage =
     this->GeneratorTarget->GetLinkerLanguage(configName.c_str());
-  if(linkLanguage.empty())
-    {
-    cmSystemTools::Error
-      ("CMake can not determine linker language for target: ",
-       this->Name.c_str());
+  if (linkLanguage.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      this->Name.c_str());
     return false;
-    }
-  if(linkLanguage == "C" || linkLanguage == "CXX"
-     || linkLanguage == "Fortran")
-    {
+  }
+  if (linkLanguage == "C" || linkLanguage == "CXX" ||
+      linkLanguage == "Fortran") {
     std::string baseFlagVar = "CMAKE_";
     baseFlagVar += linkLanguage;
     baseFlagVar += "_FLAGS";
-    flags = this->GeneratorTarget->
-      Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str());
-    std::string flagVar = baseFlagVar + std::string("_") +
-      cmSystemTools::UpperCase(configName);
+    flags =
+      this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
+        baseFlagVar.c_str());
+    std::string flagVar =
+      baseFlagVar + std::string("_") + cmSystemTools::UpperCase(configName);
     flags += " ";
-    flags += this->GeneratorTarget->
-      Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str());
-    }
+    flags +=
+      this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
+        flagVar.c_str());
+  }
   // set the correct language
-  if(linkLanguage == "C")
-    {
+  if (linkLanguage == "C") {
     clOptions.AddFlag("CompileAs", "CompileAsC");
-    }
-  if(linkLanguage == "CXX")
-    {
+  }
+  if (linkLanguage == "CXX") {
     clOptions.AddFlag("CompileAs", "CompileAsCpp");
-    }
+  }
   this->LocalGenerator->AddCompileOptions(flags, this->GeneratorTarget,
                                           linkLanguage, configName.c_str());
 
   // Get preprocessor definitions for this directory.
   std::string defineFlags =
-      this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
-  if(this->MSTools)
-    {
+    this->GeneratorTarget->Target->GetMakefile()->GetDefineFlags();
+  if (this->MSTools) {
     clOptions.FixExceptionHandlingDefault();
     clOptions.AddFlag("PrecompiledHeader", "NotUsing");
     std::string asmLocation = configName + "/";
     clOptions.AddFlag("AssemblerListingLocation", asmLocation.c_str());
-    }
+  }
   clOptions.Parse(flags.c_str());
   clOptions.Parse(defineFlags.c_str());
   std::vector<std::string> targetDefines;
   this->GeneratorTarget->GetCompileDefinitions(targetDefines,
-                                      configName.c_str(), "CXX");
+                                               configName.c_str(), "CXX");
   clOptions.AddDefines(targetDefines);
-  if(this->MSTools)
-    {
+  if (this->MSTools) {
     clOptions.SetVerboseMakefile(
       this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"));
-    }
+  }
 
   // Add a definition for the configuration name.
   std::string configDefine = "CMAKE_INTDIR=\"";
   configDefine += configName;
   configDefine += "\"";
   clOptions.AddDefine(configDefine);
-  if(const char* exportMacro =
-          this->GeneratorTarget->GetExportMacro())
-    {
+  if (const char* exportMacro = this->GeneratorTarget->GetExportMacro()) {
     clOptions.AddDefine(exportMacro);
-    }
+  }
 
-  if (this->MSTools)
-    {
+  if (this->MSTools) {
     // If we have the VS_WINRT_COMPONENT set then force Compile as WinRT.
-    if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT"))
-      {
+    if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT")) {
       clOptions.AddFlag("CompileAsWinRT", "true");
       // For WinRT components, add the _WINRT_DLL define to produce a lib
       if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
-          this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY )
-        {
+          this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
         clOptions.AddDefine("_WINRT_DLL");
-        }
       }
-    else if (this->GlobalGenerator->TargetsWindowsStore() ||
-             this->GlobalGenerator->TargetsWindowsPhone())
-      {
-      if (!clOptions.IsWinRt())
-        {
+    } else if (this->GlobalGenerator->TargetsWindowsStore() ||
+               this->GlobalGenerator->TargetsWindowsPhone()) {
+      if (!clOptions.IsWinRt()) {
         clOptions.AddFlag("CompileAsWinRT", "false");
-        }
       }
-    if(const char* winRT = clOptions.GetFlag("CompileAsWinRT"))
-      {
-      if(cmSystemTools::IsOn(winRT))
-        {
+    }
+    if (const char* winRT = clOptions.GetFlag("CompileAsWinRT")) {
+      if (cmSystemTools::IsOn(winRT)) {
         this->TargetCompileAsWinRT = true;
-        }
       }
     }
+  }
 
   this->ClOptions[configName] = pOptions.release();
   return true;
 }
 
 void cmVisualStudio10TargetGenerator::WriteClOptions(
-  std::string const& configName,
-  std::vector<std::string> const& includes)
+  std::string const& configName, std::vector<std::string> const& includes)
 {
   Options& clOptions = *(this->ClOptions[configName]);
   this->WriteString("<ClCompile>\n", 2);
@@ -2060,97 +1785,86 @@ void cmVisualStudio10TargetGenerator::WriteClOptions(
   clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, "      ",
                                           "\n", "CXX");
 
-  if(this->NsightTegra)
-    {
-    if(const char* processMax =
-        this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX"))
-      {
+  if (this->NsightTegra) {
+    if (const char* processMax =
+          this->GeneratorTarget->GetProperty("ANDROID_PROCESS_MAX")) {
       this->WriteString("<ProcessMax>", 3);
-      *this->BuildFileStream << cmVS10EscapeXML(processMax) <<
-        "</ProcessMax>\n";
-      }
+      *this->BuildFileStream << cmVS10EscapeXML(processMax)
+                             << "</ProcessMax>\n";
     }
+  }
 
-  if(this->MSTools)
-    {
+  if (this->MSTools) {
     cmsys::RegularExpression clangToolset("v[0-9]+_clang_.*");
     const char* toolset = this->GlobalGenerator->GetPlatformToolset();
-    if (toolset && clangToolset.find(toolset))
-      {
+    if (toolset && clangToolset.find(toolset)) {
       this->WriteString("<ObjectFileName>"
                         "$(IntDir)%(filename).obj"
-                        "</ObjectFileName>\n", 3);
-      }
-    else
-      {
+                        "</ObjectFileName>\n",
+                        3);
+    } else {
       this->WriteString("<ObjectFileName>$(IntDir)</ObjectFileName>\n", 3);
-      }
+    }
 
     // If not in debug mode, write the DebugInformationFormat field
     // without value so PDBs don't get generated uselessly.
-    if(!clOptions.IsDebug())
-      {
+    if (!clOptions.IsDebug()) {
       this->WriteString("<DebugInformationFormat>"
-                        "</DebugInformationFormat>\n", 3);
-      }
+                        "</DebugInformationFormat>\n",
+                        3);
+    }
 
     // Specify the compiler program database file if configured.
     std::string pdb =
-        this->GeneratorTarget->GetCompilePDBPath(configName.c_str());
-    if(!pdb.empty())
-      {
+      this->GeneratorTarget->GetCompilePDBPath(configName.c_str());
+    if (!pdb.empty()) {
       this->ConvertToWindowsSlash(pdb);
       this->WriteString("<ProgramDataBaseFileName>", 3);
       *this->BuildFileStream << cmVS10EscapeXML(pdb)
                              << "</ProgramDataBaseFileName>\n";
-      }
     }
+  }
 
   this->WriteString("</ClCompile>\n", 2);
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeRcOptions()
 {
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
-    if(!this->ComputeRcOptions(*i))
-      {
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
+    if (!this->ComputeRcOptions(*i)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
   std::string const& configName)
 {
-  cmsys::auto_ptr<Options> pOptions(
-    new Options(this->LocalGenerator, Options::ResourceCompiler,
-                this->GetRcFlagTable()));
+  cmsys::auto_ptr<Options> pOptions(new Options(
+    this->LocalGenerator, Options::ResourceCompiler, this->GetRcFlagTable()));
   Options& rcOptions = *pOptions;
 
   std::string CONFIG = cmSystemTools::UpperCase(configName);
   std::string rcConfigFlagsVar = std::string("CMAKE_RC_FLAGS_") + CONFIG;
   std::string flags =
-      std::string(this->Makefile->GetSafeDefinition("CMAKE_RC_FLAGS")) +
-      std::string(" ") +
-      std::string(this->Makefile->GetSafeDefinition(rcConfigFlagsVar));
+    std::string(this->Makefile->GetSafeDefinition("CMAKE_RC_FLAGS")) +
+    std::string(" ") +
+    std::string(this->Makefile->GetSafeDefinition(rcConfigFlagsVar));
 
   rcOptions.Parse(flags.c_str());
   this->RcOptions[configName] = pOptions.release();
   return true;
 }
 
-void cmVisualStudio10TargetGenerator::
-WriteRCOptions(std::string const& configName,
-               std::vector<std::string> const & includes)
+void cmVisualStudio10TargetGenerator::WriteRCOptions(
+  std::string const& configName, std::vector<std::string> const& includes)
 {
-  if(!this->MSTools)
-    {
+  if (!this->MSTools) {
     return;
-    }
+  }
   this->WriteString("<ResourceCompile>\n", 2);
 
   // Preprocessor definitions and includes are shared with clOptions.
@@ -2170,50 +1884,44 @@ WriteRCOptions(std::string const& configName,
 
 bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
 {
-  if(!this->GlobalGenerator->IsMasmEnabled())
-    {
+  if (!this->GlobalGenerator->IsMasmEnabled()) {
     return true;
-    }
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
-    if(!this->ComputeMasmOptions(*i))
-      {
+  }
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
+    if (!this->ComputeMasmOptions(*i)) {
       return false;
-      }
     }
+  }
   return true;
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
   std::string const& configName)
 {
-  cmsys::auto_ptr<Options> pOptions(
-    new Options(this->LocalGenerator, Options::MasmCompiler,
-                this->GetMasmFlagTable()));
+  cmsys::auto_ptr<Options> pOptions(new Options(
+    this->LocalGenerator, Options::MasmCompiler, this->GetMasmFlagTable()));
   Options& masmOptions = *pOptions;
 
   std::string CONFIG = cmSystemTools::UpperCase(configName);
   std::string configFlagsVar = std::string("CMAKE_ASM_MASM_FLAGS_") + CONFIG;
   std::string flags =
-      std::string(this->Makefile->GetSafeDefinition("CMAKE_ASM_MASM_FLAGS")) +
-      std::string(" ") +
-      std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
+    std::string(this->Makefile->GetSafeDefinition("CMAKE_ASM_MASM_FLAGS")) +
+    std::string(" ") +
+    std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
 
   masmOptions.Parse(flags.c_str());
   this->MasmOptions[configName] = pOptions.release();
   return true;
 }
 
-void cmVisualStudio10TargetGenerator::
-WriteMasmOptions(std::string const& configName,
-                 std::vector<std::string> const& includes)
+void cmVisualStudio10TargetGenerator::WriteMasmOptions(
+  std::string const& configName, std::vector<std::string> const& includes)
 {
-  if(!this->MSTools || !this->GlobalGenerator->IsMasmEnabled())
-    {
+  if (!this->MSTools || !this->GlobalGenerator->IsMasmEnabled()) {
     return;
-    }
+  }
   this->WriteString("<MASM>\n", 2);
 
   // Preprocessor definitions and includes are shared with clOptions.
@@ -2230,42 +1938,38 @@ WriteMasmOptions(std::string const& configName,
   this->WriteString("</MASM>\n", 2);
 }
 
-
-void
-cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config)
+void cmVisualStudio10TargetGenerator::WriteLibOptions(
+  std::string const& config)
 {
-  if(this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY &&
-     this->GeneratorTarget->GetType() != cmState::OBJECT_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() != cmState::STATIC_LIBRARY &&
+      this->GeneratorTarget->GetType() != cmState::OBJECT_LIBRARY) {
     return;
-    }
+  }
   std::string libflags;
-  this->LocalGenerator->GetStaticLibraryFlags(libflags,
-    cmSystemTools::UpperCase(config), this->GeneratorTarget);
-  if(!libflags.empty())
-    {
+  this->LocalGenerator->GetStaticLibraryFlags(
+    libflags, cmSystemTools::UpperCase(config), this->GeneratorTarget);
+  if (!libflags.empty()) {
     this->WriteString("<Lib>\n", 2);
-    cmVisualStudioGeneratorOptions
-      libOptions(this->LocalGenerator,
-                 cmVisualStudioGeneratorOptions::Linker,
-                 this->GetLibFlagTable(), 0, this);
+    cmVisualStudioGeneratorOptions libOptions(
+      this->LocalGenerator, cmVisualStudioGeneratorOptions::Linker,
+      this->GetLibFlagTable(), 0, this);
     libOptions.Parse(libflags.c_str());
     libOptions.OutputAdditionalOptions(*this->BuildFileStream, "      ", "");
     libOptions.OutputFlagMap(*this->BuildFileStream, "      ");
     this->WriteString("</Lib>\n", 2);
-    }
+  }
 
   // We cannot generate metadata for static libraries.  WindowsPhone
   // and WindowsStore tools look at GenerateWindowsMetadata in the
   // Link tool options even for static libraries.
-  if(this->GlobalGenerator->TargetsWindowsPhone() ||
-     this->GlobalGenerator->TargetsWindowsStore())
-    {
+  if (this->GlobalGenerator->TargetsWindowsPhone() ||
+      this->GlobalGenerator->TargetsWindowsStore()) {
     this->WriteString("<Link>\n", 2);
     this->WriteString("<GenerateWindowsMetadata>false"
-                      "</GenerateWindowsMetadata>\n", 3);
+                      "</GenerateWindowsMetadata>\n",
+                      3);
     this->WriteString("</Link>\n", 2);
-    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteManifestOptions(
@@ -2273,27 +1977,25 @@ void cmVisualStudio10TargetGenerator::WriteManifestOptions(
 {
   if (this->GeneratorTarget->GetType() != cmState::EXECUTABLE &&
       this->GeneratorTarget->GetType() != cmState::SHARED_LIBRARY &&
-      this->GeneratorTarget->GetType() != cmState::MODULE_LIBRARY)
-    {
+      this->GeneratorTarget->GetType() != cmState::MODULE_LIBRARY) {
     return;
-    }
+  }
 
   std::vector<cmSourceFile const*> manifest_srcs;
   this->GeneratorTarget->GetManifests(manifest_srcs, config);
-  if (!manifest_srcs.empty())
-    {
+  if (!manifest_srcs.empty()) {
     this->WriteString("<Manifest>\n", 2);
     this->WriteString("<AdditionalManifestFiles>", 3);
-    for (std::vector<cmSourceFile const*>::const_iterator
-           mi = manifest_srcs.begin(); mi != manifest_srcs.end(); ++mi)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator mi =
+           manifest_srcs.begin();
+         mi != manifest_srcs.end(); ++mi) {
       std::string m = this->ConvertPath((*mi)->GetFullPath(), false);
       this->ConvertToWindowsSlash(m);
       (*this->BuildFileStream) << m << ";";
-      }
+    }
     (*this->BuildFileStream) << "</AdditionalManifestFiles>\n";
     this->WriteString("</Manifest>\n", 2);
-    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
@@ -2303,230 +2005,207 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
   // its location as the root source directory.
   std::string rootDir = this->LocalGenerator->GetCurrentSourceDirectory();
   {
-  std::vector<cmSourceFile const*> extraSources;
-  this->GeneratorTarget->GetExtraSources(extraSources, "");
-  for(std::vector<cmSourceFile const*>::const_iterator si =
-        extraSources.begin(); si != extraSources.end(); ++si)
-    {
-    if("androidmanifest.xml" == cmSystemTools::LowerCase(
-         (*si)->GetLocation().GetName()))
-      {
-      rootDir = (*si)->GetLocation().GetDirectory();
-      break;
+    std::vector<cmSourceFile const*> extraSources;
+    this->GeneratorTarget->GetExtraSources(extraSources, "");
+    for (std::vector<cmSourceFile const*>::const_iterator si =
+           extraSources.begin();
+         si != extraSources.end(); ++si) {
+      if ("androidmanifest.xml" ==
+          cmSystemTools::LowerCase((*si)->GetLocation().GetName())) {
+        rootDir = (*si)->GetLocation().GetDirectory();
+        break;
       }
     }
   }
 
   // Tell MSBuild to launch Ant.
   {
-  std::string antBuildPath = rootDir;
-  this->WriteString("<AntBuild>\n", 2);
-  this->WriteString("<AntBuildPath>", 3);
-  this->ConvertToWindowsSlash(antBuildPath);
-  (*this->BuildFileStream) <<
-    cmVS10EscapeXML(antBuildPath) << "</AntBuildPath>\n";
+    std::string antBuildPath = rootDir;
+    this->WriteString("<AntBuild>\n", 2);
+    this->WriteString("<AntBuildPath>", 3);
+    this->ConvertToWindowsSlash(antBuildPath);
+    (*this->BuildFileStream) << cmVS10EscapeXML(antBuildPath)
+                             << "</AntBuildPath>\n";
   }
 
-  if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP"))
-    {
+  if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_SKIP_ANT_STEP")) {
     this->WriteString("<SkipAntStep>true</SkipAntStep>\n", 3);
-    }
+  }
 
-  if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD"))
-    {
+  if (this->GeneratorTarget->GetPropertyAsBool("ANDROID_PROGUARD")) {
     this->WriteString("<EnableProGuard>true</EnableProGuard>\n", 3);
-    }
+  }
 
   if (const char* proGuardConfigLocation =
-      this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_PROGUARD_CONFIG_PATH")) {
     this->WriteString("<ProGuardConfigLocation>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation) <<
-      "</ProGuardConfigLocation>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(proGuardConfigLocation)
+                             << "</ProGuardConfigLocation>\n";
+  }
 
   if (const char* securePropertiesLocation =
-      this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_SECURE_PROPS_PATH")) {
     this->WriteString("<SecurePropertiesLocation>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation) <<
-      "</SecurePropertiesLocation>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(securePropertiesLocation)
+                             << "</SecurePropertiesLocation>\n";
+  }
 
   if (const char* nativeLibDirectoriesExpression =
-      this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) {
     cmGeneratorExpression ge;
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
-        ge.Parse(nativeLibDirectoriesExpression);
-    std::string nativeLibDirs = cge->Evaluate(this->LocalGenerator,
-                                              configName);
+      ge.Parse(nativeLibDirectoriesExpression);
+    std::string nativeLibDirs =
+      cge->Evaluate(this->LocalGenerator, configName);
     this->WriteString("<NativeLibDirectories>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs) <<
-      "</NativeLibDirectories>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDirs)
+                             << "</NativeLibDirectories>\n";
+  }
 
   if (const char* nativeLibDependenciesExpression =
-      this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DEPENDENCIES"))
-    {
+        this->GeneratorTarget->GetProperty(
+          "ANDROID_NATIVE_LIB_DEPENDENCIES")) {
     cmGeneratorExpression ge;
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
-        ge.Parse(nativeLibDependenciesExpression);
-    std::string nativeLibDeps = cge->Evaluate(this->LocalGenerator,
-                                              configName);
+      ge.Parse(nativeLibDependenciesExpression);
+    std::string nativeLibDeps =
+      cge->Evaluate(this->LocalGenerator, configName);
     this->WriteString("<NativeLibDependencies>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps) <<
-      "</NativeLibDependencies>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(nativeLibDeps)
+                             << "</NativeLibDependencies>\n";
+  }
 
   if (const char* javaSourceDir =
-      this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_JAVA_SOURCE_DIR")) {
     this->WriteString("<JavaSourceDir>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir) <<
-      "</JavaSourceDir>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(javaSourceDir)
+                             << "</JavaSourceDir>\n";
+  }
 
   if (const char* jarDirectoriesExpression =
-      this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) {
     cmGeneratorExpression ge;
     cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
       ge.Parse(jarDirectoriesExpression);
-    std::string jarDirectories = cge->Evaluate(this->LocalGenerator,
-                                               configName);
+    std::string jarDirectories =
+      cge->Evaluate(this->LocalGenerator, configName);
     this->WriteString("<JarDirectories>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories) <<
-      "</JarDirectories>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(jarDirectories)
+                             << "</JarDirectories>\n";
+  }
 
   if (const char* jarDeps =
-      this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_JAR_DEPENDENCIES")) {
     this->WriteString("<JarDependencies>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(jarDeps) <<
-      "</JarDependencies>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(jarDeps)
+                             << "</JarDependencies>\n";
+  }
 
   if (const char* assetsDirectories =
-      this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_ASSETS_DIRECTORIES")) {
     this->WriteString("<AssetsDirectories>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories) <<
-      "</AssetsDirectories>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(assetsDirectories)
+                             << "</AssetsDirectories>\n";
+  }
 
   {
-  std::string manifest_xml = rootDir + "/AndroidManifest.xml";
-  this->ConvertToWindowsSlash(manifest_xml);
-  this->WriteString("<AndroidManifestLocation>", 3);
-  (*this->BuildFileStream) <<
-    cmVS10EscapeXML(manifest_xml) << "</AndroidManifestLocation>\n";
+    std::string manifest_xml = rootDir + "/AndroidManifest.xml";
+    this->ConvertToWindowsSlash(manifest_xml);
+    this->WriteString("<AndroidManifestLocation>", 3);
+    (*this->BuildFileStream) << cmVS10EscapeXML(manifest_xml)
+                             << "</AndroidManifestLocation>\n";
   }
 
   if (const char* antAdditionalOptions =
-      this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS"))
-    {
+        this->GeneratorTarget->GetProperty("ANDROID_ANT_ADDITIONAL_OPTIONS")) {
     this->WriteString("<AdditionalOptions>", 3);
-    (*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions) <<
-      " %(AdditionalOptions)</AdditionalOptions>\n";
-    }
+    (*this->BuildFileStream) << cmVS10EscapeXML(antAdditionalOptions)
+                             << " %(AdditionalOptions)</AdditionalOptions>\n";
+  }
 
   this->WriteString("</AntBuild>\n", 2);
 }
 
 bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
 {
-  if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
-     this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
-     this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
-    {
-    for(std::vector<std::string>::const_iterator
-          i = this->Configurations.begin();
-        i != this->Configurations.end(); ++i)
-      {
-      if(!this->ComputeLinkOptions(*i))
-        {
+  if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
+      this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
+      this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
+    for (std::vector<std::string>::const_iterator i =
+           this->Configurations.begin();
+         i != this->Configurations.end(); ++i) {
+      if (!this->ComputeLinkOptions(*i)) {
         return false;
-        }
       }
     }
+  }
   return true;
 }
 
-bool
-cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
+bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
+  std::string const& config)
 {
-  cmsys::auto_ptr<Options> pOptions(
-    new Options(this->LocalGenerator, Options::Linker,
-                this->GetLinkFlagTable(), 0, this));
+  cmsys::auto_ptr<Options> pOptions(new Options(
+    this->LocalGenerator, Options::Linker, this->GetLinkFlagTable(), 0, this));
   Options& linkOptions = *pOptions;
 
   const std::string& linkLanguage =
     this->GeneratorTarget->GetLinkerLanguage(config.c_str());
-  if(linkLanguage.empty())
-    {
-    cmSystemTools::Error
-      ("CMake can not determine linker language for target: ",
-       this->Name.c_str());
+  if (linkLanguage.empty()) {
+    cmSystemTools::Error(
+      "CMake can not determine linker language for target: ",
+      this->Name.c_str());
     return false;
-    }
+  }
 
   std::string CONFIG = cmSystemTools::UpperCase(config);
 
   const char* linkType = "SHARED";
-  if(this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY) {
     linkType = "MODULE";
-    }
-  if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-    {
+  }
+  if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
     linkType = "EXE";
-    }
+  }
   std::string flags;
   std::string linkFlagVarBase = "CMAKE_";
   linkFlagVarBase += linkType;
   linkFlagVarBase += "_LINKER_FLAGS";
   flags += " ";
-  flags += this->GeneratorTarget->
-    Target->GetMakefile()->GetRequiredDefinition(linkFlagVarBase.c_str());
+  flags += this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
+    linkFlagVarBase.c_str());
   std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG;
   flags += " ";
-  flags += this->GeneratorTarget->
-    Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str());
+  flags += this->GeneratorTarget->Target->GetMakefile()->GetRequiredDefinition(
+    linkFlagVar.c_str());
   const char* targetLinkFlags =
-      this->GeneratorTarget->GetProperty("LINK_FLAGS");
-  if(targetLinkFlags)
-    {
+    this->GeneratorTarget->GetProperty("LINK_FLAGS");
+  if (targetLinkFlags) {
     flags += " ";
     flags += targetLinkFlags;
-    }
+  }
   std::string flagsProp = "LINK_FLAGS_";
   flagsProp += CONFIG;
-  if(const char* flagsConfig =
-     this->GeneratorTarget->GetProperty(flagsProp.c_str()))
-    {
+  if (const char* flagsConfig =
+        this->GeneratorTarget->GetProperty(flagsProp.c_str())) {
     flags += " ";
     flags += flagsConfig;
-    }
+  }
   std::string standardLibsVar = "CMAKE_";
   standardLibsVar += linkLanguage;
   standardLibsVar += "_STANDARD_LIBRARIES";
-  std::string
-    libs = this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
+  std::string libs =
+    this->Makefile->GetSafeDefinition(standardLibsVar.c_str());
   // Remove trailing spaces from libs
-  std::string::size_type pos = libs.size()-1;
-  if(!libs.empty())
-    {
-    while(libs[pos] == ' ')
-      {
+  std::string::size_type pos = libs.size() - 1;
+  if (!libs.empty()) {
+    while (libs[pos] == ' ') {
       pos--;
-      }
-    }
-  if(pos != libs.size()-1)
-    {
-    libs = libs.substr(0, pos+1);
     }
+  }
+  if (pos != libs.size() - 1) {
+    libs = libs.substr(0, pos + 1);
+  }
   // Replace spaces in libs with ;
   cmSystemTools::ReplaceString(libs, " ", ";");
   std::vector<std::string> libVec;
@@ -2534,13 +2213,12 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
 
   cmComputeLinkInformation* pcli =
     this->GeneratorTarget->GetLinkInformation(config.c_str());
-  if(!pcli)
-    {
-    cmSystemTools::Error
-      ("CMake can not compute cmComputeLinkInformation for target: ",
-       this->Name.c_str());
+  if (!pcli) {
+    cmSystemTools::Error(
+      "CMake can not compute cmComputeLinkInformation for target: ",
+      this->Name.c_str());
     return false;
-    }
+  }
   // add the libraries for the target to libs string
   cmComputeLinkInformation& cli = *pcli;
   this->AddLibraries(cli, libVec);
@@ -2548,14 +2226,13 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
 
   std::vector<std::string> const& ldirs = cli.GetDirectories();
   std::vector<std::string> linkDirs;
-  for(std::vector<std::string>::const_iterator d = ldirs.begin();
-      d != ldirs.end(); ++d)
-    {
+  for (std::vector<std::string>::const_iterator d = ldirs.begin();
+       d != ldirs.end(); ++d) {
     // first just full path
     linkDirs.push_back(*d);
     // next path with configuration type Debug, Release, etc
     linkDirs.push_back(*d + "/$(Configuration)");
-    }
+  }
   linkDirs.push_back("%(AdditionalLibraryDirectories)");
   linkOptions.AddFlag("AdditionalLibraryDirectories", linkDirs);
 
@@ -2564,90 +2241,64 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
   std::string targetNameFull;
   std::string targetNameImport;
   std::string targetNamePDB;
-  if(this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
     this->GeneratorTarget->GetExecutableNames(targetName, targetNameFull,
-                                     targetNameImport, targetNamePDB,
-                                     config.c_str());
-    }
-  else
-    {
+                                              targetNameImport, targetNamePDB,
+                                              config.c_str());
+  } else {
     this->GeneratorTarget->GetLibraryNames(targetName, targetNameSO,
-                                  targetNameFull,
-                                  targetNameImport, targetNamePDB,
-                                  config.c_str());
-    }
+                                           targetNameFull, targetNameImport,
+                                           targetNamePDB, config.c_str());
+  }
 
-  if(this->MSTools)
-    {
+  if (this->MSTools) {
     linkOptions.AddFlag("Version", "");
 
-    if ( this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE") )
-      {
-      if (this->GlobalGenerator->TargetsWindowsCE())
-        {
+    if (this->GeneratorTarget->GetPropertyAsBool("WIN32_EXECUTABLE")) {
+      if (this->GlobalGenerator->TargetsWindowsCE()) {
         linkOptions.AddFlag("SubSystem", "WindowsCE");
-        if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-          {
-          if (this->ClOptions[config]->UsingUnicode())
-            {
+        if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
+          if (this->ClOptions[config]->UsingUnicode()) {
             linkOptions.AddFlag("EntryPointSymbol", "wWinMainCRTStartup");
-            }
-          else
-            {
+          } else {
             linkOptions.AddFlag("EntryPointSymbol", "WinMainCRTStartup");
-            }
           }
         }
-      else
-        {
+      } else {
         linkOptions.AddFlag("SubSystem", "Windows");
-        }
       }
-    else
-      {
-      if (this->GlobalGenerator->TargetsWindowsCE())
-        {
+    } else {
+      if (this->GlobalGenerator->TargetsWindowsCE()) {
         linkOptions.AddFlag("SubSystem", "WindowsCE");
-        if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-          {
-          if (this->ClOptions[config]->UsingUnicode())
-            {
+        if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
+          if (this->ClOptions[config]->UsingUnicode()) {
             linkOptions.AddFlag("EntryPointSymbol", "mainWCRTStartup");
-            }
-          else
-            {
+          } else {
             linkOptions.AddFlag("EntryPointSymbol", "mainACRTStartup");
-            }
           }
         }
-      else
-        {
+      } else {
         linkOptions.AddFlag("SubSystem", "Console");
-        };
-      }
+      };
+    }
 
-    if(const char* stackVal =
-       this->Makefile->GetDefinition("CMAKE_"+linkLanguage+"_STACK_SIZE"))
-      {
+    if (const char* stackVal = this->Makefile->GetDefinition(
+          "CMAKE_" + linkLanguage + "_STACK_SIZE")) {
       linkOptions.AddFlag("StackReserveSize", stackVal);
-      }
+    }
 
     if (this->LocalGenerator->GetVersion() >=
-        cmGlobalVisualStudioGenerator::VS14)
-      {
+        cmGlobalVisualStudioGenerator::VS14) {
       linkOptions.AddFlag("GenerateDebugInformation", "No");
-      }
-    else
-      {
+    } else {
       linkOptions.AddFlag("GenerateDebugInformation", "false");
-      }
+    }
 
     std::string pdb = this->GeneratorTarget->GetPDBDirectory(config.c_str());
     pdb += "/";
     pdb += targetNamePDB;
     std::string imLib =
-        this->GeneratorTarget->GetDirectory(config.c_str(), true);
+      this->GeneratorTarget->GetDirectory(config.c_str(), true);
     imLib += "/";
     imLib += targetNameImport;
 
@@ -2656,95 +2307,79 @@ cmVisualStudio10TargetGenerator::ComputeLinkOptions(std::string const& config)
 
     // A Windows Runtime component uses internal .NET metadata,
     // so does not have an import library.
-    if(this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") &&
-       this->GeneratorTarget->GetType() != cmState::EXECUTABLE)
-      {
+    if (this->GeneratorTarget->GetPropertyAsBool("VS_WINRT_COMPONENT") &&
+        this->GeneratorTarget->GetType() != cmState::EXECUTABLE) {
       linkOptions.AddFlag("GenerateWindowsMetadata", "true");
-      }
-    else if (this->GlobalGenerator->TargetsWindowsPhone() ||
-             this->GlobalGenerator->TargetsWindowsStore())
-      {
+    } else if (this->GlobalGenerator->TargetsWindowsPhone() ||
+               this->GlobalGenerator->TargetsWindowsStore()) {
       // WindowsPhone and WindowsStore components are in an app container
       // and produce WindowsMetadata.  If we are not producing a WINRT
       // component, then do not generate the metadata here.
       linkOptions.AddFlag("GenerateWindowsMetadata", "false");
-      }
+    }
 
     if (this->GlobalGenerator->TargetsWindowsPhone() &&
-        this->GlobalGenerator->GetSystemVersion() == "8.0")
-      {
+        this->GlobalGenerator->GetSystemVersion() == "8.0") {
       // WindowsPhone 8.0 does not have ole32.
       linkOptions.AppendFlag("IgnoreSpecificDefaultLibraries", "ole32.lib");
-      }
     }
-  else if(this->NsightTegra)
-    {
+  } else if (this->NsightTegra) {
     linkOptions.AddFlag("SoName", targetNameSO.c_str());
-    }
+  }
 
   linkOptions.Parse(flags.c_str());
 
-  if(this->MSTools)
-    {
+  if (this->MSTools) {
     if (cmSourceFile const* defsrc =
-        this->GeneratorTarget->GetModuleDefinitionFile(""))
-      {
+          this->GeneratorTarget->GetModuleDefinitionFile("")) {
       linkOptions.AddFlag("ModuleDefinitionFile",
                           defsrc->GetFullPath().c_str());
-      }
+    }
     linkOptions.AppendFlag("IgnoreSpecificDefaultLibraries",
                            "%(IgnoreSpecificDefaultLibraries)");
-    }
+  }
 
   if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
-      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
-    {
-    if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
+      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) {
+    if (this->GeneratorTarget->GetPropertyAsBool(
+          "WINDOWS_EXPORT_ALL_SYMBOLS")) {
       linkOptions.AddFlag("ModuleDefinitionFile", "$(IntDir)exportall.def");
-      }
     }
+  }
 
   // Hack to fix flag version selection in a common use case.
   // FIXME: Select flag table based on toolset instead of VS version.
   if (this->LocalGenerator->GetVersion() >=
-      cmGlobalVisualStudioGenerator::VS14)
-    {
+      cmGlobalVisualStudioGenerator::VS14) {
     cmGlobalVisualStudio10Generator* gg =
       static_cast<cmGlobalVisualStudio10Generator*>(this->GlobalGenerator);
     const char* toolset = gg->GetPlatformToolset();
-    if (toolset &&
-        (cmHasLiteralPrefix(toolset, "v100") ||
-         cmHasLiteralPrefix(toolset, "v110") ||
-         cmHasLiteralPrefix(toolset, "v120")))
-      {
-      if (const char* debug = linkOptions.GetFlag("GenerateDebugInformation"))
-        {
+    if (toolset && (cmHasLiteralPrefix(toolset, "v100") ||
+                    cmHasLiteralPrefix(toolset, "v110") ||
+                    cmHasLiteralPrefix(toolset, "v120"))) {
+      if (const char* debug =
+            linkOptions.GetFlag("GenerateDebugInformation")) {
         // Convert value from enumeration back to boolean for older toolsets.
-        if (strcmp(debug, "No") == 0)
-          {
+        if (strcmp(debug, "No") == 0) {
           linkOptions.AddFlag("GenerateDebugInformation", "false");
-          }
-        else if (strcmp(debug, "Debug") == 0)
-          {
+        } else if (strcmp(debug, "Debug") == 0) {
           linkOptions.AddFlag("GenerateDebugInformation", "true");
-          }
         }
       }
     }
+  }
 
   this->LinkOptions[config] = pOptions.release();
   return true;
 }
 
-void
-cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config)
+void cmVisualStudio10TargetGenerator::WriteLinkOptions(
+  std::string const& config)
 {
-  if(this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY
-     || this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
+      this->GeneratorTarget->GetType() > cmState::MODULE_LIBRARY) {
     return;
-    }
+  }
   Options& linkOptions = *(this->LinkOptions[config]);
   this->WriteString("<Link>\n", 2);
 
@@ -2752,50 +2387,40 @@ cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& config)
   linkOptions.OutputFlagMap(*this->BuildFileStream, "      ");
 
   this->WriteString("</Link>\n", 2);
-  if(!this->GlobalGenerator->NeedLinkLibraryDependencies(
-              this->GeneratorTarget))
-    {
+  if (!this->GlobalGenerator->NeedLinkLibraryDependencies(
+        this->GeneratorTarget)) {
     this->WriteString("<ProjectReference>\n", 2);
     this->WriteString(
       "<LinkLibraryDependencies>false</LinkLibraryDependencies>\n", 3);
     this->WriteString("</ProjectReference>\n", 2);
-    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::AddLibraries(
-  cmComputeLinkInformation& cli,
-  std::vector<std::string>& libVec)
+  cmComputeLinkInformation& cli, std::vector<std::string>& libVec)
 {
   typedef cmComputeLinkInformation::ItemVector ItemVector;
   ItemVector libs = cli.GetItems();
-  for(ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l)
-    {
-    if(l->IsPath)
-      {
-      std::string path = this->LocalGenerator->
-        Convert(l->Value.c_str(),
-                cmLocalGenerator::START_OUTPUT,
-                cmLocalGenerator::UNCHANGED);
+  for (ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) {
+    if (l->IsPath) {
+      std::string path = this->LocalGenerator->Convert(
+        l->Value.c_str(), cmLocalGenerator::START_OUTPUT,
+        cmLocalGenerator::UNCHANGED);
       this->ConvertToWindowsSlash(path);
       libVec.push_back(path);
-      }
-    else if (!l->Target
-        || l->Target->GetType() != cmState::INTERFACE_LIBRARY)
-      {
+    } else if (!l->Target ||
+               l->Target->GetType() != cmState::INTERFACE_LIBRARY) {
       libVec.push_back(l->Value);
-      }
     }
+  }
 }
 
-
-void cmVisualStudio10TargetGenerator::
-WriteMidlOptions(std::string const& /*config*/,
-                 std::vector<std::string> const & includes)
+void cmVisualStudio10TargetGenerator::WriteMidlOptions(
+  std::string const& /*config*/, std::vector<std::string> const& includes)
 {
-  if(!this->MSTools)
-    {
+  if (!this->MSTools) {
     return;
-    }
+  }
 
   // This processes *any* of the .idl files specified in the project's file
   // list (and passed as the item metadata %(Filename) expressing the rule
@@ -2814,51 +2439,46 @@ WriteMidlOptions(std::string const& /*config*/,
   // on the CMake side?
   this->WriteString("<Midl>\n", 2);
   this->WriteString("<AdditionalIncludeDirectories>", 3);
-  for(std::vector<std::string>::const_iterator i =  includes.begin();
-      i != includes.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i = includes.begin();
+       i != includes.end(); ++i) {
     *this->BuildFileStream << cmVS10EscapeXML(*i) << ";";
-    }
+  }
   this->WriteString("%(AdditionalIncludeDirectories)"
-                    "</AdditionalIncludeDirectories>\n", 0);
+                    "</AdditionalIncludeDirectories>\n",
+                    0);
   this->WriteString("<OutputDirectory>$(ProjectDir)/$(IntDir)"
-                    "</OutputDirectory>\n", 3);
+                    "</OutputDirectory>\n",
+                    3);
   this->WriteString("<HeaderFileName>%(Filename).h</HeaderFileName>\n", 3);
-  this->WriteString(
-    "<TypeLibraryName>%(Filename).tlb</TypeLibraryName>\n", 3);
-  this->WriteString(
-    "<InterfaceIdentifierFileName>"
-    "%(Filename)_i.c</InterfaceIdentifierFileName>\n", 3);
-  this->WriteString("<ProxyFileName>%(Filename)_p.c</ProxyFileName>\n",3);
+  this->WriteString("<TypeLibraryName>%(Filename).tlb</TypeLibraryName>\n", 3);
+  this->WriteString("<InterfaceIdentifierFileName>"
+                    "%(Filename)_i.c</InterfaceIdentifierFileName>\n",
+                    3);
+  this->WriteString("<ProxyFileName>%(Filename)_p.c</ProxyFileName>\n", 3);
   this->WriteString("</Midl>\n", 2);
 }
 
-
 void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
 {
-  for(std::vector<std::string>::const_iterator
-        i = this->Configurations.begin();
-      i != this->Configurations.end(); ++i)
-    {
+  for (std::vector<std::string>::const_iterator i =
+         this->Configurations.begin();
+       i != this->Configurations.end(); ++i) {
     std::vector<std::string> includes;
-    this->LocalGenerator->GetIncludeDirectories(includes,
-                                                this->GeneratorTarget,
-                                                "C", i->c_str());
-    for(std::vector<std::string>::iterator ii = includes.begin();
-        ii != includes.end(); ++ii)
-      {
+    this->LocalGenerator->GetIncludeDirectories(
+      includes, this->GeneratorTarget, "C", i->c_str());
+    for (std::vector<std::string>::iterator ii = includes.begin();
+         ii != includes.end(); ++ii) {
       this->ConvertToWindowsSlash(*ii);
-      }
+    }
     this->WritePlatformConfigTag("ItemDefinitionGroup", i->c_str(), 1);
     *this->BuildFileStream << "\n";
     //    output cl compile flags <ClCompile></ClCompile>
-    if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
-      {
+    if (this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY) {
       this->WriteClOptions(*i, includes);
       //    output rc compile flags <ResourceCompile></ResourceCompile>
       this->WriteRCOptions(*i, includes);
       this->WriteMasmOptions(*i, includes);
-      }
+    }
     //    output midl flags       <Midl></Midl>
     this->WriteMidlOptions(*i, includes);
     // write events
@@ -2869,126 +2489,113 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
     this->WriteLibOptions(*i);
     //    output manifest flags  <Manifest></Manifest>
     this->WriteManifestOptions(*i);
-    if(this->NsightTegra &&
-       this->GeneratorTarget->GetType() == cmState::EXECUTABLE &&
-       this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI"))
-      {
+    if (this->NsightTegra &&
+        this->GeneratorTarget->GetType() == cmState::EXECUTABLE &&
+        this->GeneratorTarget->GetPropertyAsBool("ANDROID_GUI")) {
       this->WriteAntBuildOptions(*i);
-      }
-    this->WriteString("</ItemDefinitionGroup>\n", 1);
     }
+    this->WriteString("</ItemDefinitionGroup>\n", 1);
+  }
 }
 
-void
-cmVisualStudio10TargetGenerator::WriteEvents(std::string const& configName)
+void cmVisualStudio10TargetGenerator::WriteEvents(
+  std::string const& configName)
 {
   bool addedPrelink = false;
   if (this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY &&
-      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS"))
-    {
-    if (this->GeneratorTarget->GetPropertyAsBool("WINDOWS_EXPORT_ALL_SYMBOLS"))
-      {
+      this->Makefile->IsOn("CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS")) {
+    if (this->GeneratorTarget->GetPropertyAsBool(
+          "WINDOWS_EXPORT_ALL_SYMBOLS")) {
       addedPrelink = true;
       std::vector<cmCustomCommand> commands =
         this->GeneratorTarget->GetPreLinkCommands();
-      this->GlobalGenerator->AddSymbolExportCommand(
-        this->GeneratorTarget, commands, configName);
+      this->GlobalGenerator->AddSymbolExportCommand(this->GeneratorTarget,
+                                                    commands, configName);
       this->WriteEvent("PreLinkEvent", commands, configName);
-      }
     }
-  if (!addedPrelink)
-    {
+  }
+  if (!addedPrelink) {
     this->WriteEvent("PreLinkEvent",
-        this->GeneratorTarget->GetPreLinkCommands(), configName);
-    }
+                     this->GeneratorTarget->GetPreLinkCommands(), configName);
+  }
   this->WriteEvent("PreBuildEvent",
-        this->GeneratorTarget->GetPreBuildCommands(), configName);
+                   this->GeneratorTarget->GetPreBuildCommands(), configName);
   this->WriteEvent("PostBuildEvent",
-        this->GeneratorTarget->GetPostBuildCommands(), configName);
+                   this->GeneratorTarget->GetPostBuildCommands(), configName);
 }
 
 void cmVisualStudio10TargetGenerator::WriteEvent(
-  const char* name,
-  std::vector<cmCustomCommand> const& commands,
+  const char* name, std::vector<cmCustomCommand> const& commands,
   std::string const& configName)
 {
-  if(commands.empty())
-    {
+  if (commands.empty()) {
     return;
-    }
+  }
   this->WriteString("<", 2);
-  (*this->BuildFileStream ) << name << ">\n";
+  (*this->BuildFileStream) << name << ">\n";
   cmLocalVisualStudio7Generator* lg = this->LocalGenerator;
   std::string script;
   const char* pre = "";
   std::string comment;
-  for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
+  for (std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+       i != commands.end(); ++i) {
     cmCustomCommandGenerator ccg(*i, configName, this->LocalGenerator);
     comment += pre;
     comment += lg->ConstructComment(ccg);
     script += pre;
     pre = "\n";
     script += cmVS10EscapeXML(lg->ConstructScript(ccg));
-    }
+  }
   comment = cmVS10EscapeComment(comment);
-  this->WriteString("<Message>",3);
-  (*this->BuildFileStream ) << cmVS10EscapeXML(comment) << "</Message>\n";
+  this->WriteString("<Message>", 3);
+  (*this->BuildFileStream) << cmVS10EscapeXML(comment) << "</Message>\n";
   this->WriteString("<Command>", 3);
-  (*this->BuildFileStream ) << script;
-  (*this->BuildFileStream ) << "</Command>" << "\n";
+  (*this->BuildFileStream) << script;
+  (*this->BuildFileStream) << "</Command>"
+                           << "\n";
   this->WriteString("</", 2);
-  (*this->BuildFileStream ) << name << ">\n";
+  (*this->BuildFileStream) << name << ">\n";
 }
 
-
 void cmVisualStudio10TargetGenerator::WriteProjectReferences()
 {
-  cmGlobalGenerator::TargetDependSet const& unordered
-    = this->GlobalGenerator->GetTargetDirectDepends(this->GeneratorTarget);
+  cmGlobalGenerator::TargetDependSet const& unordered =
+    this->GlobalGenerator->GetTargetDirectDepends(this->GeneratorTarget);
   typedef cmGlobalVisualStudioGenerator::OrderedTargetDependSet
     OrderedTargetDependSet;
   OrderedTargetDependSet depends(unordered, CMAKE_CHECK_BUILD_SYSTEM_TARGET);
   this->WriteString("<ItemGroup>\n", 1);
-  for( OrderedTargetDependSet::const_iterator i = depends.begin();
-       i != depends.end(); ++i)
-    {
+  for (OrderedTargetDependSet::const_iterator i = depends.begin();
+       i != depends.end(); ++i) {
     cmGeneratorTarget const* dt = *i;
-    if(dt->GetType() == cmState::INTERFACE_LIBRARY)
-      {
+    if (dt->GetType() == cmState::INTERFACE_LIBRARY) {
       continue;
-      }
+    }
     // skip fortran targets as they can not be processed by MSBuild
     // the only reference will be in the .sln file
-    if(static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
-       ->TargetIsFortranOnly(dt))
-      {
+    if (static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator)
+          ->TargetIsFortranOnly(dt)) {
       continue;
-      }
+    }
     this->WriteString("<ProjectReference Include=\"", 2);
     cmLocalGenerator* lg = dt->GetLocalGenerator();
     std::string name = dt->GetName();
     std::string path;
     const char* p = dt->GetProperty("EXTERNAL_MSPROJECT");
-    if(p)
-      {
+    if (p) {
       path = p;
-      }
-    else
-      {
-      path =  lg->GetCurrentBinaryDirectory();
+    } else {
+      path = lg->GetCurrentBinaryDirectory();
       path += "/";
       path += dt->GetName();
       path += ".vcxproj";
-      }
+    }
     (*this->BuildFileStream) << cmVS10EscapeXML(path) << "\">\n";
     this->WriteString("<Project>", 3);
-    (*this->BuildFileStream)
-      << this->GlobalGenerator->GetGUID(name.c_str())
-      << "</Project>\n";
+    (*this->BuildFileStream) << this->GlobalGenerator->GetGUID(name.c_str())
+                             << "</Project>\n";
     this->WriteString("</ProjectReference>\n", 2);
-    }
+  }
   this->WriteString("</ItemGroup>\n", 1);
 }
 
@@ -2996,55 +2603,49 @@ void cmVisualStudio10TargetGenerator::WritePlatformExtensions()
 {
   // This only applies to Windows 10 apps
   if (this->GlobalGenerator->TargetsWindowsStore() &&
-      cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0"))
-    {
+      cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) {
     const char* desktopExtensionsVersion =
       this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
-    if (desktopExtensionsVersion)
-      {
+    if (desktopExtensionsVersion) {
       this->WriteSinglePlatformExtension("WindowsDesktop",
                                          desktopExtensionsVersion);
-      }
+    }
     const char* mobileExtensionsVersion =
       this->GeneratorTarget->GetProperty("VS_MOBILE_EXTENSIONS_VERSION");
-    if (mobileExtensionsVersion)
-      {
+    if (mobileExtensionsVersion) {
       this->WriteSinglePlatformExtension("WindowsMobile",
                                          mobileExtensionsVersion);
-      }
     }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteSinglePlatformExtension(
-  std::string const& extension,
-  std::string const& version
-  )
+  std::string const& extension, std::string const& version)
 {
   this->WriteString("<Import Project=", 2);
   (*this->BuildFileStream)
     << "\"$([Microsoft.Build.Utilities.ToolLocationHelper]"
-    << "::GetPlatformExtensionSDKLocation(`"
-    << extension <<", Version=" << version
+    << "::GetPlatformExtensionSDKLocation(`" << extension
+    << ", Version=" << version
     << "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, "
     << "$(ExtensionSDKDirectoryRoot), null))"
-    << "\\DesignTime\\CommonConfiguration\\Neutral\\"
-    << extension << ".props\" "
+    << "\\DesignTime\\CommonConfiguration\\Neutral\\" << extension
+    << ".props\" "
     << "Condition=\"exists('$("
     << "[Microsoft.Build.Utilities.ToolLocationHelper]"
-    << "::GetPlatformExtensionSDKLocation(`"
-    << extension << ", Version=" << version
+    << "::GetPlatformExtensionSDKLocation(`" << extension
+    << ", Version=" << version
     << "`, $(TargetPlatformIdentifier), $(TargetPlatformVersion), null, "
     << "$(ExtensionSDKDirectoryRoot), null))"
-    << "\\DesignTime\\CommonConfiguration\\Neutral\\"
-    << extension << ".props')\" />\n";
+    << "\\DesignTime\\CommonConfiguration\\Neutral\\" << extension
+    << ".props')\" />\n";
 }
 
 void cmVisualStudio10TargetGenerator::WriteSDKReferences()
 {
   // This only applies to Windows 10 apps
   if (this->GlobalGenerator->TargetsWindowsStore() &&
-      cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0"))
-    {
+      cmHasLiteralPrefix(this->GlobalGenerator->GetSystemVersion(), "10.0")) {
     const char* desktopExtensionsVersion =
       this->GeneratorTarget->GetProperty("VS_DESKTOP_EXTENSIONS_VERSION");
     const char* mobileExtensionsVersion =
@@ -3052,129 +2653,115 @@ void cmVisualStudio10TargetGenerator::WriteSDKReferences()
     const char* iotExtensionsVersion =
       this->GeneratorTarget->GetProperty("VS_IOT_EXTENSIONS_VERSION");
 
-    if(desktopExtensionsVersion || mobileExtensionsVersion ||
-       iotExtensionsVersion)
-      {
+    if (desktopExtensionsVersion || mobileExtensionsVersion ||
+        iotExtensionsVersion) {
       this->WriteString("<ItemGroup>\n", 1);
-      if(desktopExtensionsVersion)
-        {
+      if (desktopExtensionsVersion) {
         this->WriteSingleSDKReference("WindowsDesktop",
                                       desktopExtensionsVersion);
-        }
-      if(mobileExtensionsVersion)
-        {
+      }
+      if (mobileExtensionsVersion) {
         this->WriteSingleSDKReference("WindowsMobile",
                                       mobileExtensionsVersion);
-        }
-      if(iotExtensionsVersion)
-        {
-        this->WriteSingleSDKReference("WindowsIoT",
-                                      iotExtensionsVersion);
-        }
-      this->WriteString("</ItemGroup>\n", 1);
       }
+      if (iotExtensionsVersion) {
+        this->WriteSingleSDKReference("WindowsIoT", iotExtensionsVersion);
+      }
+      this->WriteString("</ItemGroup>\n", 1);
     }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteSingleSDKReference(
-  std::string const& extension,
-  std::string const& version
-  )
+  std::string const& extension, std::string const& version)
 {
   this->WriteString("<SDKReference Include=\"", 2);
-  (*this->BuildFileStream) << extension
-    << ", Version=" << version << "\" />\n";
+  (*this->BuildFileStream) << extension << ", Version=" << version
+                           << "\" />\n";
 }
 
-
 void cmVisualStudio10TargetGenerator::WriteWinRTPackageCertificateKeyFile()
 {
-  if((this->GlobalGenerator->TargetsWindowsStore() ||
-      this->GlobalGenerator->TargetsWindowsPhone())
-      && (cmState::EXECUTABLE == this->GeneratorTarget->GetType()))
-    {
+  if ((this->GlobalGenerator->TargetsWindowsStore() ||
+       this->GlobalGenerator->TargetsWindowsPhone()) &&
+      (cmState::EXECUTABLE == this->GeneratorTarget->GetType())) {
     std::string pfxFile;
     std::vector<cmSourceFile const*> certificates;
     this->GeneratorTarget->GetCertificates(certificates, "");
-    for(std::vector<cmSourceFile const*>::const_iterator si =
-        certificates.begin(); si != certificates.end(); ++si)
-      {
+    for (std::vector<cmSourceFile const*>::const_iterator si =
+           certificates.begin();
+         si != certificates.end(); ++si) {
       pfxFile = this->ConvertPath((*si)->GetFullPath(), false);
       this->ConvertToWindowsSlash(pfxFile);
       break;
-      }
+    }
 
-    if(this->IsMissingFiles &&
-       !(this->GlobalGenerator->TargetsWindowsPhone() &&
-         this->GlobalGenerator->GetSystemVersion() == "8.0"))
-      {
+    if (this->IsMissingFiles &&
+        !(this->GlobalGenerator->TargetsWindowsPhone() &&
+          this->GlobalGenerator->GetSystemVersion() == "8.0")) {
       // Move the manifest to a project directory to avoid clashes
       std::string artifactDir =
         this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
       this->ConvertToWindowsSlash(artifactDir);
       this->WriteString("<PropertyGroup>\n", 1);
       this->WriteString("<AppxPackageArtifactsDir>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(artifactDir) <<
-        "\\</AppxPackageArtifactsDir>\n";
+      (*this->BuildFileStream) << cmVS10EscapeXML(artifactDir)
+                               << "\\</AppxPackageArtifactsDir>\n";
       this->WriteString("<ProjectPriFullPath>"
-        "$(TargetDir)resources.pri</ProjectPriFullPath>\n", 2);
+                        "$(TargetDir)resources.pri</ProjectPriFullPath>\n",
+                        2);
 
       // If we are missing files and we don't have a certificate and
       // aren't targeting WP8.0, add a default certificate
-      if(pfxFile.empty())
-        {
-        std::string templateFolder = cmSystemTools::GetCMakeRoot() +
-                                     "/Templates/Windows";
+      if (pfxFile.empty()) {
+        std::string templateFolder =
+          cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
         pfxFile = this->DefaultArtifactDir + "/Windows_TemporaryKey.pfx";
         cmSystemTools::CopyAFile(templateFolder + "/Windows_TemporaryKey.pfx",
                                  pfxFile, false);
         this->ConvertToWindowsSlash(pfxFile);
         this->AddedFiles.push_back(pfxFile);
-        }
+      }
 
       this->WriteString("<", 2);
-      (*this->BuildFileStream) << "PackageCertificateKeyFile>"
-        << pfxFile << "</PackageCertificateKeyFile>\n";
+      (*this->BuildFileStream) << "PackageCertificateKeyFile>" << pfxFile
+                               << "</PackageCertificateKeyFile>\n";
       std::string thumb = cmSystemTools::ComputeCertificateThumbprint(pfxFile);
-      if (!thumb.empty())
-        {
+      if (!thumb.empty()) {
         this->WriteString("<PackageCertificateThumbprint>", 2);
         (*this->BuildFileStream) << thumb
-          << "</PackageCertificateThumbprint>\n";
-        }
-      this->WriteString("</PropertyGroup>\n", 1);
+                                 << "</PackageCertificateThumbprint>\n";
       }
-    else if(!pfxFile.empty())
-      {
+      this->WriteString("</PropertyGroup>\n", 1);
+    } else if (!pfxFile.empty()) {
       this->WriteString("<PropertyGroup>\n", 1);
       this->WriteString("<", 2);
-      (*this->BuildFileStream) << "PackageCertificateKeyFile>"
-        << pfxFile << "</PackageCertificateKeyFile>\n";
+      (*this->BuildFileStream) << "PackageCertificateKeyFile>" << pfxFile
+                               << "</PackageCertificateKeyFile>\n";
       std::string thumb = cmSystemTools::ComputeCertificateThumbprint(pfxFile);
-      if (!thumb.empty())
-        {
+      if (!thumb.empty()) {
         this->WriteString("<PackageCertificateThumbprint>", 2);
         (*this->BuildFileStream) << thumb
-          << "</PackageCertificateThumbprint>\n";
-        }
-      this->WriteString("</PropertyGroup>\n", 1);
+                                 << "</PackageCertificateThumbprint>\n";
       }
+      this->WriteString("</PropertyGroup>\n", 1);
     }
+  }
 }
 
-bool cmVisualStudio10TargetGenerator::
-  IsResxHeader(const std::string& headerFile)
+bool cmVisualStudio10TargetGenerator::IsResxHeader(
+  const std::string& headerFile)
 {
   std::set<std::string> expectedResxHeaders;
   this->GeneratorTarget->GetExpectedResxHeaders(expectedResxHeaders, "");
 
   std::set<std::string>::const_iterator it =
-                                        expectedResxHeaders.find(headerFile);
+    expectedResxHeaders.find(headerFile);
   return it != expectedResxHeaders.end();
 }
 
-bool cmVisualStudio10TargetGenerator::
-IsXamlHeader(const std::string& headerFile)
+bool cmVisualStudio10TargetGenerator::IsXamlHeader(
+  const std::string& headerFile)
 {
   std::set<std::string> expectedXamlHeaders;
   this->GeneratorTarget->GetExpectedXamlHeaders(expectedXamlHeaders, "");
@@ -3184,8 +2771,8 @@ IsXamlHeader(const std::string& headerFile)
   return it != expectedXamlHeaders.end();
 }
 
-bool cmVisualStudio10TargetGenerator::
-IsXamlSource(const std::string& sourceFile)
+bool cmVisualStudio10TargetGenerator::IsXamlSource(
+  const std::string& sourceFile)
 {
   std::set<std::string> expectedXamlSources;
   this->GeneratorTarget->GetExpectedXamlSources(expectedXamlSources, "");
@@ -3203,219 +2790,180 @@ void cmVisualStudio10TargetGenerator::WriteApplicationTypeSettings()
   bool const isWindowsPhone = this->GlobalGenerator->TargetsWindowsPhone();
   bool const isWindowsStore = this->GlobalGenerator->TargetsWindowsStore();
   std::string const& v = this->GlobalGenerator->GetSystemVersion();
-  if(isWindowsPhone || isWindowsStore)
-    {
+  if (isWindowsPhone || isWindowsStore) {
     this->WriteString("<ApplicationType>", 2);
-    (*this->BuildFileStream) << (isWindowsPhone ?
-                                 "Windows Phone" : "Windows Store")
-                             << "</ApplicationType>\n";
+    (*this->BuildFileStream)
+      << (isWindowsPhone ? "Windows Phone" : "Windows Store")
+      << "</ApplicationType>\n";
     this->WriteString("<DefaultLanguage>en-US"
-                      "</DefaultLanguage>\n", 2);
-    if (cmHasLiteralPrefix(v, "10.0"))
-      {
+                      "</DefaultLanguage>\n",
+                      2);
+    if (cmHasLiteralPrefix(v, "10.0")) {
       this->WriteString("<ApplicationTypeRevision>", 2);
       (*this->BuildFileStream) << cmVS10EscapeXML("10.0")
                                << "</ApplicationTypeRevision>\n";
       // Visual Studio 14.0 is necessary for building 10.0 apps
       this->WriteString("<MinimumVisualStudioVersion>14.0"
-        "</MinimumVisualStudioVersion>\n", 2);
+                        "</MinimumVisualStudioVersion>\n",
+                        2);
 
-      if(this->GeneratorTarget->GetType() < cmState::UTILITY)
-        {
+      if (this->GeneratorTarget->GetType() < cmState::UTILITY) {
         isAppContainer = true;
-        }
       }
-    else if(v == "8.1")
-      {
+    } else if (v == "8.1") {
       this->WriteString("<ApplicationTypeRevision>", 2);
       (*this->BuildFileStream) << cmVS10EscapeXML(v)
                                << "</ApplicationTypeRevision>\n";
       // Visual Studio 12.0 is necessary for building 8.1 apps
       this->WriteString("<MinimumVisualStudioVersion>12.0"
-                        "</MinimumVisualStudioVersion>\n", 2);
+                        "</MinimumVisualStudioVersion>\n",
+                        2);
 
-      if (this->GeneratorTarget->GetType() < cmState::UTILITY)
-        {
+      if (this->GeneratorTarget->GetType() < cmState::UTILITY) {
         isAppContainer = true;
-        }
       }
-    else if (v == "8.0")
-      {
+    } else if (v == "8.0") {
       this->WriteString("<ApplicationTypeRevision>", 2);
       (*this->BuildFileStream) << cmVS10EscapeXML(v)
                                << "</ApplicationTypeRevision>\n";
       // Visual Studio 11.0 is necessary for building 8.0 apps
       this->WriteString("<MinimumVisualStudioVersion>11.0"
-                        "</MinimumVisualStudioVersion>\n", 2);
+                        "</MinimumVisualStudioVersion>\n",
+                        2);
 
-      if (isWindowsStore
-          && this->GeneratorTarget->GetType() < cmState::UTILITY)
-        {
+      if (isWindowsStore &&
+          this->GeneratorTarget->GetType() < cmState::UTILITY) {
         isAppContainer = true;
-        }
-      else if (isWindowsPhone &&
-               this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-        {
+      } else if (isWindowsPhone &&
+                 this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
         this->WriteString("<XapOutputs>true</XapOutputs>\n", 2);
         this->WriteString("<XapFilename>", 2);
-        (*this->BuildFileStream) << cmVS10EscapeXML(this->Name.c_str()) <<
-           "_$(Configuration)_$(Platform).xap</XapFilename>\n";
-        }
+        (*this->BuildFileStream)
+          << cmVS10EscapeXML(this->Name.c_str())
+          << "_$(Configuration)_$(Platform).xap</XapFilename>\n";
       }
     }
-  if(isAppContainer)
-    {
+  }
+  if (isAppContainer) {
     this->WriteString("<AppContainerApplication>true"
-                      "</AppContainerApplication>\n", 2);
-    }
-  else if (this->Platform == "ARM")
-    {
+                      "</AppContainerApplication>\n",
+                      2);
+  } else if (this->Platform == "ARM") {
     this->WriteString("<WindowsSDKDesktopARMSupport>true"
-                      "</WindowsSDKDesktopARMSupport>\n", 2);
-    }
+                      "</WindowsSDKDesktopARMSupport>\n",
+                      2);
+  }
   std::string const& targetPlatformVersion =
     gg->GetWindowsTargetPlatformVersion();
-  if (!targetPlatformVersion.empty())
-    {
+  if (!targetPlatformVersion.empty()) {
     this->WriteString("<WindowsTargetPlatformVersion>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion) <<
-      "</WindowsTargetPlatformVersion>\n";
-    }
-  const char* targetPlatformMinVersion =
-      this->GeneratorTarget
-      ->GetProperty("VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION");
-  if(targetPlatformMinVersion)
-    {
+    (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion)
+                             << "</WindowsTargetPlatformVersion>\n";
+  }
+  const char* targetPlatformMinVersion = this->GeneratorTarget->GetProperty(
+    "VS_WINDOWS_TARGET_PLATFORM_MIN_VERSION");
+  if (targetPlatformMinVersion) {
     this->WriteString("<WindowsTargetPlatformMinVersion>", 2);
-    (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformMinVersion) <<
-      "</WindowsTargetPlatformMinVersion>\n";
-    }
-  else if (isWindowsStore && cmHasLiteralPrefix(v, "10.0"))
-    {
+    (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformMinVersion)
+                             << "</WindowsTargetPlatformMinVersion>\n";
+  } else if (isWindowsStore && cmHasLiteralPrefix(v, "10.0")) {
     // If the min version is not set, then use the TargetPlatformVersion
-    if (!targetPlatformVersion.empty())
-      {
+    if (!targetPlatformVersion.empty()) {
       this->WriteString("<WindowsTargetPlatformMinVersion>", 2);
-      (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion) <<
-        "</WindowsTargetPlatformMinVersion>\n";
-      }
+      (*this->BuildFileStream) << cmVS10EscapeXML(targetPlatformVersion)
+                               << "</WindowsTargetPlatformMinVersion>\n";
     }
+  }
 
   // Added IoT Startup Task support
-  if(this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK"))
-    {
+  if (this->GeneratorTarget->GetPropertyAsBool("VS_IOT_STARTUP_TASK")) {
     this->WriteString("<ContainsStartupTask>true</ContainsStartupTask>\n", 2);
-    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::VerifyNecessaryFiles()
 {
   // For Windows and Windows Phone executables, we will assume that if a
   // manifest is not present that we need to add all the necessary files
-  if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE)
-    {
+  if (this->GeneratorTarget->GetType() == cmState::EXECUTABLE) {
     std::vector<cmSourceFile const*> manifestSources;
     this->GeneratorTarget->GetAppManifest(manifestSources, "");
-      {
+    {
       std::string const& v = this->GlobalGenerator->GetSystemVersion();
-      if(this->GlobalGenerator->TargetsWindowsPhone())
-        {
-        if (v == "8.0")
-          {
+      if (this->GlobalGenerator->TargetsWindowsPhone()) {
+        if (v == "8.0") {
           // Look through the sources for WMAppManifest.xml
           std::vector<cmSourceFile const*> extraSources;
           this->GeneratorTarget->GetExtraSources(extraSources, "");
           bool foundManifest = false;
-          for(std::vector<cmSourceFile const*>::const_iterator si =
-            extraSources.begin(); si != extraSources.end(); ++si)
-            {
+          for (std::vector<cmSourceFile const*>::const_iterator si =
+                 extraSources.begin();
+               si != extraSources.end(); ++si) {
             // Need to do a lowercase comparison on the filename
-            if("wmappmanifest.xml" == cmSystemTools::LowerCase(
-              (*si)->GetLocation().GetName()))
-              {
+            if ("wmappmanifest.xml" ==
+                cmSystemTools::LowerCase((*si)->GetLocation().GetName())) {
               foundManifest = true;
               break;
-              }
             }
-          if (!foundManifest)
-            {
+          }
+          if (!foundManifest) {
             this->IsMissingFiles = true;
-            }
           }
-        else if (v == "8.1")
-          {
-          if(manifestSources.empty())
-            {
+        } else if (v == "8.1") {
+          if (manifestSources.empty()) {
             this->IsMissingFiles = true;
-            }
           }
         }
-      else if (this->GlobalGenerator->TargetsWindowsStore())
-        {
-        if (manifestSources.empty())
-          {
-          if (v == "8.0")
-            {
+      } else if (this->GlobalGenerator->TargetsWindowsStore()) {
+        if (manifestSources.empty()) {
+          if (v == "8.0") {
             this->IsMissingFiles = true;
-            }
-          else if (v == "8.1" || cmHasLiteralPrefix(v, "10.0"))
-            {
+          } else if (v == "8.1" || cmHasLiteralPrefix(v, "10.0")) {
             this->IsMissingFiles = true;
-            }
           }
         }
       }
     }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteMissingFiles()
 {
   std::string const& v = this->GlobalGenerator->GetSystemVersion();
-  if(this->GlobalGenerator->TargetsWindowsPhone())
-    {
-    if (v == "8.0")
-      {
+  if (this->GlobalGenerator->TargetsWindowsPhone()) {
+    if (v == "8.0") {
       this->WriteMissingFilesWP80();
-      }
-    else if (v == "8.1")
-      {
+    } else if (v == "8.1") {
       this->WriteMissingFilesWP81();
-      }
     }
-  else if (this->GlobalGenerator->TargetsWindowsStore())
-   {
-   if (v == "8.0")
-     {
-     this->WriteMissingFilesWS80();
-     }
-   else if (v == "8.1")
-     {
-     this->WriteMissingFilesWS81();
-     }
-   else if (cmHasLiteralPrefix(v, "10.0"))
-     {
-     this->WriteMissingFilesWS10_0();
-     }
-   }
+  } else if (this->GlobalGenerator->TargetsWindowsStore()) {
+    if (v == "8.0") {
+      this->WriteMissingFilesWS80();
+    } else if (v == "8.1") {
+      this->WriteMissingFilesWS81();
+    } else if (cmHasLiteralPrefix(v, "10.0")) {
+      this->WriteMissingFilesWS10_0();
+    }
+  }
 }
 
 void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
 {
-  std::string templateFolder = cmSystemTools::GetCMakeRoot() +
-                               "/Templates/Windows";
+  std::string templateFolder =
+    cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
 
   // For WP80, the manifest needs to be in the same folder as the project
   // this can cause an overwrite problem if projects aren't organized in
   // folders
   std::string manifestFile =
-      this->LocalGenerator->GetCurrentBinaryDirectory() +
-                             std::string("/WMAppManifest.xml");
+    this->LocalGenerator->GetCurrentBinaryDirectory() +
+    std::string("/WMAppManifest.xml");
   std::string artifactDir =
     this->LocalGenerator->GetTargetDirectory(this->GeneratorTarget);
   this->ConvertToWindowsSlash(artifactDir);
   std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
   std::string targetNameXML =
-      cmVS10EscapeXML(this->GeneratorTarget->GetName());
+    cmVS10EscapeXML(this->GeneratorTarget->GetName());
 
   cmGeneratedFileStream fout(manifestFile.c_str());
   fout.SetCopyIfDifferent(true);
@@ -3467,16 +3015,15 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP80()
   this->AddedFiles.push_back(sourceFile);
 
   std::string smallLogo = this->DefaultArtifactDir + "/SmallLogo.png";
-  cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png",
-                           smallLogo, false);
+  cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png", smallLogo,
+                           false);
   this->ConvertToWindowsSlash(smallLogo);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n";
   this->AddedFiles.push_back(smallLogo);
 
   std::string logo = this->DefaultArtifactDir + "/Logo.png";
-  cmSystemTools::CopyAFile(templateFolder + "/Logo.png",
-                           logo, false);
+  cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false);
   this->ConvertToWindowsSlash(logo);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(logo) << "\" />\n";
@@ -3501,7 +3048,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWP81()
   this->ConvertToWindowsSlash(artifactDir);
   std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
   std::string targetNameXML =
-      cmVS10EscapeXML(this->GeneratorTarget->GetName());
+    cmVS10EscapeXML(this->GeneratorTarget->GetName());
 
   cmGeneratedFileStream fout(manifestFile.c_str());
   fout.SetCopyIfDifferent(true);
@@ -3564,7 +3111,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS80()
   this->ConvertToWindowsSlash(artifactDir);
   std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
   std::string targetNameXML =
-      cmVS10EscapeXML(this->GeneratorTarget->GetName());
+    cmVS10EscapeXML(this->GeneratorTarget->GetName());
 
   cmGeneratedFileStream fout(manifestFile.c_str());
   fout.SetCopyIfDifferent(true);
@@ -3619,7 +3166,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS81()
   this->ConvertToWindowsSlash(artifactDir);
   std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
   std::string targetNameXML =
-      cmVS10EscapeXML(this->GeneratorTarget->GetName());
+    cmVS10EscapeXML(this->GeneratorTarget->GetName());
 
   cmGeneratedFileStream fout(manifestFile.c_str());
   fout.SetCopyIfDifferent(true);
@@ -3679,7 +3226,7 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
   this->ConvertToWindowsSlash(artifactDir);
   std::string artifactDirXML = cmVS10EscapeXML(artifactDir);
   std::string targetNameXML =
-      cmVS10EscapeXML(this->GeneratorTarget->GetName());
+    cmVS10EscapeXML(this->GeneratorTarget->GetName());
 
   cmGeneratedFileStream fout(manifestFile.c_str());
   fout.SetCopyIfDifferent(true);
@@ -3731,12 +3278,11 @@ void cmVisualStudio10TargetGenerator::WriteMissingFilesWS10_0()
   this->WriteCommonMissingFiles(manifestFile);
 }
 
-void
-cmVisualStudio10TargetGenerator
-::WriteCommonMissingFiles(const std::string& manifestFile)
+void cmVisualStudio10TargetGenerator::WriteCommonMissingFiles(
+  const std::string& manifestFile)
 {
-  std::string templateFolder = cmSystemTools::GetCMakeRoot() +
-                               "/Templates/Windows";
+  std::string templateFolder =
+    cmSystemTools::GetCMakeRoot() + "/Templates/Windows";
 
   std::string sourceFile = this->ConvertPath(manifestFile, false);
   this->ConvertToWindowsSlash(sourceFile);
@@ -3747,40 +3293,39 @@ cmVisualStudio10TargetGenerator
   this->AddedFiles.push_back(sourceFile);
 
   std::string smallLogo = this->DefaultArtifactDir + "/SmallLogo.png";
-  cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png",
-                           smallLogo, false);
+  cmSystemTools::CopyAFile(templateFolder + "/SmallLogo.png", smallLogo,
+                           false);
   this->ConvertToWindowsSlash(smallLogo);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo) << "\" />\n";
   this->AddedFiles.push_back(smallLogo);
 
   std::string smallLogo44 = this->DefaultArtifactDir + "/SmallLogo44x44.png";
-  cmSystemTools::CopyAFile(templateFolder + "/SmallLogo44x44.png",
-                           smallLogo44, false);
+  cmSystemTools::CopyAFile(templateFolder + "/SmallLogo44x44.png", smallLogo44,
+                           false);
   this->ConvertToWindowsSlash(smallLogo44);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(smallLogo44) << "\" />\n";
   this->AddedFiles.push_back(smallLogo44);
 
   std::string logo = this->DefaultArtifactDir + "/Logo.png";
-  cmSystemTools::CopyAFile(templateFolder + "/Logo.png",
-                           logo, false);
+  cmSystemTools::CopyAFile(templateFolder + "/Logo.png", logo, false);
   this->ConvertToWindowsSlash(logo);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(logo) << "\" />\n";
   this->AddedFiles.push_back(logo);
 
   std::string storeLogo = this->DefaultArtifactDir + "/StoreLogo.png";
-  cmSystemTools::CopyAFile(templateFolder + "/StoreLogo.png",
-                           storeLogo, false);
+  cmSystemTools::CopyAFile(templateFolder + "/StoreLogo.png", storeLogo,
+                           false);
   this->ConvertToWindowsSlash(storeLogo);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(storeLogo) << "\" />\n";
   this->AddedFiles.push_back(storeLogo);
 
   std::string splashScreen = this->DefaultArtifactDir + "/SplashScreen.png";
-  cmSystemTools::CopyAFile(templateFolder + "/SplashScreen.png",
-                           splashScreen, false);
+  cmSystemTools::CopyAFile(templateFolder + "/SplashScreen.png", splashScreen,
+                           false);
   this->ConvertToWindowsSlash(splashScreen);
   this->WriteString("<Image Include=\"", 2);
   (*this->BuildFileStream) << cmVS10EscapeXML(splashScreen) << "\" />\n";
@@ -3795,22 +3340,19 @@ cmVisualStudio10TargetGenerator
 
 bool cmVisualStudio10TargetGenerator::ForceOld(const std::string& source) const
 {
-  HANDLE h = CreateFileW(
-    cmSystemTools::ConvertToWindowsExtendedPath(source).c_str(),
-    FILE_WRITE_ATTRIBUTES,
-    FILE_SHARE_WRITE, 0, OPEN_EXISTING,
-    FILE_FLAG_BACKUP_SEMANTICS, 0);
-  if (!h)
-    {
+  HANDLE h =
+    CreateFileW(cmSystemTools::ConvertToWindowsExtendedPath(source).c_str(),
+                FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, 0, OPEN_EXISTING,
+                FILE_FLAG_BACKUP_SEMANTICS, 0);
+  if (!h) {
     return false;
-    }
+  }
 
   FILETIME const ftime_20010101 = { 3365781504u, 29389701u };
-  if (!SetFileTime(h, &ftime_20010101, &ftime_20010101, &ftime_20010101))
-    {
+  if (!SetFileTime(h, &ftime_20010101, &ftime_20010101, &ftime_20010101)) {
     CloseHandle(h);
     return false;
-    }
+  }
 
   CloseHandle(h);
   return true;
diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h
index 6c946c9..109a100 100644
--- a/Source/cmVisualStudio10TargetGenerator.h
+++ b/Source/cmVisualStudio10TargetGenerator.h
@@ -34,14 +34,9 @@ public:
   ~cmVisualStudio10TargetGenerator();
   void Generate();
   // used by cmVisualStudioGeneratorOptions
-  void WritePlatformConfigTag(
-    const char* tag,
-    const std::string& config,
-    int indentLevel,
-    const char* attribute = 0,
-    const char* end = 0,
-    std::ostream* strm = 0
-    );
+  void WritePlatformConfigTag(const char* tag, const std::string& config,
+                              int indentLevel, const char* attribute = 0,
+                              const char* end = 0, std::ostream* strm = 0);
 
 private:
   struct ToolSource
@@ -49,7 +44,9 @@ private:
     cmSourceFile const* SourceFile;
     bool RelativePath;
   };
-  struct ToolSources: public std::vector<ToolSource> {};
+  struct ToolSources : public std::vector<ToolSource>
+  {
+  };
 
   std::string ConvertPath(std::string const& path, bool forceRelative);
   void ConvertToWindowsSlash(std::string& s);
@@ -91,11 +88,11 @@ private:
   bool ComputeClOptions();
   bool ComputeClOptions(std::string const& configName);
   void WriteClOptions(std::string const& config,
-                      std::vector<std::string> const & includes);
+                      std::vector<std::string> const& includes);
   bool ComputeRcOptions();
   bool ComputeRcOptions(std::string const& config);
   void WriteRCOptions(std::string const& config,
-                      std::vector<std::string> const & includes);
+                      std::vector<std::string> const& includes);
   bool ComputeMasmOptions();
   bool ComputeMasmOptions(std::string const& config);
   void WriteMasmOptions(std::string const& config,
@@ -104,11 +101,11 @@ private:
   bool ComputeLinkOptions(std::string const& config);
   void WriteLinkOptions(std::string const& config);
   void WriteMidlOptions(std::string const& config,
-                        std::vector<std::string> const & includes);
+                        std::vector<std::string> const& includes);
   void WriteAntBuildOptions(std::string const& config);
   void OutputLinkIncremental(std::string const& configName);
   void WriteCustomRule(cmSourceFile const* source,
-                       cmCustomCommand const & command);
+                       cmCustomCommand const& command);
   void WriteCustomCommands();
   void WriteCustomCommand(cmSourceFile const* sf);
   void WriteGroups();
@@ -124,7 +121,7 @@ private:
                   std::vector<cmCustomCommand> const& commands,
                   std::string const& configName);
   void WriteGroupSources(const char* name, ToolSources const& sources,
-                         std::vector<cmSourceGroup>& );
+                         std::vector<cmSourceGroup>&);
   void AddMissingSourceGroups(std::set<cmSourceGroup*>& groupsUsed,
                               const std::vector<cmSourceGroup>& allGroups);
   bool IsResxHeader(const std::string& headerFile);
@@ -155,7 +152,7 @@ private:
   std::string Name;
   bool MSTools;
   bool NsightTegra;
-  int  NsightTegraVersion[4];
+  int NsightTegraVersion[4];
   bool TargetCompileAsWinRT;
   cmGlobalVisualStudio10Generator* GlobalGenerator;
   cmGeneratedFileStream* BuildFileStream;
diff --git a/Source/cmVisualStudioGeneratorOptions.cxx b/Source/cmVisualStudioGeneratorOptions.cxx
index 00374e8..3b31d7b 100644
--- a/Source/cmVisualStudioGeneratorOptions.cxx
+++ b/Source/cmVisualStudioGeneratorOptions.cxx
@@ -4,8 +4,8 @@
 #include "cmSystemTools.h"
 #include "cmVisualStudio10TargetGenerator.h"
 
-static
-std::string cmVisualStudio10GeneratorOptionsEscapeForXML(std::string ret)
+static std::string cmVisualStudio10GeneratorOptionsEscapeForXML(
+  std::string ret)
 {
   cmSystemTools::ReplaceString(ret, ";", "%3B");
   cmSystemTools::ReplaceString(ret, "&", "&amp;");
@@ -14,8 +14,7 @@ std::string cmVisualStudio10GeneratorOptionsEscapeForXML(std::string ret)
   return ret;
 }
 
-static
-std::string cmVisualStudioGeneratorOptionsEscapeForXML(std::string ret)
+static std::string cmVisualStudioGeneratorOptionsEscapeForXML(std::string ret)
 {
   cmSystemTools::ReplaceString(ret, "&", "&amp;");
   cmSystemTools::ReplaceString(ret, "\"", "&quot;");
@@ -25,13 +24,14 @@ std::string cmVisualStudioGeneratorOptionsEscapeForXML(std::string ret)
   return ret;
 }
 
-cmVisualStudioGeneratorOptions
-::cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg,
-                                 Tool tool,
-                                 cmVisualStudio10TargetGenerator* g):
-  cmIDEOptions(),
-  LocalGenerator(lg), Version(lg->GetVersion()), CurrentTool(tool),
-  TargetGenerator(g)
+cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
+  cmLocalVisualStudioGenerator* lg, Tool tool,
+  cmVisualStudio10TargetGenerator* g)
+  : cmIDEOptions()
+  , LocalGenerator(lg)
+  , Version(lg->GetVersion())
+  , CurrentTool(tool)
+  , TargetGenerator(g)
 {
   // Preprocessor definitions are not allowed for linker tools.
   this->AllowDefine = (tool != Linker);
@@ -44,15 +44,14 @@ cmVisualStudioGeneratorOptions
   this->FortranRuntimeMT = false;
 }
 
-cmVisualStudioGeneratorOptions
-::cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg,
-                                 Tool tool,
-                                 cmVS7FlagTable const* table,
-                                 cmVS7FlagTable const* extraTable,
-                                 cmVisualStudio10TargetGenerator* g):
-  cmIDEOptions(),
-  LocalGenerator(lg), Version(lg->GetVersion()), CurrentTool(tool),
-  TargetGenerator(g)
+cmVisualStudioGeneratorOptions::cmVisualStudioGeneratorOptions(
+  cmLocalVisualStudioGenerator* lg, Tool tool, cmVS7FlagTable const* table,
+  cmVS7FlagTable const* extraTable, cmVisualStudio10TargetGenerator* g)
+  : cmIDEOptions()
+  , LocalGenerator(lg)
+  , Version(lg->GetVersion())
+  , CurrentTool(tool)
+  , TargetGenerator(g)
 {
   // Store the given flag tables.
   this->AddTable(table);
@@ -71,17 +70,14 @@ cmVisualStudioGeneratorOptions
 
 void cmVisualStudioGeneratorOptions::AddTable(cmVS7FlagTable const* table)
 {
-  if(table)
-    {
-    for(int i=0; i < FlagTableCount; ++i)
-      {
-      if (!this->FlagTable[i])
-        {
+  if (table) {
+    for (int i = 0; i < FlagTableCount; ++i) {
+      if (!this->FlagTable[i]) {
         this->FlagTable[i] = table;
         break;
-        }
       }
     }
+  }
 }
 
 void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
@@ -91,8 +87,7 @@ void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
   // initialization to off, but the user has the option of removing
   // the flag to disable exception handling.  When the user does
   // remove the flag we need to override the IDE default of on.
-  switch (this->Version)
-    {
+  switch (this->Version) {
     case cmGlobalVisualStudioGenerator::VS7:
     case cmGlobalVisualStudioGenerator::VS71:
       this->FlagMap["ExceptionHandling"] = "FALSE";
@@ -109,8 +104,8 @@ void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
       break;
     default:
       this->FlagMap["ExceptionHandling"] = "0";
-    break;
-    }
+      break;
+  }
 }
 
 void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
@@ -124,12 +119,11 @@ void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
   // an empty string, instead of "FALSE", in order to avoid a warning:
   //   "cl ... warning D9035: option 'nologo-' has been deprecated"
   //
-  if(verbose &&
-     this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end())
-    {
+  if (verbose &&
+      this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end()) {
     this->FlagMap["SuppressStartupBanner"] =
       this->Version < cmGlobalVisualStudioGenerator::VS10 ? "FALSE" : "";
-    }
+  }
 }
 
 bool cmVisualStudioGeneratorOptions::IsDebug() const
@@ -145,27 +139,23 @@ bool cmVisualStudioGeneratorOptions::IsWinRt() const
 bool cmVisualStudioGeneratorOptions::UsingUnicode() const
 {
   // Look for the a _UNICODE definition.
-  for(std::vector<std::string>::const_iterator di = this->Defines.begin();
-      di != this->Defines.end(); ++di)
-    {
-    if(*di == "_UNICODE")
-      {
+  for (std::vector<std::string>::const_iterator di = this->Defines.begin();
+       di != this->Defines.end(); ++di) {
+    if (*di == "_UNICODE") {
       return true;
-      }
     }
+  }
   return false;
 }
 bool cmVisualStudioGeneratorOptions::UsingSBCS() const
 {
   // Look for the a _SBCS definition.
-  for(std::vector<std::string>::const_iterator di = this->Defines.begin();
-      di != this->Defines.end(); ++di)
-    {
-    if(*di == "_SBCS")
-      {
+  for (std::vector<std::string>::const_iterator di = this->Defines.begin();
+       di != this->Defines.end(); ++di) {
+    if (*di == "_SBCS") {
       return true;
-      }
     }
+  }
   return false;
 }
 
@@ -178,17 +168,15 @@ void cmVisualStudioGeneratorOptions::Parse(const char* flags)
 
   // Process flags that need to be represented specially in the IDE
   // project file.
-  for(std::vector<std::string>::iterator ai = args.begin();
-      ai != args.end(); ++ai)
-    {
+  for (std::vector<std::string>::iterator ai = args.begin(); ai != args.end();
+       ++ai) {
     this->HandleFlag(ai->c_str());
-    }
+  }
 }
 
 void cmVisualStudioGeneratorOptions::ParseFinish()
 {
-  if(this->CurrentTool == FortranCompiler)
-    {
+  if (this->CurrentTool == FortranCompiler) {
     // "RuntimeLibrary" attribute values:
     //  "rtMultiThreaded", "0", /threads /libs:static
     //  "rtMultiThreadedDLL", "2", /threads /libs:dll
@@ -200,45 +188,38 @@ void cmVisualStudioGeneratorOptions::ParseFinish()
     //  "rtSingleThreadedDebug", "5", /dbglibs /libs:static
     //  "rtSingleThreadedDebugDLL", "11", /dbglibs /libs:dll
     std::string rl = "rtMultiThreaded";
-    rl += this->FortranRuntimeDebug? "Debug" : "";
-    rl += this->FortranRuntimeDLL? "DLL" : "";
+    rl += this->FortranRuntimeDebug ? "Debug" : "";
+    rl += this->FortranRuntimeDLL ? "DLL" : "";
     this->FlagMap["RuntimeLibrary"] = rl;
-    }
+  }
 }
 
 void cmVisualStudioGeneratorOptions::StoreUnknownFlag(const char* flag)
 {
   // Look for Intel Fortran flags that do not map well in the flag table.
-  if(this->CurrentTool == FortranCompiler)
-    {
-    if(strcmp(flag, "/dbglibs") == 0)
-      {
+  if (this->CurrentTool == FortranCompiler) {
+    if (strcmp(flag, "/dbglibs") == 0) {
       this->FortranRuntimeDebug = true;
       return;
-      }
-    if(strcmp(flag, "/threads") == 0)
-      {
+    }
+    if (strcmp(flag, "/threads") == 0) {
       this->FortranRuntimeMT = true;
       return;
-      }
-    if(strcmp(flag, "/libs:dll") == 0)
-      {
+    }
+    if (strcmp(flag, "/libs:dll") == 0) {
       this->FortranRuntimeDLL = true;
       return;
-      }
-    if(strcmp(flag, "/libs:static") == 0)
-      {
+    }
+    if (strcmp(flag, "/libs:static") == 0) {
       this->FortranRuntimeDLL = false;
       return;
-      }
     }
+  }
 
   // This option is not known.  Store it in the output flags.
   this->FlagString += " ";
-  this->FlagString +=
-    cmOutputConverter::EscapeWindowsShellArgument(
-      flag,
-      cmOutputConverter::Shell_Flag_AllowMakeVariables |
+  this->FlagString += cmOutputConverter::EscapeWindowsShellArgument(
+    flag, cmOutputConverter::Shell_Flag_AllowMakeVariables |
       cmOutputConverter::Shell_Flag_VSIDE);
 }
 
@@ -247,163 +228,112 @@ void cmVisualStudioGeneratorOptions::SetConfiguration(const char* config)
   this->Configuration = config;
 }
 
-void
-cmVisualStudioGeneratorOptions
-::OutputPreprocessorDefinitions(std::ostream& fout,
-                                const char* prefix,
-                                const char* suffix,
-                                const std::string& lang)
+void cmVisualStudioGeneratorOptions::OutputPreprocessorDefinitions(
+  std::ostream& fout, const char* prefix, const char* suffix,
+  const std::string& lang)
 {
-  if(this->Defines.empty())
-    {
+  if (this->Defines.empty()) {
     return;
-    }
-  if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
-    {
+  }
+  if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
     // if there are configuration specific flags, then
     // use the configuration specific tag for PreprocessorDefinitions
-    if(!this->Configuration.empty())
-      {
+    if (!this->Configuration.empty()) {
       fout << prefix;
       this->TargetGenerator->WritePlatformConfigTag(
-        "PreprocessorDefinitions",
-        this->Configuration.c_str(),
-        0,
-        0, 0, &fout);
-      }
-    else
-      {
+        "PreprocessorDefinitions", this->Configuration.c_str(), 0, 0, 0,
+        &fout);
+    } else {
       fout << prefix << "<PreprocessorDefinitions>";
-      }
-    }
-  else
-    {
-    fout << prefix <<  "PreprocessorDefinitions=\"";
     }
+  } else {
+    fout << prefix << "PreprocessorDefinitions=\"";
+  }
   const char* sep = "";
-  for(std::vector<std::string>::const_iterator di = this->Defines.begin();
-      di != this->Defines.end(); ++di)
-    {
+  for (std::vector<std::string>::const_iterator di = this->Defines.begin();
+       di != this->Defines.end(); ++di) {
     // Escape the definition for the compiler.
     std::string define;
-    if(this->Version < cmGlobalVisualStudioGenerator::VS10)
-      {
-      define =
-        this->LocalGenerator->EscapeForShell(di->c_str(), true);
-      }
-    else
-      {
+    if (this->Version < cmGlobalVisualStudioGenerator::VS10) {
+      define = this->LocalGenerator->EscapeForShell(di->c_str(), true);
+    } else {
       define = *di;
-      }
+    }
     // Escape this flag for the IDE.
-    if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
-      {
+    if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
       define = cmVisualStudio10GeneratorOptionsEscapeForXML(define);
 
-      if(lang == "RC")
-        {
+      if (lang == "RC") {
         cmSystemTools::ReplaceString(define, "\"", "\\\"");
-        }
       }
-    else
-      {
+    } else {
       define = cmVisualStudioGeneratorOptionsEscapeForXML(define);
-      }
+    }
     // Store the flag in the project file.
     fout << sep << define;
     sep = ";";
-    }
-  if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
-    {
-    fout <<  ";%(PreprocessorDefinitions)</PreprocessorDefinitions>" << suffix;
-    }
-  else
-    {
+  }
+  if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
+    fout << ";%(PreprocessorDefinitions)</PreprocessorDefinitions>" << suffix;
+  } else {
     fout << "\"" << suffix;
-    }
+  }
 }
 
-void
-cmVisualStudioGeneratorOptions
-::OutputFlagMap(std::ostream& fout, const char* indent)
+void cmVisualStudioGeneratorOptions::OutputFlagMap(std::ostream& fout,
+                                                   const char* indent)
 {
-  if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
-    {
-    for(std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
-        m != this->FlagMap.end(); ++m)
-      {
+  if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
+    for (std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
+         m != this->FlagMap.end(); ++m) {
       fout << indent;
-      if(!this->Configuration.empty())
-        {
+      if (!this->Configuration.empty()) {
         this->TargetGenerator->WritePlatformConfigTag(
-          m->first.c_str(),
-          this->Configuration.c_str(),
-          0,
-          0, 0, &fout);
-        }
-      else
-        {
+          m->first.c_str(), this->Configuration.c_str(), 0, 0, 0, &fout);
+      } else {
         fout << "<" << m->first << ">";
-        }
+      }
       const char* sep = "";
-      for(std::vector<std::string>::iterator i = m->second.begin();
-            i != m->second.end(); ++i)
-        {
+      for (std::vector<std::string>::iterator i = m->second.begin();
+           i != m->second.end(); ++i) {
         fout << sep << cmVisualStudio10GeneratorOptionsEscapeForXML(*i);
         sep = ";";
-        }
-      fout  << "</" << m->first << ">\n";
       }
+      fout << "</" << m->first << ">\n";
     }
-  else
-    {
-    for(std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
-        m != this->FlagMap.end(); ++m)
-      {
+  } else {
+    for (std::map<std::string, FlagValue>::iterator m = this->FlagMap.begin();
+         m != this->FlagMap.end(); ++m) {
       fout << indent << m->first << "=\"";
       const char* sep = "";
-      for(std::vector<std::string>::iterator i = m->second.begin();
-            i != m->second.end(); ++i)
-        {
+      for (std::vector<std::string>::iterator i = m->second.begin();
+           i != m->second.end(); ++i) {
         fout << sep << cmVisualStudioGeneratorOptionsEscapeForXML(*i);
         sep = ";";
-        }
-      fout << "\"\n";
       }
+      fout << "\"\n";
     }
+  }
 }
 
-void
-cmVisualStudioGeneratorOptions
-::OutputAdditionalOptions(std::ostream& fout,
-                          const char* prefix,
-                          const char* suffix)
+void cmVisualStudioGeneratorOptions::OutputAdditionalOptions(
+  std::ostream& fout, const char* prefix, const char* suffix)
 {
-  if(!this->FlagString.empty())
-    {
-    if(this->Version >= cmGlobalVisualStudioGenerator::VS10)
-      {
+  if (!this->FlagString.empty()) {
+    if (this->Version >= cmGlobalVisualStudioGenerator::VS10) {
       fout << prefix;
-      if(!this->Configuration.empty())
-        {
+      if (!this->Configuration.empty()) {
         this->TargetGenerator->WritePlatformConfigTag(
-          "AdditionalOptions",
-          this->Configuration.c_str(),
-          0,
-          0, 0, &fout);
-        }
-      else
-        {
+          "AdditionalOptions", this->Configuration.c_str(), 0, 0, 0, &fout);
+      } else {
         fout << "<AdditionalOptions>";
-        }
+      }
       fout << cmVisualStudio10GeneratorOptionsEscapeForXML(this->FlagString)
            << " %(AdditionalOptions)</AdditionalOptions>\n";
-      }
-    else
-      {
+    } else {
       fout << prefix << "AdditionalOptions=\"";
       fout << cmVisualStudioGeneratorOptionsEscapeForXML(this->FlagString);
       fout << "\"" << suffix;
-      }
     }
+  }
 }
diff --git a/Source/cmVisualStudioGeneratorOptions.h b/Source/cmVisualStudioGeneratorOptions.h
index e5633be..219b009 100644
--- a/Source/cmVisualStudioGeneratorOptions.h
+++ b/Source/cmVisualStudioGeneratorOptions.h
@@ -19,7 +19,7 @@ typedef cmIDEFlagTable cmVS7FlagTable;
 
 class cmVisualStudio10TargetGenerator;
 
-class cmVisualStudioGeneratorOptions: public cmIDEOptions
+class cmVisualStudioGeneratorOptions : public cmIDEOptions
 {
 public:
   // Construct an options table for a given tool.
@@ -31,14 +31,12 @@ public:
     Linker,
     FortranCompiler
   };
-  cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg,
-                                 Tool tool,
+  cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg, Tool tool,
                                  cmVS7FlagTable const* table,
                                  cmVS7FlagTable const* extraTable = 0,
                                  cmVisualStudio10TargetGenerator* g = 0);
 
-  cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg,
-                                 Tool tool,
+  cmVisualStudioGeneratorOptions(cmLocalVisualStudioGenerator* lg, Tool tool,
                                  cmVisualStudio10TargetGenerator* g = 0);
 
   // Add a table of flags.
@@ -61,15 +59,14 @@ public:
   bool IsDebug() const;
   bool IsWinRt() const;
   // Write options to output.
-  void OutputPreprocessorDefinitions(std::ostream& fout,
-                                     const char* prefix,
+  void OutputPreprocessorDefinitions(std::ostream& fout, const char* prefix,
                                      const char* suffix,
                                      const std::string& lang);
   void OutputFlagMap(std::ostream& fout, const char* indent);
-  void OutputAdditionalOptions(std::ostream& fout,
-                               const char* prefix,
+  void OutputAdditionalOptions(std::ostream& fout, const char* prefix,
                                const char* suffix);
   void SetConfiguration(const char* config);
+
 private:
   cmLocalVisualStudioGenerator* LocalGenerator;
   cmGlobalVisualStudioGenerator::VSVersion Version;
diff --git a/Source/cmVisualStudioSlnData.cxx b/Source/cmVisualStudioSlnData.cxx
index 6d7c5ce..7ffa0b5 100644
--- a/Source/cmVisualStudioSlnData.cxx
+++ b/Source/cmVisualStudioSlnData.cxx
@@ -11,8 +11,8 @@
 ============================================================================*/
 #include "cmVisualStudioSlnData.h"
 
-const cmSlnProjectEntry*
-cmSlnData::GetProjectByGUID(const std::string& projectGUID) const
+const cmSlnProjectEntry* cmSlnData::GetProjectByGUID(
+  const std::string& projectGUID) const
 {
   ProjectStorage::const_iterator it(ProjectsByGUID.find(projectGUID));
   if (it != ProjectsByGUID.end())
@@ -21,8 +21,8 @@ cmSlnData::GetProjectByGUID(const std::string& projectGUID) const
     return NULL;
 }
 
-const cmSlnProjectEntry*
-cmSlnData::GetProjectByName(const std::string& projectName) const
+const cmSlnProjectEntry* cmSlnData::GetProjectByName(
+  const std::string& projectName) const
 {
   ProjectStringIndex::const_iterator it(ProjectNameIndex.find(projectName));
   if (it != ProjectNameIndex.end())
@@ -34,7 +34,7 @@ cmSlnData::GetProjectByName(const std::string& projectName) const
 std::vector<cmSlnProjectEntry> cmSlnData::GetProjects() const
 {
   ProjectStringIndex::const_iterator it(this->ProjectNameIndex.begin()),
-                                     itEnd(this->ProjectNameIndex.end());
+    itEnd(this->ProjectNameIndex.end());
   std::vector<cmSlnProjectEntry> result;
   for (; it != itEnd; ++it)
     result.push_back(it->second->second);
@@ -42,17 +42,17 @@ std::vector<cmSlnProjectEntry> cmSlnData::GetProjects() const
 }
 
 cmSlnProjectEntry* cmSlnData::AddProject(
-  const std::string& projectGUID,
-  const std::string& projectName,
+  const std::string& projectGUID, const std::string& projectName,
   const std::string& projectRelativePath)
 {
   ProjectStorage::iterator it(ProjectsByGUID.find(projectGUID));
   if (it != ProjectsByGUID.end())
     return NULL;
-  it = ProjectsByGUID.insert(
-    ProjectStorage::value_type(
-      projectGUID,
-      cmSlnProjectEntry(projectGUID, projectName, projectRelativePath))).first;
+  it = ProjectsByGUID
+         .insert(ProjectStorage::value_type(
+           projectGUID,
+           cmSlnProjectEntry(projectGUID, projectName, projectRelativePath)))
+         .first;
   ProjectNameIndex[projectName] = it;
   return &it->second;
 }
diff --git a/Source/cmVisualStudioSlnData.h b/Source/cmVisualStudioSlnData.h
index ec128cf..4508370 100644
--- a/Source/cmVisualStudioSlnData.h
+++ b/Source/cmVisualStudioSlnData.h
@@ -18,11 +18,13 @@ class cmSlnProjectEntry
 {
 public:
   cmSlnProjectEntry() {}
-  cmSlnProjectEntry(const std::string& guid,
-                    const std::string& name,
+  cmSlnProjectEntry(const std::string& guid, const std::string& name,
                     const std::string& relativePath)
-    : Guid(guid), Name(name), RelativePath(relativePath)
-  {}
+    : Guid(guid)
+    , Name(name)
+    , RelativePath(relativePath)
+  {
+  }
 
   std::string GetGUID() const { return Guid; }
   std::string GetName() const { return Name; }
@@ -32,15 +34,14 @@ private:
   std::string Guid, Name, RelativePath;
 };
 
-
 class cmSlnData
 {
 public:
-  const cmSlnProjectEntry*
-  GetProjectByGUID(const std::string& projectGUID) const;
+  const cmSlnProjectEntry* GetProjectByGUID(
+    const std::string& projectGUID) const;
 
-  const cmSlnProjectEntry*
-  GetProjectByName(const std::string& projectName) const;
+  const cmSlnProjectEntry* GetProjectByName(
+    const std::string& projectName) const;
 
   std::vector<cmSlnProjectEntry> GetProjects() const;
 
diff --git a/Source/cmVisualStudioSlnParser.cxx b/Source/cmVisualStudioSlnParser.cxx
index 2bbea55..7d7bb5b 100644
--- a/Source/cmVisualStudioSlnParser.cxx
+++ b/Source/cmVisualStudioSlnParser.cxx
@@ -18,15 +18,14 @@
 #include <cassert>
 #include <stack>
 
-namespace
+namespace {
+enum LineFormat
 {
-  enum LineFormat
-  {
-    LineMultiValueTag,
-    LineSingleValueTag,
-    LineKeyValuePair,
-    LineVerbatim
-  };
+  LineMultiValueTag,
+  LineSingleValueTag,
+  LineKeyValuePair,
+  LineVerbatim
+};
 }
 
 class cmVisualStudioSlnParser::ParsedLine
@@ -45,11 +44,17 @@ public:
   void SetTag(const std::string& tag) { this->Tag = tag; }
   void SetArg(const std::string& arg) { this->Arg = StringData(arg, false); }
   void SetQuotedArg(const std::string& arg)
-    { this->Arg = StringData(arg, true); }
+  {
+    this->Arg = StringData(arg, true);
+  }
   void AddValue(const std::string& value)
-    { this->Values.push_back(StringData(value, false)); }
+  {
+    this->Values.push_back(StringData(value, false));
+  }
   void AddQuotedValue(const std::string& value)
-    { this->Values.push_back(StringData(value, true)); }
+  {
+    this->Values.push_back(StringData(value, true));
+  }
 
   void CopyVerbatim(const std::string& line) { this->Tag = line; }
 
@@ -68,7 +73,7 @@ const std::string cmVisualStudioSlnParser::ParsedLine::Quote("\"");
 bool cmVisualStudioSlnParser::ParsedLine::IsComment() const
 {
   assert(!this->Tag.empty());
-  return (this->Tag[0]== '#');
+  return (this->Tag[0] == '#');
 }
 
 bool cmVisualStudioSlnParser::ParsedLine::IsKeyValuePair() const
@@ -85,8 +90,8 @@ std::string cmVisualStudioSlnParser::ParsedLine::GetArgVerbatim() const
     return this->Arg.first;
 }
 
-const std::string&
-cmVisualStudioSlnParser::ParsedLine::GetValue(size_t idxValue) const
+const std::string& cmVisualStudioSlnParser::ParsedLine::GetValue(
+  size_t idxValue) const
 {
   if (idxValue < this->Values.size())
     return this->Values[idxValue].first;
@@ -94,18 +99,16 @@ cmVisualStudioSlnParser::ParsedLine::GetValue(size_t idxValue) const
     return BadString;
 }
 
-std::string
-cmVisualStudioSlnParser::ParsedLine::GetValueVerbatim(size_t idxValue) const
+std::string cmVisualStudioSlnParser::ParsedLine::GetValueVerbatim(
+  size_t idxValue) const
 {
-  if (idxValue < this->Values.size())
-    {
+  if (idxValue < this->Values.size()) {
     const StringData& data = this->Values[idxValue];
     if (data.second)
       return Quote + data.first + Quote;
     else
       return data.first;
-    }
-  else
+  } else
     return BadString;
 }
 
@@ -120,8 +123,7 @@ public:
   LineFormat NextLineFormat() const;
 
   bool Process(const cmVisualStudioSlnParser::ParsedLine& line,
-               cmSlnData& output,
-               cmVisualStudioSlnParser::ResultData& result);
+               cmSlnData& output, cmVisualStudioSlnParser::ResultData& result);
 
   bool Finished(cmVisualStudioSlnParser::ResultData& result);
 
@@ -147,9 +149,9 @@ private:
   void IgnoreUntilTag(const std::string& endTag);
 };
 
-cmVisualStudioSlnParser::State::State(DataGroupSet requestedData) :
-  RequestedData(requestedData),
-  CurrentLine(0)
+cmVisualStudioSlnParser::State::State(DataGroupSet requestedData)
+  : RequestedData(requestedData)
+  , CurrentLine(0)
 {
   if (this->RequestedData.test(DataGroupProjectDependenciesBit))
     this->RequestedData.set(DataGroupProjectsBit);
@@ -165,92 +167,86 @@ bool cmVisualStudioSlnParser::State::ReadLine(std::istream& input,
 
 LineFormat cmVisualStudioSlnParser::State::NextLineFormat() const
 {
-  switch (this->Stack.top())
-    {
-    case FileStateStart: return LineVerbatim;
-    case FileStateTopLevel: return LineMultiValueTag;
-    case FileStateProject: return LineSingleValueTag;
-    case FileStateProjectDependencies: return LineKeyValuePair;
-    case FileStateGlobal: return LineSingleValueTag;
-    case FileStateSolutionConfigurations: return LineKeyValuePair;
-    case FileStateProjectConfigurations: return LineKeyValuePair;
-    case FileStateSolutionFilters: return LineKeyValuePair;
-    case FileStateGlobalSection: return LineKeyValuePair;
-    case FileStateIgnore: return LineVerbatim;
+  switch (this->Stack.top()) {
+    case FileStateStart:
+      return LineVerbatim;
+    case FileStateTopLevel:
+      return LineMultiValueTag;
+    case FileStateProject:
+      return LineSingleValueTag;
+    case FileStateProjectDependencies:
+      return LineKeyValuePair;
+    case FileStateGlobal:
+      return LineSingleValueTag;
+    case FileStateSolutionConfigurations:
+      return LineKeyValuePair;
+    case FileStateProjectConfigurations:
+      return LineKeyValuePair;
+    case FileStateSolutionFilters:
+      return LineKeyValuePair;
+    case FileStateGlobalSection:
+      return LineKeyValuePair;
+    case FileStateIgnore:
+      return LineVerbatim;
     default:
       assert(false);
       return LineVerbatim;
-    }
+  }
 }
 
 bool cmVisualStudioSlnParser::State::Process(
-  const cmVisualStudioSlnParser::ParsedLine& line,
-  cmSlnData& output, cmVisualStudioSlnParser::ResultData& result)
+  const cmVisualStudioSlnParser::ParsedLine& line, cmSlnData& output,
+  cmVisualStudioSlnParser::ResultData& result)
 {
   assert(!line.IsComment());
-  switch (this->Stack.top())
-    {
+  switch (this->Stack.top()) {
     case FileStateStart:
       if (!cmSystemTools::StringStartsWith(
-        line.GetTag().c_str(), "Microsoft Visual Studio Solution File"))
-        {
+            line.GetTag().c_str(), "Microsoft Visual Studio Solution File")) {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       this->Stack.pop();
       this->Stack.push(FileStateTopLevel);
       break;
     case FileStateTopLevel:
-      if (line.GetTag().compare("Project") == 0)
-        {
-        if (line.GetValueCount() != 3)
-          {
+      if (line.GetTag().compare("Project") == 0) {
+        if (line.GetValueCount() != 3) {
           result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
           return false;
-          }
-        if (this->RequestedData.test(DataGroupProjectsBit))
-          {
-          if (!output.AddProject(line.GetValue(2),
-                                 line.GetValue(0),
-                                 line.GetValue(1)))
-            {
+        }
+        if (this->RequestedData.test(DataGroupProjectsBit)) {
+          if (!output.AddProject(line.GetValue(2), line.GetValue(0),
+                                 line.GetValue(1))) {
             result.SetError(ResultErrorInputData, this->GetCurrentLine());
             return false;
-            }
-          this->Stack.push(FileStateProject);
           }
-        else
+          this->Stack.push(FileStateProject);
+        } else
           this->IgnoreUntilTag("EndProject");
-        }
-      else if (line.GetTag().compare("Global") == 0)
+      } else if (line.GetTag().compare("Global") == 0)
         this->Stack.push(FileStateGlobal);
-      else
-        {
+      else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateProject:
       if (line.GetTag().compare("EndProject") == 0)
         this->Stack.pop();
-      else if (line.GetTag().compare("ProjectSection") == 0)
-        {
+      else if (line.GetTag().compare("ProjectSection") == 0) {
         if (line.GetArg().compare("ProjectDependencies") == 0 &&
-            line.GetValue(0).compare("postProject") == 0)
-          {
+            line.GetValue(0).compare("postProject") == 0) {
           if (this->RequestedData.test(DataGroupProjectDependenciesBit))
             this->Stack.push(FileStateProjectDependencies);
           else
             this->IgnoreUntilTag("EndProjectSection");
-          }
-        else
+        } else
           this->IgnoreUntilTag("EndProjectSection");
-        }
-      else
-        {
+      } else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateProjectDependencies:
       if (line.GetTag().compare("EndProjectSection") == 0)
@@ -258,51 +254,42 @@ bool cmVisualStudioSlnParser::State::Process(
       else if (line.IsKeyValuePair())
         // implement dependency storing here, once needed
         ;
-      else
-        {
+      else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateGlobal:
       if (line.GetTag().compare("EndGlobal") == 0)
         this->Stack.pop();
-      else if (line.GetTag().compare("GlobalSection") == 0)
-        {
+      else if (line.GetTag().compare("GlobalSection") == 0) {
         if (line.GetArg().compare("SolutionConfigurationPlatforms") == 0 &&
-            line.GetValue(0).compare("preSolution") == 0)
-          {
+            line.GetValue(0).compare("preSolution") == 0) {
           if (this->RequestedData.test(DataGroupSolutionConfigurationsBit))
             this->Stack.push(FileStateSolutionConfigurations);
           else
             this->IgnoreUntilTag("EndGlobalSection");
-          }
-        else if (line.GetArg().compare("ProjectConfigurationPlatforms") == 0 &&
-                 line.GetValue(0).compare("postSolution") == 0)
-          {
+        } else if (line.GetArg().compare("ProjectConfigurationPlatforms") ==
+                     0 &&
+                   line.GetValue(0).compare("postSolution") == 0) {
           if (this->RequestedData.test(DataGroupProjectConfigurationsBit))
             this->Stack.push(FileStateProjectConfigurations);
           else
             this->IgnoreUntilTag("EndGlobalSection");
-          }
-        else if (line.GetArg().compare("NestedProjects") == 0 &&
-                 line.GetValue(0).compare("preSolution") == 0)
-          {
+        } else if (line.GetArg().compare("NestedProjects") == 0 &&
+                   line.GetValue(0).compare("preSolution") == 0) {
           if (this->RequestedData.test(DataGroupSolutionFiltersBit))
             this->Stack.push(FileStateSolutionFilters);
           else
             this->IgnoreUntilTag("EndGlobalSection");
-          }
-        else if (this->RequestedData.test(DataGroupGenericGlobalSectionsBit))
+        } else if (this->RequestedData.test(DataGroupGenericGlobalSectionsBit))
           this->Stack.push(FileStateGlobalSection);
         else
           this->IgnoreUntilTag("EndGlobalSection");
-        }
-      else
-        {
+      } else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateSolutionConfigurations:
       if (line.GetTag().compare("EndGlobalSection") == 0)
@@ -310,11 +297,10 @@ bool cmVisualStudioSlnParser::State::Process(
       else if (line.IsKeyValuePair())
         // implement configuration storing here, once needed
         ;
-      else
-        {
+      else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateProjectConfigurations:
       if (line.GetTag().compare("EndGlobalSection") == 0)
@@ -322,11 +308,10 @@ bool cmVisualStudioSlnParser::State::Process(
       else if (line.IsKeyValuePair())
         // implement configuration storing here, once needed
         ;
-      else
-        {
+      else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateSolutionFilters:
       if (line.GetTag().compare("EndGlobalSection") == 0)
@@ -334,11 +319,10 @@ bool cmVisualStudioSlnParser::State::Process(
       else if (line.IsKeyValuePair())
         // implement filter storing here, once needed
         ;
-      else
-        {
+      else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateGlobalSection:
       if (line.GetTag().compare("EndGlobalSection") == 0)
@@ -346,34 +330,31 @@ bool cmVisualStudioSlnParser::State::Process(
       else if (line.IsKeyValuePair())
         // implement section storing here, once needed
         ;
-      else
-        {
+      else {
         result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
         return false;
-        }
+      }
       break;
     case FileStateIgnore:
-      if (line.GetTag() == this->EndIgnoreTag)
-        {
+      if (line.GetTag() == this->EndIgnoreTag) {
         this->Stack.pop();
         this->EndIgnoreTag = "";
-        }
+      }
       break;
     default:
       result.SetError(ResultErrorBadInternalState, this->GetCurrentLine());
       return false;
-    }
+  }
   return true;
 }
 
 bool cmVisualStudioSlnParser::State::Finished(
   cmVisualStudioSlnParser::ResultData& result)
 {
-  if (this->Stack.top() != FileStateTopLevel)
-    {
+  if (this->Stack.top() != FileStateTopLevel) {
     result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
     return false;
-    }
+  }
   result.Result = ResultOK;
   return true;
 }
@@ -387,7 +368,8 @@ void cmVisualStudioSlnParser::State::IgnoreUntilTag(const std::string& endTag)
 cmVisualStudioSlnParser::ResultData::ResultData()
   : Result(ResultOK)
   , ResultLine(0)
-{}
+{
+}
 
 void cmVisualStudioSlnParser::ResultData::Clear()
 {
@@ -402,42 +384,40 @@ void cmVisualStudioSlnParser::ResultData::SetError(ParseResult error,
 }
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupProjects(
-  1 << cmVisualStudioSlnParser::DataGroupProjectsBit);
+  cmVisualStudioSlnParser::DataGroupProjects(
+    1 << cmVisualStudioSlnParser::DataGroupProjectsBit);
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupProjectDependencies(
-  1 << cmVisualStudioSlnParser::DataGroupProjectDependenciesBit);
+  cmVisualStudioSlnParser::DataGroupProjectDependencies(
+    1 << cmVisualStudioSlnParser::DataGroupProjectDependenciesBit);
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupSolutionConfigurations(
-  1 << cmVisualStudioSlnParser::DataGroupSolutionConfigurationsBit);
+  cmVisualStudioSlnParser::DataGroupSolutionConfigurations(
+    1 << cmVisualStudioSlnParser::DataGroupSolutionConfigurationsBit);
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupProjectConfigurations(
-  1 << cmVisualStudioSlnParser::DataGroupProjectConfigurationsBit);
+  cmVisualStudioSlnParser::DataGroupProjectConfigurations(
+    1 << cmVisualStudioSlnParser::DataGroupProjectConfigurationsBit);
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupSolutionFilters(
-  1 << cmVisualStudioSlnParser::DataGroupSolutionFiltersBit);
+  cmVisualStudioSlnParser::DataGroupSolutionFilters(
+    1 << cmVisualStudioSlnParser::DataGroupSolutionFiltersBit);
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupGenericGlobalSections(
-  1 << cmVisualStudioSlnParser::DataGroupGenericGlobalSectionsBit);
+  cmVisualStudioSlnParser::DataGroupGenericGlobalSections(
+    1 << cmVisualStudioSlnParser::DataGroupGenericGlobalSectionsBit);
 
 const cmVisualStudioSlnParser::DataGroupSet
-cmVisualStudioSlnParser::DataGroupAll(~0);
+  cmVisualStudioSlnParser::DataGroupAll(~0);
 
-bool cmVisualStudioSlnParser::Parse(std::istream& input,
-                                    cmSlnData& output,
+bool cmVisualStudioSlnParser::Parse(std::istream& input, cmSlnData& output,
                                     DataGroupSet dataGroups)
 {
   this->LastResult.Clear();
-  if (!this->IsDataGroupSetSupported(dataGroups))
-    {
+  if (!this->IsDataGroupSetSupported(dataGroups)) {
     this->LastResult.SetError(ResultErrorUnsupportedDataGroup, 0);
     return false;
-    }
+  }
   State state(dataGroups);
   return this->ParseImpl(input, output, state);
 }
@@ -447,23 +427,21 @@ bool cmVisualStudioSlnParser::ParseFile(const std::string& file,
                                         DataGroupSet dataGroups)
 {
   this->LastResult.Clear();
-  if (!this->IsDataGroupSetSupported(dataGroups))
-    {
+  if (!this->IsDataGroupSetSupported(dataGroups)) {
     this->LastResult.SetError(ResultErrorUnsupportedDataGroup, 0);
     return false;
-    }
+  }
   cmsys::ifstream f(file.c_str());
-  if (!f)
-    {
+  if (!f) {
     this->LastResult.SetError(ResultErrorOpeningInput, 0);
     return false;
-    }
+  }
   State state(dataGroups);
   return this->ParseImpl(f, output, state);
 }
 
-cmVisualStudioSlnParser::ParseResult
-cmVisualStudioSlnParser::GetParseResult() const
+cmVisualStudioSlnParser::ParseResult cmVisualStudioSlnParser::GetParseResult()
+  const
 {
   return this->LastResult.Result;
 }
@@ -478,29 +456,26 @@ bool cmVisualStudioSlnParser::GetParseHadBOM() const
   return this->LastResult.HadBOM;
 }
 
-bool
-cmVisualStudioSlnParser::IsDataGroupSetSupported(DataGroupSet dataGroups) const
+bool cmVisualStudioSlnParser::IsDataGroupSetSupported(
+  DataGroupSet dataGroups) const
 {
   return (dataGroups & DataGroupProjects) == dataGroups;
-    //only supporting DataGroupProjects for now
+  // only supporting DataGroupProjects for now
 }
 
-bool cmVisualStudioSlnParser::ParseImpl(std::istream& input,
-                                        cmSlnData& output,
+bool cmVisualStudioSlnParser::ParseImpl(std::istream& input, cmSlnData& output,
                                         State& state)
 {
   std::string line;
   // Does the .sln start with a Byte Order Mark?
   if (!this->ParseBOM(input, line, state))
     return false;
-  do
-    {
+  do {
     line = cmSystemTools::TrimWhitespace(line);
     if (line.empty())
       continue;
     ParsedLine parsedLine;
-    switch (state.NextLineFormat())
-      {
+    switch (state.NextLineFormat()) {
       case LineMultiValueTag:
         if (!this->ParseMultiValueTag(line, parsedLine, state))
           return false;
@@ -516,35 +491,31 @@ bool cmVisualStudioSlnParser::ParseImpl(std::istream& input,
       case LineVerbatim:
         parsedLine.CopyVerbatim(line);
         break;
-      }
+    }
     if (parsedLine.IsComment())
       continue;
     if (!state.Process(parsedLine, output, this->LastResult))
       return false;
-    }
-    while (state.ReadLine(input, line));
+  } while (state.ReadLine(input, line));
   return state.Finished(this->LastResult);
 }
 
-bool cmVisualStudioSlnParser::ParseBOM(std::istream& input,
-                                       std::string& line,
+bool cmVisualStudioSlnParser::ParseBOM(std::istream& input, std::string& line,
                                        State& state)
 {
   char bom[4];
-  if (!input.get(bom, 4))
-    {
+  if (!input.get(bom, 4)) {
     this->LastResult.SetError(ResultErrorReadingInput, 1);
     return false;
-    }
+  }
   this->LastResult.HadBOM =
     (bom[0] == char(0xEF) && bom[1] == char(0xBB) && bom[2] == char(0xBF));
-  if (!state.ReadLine(input, line))
-    {
+  if (!state.ReadLine(input, line)) {
     this->LastResult.SetError(ResultErrorReadingInput, 1);
     return false;
-    }
+  }
   if (!this->LastResult.HadBOM)
-    line = bom + line;  // it wasn't a BOM, prepend it to first line
+    line = bom + line; // it wasn't a BOM, prepend it to first line
   return true;
 }
 
@@ -556,45 +527,38 @@ bool cmVisualStudioSlnParser::ParseMultiValueTag(const std::string& line,
   const std::string& fullTag = line.substr(0, idxEqualSign);
   if (!this->ParseTag(fullTag, parsedLine, state))
     return false;
-  if (idxEqualSign != line.npos)
-    {
+  if (idxEqualSign != line.npos) {
     size_t idxFieldStart = idxEqualSign + 1;
-    if (idxFieldStart < line.size())
-      {
+    if (idxFieldStart < line.size()) {
       size_t idxParsing = idxFieldStart;
       bool inQuotes = false;
-      for (;;)
-        {
+      for (;;) {
         idxParsing = line.find_first_of(",\"", idxParsing);
         bool fieldOver = false;
-        if (idxParsing == line.npos)
-          {
+        if (idxParsing == line.npos) {
           fieldOver = true;
-          if (inQuotes)
-            {
+          if (inQuotes) {
             this->LastResult.SetError(ResultErrorInputStructure,
                                       state.GetCurrentLine());
             return false;
-            }
           }
-        else if (line[idxParsing] == ',' && !inQuotes)
+        } else if (line[idxParsing] == ',' && !inQuotes)
           fieldOver = true;
         else if (line[idxParsing] == '"')
           inQuotes = !inQuotes;
-        if (fieldOver)
-          {
-          if (!this->ParseValue(line.substr(idxFieldStart,
-                                            idxParsing - idxFieldStart),
-                                parsedLine))
+        if (fieldOver) {
+          if (!this->ParseValue(
+                line.substr(idxFieldStart, idxParsing - idxFieldStart),
+                parsedLine))
             return false;
           if (idxParsing == line.npos)
-            break;  //end of last field
+            break; // end of last field
           idxFieldStart = idxParsing + 1;
-          }
-        ++idxParsing;
         }
+        ++idxParsing;
       }
     }
+  }
   return true;
 }
 
@@ -606,11 +570,10 @@ bool cmVisualStudioSlnParser::ParseSingleValueTag(const std::string& line,
   const std::string& fullTag = line.substr(0, idxEqualSign);
   if (!this->ParseTag(fullTag, parsedLine, state))
     return false;
-  if (idxEqualSign != line.npos)
-    {
+  if (idxEqualSign != line.npos) {
     if (!this->ParseValue(line.substr(idxEqualSign + 1), parsedLine))
       return false;
-    }
+  }
   return true;
 }
 
@@ -619,11 +582,10 @@ bool cmVisualStudioSlnParser::ParseKeyValuePair(const std::string& line,
                                                 State& /*state*/)
 {
   size_t idxEqualSign = line.find('=');
-  if (idxEqualSign == line.npos)
-    {
+  if (idxEqualSign == line.npos) {
     parsedLine.CopyVerbatim(line);
     return true;
-    }
+  }
   const std::string& key = line.substr(0, idxEqualSign);
   parsedLine.SetTag(cmSystemTools::TrimWhitespace(key));
   const std::string& value = line.substr(idxEqualSign + 1);
@@ -632,37 +594,31 @@ bool cmVisualStudioSlnParser::ParseKeyValuePair(const std::string& line,
 }
 
 bool cmVisualStudioSlnParser::ParseTag(const std::string& fullTag,
-                                       ParsedLine& parsedLine,
-                                       State& state)
+                                       ParsedLine& parsedLine, State& state)
 {
   size_t idxLeftParen = fullTag.find('(');
-  if (idxLeftParen == fullTag.npos)
-    {
+  if (idxLeftParen == fullTag.npos) {
     parsedLine.SetTag(cmSystemTools::TrimWhitespace(fullTag));
     return true;
-    }
+  }
   parsedLine.SetTag(
     cmSystemTools::TrimWhitespace(fullTag.substr(0, idxLeftParen)));
   size_t idxRightParen = fullTag.rfind(')');
-  if (idxRightParen == fullTag.npos)
-    {
+  if (idxRightParen == fullTag.npos) {
     this->LastResult.SetError(ResultErrorInputStructure,
                               state.GetCurrentLine());
     return false;
-    }
+  }
   const std::string& arg = cmSystemTools::TrimWhitespace(
     fullTag.substr(idxLeftParen + 1, idxRightParen - idxLeftParen - 1));
-  if (arg[0] == '"')
-    {
-    if (arg[arg.size() - 1] != '"')
-      {
+  if (arg[0] == '"') {
+    if (arg[arg.size() - 1] != '"') {
       this->LastResult.SetError(ResultErrorInputStructure,
                                 state.GetCurrentLine());
       return false;
-      }
-      parsedLine.SetQuotedArg(arg.substr(1, arg.size() - 2));
     }
-  else
+    parsedLine.SetQuotedArg(arg.substr(1, arg.size() - 2));
+  } else
     parsedLine.SetArg(arg);
   return true;
 }
diff --git a/Source/cmVisualStudioSlnParser.h b/Source/cmVisualStudioSlnParser.h
index bee70cc..b9f8a92 100644
--- a/Source/cmVisualStudioSlnParser.h
+++ b/Source/cmVisualStudioSlnParser.h
@@ -16,10 +16,8 @@
 
 #include <bitset>
 
-
 class cmSlnData;
 
-
 class cmVisualStudioSlnParser
 {
 public:
@@ -60,12 +58,10 @@ public:
   static const DataGroupSet DataGroupGenericGlobalSections;
   static const DataGroupSet DataGroupAll;
 
-  bool Parse(std::istream& input,
-             cmSlnData& output,
+  bool Parse(std::istream& input, cmSlnData& output,
              DataGroupSet dataGroups = DataGroupAll);
 
-  bool ParseFile(const std::string& file,
-                 cmSlnData& output,
+  bool ParseFile(const std::string& file, cmSlnData& output,
                  DataGroupSet dataGroups = DataGroupAll);
 
   ParseResult GetParseResult() const;
@@ -96,20 +92,16 @@ protected:
 
   bool ParseBOM(std::istream& input, std::string& line, State& state);
 
-  bool ParseMultiValueTag(const std::string& line,
-                          ParsedLine& parsedLine,
+  bool ParseMultiValueTag(const std::string& line, ParsedLine& parsedLine,
                           State& state);
 
-  bool ParseSingleValueTag(const std::string& line,
-                           ParsedLine& parsedLine,
+  bool ParseSingleValueTag(const std::string& line, ParsedLine& parsedLine,
                            State& state);
 
-  bool ParseKeyValuePair(const std::string& line,
-                         ParsedLine& parsedLine,
+  bool ParseKeyValuePair(const std::string& line, ParsedLine& parsedLine,
                          State& state);
 
-  bool ParseTag(const std::string& fullTag,
-                ParsedLine& parsedLine,
+  bool ParseTag(const std::string& fullTag, ParsedLine& parsedLine,
                 State& state);
 
   bool ParseValue(const std::string& value, ParsedLine& parsedLine);
diff --git a/Source/cmVisualStudioWCEPlatformParser.cxx b/Source/cmVisualStudioWCEPlatformParser.cxx
index b6ee754..4f5e7c0 100644
--- a/Source/cmVisualStudioWCEPlatformParser.cxx
+++ b/Source/cmVisualStudioWCEPlatformParser.cxx
@@ -21,15 +21,12 @@ int cmVisualStudioWCEPlatformParser::ParseVersion(const char* version)
   const std::string vckey = registryBase + "\\Setup\\VC;ProductDir";
   const std::string vskey = registryBase + "\\Setup\\VS;ProductDir";
 
-  if(!cmSystemTools::ReadRegistryValue(vckey.c_str(),
-                                       this->VcInstallDir,
-                                       cmSystemTools::KeyWOW64_32) ||
-     !cmSystemTools::ReadRegistryValue(vskey.c_str(),
-                                       this->VsInstallDir,
-                                       cmSystemTools::KeyWOW64_32))
-    {
+  if (!cmSystemTools::ReadRegistryValue(vckey.c_str(), this->VcInstallDir,
+                                        cmSystemTools::KeyWOW64_32) ||
+      !cmSystemTools::ReadRegistryValue(vskey.c_str(), this->VsInstallDir,
+                                        cmSystemTools::KeyWOW64_32)) {
     return 0;
-    }
+  }
   cmSystemTools::ConvertToUnixSlashes(this->VcInstallDir);
   cmSystemTools::ConvertToUnixSlashes(this->VsInstallDir);
   this->VcInstallDir.append("/");
@@ -43,10 +40,9 @@ int cmVisualStudioWCEPlatformParser::ParseVersion(const char* version)
 
 std::string cmVisualStudioWCEPlatformParser::GetOSVersion() const
 {
-  if (this->OSMinorVersion.empty())
-    {
+  if (this->OSMinorVersion.empty()) {
     return OSMajorVersion;
-    }
+  }
 
   return OSMajorVersion + "." + OSMinorVersion;
 }
@@ -55,10 +51,9 @@ const char* cmVisualStudioWCEPlatformParser::GetArchitectureFamily() const
 {
   std::map<std::string, std::string>::const_iterator it =
     this->Macros.find("ARCHFAM");
-  if (it != this->Macros.end())
-    {
+  if (it != this->Macros.end()) {
     return it->second.c_str();
-    }
+  }
 
   return 0;
 }
@@ -66,98 +61,71 @@ const char* cmVisualStudioWCEPlatformParser::GetArchitectureFamily() const
 void cmVisualStudioWCEPlatformParser::StartElement(const std::string& name,
                                                    const char** attributes)
 {
-  if(this->FoundRequiredName)
-    {
+  if (this->FoundRequiredName) {
     return;
-    }
+  }
 
   this->CharacterData = "";
 
-  if(name == "PlatformData")
-    {
+  if (name == "PlatformData") {
     this->PlatformName = "";
     this->OSMajorVersion = "";
     this->OSMinorVersion = "";
     this->Macros.clear();
-    }
+  }
 
-  if(name == "Macro")
-    {
+  if (name == "Macro") {
     std::string macroName;
     std::string macroValue;
 
-    for(const char** attr = attributes; *attr; attr += 2)
-      {
-      if(strcmp(attr[0], "Name") == 0)
-        {
+    for (const char** attr = attributes; *attr; attr += 2) {
+      if (strcmp(attr[0], "Name") == 0) {
         macroName = attr[1];
-        }
-      else if(strcmp(attr[0], "Value") == 0)
-        {
+      } else if (strcmp(attr[0], "Value") == 0) {
         macroValue = attr[1];
-        }
       }
+    }
 
-    if(!macroName.empty())
-      {
+    if (!macroName.empty()) {
       this->Macros[macroName] = macroValue;
-      }
     }
-  else if(name == "Directories")
-    {
-    for(const char** attr = attributes; *attr; attr += 2)
-      {
-      if(strcmp(attr[0], "Include") == 0)
-        {
+  } else if (name == "Directories") {
+    for (const char** attr = attributes; *attr; attr += 2) {
+      if (strcmp(attr[0], "Include") == 0) {
         this->Include = attr[1];
-        }
-      else if(strcmp(attr[0], "Library") == 0)
-        {
+      } else if (strcmp(attr[0], "Library") == 0) {
         this->Library = attr[1];
-        }
-      else if(strcmp(attr[0], "Path") == 0)
-        {
+      } else if (strcmp(attr[0], "Path") == 0) {
         this->Path = attr[1];
-        }
       }
     }
+  }
 }
 
 void cmVisualStudioWCEPlatformParser::EndElement(const std::string& name)
 {
-  if(!this->RequiredName)
-    {
-    if(name == "PlatformName")
-      {
+  if (!this->RequiredName) {
+    if (name == "PlatformName") {
       this->AvailablePlatforms.push_back(this->CharacterData);
-      }
-    return;
     }
+    return;
+  }
 
-  if(this->FoundRequiredName)
-    {
+  if (this->FoundRequiredName) {
     return;
-    }
+  }
 
-  if(name == "PlatformName")
-    {
+  if (name == "PlatformName") {
     this->PlatformName = this->CharacterData;
-    }
-  else if(name == "OSMajorVersion")
-    {
+  } else if (name == "OSMajorVersion") {
     this->OSMajorVersion = this->CharacterData;
-    }
-  else if(name == "OSMinorVersion")
-   {
-   this->OSMinorVersion = this->CharacterData;
-   }
-  else if(name == "Platform")
-    {
-    if(this->PlatformName == this->RequiredName)
-      {
+  } else if (name == "OSMinorVersion") {
+    this->OSMinorVersion = this->CharacterData;
+  } else if (name == "Platform") {
+    if (this->PlatformName == this->RequiredName) {
       this->FoundRequiredName = true;
-      }
     }
+  }
 }
 
 void cmVisualStudioWCEPlatformParser::CharacterDataHandler(const char* data,
@@ -167,7 +135,7 @@ void cmVisualStudioWCEPlatformParser::CharacterDataHandler(const char* data,
 }
 
 std::string cmVisualStudioWCEPlatformParser::FixPaths(
-    const std::string& paths) const
+  const std::string& paths) const
 {
   std::string ret = paths;
   cmSystemTools::ReplaceString(ret, "$(PATH)", "%PATH%");
diff --git a/Source/cmVisualStudioWCEPlatformParser.h b/Source/cmVisualStudioWCEPlatformParser.h
index 14f8df8..2b20eba 100644
--- a/Source/cmVisualStudioWCEPlatformParser.h
+++ b/Source/cmVisualStudioWCEPlatformParser.h
@@ -22,24 +22,29 @@ class cmVisualStudioWCEPlatformParser : public cmXMLParser
 {
 public:
   cmVisualStudioWCEPlatformParser(const char* name = NULL)
-      : RequiredName(name)
-      , FoundRequiredName(false)
-    {
-    }
+    : RequiredName(name)
+    , FoundRequiredName(false)
+  {
+  }
 
   int ParseVersion(const char* version);
 
-  bool Found() const {return this->FoundRequiredName;}
+  bool Found() const { return this->FoundRequiredName; }
   const char* GetArchitectureFamily() const;
   std::string GetOSVersion() const;
-  std::string GetIncludeDirectories() const {
-    return this->FixPaths(this->Include); }
-  std::string GetLibraryDirectories() const {
-    return this->FixPaths(this->Library); }
-  std::string GetPathDirectories() const {
-    return this->FixPaths(this->Path); }
-  const std::vector<std::string>& GetAvailablePlatforms() const {
-    return this->AvailablePlatforms; }
+  std::string GetIncludeDirectories() const
+  {
+    return this->FixPaths(this->Include);
+  }
+  std::string GetLibraryDirectories() const
+  {
+    return this->FixPaths(this->Library);
+  }
+  std::string GetPathDirectories() const { return this->FixPaths(this->Path); }
+  const std::vector<std::string>& GetAvailablePlatforms() const
+  {
+    return this->AvailablePlatforms;
+  }
 
 protected:
   virtual void StartElement(const std::string& name, const char** attributes);
diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx
index 5fdccaa..bec2861 100644
--- a/Source/cmWhileCommand.cxx
+++ b/Source/cmWhileCommand.cxx
@@ -13,8 +13,9 @@
 
 #include "cmConditionEvaluator.h"
 
-cmWhileFunctionBlocker::cmWhileFunctionBlocker(cmMakefile* mf):
-  Makefile(mf), Depth(0)
+cmWhileFunctionBlocker::cmWhileFunctionBlocker(cmMakefile* mf)
+  : Makefile(mf)
+  , Depth(0)
 {
   this->Makefile->PushLoopBlock();
 }
@@ -24,25 +25,23 @@ cmWhileFunctionBlocker::~cmWhileFunctionBlocker()
   this->Makefile->PopLoopBlock();
 }
 
-bool cmWhileFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
-                  cmExecutionStatus &inStatus)
+bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
+                                               cmMakefile& mf,
+                                               cmExecutionStatus& inStatus)
 {
   // at end of for each execute recorded commands
-  if (!cmSystemTools::Strucmp(lff.Name.c_str(),"while"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "while")) {
     // record the number of while commands past this one
     this->Depth++;
-    }
-  else if (!cmSystemTools::Strucmp(lff.Name.c_str(),"endwhile"))
-    {
+  } else if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endwhile")) {
     // if this is the endwhile for this while loop then execute
-    if (!this->Depth)
-      {
+    if (!this->Depth) {
       // Remove the function blocker for this scope or bail.
-      cmsys::auto_ptr<cmFunctionBlocker>
-        fb(mf.RemoveFunctionBlocker(this, lff));
-      if(!fb.get()) { return false; }
+      cmsys::auto_ptr<cmFunctionBlocker> fb(
+        mf.RemoveFunctionBlocker(this, lff));
+      if (!fb.get()) {
+        return false;
+      }
 
       std::string errorString;
 
@@ -56,74 +55,61 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
       commandContext.Line = execContext.Line;
       commandContext.Name = execContext.Name;
 
-      cmConditionEvaluator conditionEvaluator(
-            mf,
-            this->GetStartingContext(),
-            mf.GetBacktrace(commandContext));
+      cmConditionEvaluator conditionEvaluator(mf, this->GetStartingContext(),
+                                              mf.GetBacktrace(commandContext));
 
-      bool isTrue = conditionEvaluator.IsTrue(
-        expandedArguments, errorString, messageType);
+      bool isTrue =
+        conditionEvaluator.IsTrue(expandedArguments, errorString, messageType);
 
-      while (isTrue)
-        {
-        if (!errorString.empty())
-          {
+      while (isTrue) {
+        if (!errorString.empty()) {
           std::string err = "had incorrect arguments: ";
           unsigned int i;
-          for(i =0; i < this->Args.size(); ++i)
-            {
-            err += (this->Args[i].Delim?"\"":"");
+          for (i = 0; i < this->Args.size(); ++i) {
+            err += (this->Args[i].Delim ? "\"" : "");
             err += this->Args[i].Value;
-            err += (this->Args[i].Delim?"\"":"");
+            err += (this->Args[i].Delim ? "\"" : "");
             err += " ";
-            }
+          }
           err += "(";
           err += errorString;
           err += ").";
           mf.IssueMessage(messageType, err);
-          if (messageType == cmake::FATAL_ERROR)
-            {
+          if (messageType == cmake::FATAL_ERROR) {
             cmSystemTools::SetFatalErrorOccured();
             return true;
-            }
           }
+        }
 
         // Invoke all the functions that were collected in the block.
-        for(unsigned int c = 0; c < this->Functions.size(); ++c)
-          {
+        for (unsigned int c = 0; c < this->Functions.size(); ++c) {
           cmExecutionStatus status;
-          mf.ExecuteCommand(this->Functions[c],status);
-          if (status.GetReturnInvoked())
-            {
+          mf.ExecuteCommand(this->Functions[c], status);
+          if (status.GetReturnInvoked()) {
             inStatus.SetReturnInvoked(true);
             return true;
-            }
-          if (status.GetBreakInvoked())
-            {
+          }
+          if (status.GetBreakInvoked()) {
             return true;
-            }
-          if (status.GetContinueInvoked())
-            {
+          }
+          if (status.GetContinueInvoked()) {
             break;
-            }
-          if(cmSystemTools::GetFatalErrorOccured() )
-            {
+          }
+          if (cmSystemTools::GetFatalErrorOccured()) {
             return true;
-            }
           }
+        }
         expandedArguments.clear();
         mf.ExpandArguments(this->Args, expandedArguments);
-        isTrue = conditionEvaluator.IsTrue(
-          expandedArguments, errorString, messageType);
-        }
-      return true;
+        isTrue = conditionEvaluator.IsTrue(expandedArguments, errorString,
+                                           messageType);
       }
-    else
-      {
+      return true;
+    } else {
       // decrement for each nested while that ends
       this->Depth--;
-      }
     }
+  }
 
   // record the command
   this->Functions.push_back(lff);
@@ -132,37 +118,31 @@ IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf,
   return true;
 }
 
-bool cmWhileFunctionBlocker::
-ShouldRemove(const cmListFileFunction& lff, cmMakefile& )
+bool cmWhileFunctionBlocker::ShouldRemove(const cmListFileFunction& lff,
+                                          cmMakefile&)
 {
-  if(!cmSystemTools::Strucmp(lff.Name.c_str(),"endwhile"))
-    {
+  if (!cmSystemTools::Strucmp(lff.Name.c_str(), "endwhile")) {
     // if the endwhile has arguments, then make sure
     // they match the arguments of the matching while
-    if (lff.Arguments.empty() ||
-        lff.Arguments == this->Args)
-      {
+    if (lff.Arguments.empty() || lff.Arguments == this->Args) {
       return true;
-      }
     }
+  }
   return false;
 }
 
-bool cmWhileCommand
-::InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                    cmExecutionStatus &)
+bool cmWhileCommand::InvokeInitialPass(
+  const std::vector<cmListFileArgument>& args, cmExecutionStatus&)
 {
-  if(args.size() < 1)
-    {
+  if (args.size() < 1) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
 
   // create a function blocker
-  cmWhileFunctionBlocker *f = new cmWhileFunctionBlocker(this->Makefile);
+  cmWhileFunctionBlocker* f = new cmWhileFunctionBlocker(this->Makefile);
   f->Args = args;
   this->Makefile->AddFunctionBlocker(f);
 
   return true;
 }
-
diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h
index 902c55a..0f35be8 100644
--- a/Source/cmWhileCommand.h
+++ b/Source/cmWhileCommand.h
@@ -22,13 +22,13 @@ class cmWhileFunctionBlocker : public cmFunctionBlocker
 public:
   cmWhileFunctionBlocker(cmMakefile* mf);
   ~cmWhileFunctionBlocker();
-  virtual bool IsFunctionBlocked(const cmListFileFunction& lff,
-                                 cmMakefile &mf,
-                                 cmExecutionStatus &);
-  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
+  virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
+                                 cmExecutionStatus&);
+  virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf);
 
   std::vector<cmListFileArgument> Args;
   std::vector<cmListFileFunction> Functions;
+
 private:
   cmMakefile* Makefile;
   int Depth;
@@ -41,24 +41,23 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmWhileCommand;
-    }
+  virtual cmCommand* Clone() { return new cmWhileCommand; }
 
   /**
    * This overrides the default InvokeInitialPass implementation.
    * It records the arguments before expansion.
    */
   virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args,
-                                 cmExecutionStatus &);
+                                 cmExecutionStatus&);
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
-  virtual bool InitialPass(std::vector<std::string> const&,
-                           cmExecutionStatus &) { return false; }
+  virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&)
+  {
+    return false;
+  }
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -68,10 +67,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "while";}
+  virtual std::string GetName() const { return "while"; }
 
   cmTypeMacro(cmWhileCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmWriteFileCommand.cxx b/Source/cmWriteFileCommand.cxx
index c4468f3..3966d38 100644
--- a/Source/cmWriteFileCommand.cxx
+++ b/Source/cmWriteFileCommand.cxx
@@ -18,14 +18,13 @@
 #include <sys/stat.h>
 
 // cmLibraryCommand
-bool cmWriteFileCommand
-::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+bool cmWriteFileCommand::InitialPass(std::vector<std::string> const& args,
+                                     cmExecutionStatus&)
 {
-  if(args.size() < 2 )
-    {
+  if (args.size() < 2) {
     this->SetError("called with incorrect number of arguments");
     return false;
-    }
+  }
   std::string message;
   std::vector<std::string>::const_iterator i = args.begin();
 
@@ -33,26 +32,21 @@ bool cmWriteFileCommand
   bool overwrite = true;
   i++;
 
-  for(;i != args.end(); ++i)
-    {
-    if ( *i == "APPEND" )
-      {
+  for (; i != args.end(); ++i) {
+    if (*i == "APPEND") {
       overwrite = false;
-      }
-    else
-      {
+    } else {
       message += *i;
-      }
     }
+  }
 
-  if ( !this->Makefile->CanIWriteThisFile(fileName.c_str()) )
-    {
-    std::string e = "attempted to write a file: " + fileName
-      + " into a source directory.";
+  if (!this->Makefile->CanIWriteThisFile(fileName.c_str())) {
+    std::string e =
+      "attempted to write a file: " + fileName + " into a source directory.";
     this->SetError(e);
     cmSystemTools::SetFatalErrorOccured();
     return false;
-    }
+  }
 
   std::string dir = cmSystemTools::GetFilenamePath(fileName);
   cmSystemTools::MakeDirectory(dir.c_str());
@@ -60,35 +54,31 @@ bool cmWriteFileCommand
   mode_t mode = 0;
 
   // Set permissions to writable
-  if ( cmSystemTools::GetPermissions(fileName.c_str(), mode) )
-    {
+  if (cmSystemTools::GetPermissions(fileName.c_str(), mode)) {
     cmSystemTools::SetPermissions(fileName.c_str(),
-#if defined( _MSC_VER ) || defined( __MINGW32__ )
-      mode | S_IWRITE
+#if defined(_MSC_VER) || defined(__MINGW32__)
+                                  mode | S_IWRITE
 #else
-      mode | S_IWUSR | S_IWGRP
+                                  mode | S_IWUSR | S_IWGRP
 #endif
-    );
-    }
+                                  );
+  }
   // If GetPermissions fails, pretend like it is ok. File open will fail if
   // the file is not writable
   cmsys::ofstream file(fileName.c_str(),
-                     overwrite?std::ios::out : std::ios::app);
-  if ( !file )
-    {
+                       overwrite ? std::ios::out : std::ios::app);
+  if (!file) {
     std::string error = "Internal CMake error when trying to open file: ";
     error += fileName.c_str();
     error += " for writing.";
     this->SetError(error);
     return false;
-    }
+  }
   file << message << std::endl;
   file.close();
-  if(mode)
-    {
+  if (mode) {
     cmSystemTools::SetPermissions(fileName.c_str(), mode);
-    }
+  }
 
   return true;
 }
-
diff --git a/Source/cmWriteFileCommand.h b/Source/cmWriteFileCommand.h
index 89dc9ff..b0eef9c 100644
--- a/Source/cmWriteFileCommand.h
+++ b/Source/cmWriteFileCommand.h
@@ -24,17 +24,14 @@ public:
   /**
    * This is a virtual constructor for the command.
    */
-  virtual cmCommand* Clone()
-    {
-    return new cmWriteFileCommand;
-    }
+  virtual cmCommand* Clone() { return new cmWriteFileCommand; }
 
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
   virtual bool InitialPass(std::vector<std::string> const& args,
-                           cmExecutionStatus &status);
+                           cmExecutionStatus& status);
 
   /**
    * This determines if the command is invoked when in script mode.
@@ -44,10 +41,9 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual std::string GetName() const { return "write_file";}
+  virtual std::string GetName() const { return "write_file"; }
 
   cmTypeMacro(cmWriteFileCommand, cmCommand);
 };
 
-
 #endif
diff --git a/Source/cmXCode21Object.cxx b/Source/cmXCode21Object.cxx
index b47e302..1abdf66 100644
--- a/Source/cmXCode21Object.cxx
+++ b/Source/cmXCode21Object.cxx
@@ -14,26 +14,23 @@
 #include "cmSystemTools.h"
 
 cmXCode21Object::cmXCode21Object(PBXType ptype, Type type)
-  :cmXCodeObject(ptype, type)
+  : cmXCodeObject(ptype, type)
 {
   this->Version = 21;
 }
 
 void cmXCode21Object::PrintComment(std::ostream& out)
 {
-  if(this->Comment.empty())
-    {
+  if (this->Comment.empty()) {
     cmXCodeObject* n = this->GetObject("name");
-    if(n)
-      {
+    if (n) {
       this->Comment = n->GetString();
       cmSystemTools::ReplaceString(this->Comment, "\"", "");
-      }
     }
-  if(this->Comment.empty())
-    {
+  }
+  if (this->Comment.empty()) {
     return;
-    }
+  }
   out << " /* ";
   out << this->Comment;
   out << " */";
@@ -43,31 +40,26 @@ void cmXCode21Object::PrintList(std::vector<cmXCodeObject*> const& v,
                                 std::ostream& out, PBXType t)
 {
   bool hasOne = false;
-  for(std::vector<cmXCodeObject*>::const_iterator i = v.begin();
-      i != v.end(); ++i)
-    {
+  for (std::vector<cmXCodeObject*>::const_iterator i = v.begin(); i != v.end();
+       ++i) {
     cmXCodeObject* obj = *i;
-    if(obj->GetType() == OBJECT && obj->GetIsA() == t)
-      {
+    if (obj->GetType() == OBJECT && obj->GetIsA() == t) {
       hasOne = true;
       break;
-      }
     }
-  if(!hasOne)
-    {
+  }
+  if (!hasOne) {
     return;
-    }
-  out << "\n/* Begin " <<  PBXTypeNames[t] << " section */\n";
-  for(std::vector<cmXCodeObject*>::const_iterator i = v.begin();
-      i != v.end(); ++i)
-    {
+  }
+  out << "\n/* Begin " << PBXTypeNames[t] << " section */\n";
+  for (std::vector<cmXCodeObject*>::const_iterator i = v.begin(); i != v.end();
+       ++i) {
     cmXCodeObject* obj = *i;
-    if(obj->GetType() == OBJECT && obj->GetIsA() == t)
-      {
-        obj->Print(out);
-      }
+    if (obj->GetType() == OBJECT && obj->GetIsA() == t) {
+      obj->Print(out);
     }
-  out << "/* End " <<  PBXTypeNames[t] << " section */\n";
+  }
+  out << "/* End " << PBXTypeNames[t] << " section */\n";
 }
 
 void cmXCode21Object::PrintList(std::vector<cmXCodeObject*> const& v,
@@ -80,8 +72,7 @@ void cmXCode21Object::PrintList(std::vector<cmXCodeObject*> const& v,
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXBuildStyle);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXContainerItemProxy);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXFileReference);
-  cmXCode21Object::PrintList(v, out,
-                             cmXCode21Object::PBXFrameworksBuildPhase);
+  cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXFrameworksBuildPhase);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXGroup);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXHeadersBuildPhase);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXNativeTarget);
@@ -91,8 +82,7 @@ void cmXCode21Object::PrintList(std::vector<cmXCodeObject*> const& v,
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXResourcesBuildPhase);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXSourcesBuildPhase);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXCopyFilesBuildPhase);
-  cmXCode21Object::PrintList(v, out,
-                             cmXCode21Object::PBXApplicationReference);
+  cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXApplicationReference);
   cmXCode21Object::PrintList(v, out,
                              cmXCode21Object::PBXExecutableFileReference);
   cmXCode21Object::PrintList(v, out, cmXCode21Object::PBXLibraryReference);
diff --git a/Source/cmXCode21Object.h b/Source/cmXCode21Object.h
index cc3ab04..9e51e0d 100644
--- a/Source/cmXCode21Object.h
+++ b/Source/cmXCode21Object.h
@@ -19,10 +19,8 @@ class cmXCode21Object : public cmXCodeObject
 public:
   cmXCode21Object(PBXType ptype, Type type);
   virtual void PrintComment(std::ostream&);
-  static void PrintList(std::vector<cmXCodeObject*> const&,
-                        std::ostream& out,
+  static void PrintList(std::vector<cmXCodeObject*> const&, std::ostream& out,
                         PBXType t);
-  static void PrintList(std::vector<cmXCodeObject*> const&,
-                        std::ostream& out);
+  static void PrintList(std::vector<cmXCodeObject*> const&, std::ostream& out);
 };
 #endif
diff --git a/Source/cmXCodeObject.cxx b/Source/cmXCodeObject.cxx
index 6a6c253..3d31343 100644
--- a/Source/cmXCodeObject.cxx
+++ b/Source/cmXCodeObject.cxx
@@ -17,17 +17,30 @@
 
 const char* cmXCodeObject::PBXTypeNames[] = {
   /* clang-format needs this comment to break after the opening brace */
-    "PBXGroup", "PBXBuildStyle", "PBXProject", "PBXHeadersBuildPhase",
-    "PBXSourcesBuildPhase", "PBXFrameworksBuildPhase", "PBXNativeTarget",
-    "PBXFileReference", "PBXBuildFile", "PBXContainerItemProxy",
-    "PBXTargetDependency", "PBXShellScriptBuildPhase",
-    "PBXResourcesBuildPhase", "PBXApplicationReference",
-    "PBXExecutableFileReference", "PBXLibraryReference", "PBXToolTarget",
-    "PBXLibraryTarget", "PBXAggregateTarget", "XCBuildConfiguration",
-    "XCConfigurationList",
-    "PBXCopyFilesBuildPhase",
-    "None"
-  };
+  "PBXGroup",
+  "PBXBuildStyle",
+  "PBXProject",
+  "PBXHeadersBuildPhase",
+  "PBXSourcesBuildPhase",
+  "PBXFrameworksBuildPhase",
+  "PBXNativeTarget",
+  "PBXFileReference",
+  "PBXBuildFile",
+  "PBXContainerItemProxy",
+  "PBXTargetDependency",
+  "PBXShellScriptBuildPhase",
+  "PBXResourcesBuildPhase",
+  "PBXApplicationReference",
+  "PBXExecutableFileReference",
+  "PBXLibraryReference",
+  "PBXToolTarget",
+  "PBXLibraryTarget",
+  "PBXAggregateTarget",
+  "XCBuildConfiguration",
+  "XCConfigurationList",
+  "PBXCopyFilesBuildPhase",
+  "None"
+};
 
 cmXCodeObject::~cmXCodeObject()
 {
@@ -38,82 +51,73 @@ cmXCodeObject::cmXCodeObject(PBXType ptype, Type type)
 {
   this->Version = 15;
   this->Target = 0;
-  this->Object =0;
+  this->Object = 0;
 
   this->IsA = ptype;
 
-  if(type == OBJECT)
-    {
+  if (type == OBJECT) {
     // Set the Id of an Xcode object to a unique string for each instance.
     // However the Xcode user file references certain Ids: for those cases,
     // override the generated Id using SetId().
     //
-    char cUuid[40] = {0};
+    char cUuid[40] = { 0 };
     CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);
     CFStringRef s = CFUUIDCreateString(kCFAllocatorDefault, uuid);
     CFStringGetCString(s, cUuid, sizeof(cUuid), kCFStringEncodingUTF8);
     this->Id = cUuid;
     CFRelease(s);
     CFRelease(uuid);
-    }
-  else
-    {
+  } else {
     this->Id =
       "Temporary cmake object, should not be referred to in Xcode file";
-    }
+  }
 
   cmSystemTools::ReplaceString(this->Id, "-", "");
-  if(this->Id.size() > 24)
-    {
+  if (this->Id.size() > 24) {
     this->Id = this->Id.substr(0, 24);
-    }
+  }
 
   this->TypeValue = type;
-  if(this->TypeValue == OBJECT)
-    {
+  if (this->TypeValue == OBJECT) {
     this->AddAttribute("isa", 0);
-    }
+  }
 }
 
 void cmXCodeObject::Indent(int level, std::ostream& out)
 {
-  while(level)
-    {
+  while (level) {
     out << "\t";
     level--;
-    }
+  }
 }
 
 void cmXCodeObject::Print(std::ostream& out)
 {
   std::string separator = "\n";
   int indentFactor = 1;
-  cmXCodeObject::Indent(2*indentFactor, out);
-  if(this->Version > 15
-     && (this->IsA == PBXFileReference || this->IsA == PBXBuildFile))
-    {
+  cmXCodeObject::Indent(2 * indentFactor, out);
+  if (this->Version > 15 &&
+      (this->IsA == PBXFileReference || this->IsA == PBXBuildFile)) {
     separator = " ";
     indentFactor = 0;
-    }
+  }
   out << this->Id;
   this->PrintComment(out);
   out << " = {";
-  if(separator == "\n")
-    {
+  if (separator == "\n") {
     out << separator;
-    }
+  }
   std::map<std::string, cmXCodeObject*>::iterator i;
-  cmXCodeObject::Indent(3*indentFactor, out);
-  out << "isa = " << PBXTypeNames[this->IsA]  << ";" << separator;
-  for(i = this->ObjectAttributes.begin();
-      i != this->ObjectAttributes.end(); ++i)
-    {
-    if(i->first == "isa")
+  cmXCodeObject::Indent(3 * indentFactor, out);
+  out << "isa = " << PBXTypeNames[this->IsA] << ";" << separator;
+  for (i = this->ObjectAttributes.begin(); i != this->ObjectAttributes.end();
+       ++i) {
+    if (i->first == "isa")
       continue;
 
     PrintAttribute(out, 3, separator, indentFactor, i->first, i->second, this);
-    }
-  cmXCodeObject::Indent(2*indentFactor, out);
+  }
+  cmXCodeObject::Indent(2 * indentFactor, out);
   out << "};\n";
 }
 
@@ -124,86 +128,66 @@ void cmXCodeObject::PrintAttribute(std::ostream& out, const int level,
                                    const cmXCodeObject* parent)
 {
   cmXCodeObject::Indent(level * factor, out);
-  switch(object->TypeValue)
-    {
-    case OBJECT_LIST:
-      {
+  switch (object->TypeValue) {
+    case OBJECT_LIST: {
       out << name << " = (";
-      if(parent->TypeValue != ATTRIBUTE_GROUP)
-        {
+      if (parent->TypeValue != ATTRIBUTE_GROUP) {
         out << separator;
-        }
-      for(unsigned int i = 0; i < object->List.size(); ++i)
-        {
-        if(object->List[i]->TypeValue == STRING)
-          {
+      }
+      for (unsigned int i = 0; i < object->List.size(); ++i) {
+        if (object->List[i]->TypeValue == STRING) {
           object->List[i]->PrintString(out);
-          if(i+1 < object->List.size())
-            {
+          if (i + 1 < object->List.size()) {
             out << ",";
-            }
           }
-        else
-          {
+        } else {
           cmXCodeObject::Indent((level + 1) * factor, out);
           out << object->List[i]->Id;
           object->List[i]->PrintComment(out);
           out << "," << separator;
-          }
         }
-      if(parent->TypeValue != ATTRIBUTE_GROUP)
-        {
+      }
+      if (parent->TypeValue != ATTRIBUTE_GROUP) {
         cmXCodeObject::Indent(level * factor, out);
-        }
-      out << ");" << separator;
       }
-      break;
+      out << ");" << separator;
+    } break;
 
-    case ATTRIBUTE_GROUP:
-      {
+    case ATTRIBUTE_GROUP: {
       out << name << " = {";
-      if(separator == "\n")
-        {
+      if (separator == "\n") {
         out << separator;
-        }
+      }
       std::map<std::string, cmXCodeObject*>::const_iterator i;
-      for(i = object->ObjectAttributes.begin();
-          i != object->ObjectAttributes.end(); ++i)
-        {
-        PrintAttribute(out, (level + 1) * factor, separator, factor,
-                       i->first, i->second, object);
-        }
+      for (i = object->ObjectAttributes.begin();
+           i != object->ObjectAttributes.end(); ++i) {
+        PrintAttribute(out, (level + 1) * factor, separator, factor, i->first,
+                       i->second, object);
+      }
       cmXCodeObject::Indent(level * factor, out);
       out << "};" << separator;
-      }
-      break;
+    } break;
 
-    case OBJECT_REF:
-      {
+    case OBJECT_REF: {
       cmXCodeObject::PrintString(out, name);
       out << " = " << object->Object->Id;
-      if(object->Object->HasComment() && name != "remoteGlobalIDString")
-        {
+      if (object->Object->HasComment() && name != "remoteGlobalIDString") {
         object->Object->PrintComment(out);
-        }
-      out << ";" << separator;
       }
-      break;
+      out << ";" << separator;
+    } break;
 
-    case STRING:
-      {
+    case STRING: {
       cmXCodeObject::PrintString(out, name);
       out << " = ";
       object->PrintString(out);
       out << ";" << separator;
-      }
-      break;
+    } break;
 
-    default:
-      {
+    default: {
       break;
-      }
     }
+  }
 }
 
 void cmXCodeObject::PrintList(std::vector<cmXCodeObject*> const& objs,
@@ -211,13 +195,11 @@ void cmXCodeObject::PrintList(std::vector<cmXCodeObject*> const& objs,
 {
   cmXCodeObject::Indent(1, out);
   out << "objects = {\n";
-  for(unsigned int i = 0; i < objs.size(); ++i)
-    {
-    if(objs[i]->TypeValue == OBJECT)
-      {
+  for (unsigned int i = 0; i < objs.size(); ++i) {
+    if (objs[i]->TypeValue == OBJECT) {
       objs[i]->Print(out);
-      }
     }
+  }
   cmXCodeObject::Indent(1, out);
   out << "};\n";
 }
@@ -230,38 +212,33 @@ void cmXCodeObject::CopyAttributes(cmXCodeObject* copy)
   this->Object = copy->Object;
 }
 
-void cmXCodeObject::PrintString(std::ostream& os,std::string String)
+void cmXCodeObject::PrintString(std::ostream& os, std::string String)
 {
   // The string needs to be quoted if it contains any characters
   // considered special by the Xcode project file parser.
-  bool needQuote =
-    (String.empty() ||
-     String.find("//") != String.npos ||
-     String.find_first_not_of(
-       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-       "abcdefghijklmnopqrstuvwxyz"
-       "0123456789"
-       "$_./") != String.npos);
-  const char* quote = needQuote? "\"" : "";
+  bool needQuote = (String.empty() || String.find("//") != String.npos ||
+                    String.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                             "abcdefghijklmnopqrstuvwxyz"
+                                             "0123456789"
+                                             "$_./") != String.npos);
+  const char* quote = needQuote ? "\"" : "";
 
   // Print the string, quoted and escaped as necessary.
   os << quote;
-  for(std::string::const_iterator i = String.begin();
-      i != String.end(); ++i)
-    {
-    if(*i == '"' || *i == '\\')
-      {
+  for (std::string::const_iterator i = String.begin(); i != String.end();
+       ++i) {
+    if (*i == '"' || *i == '\\') {
       // Escape double-quotes and backslashes.
       os << '\\';
-      }
-    os << *i;
     }
+    os << *i;
+  }
   os << quote;
 }
 
 void cmXCodeObject::PrintString(std::ostream& os) const
 {
-  cmXCodeObject::PrintString(os,this->String);
+  cmXCodeObject::PrintString(os, this->String);
 }
 
 void cmXCodeObject::SetString(const std::string& s)
diff --git a/Source/cmXCodeObject.h b/Source/cmXCodeObject.h
index d00cf0f..d2f7cb7 100644
--- a/Source/cmXCodeObject.h
+++ b/Source/cmXCodeObject.h
@@ -19,60 +19,71 @@ class cmGeneratorTarget;
 class cmXCodeObject
 {
 public:
-  enum Type { OBJECT_LIST, STRING, ATTRIBUTE_GROUP, OBJECT_REF, OBJECT };
-  enum PBXType { PBXGroup, PBXBuildStyle, PBXProject, PBXHeadersBuildPhase,
-                 PBXSourcesBuildPhase, PBXFrameworksBuildPhase,
-                 PBXNativeTarget, PBXFileReference, PBXBuildFile,
-                 PBXContainerItemProxy, PBXTargetDependency,
-                 PBXShellScriptBuildPhase, PBXResourcesBuildPhase,
-                 PBXApplicationReference, PBXExecutableFileReference,
-                 PBXLibraryReference, PBXToolTarget, PBXLibraryTarget,
-                 PBXAggregateTarget,XCBuildConfiguration,XCConfigurationList,
-                 PBXCopyFilesBuildPhase,
-                 None
+  enum Type
+  {
+    OBJECT_LIST,
+    STRING,
+    ATTRIBUTE_GROUP,
+    OBJECT_REF,
+    OBJECT
+  };
+  enum PBXType
+  {
+    PBXGroup,
+    PBXBuildStyle,
+    PBXProject,
+    PBXHeadersBuildPhase,
+    PBXSourcesBuildPhase,
+    PBXFrameworksBuildPhase,
+    PBXNativeTarget,
+    PBXFileReference,
+    PBXBuildFile,
+    PBXContainerItemProxy,
+    PBXTargetDependency,
+    PBXShellScriptBuildPhase,
+    PBXResourcesBuildPhase,
+    PBXApplicationReference,
+    PBXExecutableFileReference,
+    PBXLibraryReference,
+    PBXToolTarget,
+    PBXLibraryTarget,
+    PBXAggregateTarget,
+    XCBuildConfiguration,
+    XCConfigurationList,
+    PBXCopyFilesBuildPhase,
+    None
+  };
+  class StringVec : public std::vector<std::string>
+  {
   };
-  class StringVec: public std::vector<std::string> {};
   static const char* PBXTypeNames[];
   virtual ~cmXCodeObject();
   cmXCodeObject(PBXType ptype, Type type);
-  Type GetType() { return this->TypeValue;}
-  PBXType GetIsA() { return this->IsA;}
+  Type GetType() { return this->TypeValue; }
+  PBXType GetIsA() { return this->IsA; }
 
   void SetString(const std::string& s);
-  const std::string& GetString()
-    {
-      return this->String;
-    }
+  const std::string& GetString() { return this->String; }
 
   void AddAttribute(const std::string& name, cmXCodeObject* value)
-    {
-      this->ObjectAttributes[name] = value;
-    }
+  {
+    this->ObjectAttributes[name] = value;
+  }
 
-  void SetObject(cmXCodeObject* value)
-    {
-      this->Object = value;
-    }
-  cmXCodeObject* GetObject()
-    {
-      return this->Object;
-    }
-  void AddObject(cmXCodeObject* value)
-    {
-      this->List.push_back(value);
-    }
+  void SetObject(cmXCodeObject* value) { this->Object = value; }
+  cmXCodeObject* GetObject() { return this->Object; }
+  void AddObject(cmXCodeObject* value) { this->List.push_back(value); }
   bool HasObject(cmXCodeObject* o)
   {
-    return !(std::find(this->List.begin(), this->List.end(), o)
-             == this->List.end());
+    return !(std::find(this->List.begin(), this->List.end(), o) ==
+             this->List.end());
   }
   void AddUniqueObject(cmXCodeObject* value)
   {
-    if(std::find(this->List.begin(), this->List.end(), value)
-       == this->List.end())
-      {
+    if (std::find(this->List.begin(), this->List.end(), value) ==
+        this->List.end()) {
       this->List.push_back(value);
-      }
+    }
   }
   static void Indent(int level, std::ostream& out);
   void Print(std::ostream& out);
@@ -82,72 +93,55 @@ public:
                       const cmXCodeObject* parent);
   virtual void PrintComment(std::ostream&) {}
 
-  static void PrintList(std::vector<cmXCodeObject*> const&,
-                        std::ostream& out);
-  const std::string& GetId()
-    {
-      return this->Id;
-    }
-  void SetId(const std::string& id)
-    {
-      this->Id = id;
-    }
-  cmGeneratorTarget* GetTarget()
-    {
-      return this->Target;
-    }
-  void SetTarget(cmGeneratorTarget* t)
-    {
-      this->Target = t;
-    }
-  const std::string& GetComment() {return this->Comment;}
-  bool HasComment() { return (!this->Comment.empty());}
+  static void PrintList(std::vector<cmXCodeObject*> const&, std::ostream& out);
+  const std::string& GetId() { return this->Id; }
+  void SetId(const std::string& id) { this->Id = id; }
+  cmGeneratorTarget* GetTarget() { return this->Target; }
+  void SetTarget(cmGeneratorTarget* t) { this->Target = t; }
+  const std::string& GetComment() { return this->Comment; }
+  bool HasComment() { return (!this->Comment.empty()); }
   cmXCodeObject* GetObject(const char* name)
-    {
-      if(this->ObjectAttributes.count(name))
-        {
-        return this->ObjectAttributes[name];
-        }
-      return 0;
+  {
+    if (this->ObjectAttributes.count(name)) {
+      return this->ObjectAttributes[name];
     }
+    return 0;
+  }
   // search the attribute list for an object of the specified type
   cmXCodeObject* GetObject(cmXCodeObject::PBXType t)
-    {
-      for(std::vector<cmXCodeObject*>::iterator i = this->List.begin();
-          i != this->List.end(); ++i)
-        {
-        cmXCodeObject* o = *i;
-        if(o->IsA == t)
-          {
-          return o;
-          }
-        }
-      return 0;
+  {
+    for (std::vector<cmXCodeObject*>::iterator i = this->List.begin();
+         i != this->List.end(); ++i) {
+      cmXCodeObject* o = *i;
+      if (o->IsA == t) {
+        return o;
+      }
     }
+    return 0;
+  }
 
-  void CopyAttributes(cmXCodeObject* );
+  void CopyAttributes(cmXCodeObject*);
 
-  void AddDependLibrary(const std::string& configName,
-                        const std::string& l)
-    {
-      this->DependLibraries[configName].push_back(l);
-    }
+  void AddDependLibrary(const std::string& configName, const std::string& l)
+  {
+    this->DependLibraries[configName].push_back(l);
+  }
   std::map<std::string, StringVec> const& GetDependLibraries()
-    {
-      return this->DependLibraries;
-    }
-  void AddDependTarget(const std::string& configName,
-                       const std::string& tName)
-    {
-      this->DependTargets[configName].push_back(tName);
-    }
+  {
+    return this->DependLibraries;
+  }
+  void AddDependTarget(const std::string& configName, const std::string& tName)
+  {
+    this->DependTargets[configName].push_back(tName);
+  }
   std::map<std::string, StringVec> const& GetDependTargets()
-    {
+  {
     return this->DependTargets;
-    }
-  std::vector<cmXCodeObject*> const& GetObjectList() { return this->List;}
-  void SetComment(const std::string& c) { this->Comment = c;}
-  static void PrintString(std::ostream& os,std::string String);
+  }
+  std::vector<cmXCodeObject*> const& GetObjectList() { return this->List; }
+  void SetComment(const std::string& c) { this->Comment = c; }
+  static void PrintString(std::ostream& os, std::string String);
+
 protected:
   void PrintString(std::ostream& os) const;
 
diff --git a/Source/cmXMLParser.cxx b/Source/cmXMLParser.cxx
index e2f7afa..5e06d36 100644
--- a/Source/cmXMLParser.cxx
+++ b/Source/cmXMLParser.cxx
@@ -26,31 +26,27 @@ cmXMLParser::cmXMLParser()
 
 cmXMLParser::~cmXMLParser()
 {
-  if ( this->Parser )
-    {
+  if (this->Parser) {
     this->CleanupParser();
-    }
+  }
 }
 
 int cmXMLParser::Parse(const char* string)
 {
   return (int)this->InitializeParser() &&
-    this->ParseChunk(string, strlen(string)) &&
-    this->CleanupParser();
+    this->ParseChunk(string, strlen(string)) && this->CleanupParser();
 }
 
 int cmXMLParser::ParseFile(const char* file)
 {
-  if ( !file )
-    {
+  if (!file) {
     return 0;
-    }
+  }
 
   cmsys::ifstream ifs(file);
-  if ( !ifs )
-    {
+  if (!ifs) {
     return 0;
-    }
+  }
 
   std::ostringstream str;
   str << ifs.rdbuf();
@@ -59,18 +55,16 @@ int cmXMLParser::ParseFile(const char* file)
 
 int cmXMLParser::InitializeParser()
 {
-  if ( this->Parser )
-    {
+  if (this->Parser) {
     std::cerr << "Parser already initialized" << std::endl;
     this->ParseError = 1;
     return 0;
-    }
+  }
 
   // Create the expat XML parser.
   this->Parser = XML_ParserCreate(0);
   XML_SetElementHandler(static_cast<XML_Parser>(this->Parser),
-                        &cmXMLParserStartElement,
-                        &cmXMLParserEndElement);
+                        &cmXMLParserStartElement, &cmXMLParserEndElement);
   XML_SetCharacterDataHandler(static_cast<XML_Parser>(this->Parser),
                               &cmXMLParserCharacterDataHandler);
   XML_SetUserData(static_cast<XML_Parser>(this->Parser), this);
@@ -81,39 +75,34 @@ int cmXMLParser::InitializeParser()
 int cmXMLParser::ParseChunk(const char* inputString,
                             std::string::size_type length)
 {
-  if ( !this->Parser )
-    {
+  if (!this->Parser) {
     std::cerr << "Parser not initialized" << std::endl;
     this->ParseError = 1;
     return 0;
-    }
+  }
   int res;
   res = this->ParseBuffer(inputString, length);
-  if ( res == 0 )
-    {
+  if (res == 0) {
     this->ParseError = 1;
-    }
+  }
   return res;
 }
 
 int cmXMLParser::CleanupParser()
 {
-  if ( !this->Parser )
-    {
+  if (!this->Parser) {
     std::cerr << "Parser not initialized" << std::endl;
     this->ParseError = 1;
     return 0;
-    }
+  }
   int result = !this->ParseError;
-  if(result)
-    {
+  if (result) {
     // Tell the expat XML parser about the end-of-input.
-    if(!XML_Parse(static_cast<XML_Parser>(this->Parser), "", 0, 1))
-      {
+    if (!XML_Parse(static_cast<XML_Parser>(this->Parser), "", 0, 1)) {
       this->ReportXmlParseError();
       result = 0;
-      }
     }
+  }
 
   // Clean up the parser.
   XML_ParserFree(static_cast<XML_Parser>(this->Parser));
@@ -125,12 +114,11 @@ int cmXMLParser::CleanupParser()
 int cmXMLParser::ParseBuffer(const char* buffer, std::string::size_type count)
 {
   // Pass the buffer to the expat XML parser.
-  if(!XML_Parse(static_cast<XML_Parser>(this->Parser), buffer,
-                static_cast<int>(count), 0))
-    {
+  if (!XML_Parse(static_cast<XML_Parser>(this->Parser), buffer,
+                 static_cast<int>(count), 0)) {
     this->ReportXmlParseError();
     return 0;
-    }
+  }
   return 1;
 }
 
@@ -145,8 +133,7 @@ int cmXMLParser::ParsingComplete()
   return 0;
 }
 
-void cmXMLParser::StartElement(const std::string& name,
-  const char ** /*atts*/)
+void cmXMLParser::StartElement(const std::string& name, const char** /*atts*/)
 {
   std::cout << "Start element: " << name << std::endl;
 }
@@ -157,7 +144,7 @@ void cmXMLParser::EndElement(const std::string& name)
 }
 
 void cmXMLParser::CharacterDataHandler(const char* /*inData*/,
-  int /*inLength*/)
+                                       int /*inLength*/)
 {
 }
 
@@ -169,21 +156,17 @@ int cmXMLParser::IsSpace(char c)
 const char* cmXMLParser::FindAttribute(const char** atts,
                                        const char* attribute)
 {
-  if(atts && attribute)
-    {
-    for(const char** a = atts; *a && *(a+1); a += 2)
-      {
-      if(strcmp(*a, attribute) == 0)
-        {
-        return *(a+1);
-        }
+  if (atts && attribute) {
+    for (const char** a = atts; *a && *(a + 1); a += 2) {
+      if (strcmp(*a, attribute) == 0) {
+        return *(a + 1);
       }
     }
+  }
   return 0;
 }
 
-void cmXMLParserStartElement(void* parser, const char *name,
-                              const char **atts)
+void cmXMLParserStartElement(void* parser, const char* name, const char** atts)
 {
   // Begin element handler that is registered with the XML_Parser.
   // This just casts the user data to a cmXMLParser and calls
@@ -191,7 +174,7 @@ void cmXMLParserStartElement(void* parser, const char *name,
   static_cast<cmXMLParser*>(parser)->StartElement(name, atts);
 }
 
-void cmXMLParserEndElement(void* parser, const char *name)
+void cmXMLParserEndElement(void* parser, const char* name)
 {
   // End element handler that is registered with the XML_Parser.  This
   // just casts the user data to a cmXMLParser and calls EndElement.
@@ -199,7 +182,7 @@ void cmXMLParserEndElement(void* parser, const char *name)
 }
 
 void cmXMLParserCharacterDataHandler(void* parser, const char* data,
-                                      int length)
+                                     int length)
 {
   // Character data handler that is registered with the XML_Parser.
   // This just casts the user data to a cmXMLParser and calls
@@ -217,13 +200,10 @@ void cmXMLParser::ReportXmlParseError()
 
 void cmXMLParser::ReportError(int line, int, const char* msg)
 {
-  if(this->ReportCallback)
-    {
+  if (this->ReportCallback) {
     this->ReportCallback(line, msg, this->ReportCallbackData);
-    }
-  else
-    {
-    std::cerr << "Error parsing XML in stream at line "
-              << line << ": " << msg << std::endl;
-    }
+  } else {
+    std::cerr << "Error parsing XML in stream at line " << line << ": " << msg
+              << std::endl;
+  }
 }
diff --git a/Source/cmXMLParser.h b/Source/cmXMLParser.h
index e72da66..6aae81d 100644
--- a/Source/cmXMLParser.h
+++ b/Source/cmXMLParser.h
@@ -14,11 +14,10 @@
 
 #include "cmStandardIncludes.h"
 
-extern "C"
-{
-  void cmXMLParserStartElement(void*, const char*, const char**);
-  void cmXMLParserEndElement(void*, const char*);
-  void cmXMLParserCharacterDataHandler(void*, const char*, int);
+extern "C" {
+void cmXMLParserStartElement(void*, const char*, const char**);
+void cmXMLParserEndElement(void*, const char*);
+void cmXMLParserCharacterDataHandler(void*, const char*, int);
 }
 
 /** \class cmXMLParser
@@ -52,18 +51,19 @@ public:
   virtual int CleanupParser();
   typedef void (*ReportFunction)(int, const char*, void*);
   void SetErrorCallback(ReportFunction f, void* d)
-    {
-      this->ReportCallback = f;
-      this->ReportCallbackData = d;
-    }
+  {
+    this->ReportCallback = f;
+    this->ReportCallbackData = d;
+  }
+
 protected:
   //! This variable is true if there was a parse error while parsing in
-  //chunks.
+  // chunks.
   int ParseError;
   ReportFunction ReportCallback;
   void* ReportCallbackData;
 
-  //1 Expat parser structure.  Exists only during call to Parse().
+  // 1 Expat parser structure.  Exists only during call to Parse().
   void* Parser;
 
   /**
@@ -84,7 +84,7 @@ protected:
   virtual void StartElement(const std::string& name, const char** atts);
 
   //! Called at the end of an element in the XML source opened when
-  //StartElement was called.
+  // StartElement was called.
   virtual void EndElement(const std::string& name);
 
   //! Called when there is character data to handle.
@@ -101,8 +101,7 @@ protected:
   static int IsSpace(char c);
 
   //! Send the given buffer to the XML parser.
-  virtual int ParseBuffer(const char* buffer,
-                          std::string::size_type length);
+  virtual int ParseBuffer(const char* buffer, std::string::size_type length);
 
   //! Send the given c-style string to the XML parser.
   int ParseBuffer(const char* buffer);
diff --git a/Source/cmXMLSafe.cxx b/Source/cmXMLSafe.cxx
index 0a76e9d..f899f57 100644
--- a/Source/cmXMLSafe.cxx
+++ b/Source/cmXMLSafe.cxx
@@ -19,17 +19,17 @@
 #include <stdio.h>
 #include <string.h>
 
-cmXMLSafe::cmXMLSafe(const char* s):
-  Data(s),
-  Size(static_cast<unsigned long>(strlen(s))),
-  DoQuotes(true)
+cmXMLSafe::cmXMLSafe(const char* s)
+  : Data(s)
+  , Size(static_cast<unsigned long>(strlen(s)))
+  , DoQuotes(true)
 {
 }
 
-cmXMLSafe::cmXMLSafe(std::string const& s):
-    Data(s.c_str()),
-    Size(static_cast<unsigned long>(s.length())),
-    DoQuotes(true)
+cmXMLSafe::cmXMLSafe(std::string const& s)
+  : Data(s.c_str())
+  , Size(static_cast<unsigned long>(s.length()))
+  , DoQuotes(true)
 {
 }
 
@@ -50,48 +50,52 @@ std::ostream& operator<<(std::ostream& os, cmXMLSafe const& self)
 {
   char const* first = self.Data;
   char const* last = self.Data + self.Size;
-  while(first != last)
-    {
+  while (first != last) {
     unsigned int ch;
-    if(const char* next = cm_utf8_decode_character(first, last, &ch))
-      {
+    if (const char* next = cm_utf8_decode_character(first, last, &ch)) {
       // http://www.w3.org/TR/REC-xml/#NT-Char
-      if((ch >= 0x20 && ch <= 0xD7FF) ||
-         (ch >= 0xE000 && ch <= 0xFFFD) ||
-         (ch >= 0x10000 && ch <= 0x10FFFF) ||
-          ch == 0x9 || ch == 0xA || ch == 0xD)
-        {
-        switch(ch)
-          {
+      if ((ch >= 0x20 && ch <= 0xD7FF) || (ch >= 0xE000 && ch <= 0xFFFD) ||
+          (ch >= 0x10000 && ch <= 0x10FFFF) || ch == 0x9 || ch == 0xA ||
+          ch == 0xD) {
+        switch (ch) {
           // Escape XML control characters.
-          case '&': os << "&amp;"; break;
-          case '<': os << "&lt;"; break;
-          case '>': os << "&gt;"; break;
-          case '"': os << (self.DoQuotes? "&quot;" : "\""); break;
-          case '\'': os << (self.DoQuotes? "&apos;" : "'"); break;
-          case '\r': break; // Ignore CR
+          case '&':
+            os << "&amp;";
+            break;
+          case '<':
+            os << "&lt;";
+            break;
+          case '>':
+            os << "&gt;";
+            break;
+          case '"':
+            os << (self.DoQuotes ? "&quot;" : "\"");
+            break;
+          case '\'':
+            os << (self.DoQuotes ? "&apos;" : "'");
+            break;
+          case '\r':
+            break; // Ignore CR
           // Print the UTF-8 character.
-          default: os.write(first, next-first); break;
-          }
+          default:
+            os.write(first, next - first);
+            break;
         }
-      else
-        {
+      } else {
         // Use a human-readable hex value for this invalid character.
         char buf[16];
         sprintf(buf, "%X", ch);
         os << "[NON-XML-CHAR-0x" << buf << "]";
-        }
+      }
 
       first = next;
-      }
-    else
-      {
+    } else {
       ch = static_cast<unsigned char>(*first++);
       // Use a human-readable hex value for this invalid byte.
       char buf[16];
       sprintf(buf, "%X", ch);
       os << "[NON-UTF-8-BYTE-0x" << buf << "]";
-      }
     }
+  }
   return os;
 }
diff --git a/Source/cmXMLSafe.h b/Source/cmXMLSafe.h
index 7cf34ba..11ced13 100644
--- a/Source/cmXMLSafe.h
+++ b/Source/cmXMLSafe.h
@@ -35,6 +35,7 @@ public:
 
   /** Get the escaped data as a string.  */
   std::string str();
+
 private:
   char const* Data;
   unsigned long Size;
diff --git a/Source/cmXMLWriter.cxx b/Source/cmXMLWriter.cxx
index ec26467..98c2680 100644
--- a/Source/cmXMLWriter.cxx
+++ b/Source/cmXMLWriter.cxx
@@ -17,11 +17,11 @@
 #include <fstream>
 
 cmXMLWriter::cmXMLWriter(std::ostream& output, std::size_t level)
-: Output(output)
-, Level(level)
-, ElementOpen(false)
-, BreakAttrib(false)
-, IsContent(false)
+  : Output(output)
+  , Level(level)
+  , ElementOpen(false)
+  , BreakAttrib(false)
+  , IsContent(false)
 {
 }
 
@@ -54,16 +54,13 @@ void cmXMLWriter::StartElement(std::string const& name)
 void cmXMLWriter::EndElement()
 {
   assert(!this->Elements.empty());
-  if (this->ElementOpen)
-    {
+  if (this->ElementOpen) {
     this->Output << "/>";
-    }
-  else
-    {
+  } else {
     this->ConditionalLineBreak(!this->IsContent, this->Elements.size() - 1);
     this->IsContent = false;
     this->Output << "</" << this->Elements.top() << '>';
-    }
+  }
   this->Elements.pop();
   this->ElementOpen = false;
 }
@@ -116,20 +113,18 @@ void cmXMLWriter::FragmentFile(const char* fname)
 
 void cmXMLWriter::ConditionalLineBreak(bool condition, std::size_t indent)
 {
-  if (condition)
-    {
+  if (condition) {
     this->Output << '\n' << std::string(indent + this->Level, '\t');
-    }
+  }
 }
 
 void cmXMLWriter::PreAttribute()
 {
   assert(this->ElementOpen);
   this->ConditionalLineBreak(this->BreakAttrib, this->Elements.size());
-  if (!this->BreakAttrib)
-    {
+  if (!this->BreakAttrib) {
     this->Output << ' ';
-    }
+  }
 }
 
 void cmXMLWriter::PreContent()
@@ -140,10 +135,9 @@ void cmXMLWriter::PreContent()
 
 void cmXMLWriter::CloseStartElement()
 {
-  if (this->ElementOpen)
-    {
+  if (this->ElementOpen) {
     this->ConditionalLineBreak(this->BreakAttrib, this->Elements.size());
     this->Output << '>';
     this->ElementOpen = false;
-    }
+  }
 }
diff --git a/Source/cmXMLWriter.h b/Source/cmXMLWriter.h
index 8fedcd4..8a88dd4 100644
--- a/Source/cmXMLWriter.h
+++ b/Source/cmXMLWriter.h
@@ -37,27 +37,27 @@ public:
 
   template <typename T>
   void Attribute(const char* name, T const& value)
-    {
+  {
     this->PreAttribute();
     this->Output << name << "=\"" << SafeAttribute(value) << '"';
-    }
+  }
 
   void Element(const char* name);
 
   template <typename T>
   void Element(std::string const& name, T const& value)
-    {
+  {
     this->StartElement(name);
     this->Content(value);
     this->EndElement();
-    }
+  }
 
   template <typename T>
   void Content(T const& content)
-    {
+  {
     this->PreContent();
     this->Output << SafeContent(content);
-    }
+  }
 
   void Comment(const char* comment);
 
@@ -82,36 +82,36 @@ private:
 
 private:
   static cmXMLSafe SafeAttribute(const char* value)
-    {
+  {
     return cmXMLSafe(value);
-    }
+  }
 
   static cmXMLSafe SafeAttribute(std::string const& value)
-    {
+  {
     return cmXMLSafe(value);
-    }
+  }
 
   template <typename T>
   static T SafeAttribute(T value)
-    {
+  {
     return value;
-    }
+  }
 
   static cmXMLSafe SafeContent(const char* value)
-    {
+  {
     return cmXMLSafe(value).Quotes(false);
-    }
+  }
 
   static cmXMLSafe SafeContent(std::string const& value)
-    {
+  {
     return cmXMLSafe(value).Quotes(false);
-    }
+  }
 
   template <typename T>
   static T SafeContent(T value)
-    {
+  {
     return value;
-    }
+  }
 
 private:
   std::ostream& Output;
diff --git a/Source/cm_get_date.h b/Source/cm_get_date.h
index d5f6d3e..3045775 100644
--- a/Source/cm_get_date.h
+++ b/Source/cm_get_date.h
@@ -19,7 +19,7 @@ extern "C" {
 #endif
 
 /** Parse a date/time string.  Treat relative times with respect to 'now'. */
-time_t cm_get_date(time_t now, const char *str);
+time_t cm_get_date(time_t now, const char* str);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/Source/cm_utf8.c b/Source/cm_utf8.c
index 6f5fa3a..2352507 100644
--- a/Source/cm_utf8.c
+++ b/Source/cm_utf8.c
@@ -25,24 +25,25 @@
 
 /* Number of leading ones before a zero in the byte.  */
 static unsigned char const cm_utf8_ones[256] = {
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
-  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,7,8
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+  3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8
 };
 
 /* Mask away control bits from bytes with n leading ones.  */
-static unsigned char const cm_utf8_mask[7] = {
-  0xEF, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01
-};
+static unsigned char const cm_utf8_mask[7] = { 0xEF, 0x3F, 0x1F, 0x0F,
+                                               0x07, 0x03, 0x01 };
 
 /* Minimum allowed value when first byte has n leading ones.  */
 static unsigned int const cm_utf8_min[7] = {
-  0, 0, 1u<<7, 1u<<11, 1u<<16, 1u<<21, 1u<<26 /*, 1u<<31 */
+  0, 0, 1u << 7, 1u << 11, 1u << 16, 1u << 21, 1u << 26 /*, 1u<<31 */
 };
 
 const char* cm_utf8_decode_character(const char* first, const char* last,
@@ -51,33 +52,35 @@ const char* cm_utf8_decode_character(const char* first, const char* last,
   /* Count leading ones in the first byte.  */
   unsigned char c = (unsigned char)*first++;
   unsigned char const ones = cm_utf8_ones[c];
-  switch(ones)
-    {
-    case 0: *pc = c; return first;    /* One-byte character.  */
-    case 1: case 7: case 8: return 0; /* Invalid leading byte.  */
-    default: break;
-    }
+  switch (ones) {
+    case 0:
+      *pc = c;
+      return first; /* One-byte character.  */
+    case 1:
+    case 7:
+    case 8:
+      return 0; /* Invalid leading byte.  */
+    default:
+      break;
+  }
 
   /* Extract bits from this multi-byte character.  */
   {
-  unsigned int uc = c & cm_utf8_mask[ones];
-  int left;
-  for(left = ones-1; left && first != last; --left)
-    {
-    c = (unsigned char)*first++;
-    if(cm_utf8_ones[c] != 1)
-      {
-      return 0;
+    unsigned int uc = c & cm_utf8_mask[ones];
+    int left;
+    for (left = ones - 1; left && first != last; --left) {
+      c = (unsigned char)*first++;
+      if (cm_utf8_ones[c] != 1) {
+        return 0;
       }
-    uc = (uc << 6) | (c & cm_utf8_mask[1]);
+      uc = (uc << 6) | (c & cm_utf8_mask[1]);
     }
 
-  if(left > 0 || uc < cm_utf8_min[ones])
-    {
-    return 0;
+    if (left > 0 || uc < cm_utf8_min[ones]) {
+      return 0;
     }
 
-  *pc = uc;
-  return first;
+    *pc = uc;
+    return first;
   }
 }
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 3fd35fb..e4d6656 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -24,9 +24,9 @@
 #include "cmTest.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cmGraphVizWriter.h"
-# include "cmVariableWatch.h"
-# include <cmsys/SystemInformation.hxx>
+#include "cmGraphVizWriter.h"
+#include "cmVariableWatch.h"
+#include <cmsys/SystemInformation.hxx>
 #endif
 
 #include <cmsys/FStream.hxx>
@@ -36,71 +36,71 @@
 // only build kdevelop generator on non-windows platforms
 // when not bootstrapping cmake
 #if !defined(_WIN32)
-# if defined(CMAKE_BUILD_WITH_CMAKE)
-#   define CMAKE_USE_KDEVELOP
-# endif
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+#define CMAKE_USE_KDEVELOP
+#endif
 #endif
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-#  define CMAKE_USE_ECLIPSE
+#define CMAKE_USE_ECLIPSE
 #endif
 
 #if defined(__MINGW32__) && !defined(CMAKE_BUILD_WITH_CMAKE)
-# define CMAKE_BOOT_MINGW
+#define CMAKE_BOOT_MINGW
 #endif
 
 // include the generator
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#  if !defined(CMAKE_BOOT_MINGW)
-#    include "cmGlobalBorlandMakefileGenerator.h"
-#    include "cmGlobalGhsMultiGenerator.h"
-#    include "cmGlobalJOMMakefileGenerator.h"
-#    include "cmGlobalNMakeMakefileGenerator.h"
-#    include "cmGlobalVisualStudio10Generator.h"
-#    include "cmGlobalVisualStudio11Generator.h"
-#    include "cmGlobalVisualStudio12Generator.h"
-#    include "cmGlobalVisualStudio14Generator.h"
-#    include "cmGlobalVisualStudio71Generator.h"
-#    include "cmGlobalVisualStudio8Generator.h"
-#    include "cmGlobalVisualStudio9Generator.h"
-#    define CMAKE_HAVE_VS_GENERATORS
-#  endif
-#  include "cmGlobalMSYSMakefileGenerator.h"
-#  include "cmGlobalMinGWMakefileGenerator.h"
+#if !defined(CMAKE_BOOT_MINGW)
+#include "cmGlobalBorlandMakefileGenerator.h"
+#include "cmGlobalGhsMultiGenerator.h"
+#include "cmGlobalJOMMakefileGenerator.h"
+#include "cmGlobalNMakeMakefileGenerator.h"
+#include "cmGlobalVisualStudio10Generator.h"
+#include "cmGlobalVisualStudio11Generator.h"
+#include "cmGlobalVisualStudio12Generator.h"
+#include "cmGlobalVisualStudio14Generator.h"
+#include "cmGlobalVisualStudio71Generator.h"
+#include "cmGlobalVisualStudio8Generator.h"
+#include "cmGlobalVisualStudio9Generator.h"
+#define CMAKE_HAVE_VS_GENERATORS
+#endif
+#include "cmGlobalMSYSMakefileGenerator.h"
+#include "cmGlobalMinGWMakefileGenerator.h"
 #else
 #endif
 #if defined(CMAKE_USE_WMAKE)
-# include "cmGlobalWatcomWMakeGenerator.h"
+#include "cmGlobalWatcomWMakeGenerator.h"
 #endif
 #include "cmGlobalUnixMakefileGenerator3.h"
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cmGlobalNinjaGenerator.h"
+#include "cmGlobalNinjaGenerator.h"
 #endif
 #include "cmExtraCodeLiteGenerator.h"
 
 #if !defined(CMAKE_BOOT_MINGW)
-# include "cmExtraCodeBlocksGenerator.h"
+#include "cmExtraCodeBlocksGenerator.h"
 #endif
 #include "cmExtraKateGenerator.h"
 #include "cmExtraSublimeTextGenerator.h"
 
 #ifdef CMAKE_USE_KDEVELOP
-# include "cmGlobalKdevelopGenerator.h"
+#include "cmGlobalKdevelopGenerator.h"
 #endif
 
 #ifdef CMAKE_USE_ECLIPSE
-# include "cmExtraEclipseCDT4Generator.h"
+#include "cmExtraEclipseCDT4Generator.h"
 #endif
 
 #include <stdlib.h> // required for atoi
 
-#if defined( __APPLE__ )
-#  if defined(CMAKE_BUILD_WITH_CMAKE)
-#    include "cmGlobalXCodeGenerator.h"
-#    define CMAKE_USE_XCODE 1
-#  endif
-#  include <sys/resource.h>
-#  include <sys/time.h>
+#if defined(__APPLE__)
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+#include "cmGlobalXCodeGenerator.h"
+#define CMAKE_USE_XCODE 1
+#endif
+#include <sys/resource.h>
+#include <sys/time.h>
 #endif
 
 #include <sys/types.h>
@@ -112,8 +112,8 @@
 static bool cmakeCheckStampFile(const char* stampName);
 static bool cmakeCheckStampList(const char* stampName);
 
-void cmWarnUnusedCliWarning(const std::string& variable,
-  int, void* ctx, const char*, const cmMakefile*)
+void cmWarnUnusedCliWarning(const std::string& variable, int, void* ctx,
+                            const char*, const cmMakefile*)
 {
   cmake* cm = reinterpret_cast<cmake*>(ctx);
   cm->MarkCliAsUsed(variable);
@@ -137,14 +137,12 @@ cmake::cmake()
 
 #ifdef __APPLE__
   struct rlimit rlp;
-  if(!getrlimit(RLIMIT_STACK, &rlp))
-    {
-    if(rlp.rlim_cur != rlp.rlim_max)
-      {
-        rlp.rlim_cur = rlp.rlim_max;
-         setrlimit(RLIMIT_STACK, &rlp);
-      }
+  if (!getrlimit(RLIMIT_STACK, &rlp)) {
+    if (rlp.rlim_cur != rlp.rlim_max) {
+      rlp.rlim_cur = rlp.rlim_max;
+      setrlimit(RLIMIT_STACK, &rlp);
     }
+  }
 #endif
 
   this->Verbose = false;
@@ -168,35 +166,34 @@ cmake::cmake()
   // these are used to find files when the extension
   // is not given
   // The "c" extension MUST precede the "C" extension.
-  this->SourceFileExtensions.push_back( "c" );
-  this->SourceFileExtensions.push_back( "C" );
-
-  this->SourceFileExtensions.push_back( "c++" );
-  this->SourceFileExtensions.push_back( "cc" );
-  this->SourceFileExtensions.push_back( "cpp" );
-  this->SourceFileExtensions.push_back( "cxx" );
-  this->SourceFileExtensions.push_back( "m" );
-  this->SourceFileExtensions.push_back( "M" );
-  this->SourceFileExtensions.push_back( "mm" );
-
-  this->HeaderFileExtensions.push_back( "h" );
-  this->HeaderFileExtensions.push_back( "hh" );
-  this->HeaderFileExtensions.push_back( "h++" );
-  this->HeaderFileExtensions.push_back( "hm" );
-  this->HeaderFileExtensions.push_back( "hpp" );
-  this->HeaderFileExtensions.push_back( "hxx" );
-  this->HeaderFileExtensions.push_back( "in" );
-  this->HeaderFileExtensions.push_back( "txx" );
+  this->SourceFileExtensions.push_back("c");
+  this->SourceFileExtensions.push_back("C");
+
+  this->SourceFileExtensions.push_back("c++");
+  this->SourceFileExtensions.push_back("cc");
+  this->SourceFileExtensions.push_back("cpp");
+  this->SourceFileExtensions.push_back("cxx");
+  this->SourceFileExtensions.push_back("m");
+  this->SourceFileExtensions.push_back("M");
+  this->SourceFileExtensions.push_back("mm");
+
+  this->HeaderFileExtensions.push_back("h");
+  this->HeaderFileExtensions.push_back("hh");
+  this->HeaderFileExtensions.push_back("h++");
+  this->HeaderFileExtensions.push_back("hm");
+  this->HeaderFileExtensions.push_back("hpp");
+  this->HeaderFileExtensions.push_back("hxx");
+  this->HeaderFileExtensions.push_back("in");
+  this->HeaderFileExtensions.push_back("txx");
 }
 
 cmake::~cmake()
 {
   delete this->State;
-  if (this->GlobalGenerator)
-    {
+  if (this->GlobalGenerator) {
     delete this->GlobalGenerator;
     this->GlobalGenerator = 0;
-    }
+  }
   cmDeleteAll(this->Generators);
 #ifdef CMAKE_BUILD_WITH_CMAKE
   delete this->VariableWatch;
@@ -215,288 +212,227 @@ void cmake::CleanupCommandsAndMacros()
 bool cmake::SetCacheArgs(const std::vector<std::string>& args)
 {
   bool findPackageMode = false;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
+  for (unsigned int i = 1; i < args.size(); ++i) {
     std::string arg = args[i];
-    if(arg.find("-D",0) == 0)
-      {
+    if (arg.find("-D", 0) == 0) {
       std::string entry = arg.substr(2);
-      if(entry.empty())
-        {
+      if (entry.empty()) {
         ++i;
-        if(i < args.size())
-          {
+        if (i < args.size()) {
           entry = args[i];
-          }
-        else
-          {
+        } else {
           cmSystemTools::Error("-D must be followed with VAR=VALUE.");
           return false;
-          }
         }
+      }
       std::string var, value;
       cmState::CacheEntryType type = cmState::UNINITIALIZED;
-      if(cmState::ParseCacheEntry(entry, var, value, type))
-        {
+      if (cmState::ParseCacheEntry(entry, var, value, type)) {
         // The value is transformed if it is a filepath for example, so
         // we can't compare whether the value is already in the cache until
         // after we call AddCacheEntry.
         bool haveValue = false;
         std::string cachedValue;
-        if(this->WarnUnusedCli)
-          {
-          if(const char *v = this->State->GetInitializedCacheValue(var))
-            {
+        if (this->WarnUnusedCli) {
+          if (const char* v = this->State->GetInitializedCacheValue(var)) {
             haveValue = true;
             cachedValue = v;
-            }
           }
+        }
 
         this->AddCacheEntry(var, value.c_str(),
-          "No help, variable specified on the command line.", type);
+                            "No help, variable specified on the command line.",
+                            type);
 
-        if(this->WarnUnusedCli)
-          {
+        if (this->WarnUnusedCli) {
           if (!haveValue ||
-              cachedValue != this->State->GetInitializedCacheValue(var))
-            {
+              cachedValue != this->State->GetInitializedCacheValue(var)) {
             this->WatchUnusedCli(var);
-            }
           }
         }
-      else
-        {
+      } else {
         std::cerr << "Parse error in command line argument: " << arg << "\n"
                   << "Should be: VAR:type=value\n";
         cmSystemTools::Error("No cmake script provided.");
         return false;
-        }
       }
-    else if(cmHasLiteralPrefix(arg, "-W"))
-      {
+    } else if (cmHasLiteralPrefix(arg, "-W")) {
       std::string entry = arg.substr(2);
-      if (entry.empty())
-        {
+      if (entry.empty()) {
         ++i;
-        if (i < args.size())
-          {
+        if (i < args.size()) {
           entry = args[i];
-          }
-        else
-          {
+        } else {
           cmSystemTools::Error("-W must be followed with [no-]<name>.");
           return false;
-          }
         }
+      }
 
       std::string name;
       bool foundNo = false;
       bool foundError = false;
       unsigned int nameStartPosition = 0;
 
-      if (entry.find("no-", nameStartPosition) == 0)
-        {
+      if (entry.find("no-", nameStartPosition) == 0) {
         foundNo = true;
         nameStartPosition += 3;
-        }
+      }
 
-      if (entry.find("error=", nameStartPosition) == 0)
-        {
+      if (entry.find("error=", nameStartPosition) == 0) {
         foundError = true;
         nameStartPosition += 6;
-        }
+      }
 
       name = entry.substr(nameStartPosition);
-      if (name.empty())
-        {
+      if (name.empty()) {
         cmSystemTools::Error("No warning name provided.");
         return false;
-        }
+      }
 
-      if (!foundNo && !foundError)
-        {
+      if (!foundNo && !foundError) {
         // -W<name>
-        this->DiagLevels[name] = std::max(this->DiagLevels[name],
-                                          DIAG_WARN);
-        }
-      else if (foundNo && !foundError)
-        {
-         // -Wno<name>
-         this->DiagLevels[name] = DIAG_IGNORE;
-        }
-      else if (!foundNo && foundError)
-        {
+        this->DiagLevels[name] = std::max(this->DiagLevels[name], DIAG_WARN);
+      } else if (foundNo && !foundError) {
+        // -Wno<name>
+        this->DiagLevels[name] = DIAG_IGNORE;
+      } else if (!foundNo && foundError) {
         // -Werror=<name>
         this->DiagLevels[name] = DIAG_ERROR;
-        }
-      else
-        {
+      } else {
         // -Wno-error=<name>
-        this->DiagLevels[name] = std::min(this->DiagLevels[name],
-                                          DIAG_WARN);
-        }
+        this->DiagLevels[name] = std::min(this->DiagLevels[name], DIAG_WARN);
       }
-    else if(arg.find("-U",0) == 0)
-      {
+    } else if (arg.find("-U", 0) == 0) {
       std::string entryPattern = arg.substr(2);
-      if(entryPattern.empty())
-        {
+      if (entryPattern.empty()) {
         ++i;
-        if(i < args.size())
-          {
+        if (i < args.size()) {
           entryPattern = args[i];
-          }
-        else
-          {
+        } else {
           cmSystemTools::Error("-U must be followed with VAR.");
           return false;
-          }
         }
+      }
       cmsys::RegularExpression regex(
         cmsys::Glob::PatternToRegex(entryPattern, true, true).c_str());
-      //go through all cache entries and collect the vars which will be removed
+      // go through all cache entries and collect the vars which will be
+      // removed
       std::vector<std::string> entriesToDelete;
       std::vector<std::string> cacheKeys = this->State->GetCacheEntryKeys();
       for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
-            it != cacheKeys.end(); ++it)
-        {
+           it != cacheKeys.end(); ++it) {
         cmState::CacheEntryType t = this->State->GetCacheEntryType(*it);
-        if(t != cmState::STATIC)
-          {
-          if (regex.find(it->c_str()))
-            {
+        if (t != cmState::STATIC) {
+          if (regex.find(it->c_str())) {
             entriesToDelete.push_back(*it);
-            }
           }
         }
+      }
 
       // now remove them from the cache
-      for(std::vector<std::string>::const_iterator currentEntry =
-          entriesToDelete.begin();
-          currentEntry != entriesToDelete.end();
-          ++currentEntry)
-        {
+      for (std::vector<std::string>::const_iterator currentEntry =
+             entriesToDelete.begin();
+           currentEntry != entriesToDelete.end(); ++currentEntry) {
         this->State->RemoveCacheEntry(*currentEntry);
-        }
       }
-    else if(arg.find("-C",0) == 0)
-      {
+    } else if (arg.find("-C", 0) == 0) {
       std::string path = arg.substr(2);
-      if (path.empty())
-        {
+      if (path.empty()) {
         ++i;
-        if(i < args.size())
-          {
+        if (i < args.size()) {
           path = args[i];
-          }
-        else
-          {
+        } else {
           cmSystemTools::Error("-C must be followed by a file name.");
           return false;
-          }
         }
+      }
       std::cout << "loading initial cache file " << path << "\n";
       this->ReadListFile(args, path.c_str());
-      }
-    else if(arg.find("-P",0) == 0)
-      {
+    } else if (arg.find("-P", 0) == 0) {
       i++;
-      if(i >= args.size())
-        {
+      if (i >= args.size()) {
         cmSystemTools::Error("-P must be followed by a file name.");
         return false;
-        }
+      }
       std::string path = args[i];
-      if (path.empty())
-        {
+      if (path.empty()) {
         cmSystemTools::Error("No cmake script provided.");
         return false;
-        }
-      this->ReadListFile(args, path.c_str());
       }
-    else if (arg.find("--find-package",0) == 0)
-      {
+      this->ReadListFile(args, path.c_str());
+    } else if (arg.find("--find-package", 0) == 0) {
       findPackageMode = true;
-      }
     }
+  }
 
-  if (findPackageMode)
-    {
+  if (findPackageMode) {
     return this->FindPackage(args);
-    }
+  }
 
   return true;
 }
 
 void cmake::ReadListFile(const std::vector<std::string>& args,
-                         const char *path)
+                         const char* path)
 {
   // if a generator was not yet created, temporarily create one
-  cmGlobalGenerator *gg = this->GetGlobalGenerator();
+  cmGlobalGenerator* gg = this->GetGlobalGenerator();
   bool created = false;
 
   // if a generator was not specified use a generic one
-  if (!gg)
-    {
+  if (!gg) {
     gg = new cmGlobalGenerator(this);
     created = true;
-    }
+  }
 
   // read in the list file to fill the cache
-  if(path)
-    {
+  if (path) {
     this->CurrentSnapshot = this->State->Reset();
     std::string homeDir = this->GetHomeDirectory();
     std::string homeOutputDir = this->GetHomeOutputDirectory();
     this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
     this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
     cmState::Snapshot snapshot = this->GetCurrentSnapshot();
-    snapshot.GetDirectory().SetCurrentBinary
-      (cmSystemTools::GetCurrentWorkingDirectory());
-    snapshot.GetDirectory().SetCurrentSource
-      (cmSystemTools::GetCurrentWorkingDirectory());
+    snapshot.GetDirectory().SetCurrentBinary(
+      cmSystemTools::GetCurrentWorkingDirectory());
+    snapshot.GetDirectory().SetCurrentSource(
+      cmSystemTools::GetCurrentWorkingDirectory());
     snapshot.SetDefaultDefinitions();
     cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot));
-    if (this->GetWorkingMode() != NORMAL_MODE)
-      {
+    if (this->GetWorkingMode() != NORMAL_MODE) {
       std::string file(cmSystemTools::CollapseFullPath(path));
       cmSystemTools::ConvertToUnixSlashes(file);
       mf->SetScriptModeFile(file.c_str());
 
       mf->SetArgcArgv(args);
-      }
-    if (!mf->ReadListFile(path))
-      {
+    }
+    if (!mf->ReadListFile(path)) {
       cmSystemTools::Error("Error processing file: ", path);
-      }
+    }
     this->SetHomeDirectory(homeDir);
     this->SetHomeOutputDirectory(homeOutputDir);
-    }
+  }
 
   // free generic one if generated
-  if (created)
-    {
+  if (created) {
     delete gg;
-    }
+  }
 }
 
-
 bool cmake::FindPackage(const std::vector<std::string>& args)
 {
-  this->SetHomeDirectory
-    (cmSystemTools::GetCurrentWorkingDirectory());
-  this->SetHomeOutputDirectory
-    (cmSystemTools::GetCurrentWorkingDirectory());
+  this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
+  this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
 
   // if a generator was not yet created, temporarily create one
-  cmGlobalGenerator *gg = new cmGlobalGenerator(this);
+  cmGlobalGenerator* gg = new cmGlobalGenerator(this);
   this->SetGlobalGenerator(gg);
 
   cmState::Snapshot snapshot = this->GetCurrentSnapshot();
-  snapshot.GetDirectory().SetCurrentBinary
-    (cmSystemTools::GetCurrentWorkingDirectory());
-  snapshot.GetDirectory().SetCurrentSource
-    (cmSystemTools::GetCurrentWorkingDirectory());
+  snapshot.GetDirectory().SetCurrentBinary(
+    cmSystemTools::GetCurrentWorkingDirectory());
+  snapshot.GetDirectory().SetCurrentSource(
+    cmSystemTools::GetCurrentWorkingDirectory());
   // read in the list file to fill the cache
   snapshot.SetDefaultDefinitions();
   cmMakefile* mf = new cmMakefile(gg, snapshot);
@@ -513,22 +449,15 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
   bool packageFound = mf->IsOn("PACKAGE_FOUND");
   bool quiet = mf->IsOn("PACKAGE_QUIET");
 
-  if (!packageFound)
-    {
-    if (!quiet)
-      {
+  if (!packageFound) {
+    if (!quiet) {
       printf("%s not found.\n", packageName.c_str());
-      }
     }
-  else if (mode == "EXIST")
-    {
-    if (!quiet)
-      {
+  } else if (mode == "EXIST") {
+    if (!quiet) {
       printf("%s found.\n", packageName.c_str());
-      }
     }
-  else if (mode == "COMPILE")
-    {
+  } else if (mode == "COMPILE") {
     std::string includes = mf->GetSafeDefinition("PACKAGE_INCLUDE_DIRS");
     std::vector<std::string> includeDirs;
     cmSystemTools::ExpandListArgument(includes, includeDirs);
@@ -539,9 +468,7 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
 
     std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS");
     printf("%s %s\n", includeFlags.c_str(), definitions.c_str());
-    }
-  else if (mode == "LINK")
-    {
+  } else if (mode == "LINK") {
     const char* targetName = "dummy";
     std::vector<std::string> srcs;
     cmTarget* tgt = mf->AddExecutable(targetName, srcs, true);
@@ -550,14 +477,10 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
     std::string libs = mf->GetSafeDefinition("PACKAGE_LIBRARIES");
     std::vector<std::string> libList;
     cmSystemTools::ExpandListArgument(libs, libList);
-    for(std::vector<std::string>::const_iterator libIt=libList.begin();
-            libIt != libList.end();
-            ++libIt)
-      {
-      mf->AddLinkLibraryForTarget(targetName, *libIt,
-                                  GENERAL_LibraryType);
-      }
-
+    for (std::vector<std::string>::const_iterator libIt = libList.begin();
+         libIt != libList.end(); ++libIt) {
+      mf->AddLinkLibraryForTarget(targetName, *libIt, GENERAL_LibraryType);
+    }
 
     std::string linkLibs;
     std::string frameworkPath;
@@ -565,32 +488,31 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
     std::string flags;
     std::string linkFlags;
     gg->CreateGenerationObjects();
-    cmGeneratorTarget *gtgt = gg->FindGeneratorTarget(tgt->GetName());
+    cmGeneratorTarget* gtgt = gg->FindGeneratorTarget(tgt->GetName());
     cmLocalGenerator* lg = gtgt->GetLocalGenerator();
     lg->GetTargetFlags(linkLibs, frameworkPath, linkPath, flags, linkFlags,
                        gtgt, false);
     linkLibs = frameworkPath + linkPath + linkLibs;
 
-    printf("%s\n", linkLibs.c_str() );
+    printf("%s\n", linkLibs.c_str());
 
-/*    if ( use_win32 )
-      {
-      tgt->SetProperty("WIN32_EXECUTABLE", "ON");
-      }
-    if ( use_macbundle)
-      {
-      tgt->SetProperty("MACOSX_BUNDLE", "ON");
-      }*/
-    }
+    /*    if ( use_win32 )
+          {
+          tgt->SetProperty("WIN32_EXECUTABLE", "ON");
+          }
+        if ( use_macbundle)
+          {
+          tgt->SetProperty("MACOSX_BUNDLE", "ON");
+          }*/
+  }
 
   // free generic one if generated
-//  this->SetGlobalGenerator(0); // setting 0-pointer is not possible
-//  delete gg; // this crashes inside the cmake instance
+  //  this->SetGlobalGenerator(0); // setting 0-pointer is not possible
+  //  delete gg; // this crashes inside the cmake instance
 
   return packageFound;
 }
 
-
 // Parse the args
 void cmake::SetArgs(const std::vector<std::string>& args,
                     bool directoriesSetBefore)
@@ -598,220 +520,155 @@ void cmake::SetArgs(const std::vector<std::string>& args,
   bool directoriesSet = directoriesSetBefore;
   bool haveToolset = false;
   bool havePlatform = false;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
+  for (unsigned int i = 1; i < args.size(); ++i) {
     std::string arg = args[i];
-    if(arg.find("-H",0) == 0)
-      {
+    if (arg.find("-H", 0) == 0) {
       directoriesSet = true;
       std::string path = arg.substr(2);
       path = cmSystemTools::CollapseFullPath(path);
       cmSystemTools::ConvertToUnixSlashes(path);
       this->SetHomeDirectory(path);
-      }
-    else if(arg.find("-S",0) == 0)
-      {
+    } else if (arg.find("-S", 0) == 0) {
       // There is no local generate anymore.  Ignore -S option.
-      }
-    else if(arg.find("-O",0) == 0)
-      {
+    } else if (arg.find("-O", 0) == 0) {
       // There is no local generate anymore.  Ignore -O option.
-      }
-    else if(arg.find("-B",0) == 0)
-      {
+    } else if (arg.find("-B", 0) == 0) {
       directoriesSet = true;
       std::string path = arg.substr(2);
       path = cmSystemTools::CollapseFullPath(path);
       cmSystemTools::ConvertToUnixSlashes(path);
       this->SetHomeOutputDirectory(path);
-      }
-    else if((i < args.size()-2) && (arg.find("--check-build-system",0) == 0))
-      {
+    } else if ((i < args.size() - 2) &&
+               (arg.find("--check-build-system", 0) == 0)) {
       this->CheckBuildSystemArgument = args[++i];
       this->ClearBuildSystem = (atoi(args[++i].c_str()) > 0);
-      }
-    else if((i < args.size()-1) && (arg.find("--check-stamp-file",0) == 0))
-      {
+    } else if ((i < args.size() - 1) &&
+               (arg.find("--check-stamp-file", 0) == 0)) {
       this->CheckStampFile = args[++i];
-      }
-    else if((i < args.size()-1) && (arg.find("--check-stamp-list",0) == 0))
-      {
+    } else if ((i < args.size() - 1) &&
+               (arg.find("--check-stamp-list", 0) == 0)) {
       this->CheckStampList = args[++i];
-      }
+    }
 #if defined(CMAKE_HAVE_VS_GENERATORS)
-    else if((i < args.size()-1) && (arg.find("--vs-solution-file",0) == 0))
-      {
+    else if ((i < args.size() - 1) &&
+             (arg.find("--vs-solution-file", 0) == 0)) {
       this->VSSolutionFile = args[++i];
-      }
+    }
 #endif
-    else if(arg.find("-V",0) == 0)
-      {
-        this->Verbose = true;
-      }
-    else if(arg.find("-D",0) == 0)
-      {
+    else if (arg.find("-V", 0) == 0) {
+      this->Verbose = true;
+    } else if (arg.find("-D", 0) == 0) {
       // skip for now
-      }
-    else if(arg.find("-U",0) == 0)
-      {
+    } else if (arg.find("-U", 0) == 0) {
       // skip for now
-      }
-    else if(arg.find("-C",0) == 0)
-      {
+    } else if (arg.find("-C", 0) == 0) {
       // skip for now
-      }
-    else if(arg.find("-P",0) == 0)
-      {
+    } else if (arg.find("-P", 0) == 0) {
       // skip for now
       i++;
-      }
-    else if(arg.find("--find-package",0) == 0)
-      {
+    } else if (arg.find("--find-package", 0) == 0) {
       // skip for now
       i++;
-      }
-    else if(arg.find("-W",0) == 0)
-      {
+    } else if (arg.find("-W", 0) == 0) {
       // skip for now
-      }
-    else if(arg.find("--graphviz=",0) == 0)
-      {
+    } else if (arg.find("--graphviz=", 0) == 0) {
       std::string path = arg.substr(strlen("--graphviz="));
       path = cmSystemTools::CollapseFullPath(path);
       cmSystemTools::ConvertToUnixSlashes(path);
       this->GraphVizFile = path;
-      if ( this->GraphVizFile.empty() )
-        {
+      if (this->GraphVizFile.empty()) {
         cmSystemTools::Error("No file specified for --graphviz");
-        }
       }
-    else if(arg.find("--debug-trycompile",0) == 0)
-      {
+    } else if (arg.find("--debug-trycompile", 0) == 0) {
       std::cout << "debug trycompile on\n";
       this->DebugTryCompileOn();
-      }
-    else if(arg.find("--debug-output",0) == 0)
-      {
+    } else if (arg.find("--debug-output", 0) == 0) {
       std::cout << "Running with debug output on.\n";
       this->SetDebugOutputOn(true);
-      }
-    else if(arg.find("--trace-expand",0) == 0)
-      {
+    } else if (arg.find("--trace-expand", 0) == 0) {
       std::cout << "Running with expanded trace output on.\n";
       this->SetTrace(true);
       this->SetTraceExpand(true);
-      }
-    else if(arg.find("--trace",0) == 0)
-      {
+    } else if (arg.find("--trace", 0) == 0) {
       std::cout << "Running with trace output on.\n";
       this->SetTrace(true);
       this->SetTraceExpand(false);
-      }
-    else if(arg.find("--warn-uninitialized",0) == 0)
-      {
+    } else if (arg.find("--warn-uninitialized", 0) == 0) {
       std::cout << "Warn about uninitialized values.\n";
       this->SetWarnUninitialized(true);
-      }
-    else if(arg.find("--warn-unused-vars",0) == 0)
-      {
+    } else if (arg.find("--warn-unused-vars", 0) == 0) {
       std::cout << "Finding unused variables.\n";
       this->SetWarnUnused(true);
-      }
-    else if(arg.find("--no-warn-unused-cli",0) == 0)
-      {
-      std::cout << "Not searching for unused variables given on the " <<
-                   "command line.\n";
+    } else if (arg.find("--no-warn-unused-cli", 0) == 0) {
+      std::cout << "Not searching for unused variables given on the "
+                << "command line.\n";
       this->SetWarnUnusedCli(false);
-      }
-    else if(arg.find("--check-system-vars",0) == 0)
-      {
-      std::cout << "Also check system files when warning about unused and " <<
-                   "uninitialized variables.\n";
+    } else if (arg.find("--check-system-vars", 0) == 0) {
+      std::cout << "Also check system files when warning about unused and "
+                << "uninitialized variables.\n";
       this->SetCheckSystemVars(true);
-      }
-    else if(arg.find("-A",0) == 0)
-      {
+    } else if (arg.find("-A", 0) == 0) {
       std::string value = arg.substr(2);
-      if(value.empty())
-        {
+      if (value.empty()) {
         ++i;
-        if(i >= args.size())
-          {
+        if (i >= args.size()) {
           cmSystemTools::Error("No platform specified for -A");
           return;
-          }
-        value = args[i];
         }
-      if(havePlatform)
-        {
+        value = args[i];
+      }
+      if (havePlatform) {
         cmSystemTools::Error("Multiple -A options not allowed");
         return;
-        }
+      }
       this->GeneratorPlatform = value;
       havePlatform = true;
-      }
-    else if(arg.find("-T",0) == 0)
-      {
+    } else if (arg.find("-T", 0) == 0) {
       std::string value = arg.substr(2);
-      if(value.empty())
-        {
+      if (value.empty()) {
         ++i;
-        if(i >= args.size())
-          {
+        if (i >= args.size()) {
           cmSystemTools::Error("No toolset specified for -T");
           return;
-          }
-        value = args[i];
         }
-      if(haveToolset)
-        {
+        value = args[i];
+      }
+      if (haveToolset) {
         cmSystemTools::Error("Multiple -T options not allowed");
         return;
-        }
+      }
       this->GeneratorToolset = value;
       haveToolset = true;
-      }
-    else if(arg.find("-G",0) == 0)
-      {
+    } else if (arg.find("-G", 0) == 0) {
       std::string value = arg.substr(2);
-      if(value.empty())
-        {
+      if (value.empty()) {
         ++i;
-        if(i >= args.size())
-          {
+        if (i >= args.size()) {
           cmSystemTools::Error("No generator specified for -G");
           this->PrintGeneratorList();
           return;
-          }
-        value = args[i];
         }
-      cmGlobalGenerator* gen =
-        this->CreateGlobalGenerator(value);
-      if(!gen)
-        {
+        value = args[i];
+      }
+      cmGlobalGenerator* gen = this->CreateGlobalGenerator(value);
+      if (!gen) {
         cmSystemTools::Error("Could not create named generator ",
                              value.c_str());
         this->PrintGeneratorList();
-        }
-      else
-        {
+      } else {
         this->SetGlobalGenerator(gen);
-        }
       }
+    }
     // no option assume it is the path to the source
-    else
-      {
+    else {
       directoriesSet = true;
       this->SetDirectoriesFromFile(arg.c_str());
-      }
-    }
-  if(!directoriesSet)
-    {
-    this->SetHomeOutputDirectory
-      (cmSystemTools::GetCurrentWorkingDirectory());
-    this->SetHomeDirectory
-      (cmSystemTools::GetCurrentWorkingDirectory());
     }
+  }
+  if (!directoriesSet) {
+    this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
+    this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
+  }
 }
 
 void cmake::SetDirectoriesFromFile(const char* arg)
@@ -821,92 +678,72 @@ void cmake::SetDirectoriesFromFile(const char* arg)
   std::string listPath;
   std::string cachePath;
   bool argIsFile = false;
-  if(cmSystemTools::FileIsDirectory(arg))
-    {
+  if (cmSystemTools::FileIsDirectory(arg)) {
     std::string path = cmSystemTools::CollapseFullPath(arg);
     cmSystemTools::ConvertToUnixSlashes(path);
     std::string cacheFile = path;
     cacheFile += "/CMakeCache.txt";
     std::string listFile = path;
     listFile += "/CMakeLists.txt";
-    if(cmSystemTools::FileExists(cacheFile.c_str()))
-      {
+    if (cmSystemTools::FileExists(cacheFile.c_str())) {
       cachePath = path;
-      }
-    if(cmSystemTools::FileExists(listFile.c_str()))
-      {
+    }
+    if (cmSystemTools::FileExists(listFile.c_str())) {
       listPath = path;
-      }
     }
-  else if(cmSystemTools::FileExists(arg))
-    {
+  } else if (cmSystemTools::FileExists(arg)) {
     argIsFile = true;
     std::string fullPath = cmSystemTools::CollapseFullPath(arg);
     std::string name = cmSystemTools::GetFilenameName(fullPath);
     name = cmSystemTools::LowerCase(name);
-    if(name == "cmakecache.txt")
-      {
+    if (name == "cmakecache.txt") {
       cachePath = cmSystemTools::GetFilenamePath(fullPath);
-      }
-    else if(name == "cmakelists.txt")
-      {
+    } else if (name == "cmakelists.txt") {
       listPath = cmSystemTools::GetFilenamePath(fullPath);
-      }
     }
-  else
-    {
+  } else {
     // Specified file or directory does not exist.  Try to set things
     // up to produce a meaningful error message.
     std::string fullPath = cmSystemTools::CollapseFullPath(arg);
     std::string name = cmSystemTools::GetFilenameName(fullPath);
     name = cmSystemTools::LowerCase(name);
-    if(name == "cmakecache.txt" || name == "cmakelists.txt")
-      {
+    if (name == "cmakecache.txt" || name == "cmakelists.txt") {
       argIsFile = true;
       listPath = cmSystemTools::GetFilenamePath(fullPath);
-      }
-    else
-      {
+    } else {
       listPath = fullPath;
-      }
     }
+  }
 
   // If there is a CMakeCache.txt file, use its settings.
-  if(!cachePath.empty())
-    {
-    if(this->LoadCache(cachePath))
-      {
+  if (!cachePath.empty()) {
+    if (this->LoadCache(cachePath)) {
       const char* existingValue =
-          this->State->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
-      if (existingValue)
-        {
+        this->State->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+      if (existingValue) {
         this->SetHomeOutputDirectory(cachePath);
         this->SetHomeDirectory(existingValue);
         return;
-        }
       }
     }
+  }
 
   // If there is a CMakeLists.txt file, use it as the source tree.
-  if(!listPath.empty())
-    {
+  if (!listPath.empty()) {
     this->SetHomeDirectory(listPath);
 
-    if(argIsFile)
-      {
+    if (argIsFile) {
       // Source CMakeLists.txt file given.  It was probably dropped
       // onto the executable in a GUI.  Default to an in-source build.
       this->SetHomeOutputDirectory(listPath);
-      }
-    else
-      {
+    } else {
       // Source directory given on command line.  Use current working
       // directory as build tree.
       std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
       this->SetHomeOutputDirectory(cwd);
-      }
-    return;
     }
+    return;
+  }
 
   // We didn't find a CMakeLists.txt or CMakeCache.txt file from the
   // argument.  Assume it is the path to the source tree, and use the
@@ -922,30 +759,29 @@ void cmake::SetDirectoriesFromFile(const char* arg)
 int cmake::AddCMakePaths()
 {
   // Save the value in the cache
-  this->AddCacheEntry
-    ("CMAKE_COMMAND", cmSystemTools::GetCMakeCommand().c_str(),
-     "Path to CMake executable.", cmState::INTERNAL);
+  this->AddCacheEntry("CMAKE_COMMAND",
+                      cmSystemTools::GetCMakeCommand().c_str(),
+                      "Path to CMake executable.", cmState::INTERNAL);
 #ifdef CMAKE_BUILD_WITH_CMAKE
-  this->AddCacheEntry
-    ("CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(),
-     "Path to ctest program executable.", cmState::INTERNAL);
-  this->AddCacheEntry
-    ("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(),
-     "Path to cpack program executable.", cmState::INTERNAL);
+  this->AddCacheEntry("CMAKE_CTEST_COMMAND",
+                      cmSystemTools::GetCTestCommand().c_str(),
+                      "Path to ctest program executable.", cmState::INTERNAL);
+  this->AddCacheEntry("CMAKE_CPACK_COMMAND",
+                      cmSystemTools::GetCPackCommand().c_str(),
+                      "Path to cpack program executable.", cmState::INTERNAL);
 #endif
-  if(!cmSystemTools::FileExists(
-       (cmSystemTools::GetCMakeRoot()+"/Modules/CMake.cmake").c_str()))
-    {
+  if (!cmSystemTools::FileExists(
+        (cmSystemTools::GetCMakeRoot() + "/Modules/CMake.cmake").c_str())) {
     // couldn't find modules
-    cmSystemTools::Error("Could not find CMAKE_ROOT !!!\n"
+    cmSystemTools::Error(
+      "Could not find CMAKE_ROOT !!!\n"
       "CMake has most likely not been installed correctly.\n"
       "Modules directory not found in\n",
       cmSystemTools::GetCMakeRoot().c_str());
     return 0;
-    }
-  this->AddCacheEntry
-    ("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
-     "Path to CMake installation.", cmState::INTERNAL);
+  }
+  this->AddCacheEntry("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
+                      "Path to CMake installation.", cmState::INTERNAL);
 
   return 1;
 }
@@ -955,17 +791,15 @@ void cmake::AddExtraGenerator(const std::string& name,
 {
   cmExternalMakefileProjectGenerator* extraGenerator = newFunction();
   const std::vector<std::string>& supportedGlobalGenerators =
-                                extraGenerator->GetSupportedGlobalGenerators();
-
-  for(std::vector<std::string>::const_iterator
-      it = supportedGlobalGenerators.begin();
-      it != supportedGlobalGenerators.end();
-      ++it )
-    {
-    std::string fullName = cmExternalMakefileProjectGenerator::
-                                    CreateFullGeneratorName(*it, name);
+    extraGenerator->GetSupportedGlobalGenerators();
+
+  for (std::vector<std::string>::const_iterator it =
+         supportedGlobalGenerators.begin();
+       it != supportedGlobalGenerators.end(); ++it) {
+    std::string fullName =
+      cmExternalMakefileProjectGenerator::CreateFullGeneratorName(*it, name);
     this->ExtraGenerators[fullName] = newFunction;
-    }
+  }
   delete extraGenerator;
 }
 
@@ -973,7 +807,7 @@ void cmake::AddDefaultExtraGenerators()
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  // e.g. kdevelop4 ?
+// e.g. kdevelop4 ?
 #endif
 
   this->AddExtraGenerator(cmExtraCodeBlocksGenerator::GetActualName(),
@@ -995,41 +829,38 @@ void cmake::AddDefaultExtraGenerators()
                           &cmGlobalKdevelopGenerator::New);
   // for kdevelop also add the generator with just the name of the
   // extra generator, since it was this way since cmake 2.2
-  this->ExtraGenerators[cmGlobalKdevelopGenerator::GetActualName()]
-                                             = &cmGlobalKdevelopGenerator::New;
+  this->ExtraGenerators[cmGlobalKdevelopGenerator::GetActualName()] =
+    &cmGlobalKdevelopGenerator::New;
 #endif
 
 #endif
 }
 
-
 void cmake::GetRegisteredGenerators(std::vector<GeneratorInfo>& generators)
 {
-  for (RegisteredGeneratorsVector::const_iterator
-       i = this->Generators.begin(), e = this->Generators.end();
-       i != e; ++i)
-    {
+  for (RegisteredGeneratorsVector::const_iterator i = this->Generators.begin(),
+                                                  e = this->Generators.end();
+       i != e; ++i) {
     std::vector<std::string> names;
     (*i)->GetGenerators(names);
 
-    for (size_t j = 0; j < names.size(); ++j)
-      {
+    for (size_t j = 0; j < names.size(); ++j) {
       GeneratorInfo info;
       info.supportsToolset = (*i)->SupportsToolset();
       info.name = names[j];
       generators.push_back(info);
-      }
     }
+  }
 
   for (RegisteredExtraGeneratorsMap::const_iterator
-       i = this->ExtraGenerators.begin(), e = this->ExtraGenerators.end();
-       i != e; ++i)
-    {
+         i = this->ExtraGenerators.begin(),
+         e = this->ExtraGenerators.end();
+       i != e; ++i) {
     GeneratorInfo info;
     info.name = i->first;
     info.supportsToolset = false;
     generators.push_back(info);
-    }
+  }
 }
 
 cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname)
@@ -1037,32 +868,26 @@ cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname)
   cmExternalMakefileProjectGenerator* extraGenerator = 0;
   std::string name = gname;
   RegisteredExtraGeneratorsMap::const_iterator extraGenIt =
-                                            this->ExtraGenerators.find(name);
-  if (extraGenIt != this->ExtraGenerators.end())
-    {
+    this->ExtraGenerators.find(name);
+  if (extraGenIt != this->ExtraGenerators.end()) {
     extraGenerator = (extraGenIt->second)();
     name = extraGenerator->GetGlobalGeneratorName(name);
-    }
+  }
 
   cmGlobalGenerator* generator = 0;
-  for (RegisteredGeneratorsVector::const_iterator i =
-    this->Generators.begin(); i != this->Generators.end(); ++i)
-    {
+  for (RegisteredGeneratorsVector::const_iterator i = this->Generators.begin();
+       i != this->Generators.end(); ++i) {
     generator = (*i)->CreateGlobalGenerator(name, this);
-    if (generator)
-      {
+    if (generator) {
       break;
-      }
     }
+  }
 
-  if (generator)
-    {
+  if (generator) {
     generator->SetExternalMakefileProjectGenerator(extraGenerator);
-    }
-  else
-    {
+  } else {
     delete extraGenerator;
-    }
+  }
 
   return generator;
 }
@@ -1070,10 +895,9 @@ cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname)
 void cmake::SetHomeDirectory(const std::string& dir)
 {
   this->State->SetSourceDirectory(dir);
-  if (this->CurrentSnapshot.IsValid())
-    {
+  if (this->CurrentSnapshot.IsValid()) {
     this->CurrentSnapshot.SetDefinition("CMAKE_SOURCE_DIR", dir);
-    }
+  }
 }
 
 const char* cmake::GetHomeDirectory() const
@@ -1084,10 +908,9 @@ const char* cmake::GetHomeDirectory() const
 void cmake::SetHomeOutputDirectory(const std::string& dir)
 {
   this->State->SetBinaryDirectory(dir);
-  if (this->CurrentSnapshot.IsValid())
-    {
+  if (this->CurrentSnapshot.IsValid()) {
     this->CurrentSnapshot.SetDefinition("CMAKE_BINARY_DIR", dir);
-    }
+  }
 }
 
 const char* cmake::GetHomeOutputDirectory() const
@@ -1095,60 +918,49 @@ const char* cmake::GetHomeOutputDirectory() const
   return this->State->GetBinaryDirectory();
 }
 
-void cmake::SetGlobalGenerator(cmGlobalGenerator *gg)
+void cmake::SetGlobalGenerator(cmGlobalGenerator* gg)
 {
-  if(!gg)
-    {
+  if (!gg) {
     cmSystemTools::Error("Error SetGlobalGenerator called with null");
     return;
-    }
+  }
   // delete the old generator
-  if (this->GlobalGenerator)
-    {
+  if (this->GlobalGenerator) {
     delete this->GlobalGenerator;
     // restore the original environment variables CXX and CC
     // Restore CC
     std::string env = "CC=";
-    if(!this->CCEnvironment.empty())
-      {
+    if (!this->CCEnvironment.empty()) {
       env += this->CCEnvironment;
-      }
+    }
     cmSystemTools::PutEnv(env);
     env = "CXX=";
-    if(!this->CXXEnvironment.empty())
-      {
+    if (!this->CXXEnvironment.empty()) {
       env += this->CXXEnvironment;
-      }
-    cmSystemTools::PutEnv(env);
     }
+    cmSystemTools::PutEnv(env);
+  }
 
   // set the new
   this->GlobalGenerator = gg;
 
   // set the global flag for unix style paths on cmSystemTools as soon as
   // the generator is set.  This allows gmake to be used on windows.
-  cmSystemTools::SetForceUnixPaths
-    (this->GlobalGenerator->GetForceUnixPaths());
+  cmSystemTools::SetForceUnixPaths(this->GlobalGenerator->GetForceUnixPaths());
 
   // Save the environment variables CXX and CC
   const char* cxx = getenv("CXX");
   const char* cc = getenv("CC");
-  if(cxx)
-    {
+  if (cxx) {
     this->CXXEnvironment = cxx;
-    }
-  else
-    {
+  } else {
     this->CXXEnvironment = "";
-    }
-  if(cc)
-    {
+  }
+  if (cc) {
     this->CCEnvironment = cc;
-    }
-  else
-    {
+  } else {
     this->CCEnvironment = "";
-    }
+  }
 }
 
 int cmake::DoPreConfigureChecks()
@@ -1156,40 +968,32 @@ int cmake::DoPreConfigureChecks()
   // Make sure the Source directory contains a CMakeLists.txt file.
   std::string srcList = this->GetHomeDirectory();
   srcList += "/CMakeLists.txt";
-  if(!cmSystemTools::FileExists(srcList.c_str()))
-    {
+  if (!cmSystemTools::FileExists(srcList.c_str())) {
     std::ostringstream err;
-    if(cmSystemTools::FileIsDirectory(this->GetHomeDirectory()))
-      {
+    if (cmSystemTools::FileIsDirectory(this->GetHomeDirectory())) {
       err << "The source directory \"" << this->GetHomeDirectory()
           << "\" does not appear to contain CMakeLists.txt.\n";
-      }
-    else if(cmSystemTools::FileExists(this->GetHomeDirectory()))
-      {
+    } else if (cmSystemTools::FileExists(this->GetHomeDirectory())) {
       err << "The source directory \"" << this->GetHomeDirectory()
           << "\" is a file, not a directory.\n";
-      }
-    else
-      {
+    } else {
       err << "The source directory \"" << this->GetHomeDirectory()
           << "\" does not exist.\n";
-      }
+    }
     err << "Specify --help for usage, or press the help button on the CMake "
-      "GUI.";
+           "GUI.";
     cmSystemTools::Error(err.str().c_str());
     return -2;
-    }
+  }
 
   // do a sanity check on some values
-  if(this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY"))
-    {
+  if (this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY")) {
     std::string cacheStart =
       this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY");
     cacheStart += "/CMakeLists.txt";
     std::string currentStart = this->GetHomeDirectory();
     currentStart += "/CMakeLists.txt";
-    if(!cmSystemTools::SameFile(cacheStart, currentStart))
-      {
+    if (!cmSystemTools::SameFile(cacheStart, currentStart)) {
       std::string message = "The source \"";
       message += currentStart;
       message += "\" does not match the source \"";
@@ -1198,12 +1002,10 @@ int cmake::DoPreConfigureChecks()
       message += "Re-run cmake with a different source directory.";
       cmSystemTools::Error(message.c_str());
       return -2;
-      }
     }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
   return 1;
 }
 struct SaveCacheEntry
@@ -1219,12 +1021,10 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
   std::vector<std::string> argsSplit;
   cmSystemTools::ExpandListArgument(std::string(var), argsSplit, true);
   // erase the property to avoid infinite recursion
-  this->State
-      ->SetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", "");
-  if(this->State->GetIsInTryCompile())
-    {
+  this->State->SetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", "");
+  if (this->State->GetIsInTryCompile()) {
     return 0;
-    }
+  }
   std::vector<SaveCacheEntry> saved;
   std::ostringstream warning;
   /* clang-format off */
@@ -1233,47 +1033,40 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
     << "Configure will be re-run and you may have to reset some variables.\n"
     << "The following variables have changed:\n";
   /* clang-format on */
-  for(std::vector<std::string>::iterator i = argsSplit.begin();
-      i != argsSplit.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = argsSplit.begin();
+       i != argsSplit.end(); ++i) {
     SaveCacheEntry save;
     save.key = *i;
     warning << *i << "= ";
     i++;
     save.value = *i;
     warning << *i << "\n";
-    const char* existingValue =
-        this->State->GetCacheEntryValue(save.key);
-    if(existingValue)
-      {
+    const char* existingValue = this->State->GetCacheEntryValue(save.key);
+    if (existingValue) {
       save.type = this->State->GetCacheEntryType(save.key);
-      if(const char* help =
-            this->State->GetCacheEntryProperty(save.key, "HELPSTRING"))
-        {
+      if (const char* help =
+            this->State->GetCacheEntryProperty(save.key, "HELPSTRING")) {
         save.help = help;
-        }
       }
-    saved.push_back(save);
     }
+    saved.push_back(save);
+  }
 
   // remove the cache
   this->DeleteCache(this->GetHomeOutputDirectory());
   // load the empty cache
   this->LoadCache();
   // restore the changed compilers
-  for(std::vector<SaveCacheEntry>::iterator i = saved.begin();
-      i != saved.end(); ++i)
-    {
-    this->AddCacheEntry(i->key, i->value.c_str(),
-                        i->help.c_str(), i->type);
-    }
+  for (std::vector<SaveCacheEntry>::iterator i = saved.begin();
+       i != saved.end(); ++i) {
+    this->AddCacheEntry(i->key, i->value.c_str(), i->help.c_str(), i->type);
+  }
   cmSystemTools::Message(warning.str().c_str());
   // avoid reconfigure if there were errors
-  if(!cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (!cmSystemTools::GetErrorOccuredFlag()) {
     // re-run configure
     return this->Configure();
-    }
+  }
   return 0;
 }
 
@@ -1281,87 +1074,69 @@ int cmake::Configure()
 {
   DiagLevel diagLevel;
 
-  if (this->DiagLevels.count("deprecated") == 1)
-    {
+  if (this->DiagLevels.count("deprecated") == 1) {
 
     diagLevel = this->DiagLevels["deprecated"];
-    if (diagLevel == DIAG_IGNORE)
-      {
+    if (diagLevel == DIAG_IGNORE) {
       this->SetSuppressDeprecatedWarnings(true);
       this->SetDeprecatedWarningsAsErrors(false);
-      }
-    else if (diagLevel == DIAG_WARN)
-      {
+    } else if (diagLevel == DIAG_WARN) {
       this->SetSuppressDeprecatedWarnings(false);
       this->SetDeprecatedWarningsAsErrors(false);
-      }
-    else if (diagLevel == DIAG_ERROR)
-      {
+    } else if (diagLevel == DIAG_ERROR) {
       this->SetSuppressDeprecatedWarnings(false);
       this->SetDeprecatedWarningsAsErrors(true);
-      }
     }
+  }
 
-  if (this->DiagLevels.count("dev") == 1)
-    {
+  if (this->DiagLevels.count("dev") == 1) {
     bool setDeprecatedVariables = false;
 
     const char* cachedWarnDeprecated =
-           this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
+      this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
     const char* cachedErrorDeprecated =
-           this->State->GetCacheEntryValue("CMAKE_ERROR_DEPRECATED");
+      this->State->GetCacheEntryValue("CMAKE_ERROR_DEPRECATED");
 
     // don't overwrite deprecated warning setting from a previous invocation
-    if (!cachedWarnDeprecated && !cachedErrorDeprecated)
-      {
+    if (!cachedWarnDeprecated && !cachedErrorDeprecated) {
       setDeprecatedVariables = true;
-      }
+    }
 
     diagLevel = this->DiagLevels["dev"];
-    if (diagLevel == DIAG_IGNORE)
-      {
+    if (diagLevel == DIAG_IGNORE) {
       this->SetSuppressDevWarnings(true);
       this->SetDevWarningsAsErrors(false);
 
-      if (setDeprecatedVariables)
-        {
+      if (setDeprecatedVariables) {
         this->SetSuppressDeprecatedWarnings(true);
         this->SetDeprecatedWarningsAsErrors(false);
-        }
       }
-    else if (diagLevel == DIAG_WARN)
-      {
+    } else if (diagLevel == DIAG_WARN) {
       this->SetSuppressDevWarnings(false);
       this->SetDevWarningsAsErrors(false);
 
-      if (setDeprecatedVariables)
-        {
+      if (setDeprecatedVariables) {
         this->SetSuppressDeprecatedWarnings(false);
         this->SetDeprecatedWarningsAsErrors(false);
-        }
       }
-    else if (diagLevel == DIAG_ERROR)
-      {
+    } else if (diagLevel == DIAG_ERROR) {
       this->SetSuppressDevWarnings(false);
       this->SetDevWarningsAsErrors(true);
 
-      if (setDeprecatedVariables)
-        {
+      if (setDeprecatedVariables) {
         this->SetSuppressDeprecatedWarnings(false);
         this->SetDeprecatedWarningsAsErrors(true);
-        }
       }
     }
+  }
 
   int ret = this->ActualConfigure();
-  const char* delCacheVars = this->State
-                    ->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_");
-  if(delCacheVars && delCacheVars[0] != 0)
-    {
+  const char* delCacheVars =
+    this->State->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_");
+  if (delCacheVars && delCacheVars[0] != 0) {
     return this->HandleDeleteCacheVariables(delCacheVars);
-    }
+  }
   return ret;
-
 }
 
 int cmake::ActualConfigure()
@@ -1371,48 +1146,39 @@ int cmake::ActualConfigure()
   this->CleanupCommandsAndMacros();
 
   int res = 0;
-  if ( this->GetWorkingMode() == NORMAL_MODE )
-    {
+  if (this->GetWorkingMode() == NORMAL_MODE) {
     res = this->DoPreConfigureChecks();
-    }
-  if ( res < 0 )
-    {
+  }
+  if (res < 0) {
     return -2;
-    }
-  if ( !res )
-    {
-    this->AddCacheEntry
-      ("CMAKE_HOME_DIRECTORY",
-       this->GetHomeDirectory(),
-       "Source directory with the top level CMakeLists.txt file for this "
-       "project",
-       cmState::INTERNAL);
-    }
+  }
+  if (!res) {
+    this->AddCacheEntry(
+      "CMAKE_HOME_DIRECTORY", this->GetHomeDirectory(),
+      "Source directory with the top level CMakeLists.txt file for this "
+      "project",
+      cmState::INTERNAL);
+  }
 
   // no generator specified on the command line
-  if(!this->GlobalGenerator)
-    {
+  if (!this->GlobalGenerator) {
     const char* genName =
       this->State->GetInitializedCacheValue("CMAKE_GENERATOR");
     const char* extraGenName =
       this->State->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
-    if(genName)
-      {
-      std::string fullName = cmExternalMakefileProjectGenerator::
-                                CreateFullGeneratorName(genName,
-                                    extraGenName ? extraGenName : "");
+    if (genName) {
+      std::string fullName =
+        cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
+          genName, extraGenName ? extraGenName : "");
       this->GlobalGenerator = this->CreateGlobalGenerator(fullName);
-      }
-    if(this->GlobalGenerator)
-      {
+    }
+    if (this->GlobalGenerator) {
       // set the global flag for unix style paths on cmSystemTools as
       // soon as the generator is set.  This allows gmake to be used
       // on windows.
-      cmSystemTools::SetForceUnixPaths
-        (this->GlobalGenerator->GetForceUnixPaths());
-      }
-    else
-      {
+      cmSystemTools::SetForceUnixPaths(
+        this->GlobalGenerator->GetForceUnixPaths());
+    } else {
 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW)
       std::string installedCompiler;
       // Try to find the newest VS installed on the computer and
@@ -1430,143 +1196,116 @@ int cmake::ActualConfigure()
       };
       VSRegistryEntryName version[] = {
         /* clang-format needs this comment to break after the opening brace */
-        {"7.1", "Visual Studio 7 .NET 2003"},
-        {"8.0", "Visual Studio 8 2005"},
-        {"9.0", "Visual Studio 9 2008"},
-        {"10.0", "Visual Studio 10 2010"},
-        {"11.0", "Visual Studio 11 2012"},
-        {"12.0", "Visual Studio 12 2013"},
-        {"14.0", "Visual Studio 14 2015"},
-        {0, 0}};
-      for(int i=0; version[i].MSVersion != 0; i++)
-        {
-        for(size_t b=0; b < vsVerions.size(); b++)
-          {
+        { "7.1", "Visual Studio 7 .NET 2003" },
+        { "8.0", "Visual Studio 8 2005" },
+        { "9.0", "Visual Studio 9 2008" },
+        { "10.0", "Visual Studio 10 2010" },
+        { "11.0", "Visual Studio 11 2012" },
+        { "12.0", "Visual Studio 12 2013" },
+        { "14.0", "Visual Studio 14 2015" },
+        { 0, 0 }
+      };
+      for (int i = 0; version[i].MSVersion != 0; i++) {
+        for (size_t b = 0; b < vsVerions.size(); b++) {
           std::string reg = vsregBase + vsVerions[b] + version[i].MSVersion;
           reg += ";InstallDir]";
-          cmSystemTools::ExpandRegistryValues(reg,
-                                              cmSystemTools::KeyWOW64_32);
-          if (!(reg == "/registry"))
-            {
+          cmSystemTools::ExpandRegistryValues(reg, cmSystemTools::KeyWOW64_32);
+          if (!(reg == "/registry")) {
             installedCompiler = version[i].GeneratorName;
             break;
-            }
           }
         }
-      cmGlobalGenerator* gen
-        = this->CreateGlobalGenerator(installedCompiler.c_str());
-      if(!gen)
-        {
+      }
+      cmGlobalGenerator* gen =
+        this->CreateGlobalGenerator(installedCompiler.c_str());
+      if (!gen) {
         gen = new cmGlobalNMakeMakefileGenerator(this);
-        }
+      }
       this->SetGlobalGenerator(gen);
       std::cout << "-- Building for: " << gen->GetName() << "\n";
 #else
       this->SetGlobalGenerator(new cmGlobalUnixMakefileGenerator3(this));
 #endif
-      }
-    if(!this->GlobalGenerator)
-      {
+    }
+    if (!this->GlobalGenerator) {
       cmSystemTools::Error("Could not create generator");
       return -1;
-      }
     }
+  }
 
-  const char* genName = this->State
-                            ->GetInitializedCacheValue("CMAKE_GENERATOR");
-  if(genName)
-    {
-    if(!this->GlobalGenerator->MatchesGeneratorName(genName))
-      {
+  const char* genName =
+    this->State->GetInitializedCacheValue("CMAKE_GENERATOR");
+  if (genName) {
+    if (!this->GlobalGenerator->MatchesGeneratorName(genName)) {
       std::string message = "Error: generator : ";
       message += this->GlobalGenerator->GetName();
       message += "\nDoes not match the generator used previously: ";
       message += genName;
-      message +=
-        "\nEither remove the CMakeCache.txt file and CMakeFiles "
-        "directory or choose a different binary directory.";
+      message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
+                 "directory or choose a different binary directory.";
       cmSystemTools::Error(message.c_str());
       return -2;
-      }
     }
-  if(!this->State->GetInitializedCacheValue("CMAKE_GENERATOR"))
-    {
+  }
+  if (!this->State->GetInitializedCacheValue("CMAKE_GENERATOR")) {
     this->AddCacheEntry("CMAKE_GENERATOR",
-                                      this->GlobalGenerator->GetName().c_str(),
-                                      "Name of generator.",
-                                      cmState::INTERNAL);
+                        this->GlobalGenerator->GetName().c_str(),
+                        "Name of generator.", cmState::INTERNAL);
     this->AddCacheEntry("CMAKE_EXTRA_GENERATOR",
                         this->GlobalGenerator->GetExtraGeneratorName().c_str(),
                         "Name of external makefile project generator.",
                         cmState::INTERNAL);
-    }
+  }
 
-  if(const char* platformName =
-     this->State->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM"))
-    {
-    if(this->GeneratorPlatform.empty())
-      {
+  if (const char* platformName =
+        this->State->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM")) {
+    if (this->GeneratorPlatform.empty()) {
       this->GeneratorPlatform = platformName;
-      }
-    else if(this->GeneratorPlatform != platformName)
-      {
+    } else if (this->GeneratorPlatform != platformName) {
       std::string message = "Error: generator platform: ";
       message += this->GeneratorPlatform;
       message += "\nDoes not match the platform used previously: ";
       message += platformName;
-      message +=
-        "\nEither remove the CMakeCache.txt file and CMakeFiles "
-        "directory or choose a different binary directory.";
+      message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
+                 "directory or choose a different binary directory.";
       cmSystemTools::Error(message.c_str());
       return -2;
-      }
     }
-  else
-    {
+  } else {
     this->AddCacheEntry("CMAKE_GENERATOR_PLATFORM",
-                                      this->GeneratorPlatform.c_str(),
-                                      "Name of generator platform.",
-                                      cmState::INTERNAL);
-    }
+                        this->GeneratorPlatform.c_str(),
+                        "Name of generator platform.", cmState::INTERNAL);
+  }
 
-  if(const char* tsName =
-     this->State->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET"))
-    {
-    if(this->GeneratorToolset.empty())
-      {
+  if (const char* tsName =
+        this->State->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET")) {
+    if (this->GeneratorToolset.empty()) {
       this->GeneratorToolset = tsName;
-      }
-    else if(this->GeneratorToolset != tsName)
-      {
+    } else if (this->GeneratorToolset != tsName) {
       std::string message = "Error: generator toolset: ";
       message += this->GeneratorToolset;
       message += "\nDoes not match the toolset used previously: ";
       message += tsName;
-      message +=
-        "\nEither remove the CMakeCache.txt file and CMakeFiles "
-        "directory or choose a different binary directory.";
+      message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
+                 "directory or choose a different binary directory.";
       cmSystemTools::Error(message.c_str());
       return -2;
-      }
     }
-  else
-    {
+  } else {
     this->AddCacheEntry("CMAKE_GENERATOR_TOOLSET",
-                                      this->GeneratorToolset.c_str(),
-                                      "Name of generator toolset.",
-                                      cmState::INTERNAL);
-    }
+                        this->GeneratorToolset.c_str(),
+                        "Name of generator toolset.", cmState::INTERNAL);
+  }
 
   // reset any system configuration information, except for when we are
   // InTryCompile. With TryCompile the system info is taken from the parent's
   // info to save time
-  if (!this->State->GetIsInTryCompile())
-    {
+  if (!this->State->GetIsInTryCompile()) {
     this->GlobalGenerator->ClearEnabledLanguages();
 
     this->TruncateOutputLog("CMakeOutput.log");
     this->TruncateOutputLog("CMakeError.log");
-    }
+  }
 
   // actually do the configure
   this->GlobalGenerator->Configure();
@@ -1580,45 +1319,37 @@ int cmake::ActualConfigure()
   // project requires compatibility with CMake 2.4.  We detect this
   // here by looking for the old CMAKE_BACKWARDS_COMPATIBILITY
   // variable created when CMP0001 is not set to NEW.
-  if(this->State
-         ->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
-    {
-    if(!this->State->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
-      {
-      this->AddCacheEntry
-        ("LIBRARY_OUTPUT_PATH", "",
-         "Single output directory for building all libraries.",
-         cmState::PATH);
-      }
-    if(!this->State
-            ->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH"))
-      {
-      this->AddCacheEntry
-        ("EXECUTABLE_OUTPUT_PATH", "",
-         "Single output directory for building all executables.",
-         cmState::PATH);
-      }
+  if (this->State->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")) {
+    if (!this->State->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH")) {
+      this->AddCacheEntry(
+        "LIBRARY_OUTPUT_PATH", "",
+        "Single output directory for building all libraries.", cmState::PATH);
+    }
+    if (!this->State->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH")) {
+      this->AddCacheEntry(
+        "EXECUTABLE_OUTPUT_PATH", "",
+        "Single output directory for building all executables.",
+        cmState::PATH);
     }
+  }
 
-  cmMakefile* mf=this->GlobalGenerator->GetMakefiles()[0];
-  if (mf->IsOn("CTEST_USE_LAUNCHERS")
-              && !this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE"))
-    {
-    cmSystemTools::Error("CTEST_USE_LAUNCHERS is enabled, but the "
-                        "RULE_LAUNCH_COMPILE global property is not defined.\n"
-                        "Did you forget to include(CTest) in the toplevel "
-                         "CMakeLists.txt ?");
-    }
+  cmMakefile* mf = this->GlobalGenerator->GetMakefiles()[0];
+  if (mf->IsOn("CTEST_USE_LAUNCHERS") &&
+      !this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE")) {
+    cmSystemTools::Error(
+      "CTEST_USE_LAUNCHERS is enabled, but the "
+      "RULE_LAUNCH_COMPILE global property is not defined.\n"
+      "Did you forget to include(CTest) in the toplevel "
+      "CMakeLists.txt ?");
+  }
 
   // only save the cache if there were no fatal errors
-  if ( this->GetWorkingMode() == NORMAL_MODE )
-    {
+  if (this->GetWorkingMode() == NORMAL_MODE) {
     this->SaveCache(this->GetHomeOutputDirectory());
-    }
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  }
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return -1;
-    }
+  }
   return 0;
 }
 
@@ -1626,23 +1357,19 @@ void cmake::PreLoadCMakeFiles()
 {
   std::vector<std::string> args;
   std::string pre_load = this->GetHomeDirectory();
-  if (!pre_load.empty())
-    {
+  if (!pre_load.empty()) {
     pre_load += "/PreLoad.cmake";
-    if ( cmSystemTools::FileExists(pre_load.c_str()) )
-      {
+    if (cmSystemTools::FileExists(pre_load.c_str())) {
       this->ReadListFile(args, pre_load.c_str());
-      }
     }
+  }
   pre_load = this->GetHomeOutputDirectory();
-  if (!pre_load.empty())
-    {
+  if (!pre_load.empty()) {
     pre_load += "/PreLoad.cmake";
-    if ( cmSystemTools::FileExists(pre_load.c_str()) )
-      {
+    if (cmSystemTools::FileExists(pre_load.c_str())) {
       this->ReadListFile(args, pre_load.c_str());
-      }
     }
+  }
 }
 
 // handle a command line invocation
@@ -1650,104 +1377,86 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
 {
   // Process the arguments
   this->SetArgs(args);
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return -1;
-    }
+  }
 
   // If we are given a stamp list file check if it is really out of date.
-  if(!this->CheckStampList.empty() &&
-     cmakeCheckStampList(this->CheckStampList.c_str()))
-    {
+  if (!this->CheckStampList.empty() &&
+      cmakeCheckStampList(this->CheckStampList.c_str())) {
     return 0;
-    }
+  }
 
   // If we are given a stamp file check if it is really out of date.
-  if(!this->CheckStampFile.empty() &&
-     cmakeCheckStampFile(this->CheckStampFile.c_str()))
-    {
+  if (!this->CheckStampFile.empty() &&
+      cmakeCheckStampFile(this->CheckStampFile.c_str())) {
     return 0;
-    }
+  }
 
-  if ( this->GetWorkingMode() == NORMAL_MODE )
-    {
+  if (this->GetWorkingMode() == NORMAL_MODE) {
     // load the cache
-    if(this->LoadCache() < 0)
-      {
+    if (this->LoadCache() < 0) {
       cmSystemTools::Error("Error executing cmake::LoadCache(). Aborting.\n");
       return -1;
-      }
     }
-  else
-    {
+  } else {
     this->AddCMakePaths();
-    }
+  }
 
   // Add any cache args
-  if ( !this->SetCacheArgs(args) )
-    {
+  if (!this->SetCacheArgs(args)) {
     cmSystemTools::Error("Problem processing arguments. Aborting.\n");
     return -1;
-    }
+  }
 
   // In script mode we terminate after running the script.
-  if(this->GetWorkingMode() != NORMAL_MODE)
-    {
-    if(cmSystemTools::GetErrorOccuredFlag())
-      {
+  if (this->GetWorkingMode() != NORMAL_MODE) {
+    if (cmSystemTools::GetErrorOccuredFlag()) {
       return -1;
-      }
-    else
-      {
+    } else {
       return 0;
-      }
     }
+  }
 
   // If MAKEFLAGS are given in the environment, remove the environment
   // variable.  This will prevent try-compile from succeeding when it
   // should fail (if "-i" is an option).  We cannot simply test
   // whether "-i" is given and remove it because some make programs
   // encode the MAKEFLAGS variable in a strange way.
-  if(getenv("MAKEFLAGS"))
-    {
+  if (getenv("MAKEFLAGS")) {
     cmSystemTools::PutEnv("MAKEFLAGS=");
-    }
+  }
 
   this->PreLoadCMakeFiles();
 
-  if ( noconfigure )
-    {
+  if (noconfigure) {
     return 0;
-    }
+  }
 
   // now run the global generate
   // Check the state of the build system to see if we need to regenerate.
-  if(!this->CheckBuildSystem())
-    {
+  if (!this->CheckBuildSystem()) {
     return 0;
-    }
+  }
 
   int ret = this->Configure();
-  if (ret || this->GetWorkingMode() != NORMAL_MODE)
-    {
+  if (ret || this->GetWorkingMode() != NORMAL_MODE) {
 #if defined(CMAKE_HAVE_VS_GENERATORS)
-    if(!this->VSSolutionFile.empty() && this->GlobalGenerator)
-      {
+    if (!this->VSSolutionFile.empty() && this->GlobalGenerator) {
       // CMake is running to regenerate a Visual Studio build tree
       // during a build from the VS IDE.  The build files cannot be
       // regenerated, so we should stop the build.
-      cmSystemTools::Message(
-        "CMake Configure step failed.  "
-        "Build files cannot be regenerated correctly.  "
-        "Attempting to stop IDE build.");
+      cmSystemTools::Message("CMake Configure step failed.  "
+                             "Build files cannot be regenerated correctly.  "
+                             "Attempting to stop IDE build.");
       cmGlobalVisualStudioGenerator* gg =
         static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
       gg->CallVisualStudioMacro(cmGlobalVisualStudioGenerator::MacroStop,
                                 this->VSSolutionFile.c_str());
-      }
+    }
 #endif
     return ret;
-    }
+  }
   ret = this->Generate();
   std::string message = "Build files have been written to: ";
   message += this->GetHomeOutputDirectory();
@@ -1757,45 +1466,37 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
 
 int cmake::Generate()
 {
-  if(!this->GlobalGenerator)
-    {
+  if (!this->GlobalGenerator) {
     return -1;
-    }
-  if (!this->GlobalGenerator->Compute())
-    {
+  }
+  if (!this->GlobalGenerator->Compute()) {
     return -1;
-    }
+  }
   this->GlobalGenerator->Generate();
-  if ( !this->GraphVizFile.empty() )
-    {
+  if (!this->GraphVizFile.empty()) {
     std::cout << "Generate graphviz: " << this->GraphVizFile << std::endl;
     this->GenerateGraphViz(this->GraphVizFile.c_str());
-    }
-  if(this->WarnUnusedCli)
-    {
+  }
+  if (this->WarnUnusedCli) {
     this->RunCheckForUnusedVariables();
-    }
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
+  }
+  if (cmSystemTools::GetErrorOccuredFlag()) {
     return -1;
-    }
+  }
   // Save the cache again after a successful Generate so that any internal
   // variables created during Generate are saved. (Specifically target GUIDs
   // for the Visual Studio and Xcode generators.)
-  if ( this->GetWorkingMode() == NORMAL_MODE )
-    {
+  if (this->GetWorkingMode() == NORMAL_MODE) {
     this->SaveCache(this->GetHomeOutputDirectory());
-    }
+  }
   return 0;
 }
 
 void cmake::AddCacheEntry(const std::string& key, const char* value,
-                          const char* helpString,
-                          int type)
+                          const char* helpString, int type)
 {
-  this->State->AddCacheEntry(key, value,
-                                    helpString,
-                                    cmState::CacheEntryType(type));
+  this->State->AddCacheEntry(key, value, helpString,
+                             cmState::CacheEntryType(type));
   this->UnwatchUnusedCli(key);
 }
 
@@ -1810,65 +1511,45 @@ void cmake::AddDefaultCommands()
   GetBootstrapCommands1(commands);
   GetBootstrapCommands2(commands);
   GetPredefinedCommands(commands);
-  for(std::vector<cmCommand*>::iterator i = commands.begin();
-      i != commands.end(); ++i)
-    {
+  for (std::vector<cmCommand*>::iterator i = commands.begin();
+       i != commands.end(); ++i) {
     this->State->AddCommand(*i);
-    }
+  }
 }
 
 void cmake::AddDefaultGenerators()
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-# if !defined(CMAKE_BOOT_MINGW)
-  this->Generators.push_back(
-    cmGlobalVisualStudio14Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalVisualStudio12Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalVisualStudio11Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalVisualStudio10Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalVisualStudio9Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalVisualStudio8Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalVisualStudio71Generator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalBorlandMakefileGenerator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalNMakeMakefileGenerator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalJOMMakefileGenerator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalGhsMultiGenerator::NewFactory());
-# endif
-  this->Generators.push_back(
-    cmGlobalMSYSMakefileGenerator::NewFactory());
-  this->Generators.push_back(
-    cmGlobalMinGWMakefileGenerator::NewFactory());
+#if !defined(CMAKE_BOOT_MINGW)
+  this->Generators.push_back(cmGlobalVisualStudio14Generator::NewFactory());
+  this->Generators.push_back(cmGlobalVisualStudio12Generator::NewFactory());
+  this->Generators.push_back(cmGlobalVisualStudio11Generator::NewFactory());
+  this->Generators.push_back(cmGlobalVisualStudio10Generator::NewFactory());
+  this->Generators.push_back(cmGlobalVisualStudio9Generator::NewFactory());
+  this->Generators.push_back(cmGlobalVisualStudio8Generator::NewFactory());
+  this->Generators.push_back(cmGlobalVisualStudio71Generator::NewFactory());
+  this->Generators.push_back(cmGlobalBorlandMakefileGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalNMakeMakefileGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalJOMMakefileGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalGhsMultiGenerator::NewFactory());
+#endif
+  this->Generators.push_back(cmGlobalMSYSMakefileGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalMinGWMakefileGenerator::NewFactory());
 #endif
-  this->Generators.push_back(
-    cmGlobalUnixMakefileGenerator3::NewFactory());
+  this->Generators.push_back(cmGlobalUnixMakefileGenerator3::NewFactory());
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-  this->Generators.push_back(
-    cmGlobalNinjaGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalNinjaGenerator::NewFactory());
 #endif
 #if defined(CMAKE_USE_WMAKE)
-  this->Generators.push_back(
-    cmGlobalWatcomWMakeGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalWatcomWMakeGenerator::NewFactory());
 #endif
 #ifdef CMAKE_USE_XCODE
-  this->Generators.push_back(
-    cmGlobalXCodeGenerator::NewFactory());
+  this->Generators.push_back(cmGlobalXCodeGenerator::NewFactory());
 #endif
 }
 
-bool cmake::ParseCacheEntry(const std::string& entry,
-                            std::string& var,
-                            std::string& value,
-                            cmState::CacheEntryType& type)
+bool cmake::ParseCacheEntry(const std::string& entry, std::string& var,
+                            std::string& value, cmState::CacheEntryType& type)
 {
   return cmState::ParseCacheEntry(entry, var, value, type);
 }
@@ -1876,26 +1557,23 @@ bool cmake::ParseCacheEntry(const std::string& entry,
 int cmake::LoadCache()
 {
   // could we not read the cache
-  if (!this->LoadCache(this->GetHomeOutputDirectory()))
-    {
+  if (!this->LoadCache(this->GetHomeOutputDirectory())) {
     // if it does exist, but isn't readable then warn the user
     std::string cacheFile = this->GetHomeOutputDirectory();
     cacheFile += "/CMakeCache.txt";
-    if(cmSystemTools::FileExists(cacheFile.c_str()))
-      {
+    if (cmSystemTools::FileExists(cacheFile.c_str())) {
       cmSystemTools::Error(
         "There is a CMakeCache.txt file for the current binary tree but "
         "cmake does not have permission to read it. Please check the "
         "permissions of the directory you are trying to run CMake on.");
       return -1;
-      }
     }
+  }
 
   // setup CMAKE_ROOT and CMAKE_COMMAND
-  if(!this->AddCMakePaths())
-    {
+  if (!this->AddCMakePaths()) {
     return -3;
-    }
+  }
   return 0;
 }
 
@@ -1906,32 +1584,30 @@ bool cmake::LoadCache(const std::string& path)
 }
 
 bool cmake::LoadCache(const std::string& path, bool internal,
-                std::set<std::string>& excludes,
-                std::set<std::string>& includes)
+                      std::set<std::string>& excludes,
+                      std::set<std::string>& includes)
 {
   bool result = this->State->LoadCache(path, internal, excludes, includes);
-  static const char* entries[] = {"CMAKE_CACHE_MAJOR_VERSION",
-                                  "CMAKE_CACHE_MINOR_VERSION"};
+  static const char* entries[] = { "CMAKE_CACHE_MAJOR_VERSION",
+                                   "CMAKE_CACHE_MINOR_VERSION" };
   for (const char* const* nameIt = cmArrayBegin(entries);
-       nameIt != cmArrayEnd(entries); ++nameIt)
-    {
+       nameIt != cmArrayEnd(entries); ++nameIt) {
     this->UnwatchUnusedCli(*nameIt);
-    }
+  }
   return result;
 }
 
 bool cmake::SaveCache(const std::string& path)
 {
   bool result = this->State->SaveCache(path);
-  static const char* entries[] = {"CMAKE_CACHE_MAJOR_VERSION",
-                                  "CMAKE_CACHE_MINOR_VERSION",
-                                  "CMAKE_CACHE_PATCH_VERSION",
-                                  "CMAKE_CACHEFILE_DIR"};
+  static const char* entries[] = { "CMAKE_CACHE_MAJOR_VERSION",
+                                   "CMAKE_CACHE_MINOR_VERSION",
+                                   "CMAKE_CACHE_PATCH_VERSION",
+                                   "CMAKE_CACHEFILE_DIR" };
   for (const char* const* nameIt = cmArrayBegin(entries);
-       nameIt != cmArrayEnd(entries); ++nameIt)
-    {
+       nameIt != cmArrayEnd(entries); ++nameIt) {
     this->UnwatchUnusedCli(*nameIt);
-    }
+  }
   return result;
 }
 
@@ -1940,19 +1616,18 @@ bool cmake::DeleteCache(const std::string& path)
   return this->State->DeleteCache(path);
 }
 
-void cmake::SetProgressCallback(ProgressCallbackType f, void *cd)
+void cmake::SetProgressCallback(ProgressCallbackType f, void* cd)
 {
   this->ProgressCallback = f;
   this->ProgressCallbackClientData = cd;
 }
 
-void cmake::UpdateProgress(const char *msg, float prog)
+void cmake::UpdateProgress(const char* msg, float prog)
 {
-  if(this->ProgressCallback && !this->State->GetIsInTryCompile())
-    {
+  if (this->ProgressCallback && !this->State->GetIsInTryCompile()) {
     (*this->ProgressCallback)(msg, prog, this->ProgressCallbackClientData);
     return;
-    }
+  }
 }
 
 bool cmake::GetIsInTryCompile() const
@@ -1967,23 +1642,22 @@ void cmake::SetIsInTryCompile(bool b)
 
 void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
 {
-  for(RegisteredGeneratorsVector::const_iterator i =
-      this->Generators.begin(); i != this->Generators.end(); ++i)
-    {
+  for (RegisteredGeneratorsVector::const_iterator i = this->Generators.begin();
+       i != this->Generators.end(); ++i) {
     cmDocumentationEntry e;
     (*i)->GetDocumentation(e);
     v.push_back(e);
-    }
-  for(RegisteredExtraGeneratorsMap::const_iterator i =
-      this->ExtraGenerators.begin(); i != this->ExtraGenerators.end(); ++i)
-    {
+  }
+  for (RegisteredExtraGeneratorsMap::const_iterator i =
+         this->ExtraGenerators.begin();
+       i != this->ExtraGenerators.end(); ++i) {
     cmDocumentationEntry e;
     cmExternalMakefileProjectGenerator* generator = (i->second)();
     generator->GetDocumentation(e, i->first);
     e.Name = i->first;
     delete generator;
     v.push_back(e);
-    }
+  }
 }
 
 void cmake::PrintGeneratorList()
@@ -1992,7 +1666,7 @@ void cmake::PrintGeneratorList()
   cmDocumentation doc;
   std::vector<cmDocumentationEntry> generators;
   this->GetGeneratorDocumentation(generators);
-  doc.AppendSection("Generators",generators);
+  doc.AppendSection("Generators", generators);
   std::cerr << "\n";
   doc.PrintDocumentation(cmDocumentation::ListGenerators, std::cerr);
 #endif
@@ -2002,29 +1676,24 @@ void cmake::UpdateConversionPathTable()
 {
   // Update the path conversion table with any specified file:
   const char* tablepath =
-    this->State
-        ->GetInitializedCacheValue("CMAKE_PATH_TRANSLATION_FILE");
+    this->State->GetInitializedCacheValue("CMAKE_PATH_TRANSLATION_FILE");
 
-  if(tablepath)
-    {
-    cmsys::ifstream table( tablepath );
-    if(!table)
-      {
+  if (tablepath) {
+    cmsys::ifstream table(tablepath);
+    if (!table) {
       cmSystemTools::Error("CMAKE_PATH_TRANSLATION_FILE set to ", tablepath,
-        ". CMake can not open file.");
+                           ". CMake can not open file.");
       cmSystemTools::ReportLastSystemError("CMake can not open file.");
-      }
-    else
-      {
+    } else {
       std::string a, b;
-      while(!table.eof())
-        {
+      while (!table.eof()) {
         // two entries per line
-        table >> a; table >> b;
-        cmSystemTools::AddTranslationPath( a, b);
-        }
+        table >> a;
+        table >> b;
+        cmSystemTools::AddTranslationPath(a, b);
       }
     }
+  }
 }
 
 int cmake::CheckBuildSystem()
@@ -2033,37 +1702,33 @@ int cmake::CheckBuildSystem()
   // the make system's VERBOSE environment variable to enable verbose
   // output. This can be skipped by setting CMAKE_NO_VERBOSE (which is set
   // by the Eclipse and KDevelop generators).
-  bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != 0)
-                   && (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == 0));
+  bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != 0) &&
+                  (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == 0));
 
   // This method will check the integrity of the build system if the
   // option was given on the command line.  It reads the given file to
   // determine whether CMake should rerun.
 
   // If no file is provided for the check, we have to rerun.
-  if(this->CheckBuildSystemArgument.empty())
-    {
-    if(verbose)
-      {
+  if (this->CheckBuildSystemArgument.empty()) {
+    if (verbose) {
       std::ostringstream msg;
       msg << "Re-run cmake no build system arguments\n";
       cmSystemTools::Stdout(msg.str().c_str());
-      }
-    return 1;
     }
+    return 1;
+  }
 
   // If the file provided does not exist, we have to rerun.
-  if(!cmSystemTools::FileExists(this->CheckBuildSystemArgument.c_str()))
-    {
-    if(verbose)
-      {
+  if (!cmSystemTools::FileExists(this->CheckBuildSystemArgument.c_str())) {
+    if (verbose) {
       std::ostringstream msg;
-      msg << "Re-run cmake missing file: "
-          << this->CheckBuildSystemArgument << "\n";
+      msg << "Re-run cmake missing file: " << this->CheckBuildSystemArgument
+          << "\n";
       cmSystemTools::Stdout(msg.str().c_str());
-      }
-    return 1;
     }
+    return 1;
+  }
 
   // Read the rerun check file and use it to decide whether to do the
   // global generate.
@@ -2073,156 +1738,129 @@ int cmake::CheckBuildSystem()
   cm.GetCurrentSnapshot().SetDefaultDefinitions();
   cmGlobalGenerator gg(&cm);
   cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
-  if(!mf->ReadListFile(this->CheckBuildSystemArgument.c_str()) ||
-     cmSystemTools::GetErrorOccuredFlag())
-    {
-    if(verbose)
-      {
+  if (!mf->ReadListFile(this->CheckBuildSystemArgument.c_str()) ||
+      cmSystemTools::GetErrorOccuredFlag()) {
+    if (verbose) {
       std::ostringstream msg;
-      msg << "Re-run cmake error reading : "
-          << this->CheckBuildSystemArgument << "\n";
+      msg << "Re-run cmake error reading : " << this->CheckBuildSystemArgument
+          << "\n";
       cmSystemTools::Stdout(msg.str().c_str());
-      }
+    }
     // There was an error reading the file.  Just rerun.
     return 1;
-    }
+  }
 
-  if(this->ClearBuildSystem)
-    {
+  if (this->ClearBuildSystem) {
     // Get the generator used for this build system.
     const char* genName = mf->GetDefinition("CMAKE_DEPENDS_GENERATOR");
-    if(!genName || genName[0] == '\0')
-      {
+    if (!genName || genName[0] == '\0') {
       genName = "Unix Makefiles";
-      }
+    }
 
     // Create the generator and use it to clear the dependencies.
-    cmsys::auto_ptr<cmGlobalGenerator>
-      ggd(this->CreateGlobalGenerator(genName));
-    if(ggd.get())
-      {
+    cmsys::auto_ptr<cmGlobalGenerator> ggd(
+      this->CreateGlobalGenerator(genName));
+    if (ggd.get()) {
       cm.GetCurrentSnapshot().SetDefaultDefinitions();
-      cmsys::auto_ptr<cmMakefile> mfd(new cmMakefile(ggd.get(),
-                                                    cm.GetCurrentSnapshot()));
+      cmsys::auto_ptr<cmMakefile> mfd(
+        new cmMakefile(ggd.get(), cm.GetCurrentSnapshot()));
       cmsys::auto_ptr<cmLocalGenerator> lgd(
-            ggd->CreateLocalGenerator(mfd.get()));
+        ggd->CreateLocalGenerator(mfd.get()));
       lgd->ClearDependencies(mfd.get(), verbose);
-      }
     }
+  }
 
   // If any byproduct of makefile generation is missing we must re-run.
   std::vector<std::string> products;
-  if(const char* productStr = mf->GetDefinition("CMAKE_MAKEFILE_PRODUCTS"))
-    {
+  if (const char* productStr = mf->GetDefinition("CMAKE_MAKEFILE_PRODUCTS")) {
     cmSystemTools::ExpandListArgument(productStr, products);
-    }
-  for(std::vector<std::string>::const_iterator pi = products.begin();
-      pi != products.end(); ++pi)
-    {
-    if(!(cmSystemTools::FileExists(pi->c_str()) ||
-         cmSystemTools::FileIsSymlink(*pi)))
-      {
-      if(verbose)
-        {
+  }
+  for (std::vector<std::string>::const_iterator pi = products.begin();
+       pi != products.end(); ++pi) {
+    if (!(cmSystemTools::FileExists(pi->c_str()) ||
+          cmSystemTools::FileIsSymlink(*pi))) {
+      if (verbose) {
         std::ostringstream msg;
         msg << "Re-run cmake, missing byproduct: " << *pi << "\n";
         cmSystemTools::Stdout(msg.str().c_str());
-        }
-      return 1;
       }
+      return 1;
     }
+  }
 
   // Get the set of dependencies and outputs.
   std::vector<std::string> depends;
   std::vector<std::string> outputs;
   const char* dependsStr = mf->GetDefinition("CMAKE_MAKEFILE_DEPENDS");
   const char* outputsStr = mf->GetDefinition("CMAKE_MAKEFILE_OUTPUTS");
-  if(dependsStr && outputsStr)
-    {
+  if (dependsStr && outputsStr) {
     cmSystemTools::ExpandListArgument(dependsStr, depends);
     cmSystemTools::ExpandListArgument(outputsStr, outputs);
-    }
-  if(depends.empty() || outputs.empty())
-    {
+  }
+  if (depends.empty() || outputs.empty()) {
     // Not enough information was provided to do the test.  Just rerun.
-    if(verbose)
-      {
+    if (verbose) {
       std::ostringstream msg;
       msg << "Re-run cmake no CMAKE_MAKEFILE_DEPENDS "
-        "or CMAKE_MAKEFILE_OUTPUTS :\n";
+             "or CMAKE_MAKEFILE_OUTPUTS :\n";
       cmSystemTools::Stdout(msg.str().c_str());
-      }
-    return 1;
     }
+    return 1;
+  }
 
   // Find the newest dependency.
   std::vector<std::string>::iterator dep = depends.begin();
   std::string dep_newest = *dep++;
-  for(;dep != depends.end(); ++dep)
-    {
+  for (; dep != depends.end(); ++dep) {
     int result = 0;
-    if(this->FileComparison->FileTimeCompare(dep_newest.c_str(),
-                                             dep->c_str(), &result))
-      {
-      if(result < 0)
-        {
+    if (this->FileComparison->FileTimeCompare(dep_newest.c_str(), dep->c_str(),
+                                              &result)) {
+      if (result < 0) {
         dep_newest = *dep;
-        }
       }
-    else
-      {
-      if(verbose)
-        {
+    } else {
+      if (verbose) {
         std::ostringstream msg;
         msg << "Re-run cmake: build system dependency is missing\n";
         cmSystemTools::Stdout(msg.str().c_str());
-        }
-      return 1;
       }
+      return 1;
     }
+  }
 
   // Find the oldest output.
   std::vector<std::string>::iterator out = outputs.begin();
   std::string out_oldest = *out++;
-  for(;out != outputs.end(); ++out)
-    {
+  for (; out != outputs.end(); ++out) {
     int result = 0;
-    if(this->FileComparison->FileTimeCompare(out_oldest.c_str(),
-                                             out->c_str(), &result))
-      {
-      if(result > 0)
-        {
+    if (this->FileComparison->FileTimeCompare(out_oldest.c_str(), out->c_str(),
+                                              &result)) {
+      if (result > 0) {
         out_oldest = *out;
-        }
       }
-    else
-      {
-      if(verbose)
-        {
+    } else {
+      if (verbose) {
         std::ostringstream msg;
         msg << "Re-run cmake: build system output is missing\n";
         cmSystemTools::Stdout(msg.str().c_str());
-        }
-      return 1;
       }
+      return 1;
     }
+  }
 
   // If any output is older than any dependency then rerun.
   {
-  int result = 0;
-  if(!this->FileComparison->FileTimeCompare(out_oldest.c_str(),
-                                            dep_newest.c_str(),
-                                            &result) ||
-     result < 0)
-    {
-    if(verbose)
-      {
-      std::ostringstream msg;
-      msg << "Re-run cmake file: " << out_oldest
-          << " older than: " << dep_newest << "\n";
-      cmSystemTools::Stdout(msg.str().c_str());
+    int result = 0;
+    if (!this->FileComparison->FileTimeCompare(out_oldest.c_str(),
+                                               dep_newest.c_str(), &result) ||
+        result < 0) {
+      if (verbose) {
+        std::ostringstream msg;
+        msg << "Re-run cmake file: " << out_oldest
+            << " older than: " << dep_newest << "\n";
+        cmSystemTools::Stdout(msg.str().c_str());
       }
-    return 1;
+      return 1;
     }
   }
 
@@ -2236,30 +1874,26 @@ void cmake::TruncateOutputLog(const char* fname)
   fullPath += "/";
   fullPath += fname;
   struct stat st;
-  if ( ::stat(fullPath.c_str(), &st) )
-    {
+  if (::stat(fullPath.c_str(), &st)) {
     return;
-    }
-  if (!this->State->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR"))
-    {
+  }
+  if (!this->State->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")) {
     cmSystemTools::RemoveFile(fullPath);
     return;
-    }
+  }
   off_t fsize = st.st_size;
   const off_t maxFileSize = 50 * 1024;
-  if ( fsize < maxFileSize )
-    {
-    //TODO: truncate file
+  if (fsize < maxFileSize) {
+    // TODO: truncate file
     return;
-    }
+  }
 }
 
 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;
 }
 
@@ -2272,7 +1906,7 @@ void cmake::GenerateGraphViz(const char* fileName) const
 {
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmsys::auto_ptr<cmGraphVizWriter> gvWriter(
-       new cmGraphVizWriter(this->GetGlobalGenerator()->GetLocalGenerators()));
+    new cmGraphVizWriter(this->GetGlobalGenerator()->GetLocalGenerators()));
 
   std::string settingsFile = this->GetHomeOutputDirectory();
   settingsFile += "/CMakeGraphVizOptions.cmake";
@@ -2293,13 +1927,13 @@ void cmake::SetProperty(const std::string& prop, const char* value)
   this->State->SetGlobalProperty(prop, value);
 }
 
-void cmake::AppendProperty(const std::string& prop,
-                           const char* value, bool asString)
+void cmake::AppendProperty(const std::string& prop, const char* value,
+                           bool asString)
 {
   this->State->AppendGlobalProperty(prop, value, asString);
 }
 
-const char *cmake::GetProperty(const std::string& prop)
+const char* cmake::GetProperty(const std::string& prop)
 {
   return this->State->GetGlobalProperty(prop);
 }
@@ -2309,23 +1943,20 @@ bool cmake::GetPropertyAsBool(const std::string& prop)
   return this->State->GetGlobalPropertyAsBool(prop);
 }
 
-cmInstalledFile *cmake::GetOrCreateInstalledFile(
-  cmMakefile* mf, const std::string& name)
+cmInstalledFile* cmake::GetOrCreateInstalledFile(cmMakefile* mf,
+                                                 const std::string& name)
 {
   std::map<std::string, cmInstalledFile>::iterator i =
     this->InstalledFiles.find(name);
 
-  if(i != this->InstalledFiles.end())
-    {
-    cmInstalledFile &file = i->second;
+  if (i != this->InstalledFiles.end()) {
+    cmInstalledFile& file = i->second;
     return &file;
-    }
-  else
-    {
-    cmInstalledFile &file = this->InstalledFiles[name];
+  } else {
+    cmInstalledFile& file = this->InstalledFiles[name];
     file.SetName(mf, name);
     return &file;
-    }
+  }
 }
 
 cmInstalledFile const* cmake::GetInstalledFile(const std::string& name) const
@@ -2333,15 +1964,12 @@ cmInstalledFile const* cmake::GetInstalledFile(const std::string& name) const
   std::map<std::string, cmInstalledFile>::const_iterator i =
     this->InstalledFiles.find(name);
 
-  if(i != this->InstalledFiles.end())
-    {
+  if (i != this->InstalledFiles.end()) {
     cmInstalledFile const& file = i->second;
     return &file;
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 int cmake::GetSystemInformation(std::vector<std::string>& args)
@@ -2351,62 +1979,48 @@ int cmake::GetSystemInformation(std::vector<std::string>& args)
   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
   std::string destPath = cwd + "/__cmake_systeminformation";
   cmSystemTools::RemoveADirectory(destPath);
-  if (!cmSystemTools::MakeDirectory(destPath.c_str()))
-    {
+  if (!cmSystemTools::MakeDirectory(destPath.c_str())) {
     std::cerr << "Error: --system-information must be run from a "
-      "writable directory!\n";
+                 "writable directory!\n";
     return 1;
-    }
+  }
 
   // process the arguments
   bool writeToStdout = true;
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
+  for (unsigned int i = 1; i < args.size(); ++i) {
     std::string arg = args[i];
-    if(arg.find("-V",0) == 0)
-      {
+    if (arg.find("-V", 0) == 0) {
       this->Verbose = true;
-      }
-    else if(arg.find("-G",0) == 0)
-      {
+    } else if (arg.find("-G", 0) == 0) {
       std::string value = arg.substr(2);
-      if(value.empty())
-        {
+      if (value.empty()) {
         ++i;
-        if(i >= args.size())
-          {
+        if (i >= args.size()) {
           cmSystemTools::Error("No generator specified for -G");
           this->PrintGeneratorList();
           return -1;
-          }
-        value = args[i];
         }
-      cmGlobalGenerator* gen =
-        this->CreateGlobalGenerator(value);
-      if(!gen)
-        {
+        value = args[i];
+      }
+      cmGlobalGenerator* gen = this->CreateGlobalGenerator(value);
+      if (!gen) {
         cmSystemTools::Error("Could not create named generator ",
                              value.c_str());
         this->PrintGeneratorList();
-        }
-      else
-        {
+      } else {
         this->SetGlobalGenerator(gen);
-        }
       }
+    }
     // no option assume it is the output file
-    else
-      {
-      if (!cmSystemTools::FileIsFullPath(arg.c_str()))
-        {
+    else {
+      if (!cmSystemTools::FileIsFullPath(arg.c_str())) {
         resultFile = cwd;
         resultFile += "/";
-        }
+      }
       resultFile += arg;
       writeToStdout = false;
-      }
     }
-
+  }
 
   // we have to find the module directory, so we can copy the files
   this->AddCMakePaths();
@@ -2418,19 +2032,17 @@ int cmake::GetSystemInformation(std::vector<std::string>& args)
   outFile += "/CMakeLists.txt";
 
   // Copy file
-  if(!cmSystemTools::cmCopyFile(inFile.c_str(), outFile.c_str()))
-    {
-    std::cerr << "Error copying file \"" << inFile
-              << "\" to \"" << outFile << "\".\n";
+  if (!cmSystemTools::cmCopyFile(inFile.c_str(), outFile.c_str())) {
+    std::cerr << "Error copying file \"" << inFile << "\" to \"" << outFile
+              << "\".\n";
     return 1;
-    }
+  }
 
   // do we write to a file or to stdout?
-  if (resultFile.empty())
-    {
+  if (resultFile.empty()) {
     resultFile = cwd;
     resultFile += "/__cmake_systeminformation/results.txt";
-    }
+  }
 
   // now run cmake on the CMakeLists file
   cmSystemTools::ChangeDirectory(destPath);
@@ -2442,35 +2054,30 @@ int cmake::GetSystemInformation(std::vector<std::string>& args)
   args2.push_back(resultArg);
   int res = this->Run(args2, false);
 
-  if (res != 0)
-    {
+  if (res != 0) {
     std::cerr << "Error: --system-information failed on internal CMake!\n";
     return res;
-    }
+  }
 
   // change back to the original directory
   cmSystemTools::ChangeDirectory(cwd);
 
   // echo results to stdout if needed
-  if (writeToStdout)
-    {
+  if (writeToStdout) {
     FILE* fin = cmsys::SystemTools::Fopen(resultFile, "r");
-    if(fin)
-      {
+    if (fin) {
       const int bufferSize = 4096;
       char buffer[bufferSize];
       size_t n;
-      while((n = fread(buffer, 1, bufferSize, fin)) > 0)
-        {
-        for(char* c = buffer; c < buffer+n; ++c)
-          {
+      while ((n = fread(buffer, 1, bufferSize, fin)) > 0) {
+        for (char* c = buffer; c < buffer + n; ++c) {
           putc(*c, stdout);
-          }
-        fflush(stdout);
         }
-      fclose(fin);
+        fflush(stdout);
       }
+      fclose(fin);
     }
+  }
 
   // clean up the directory
   cmSystemTools::RemoveADirectory(destPath);
@@ -2491,25 +2098,22 @@ static bool cmakeCheckStampFile(const char* stampName)
 #else
   cmsys::ifstream fin(stampDepends.c_str(), std::ios::in);
 #endif
-  if(!fin)
-    {
+  if (!fin) {
     // The stamp dependencies file cannot be read.  Just assume the
     // build system is really out of date.
     std::cout << "CMake is re-running because " << stampName
               << " dependency file is missing.\n";
     return false;
-    }
+  }
 
   // Compare the stamp dependencies against the dependency file itself.
   cmFileTimeComparison ftc;
   std::string dep;
-  while(cmSystemTools::GetLineFromStream(fin, dep))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, dep)) {
     int result;
-    if(!dep.empty() && dep[0] != '#' &&
-       (!ftc.FileTimeCompare(stampDepends.c_str(), dep.c_str(), &result)
-        || result < 0))
-      {
+    if (!dep.empty() && dep[0] != '#' &&
+        (!ftc.FileTimeCompare(stampDepends.c_str(), dep.c_str(), &result) ||
+         result < 0)) {
       // The stamp depends file is older than this dependency.  The
       // build system is really out of date.
       std::cout << "CMake is re-running because " << stampName
@@ -2518,8 +2122,8 @@ static bool cmakeCheckStampFile(const char* stampName)
       std::cout << "  is newer than '" << stampDepends << "'\n";
       std::cout << "  result='" << result << "'\n";
       return false;
-      }
     }
+  }
 
   // The build system is up to date.  The stamp file has been removed
   // by the VS IDE due to a "rebuild" request.  Restore it atomically.
@@ -2528,54 +2132,47 @@ static bool cmakeCheckStampFile(const char* stampName)
   std::string stampTempString = stampTempStream.str();
   const char* stampTemp = stampTempString.c_str();
   {
-  // TODO: Teach cmGeneratedFileStream to use a random temp file (with
-  // multiple tries in unlikely case of conflict) and use that here.
-  cmsys::ofstream stamp(stampTemp);
-  stamp << "# CMake generation timestamp file for this directory.\n";
+    // TODO: Teach cmGeneratedFileStream to use a random temp file (with
+    // multiple tries in unlikely case of conflict) and use that here.
+    cmsys::ofstream stamp(stampTemp);
+    stamp << "# CMake generation timestamp file for this directory.\n";
   }
-  if(cmSystemTools::RenameFile(stampTemp, stampName))
-    {
+  if (cmSystemTools::RenameFile(stampTemp, stampName)) {
     // Notify the user why CMake is not re-running.  It is safe to
     // just print to stdout here because this code is only reachable
     // through an undocumented flag used by the VS generator.
-    std::cout << "CMake does not need to re-run because "
-              << stampName << " is up-to-date.\n";
+    std::cout << "CMake does not need to re-run because " << stampName
+              << " is up-to-date.\n";
     return true;
-    }
-  else
-    {
+  } else {
     cmSystemTools::RemoveFile(stampTemp);
     cmSystemTools::Error("Cannot restore timestamp ", stampName);
     return false;
-    }
+  }
 }
 
 static bool cmakeCheckStampList(const char* stampList)
 {
   // If the stamp list does not exist CMake must rerun to generate it.
-  if(!cmSystemTools::FileExists(stampList))
-    {
+  if (!cmSystemTools::FileExists(stampList)) {
     std::cout << "CMake is re-running because generate.stamp.list "
               << "is missing.\n";
     return false;
-    }
+  }
   cmsys::ifstream fin(stampList);
-  if(!fin)
-    {
+  if (!fin) {
     std::cout << "CMake is re-running because generate.stamp.list "
               << "could not be read.\n";
     return false;
-    }
+  }
 
   // Check each stamp.
   std::string stampName;
-  while(cmSystemTools::GetLineFromStream(fin, stampName))
-    {
-    if(!cmakeCheckStampFile(stampName.c_str()))
-      {
+  while (cmSystemTools::GetLineFromStream(fin, stampName)) {
+    if (!cmakeCheckStampFile(stampName.c_str())) {
       return false;
-      }
     }
+  }
   return true;
 }
 
@@ -2583,30 +2180,22 @@ cmake::MessageType cmake::ConvertMessageType(cmake::MessageType t)
 {
   bool warningsAsErrors;
 
-  if (t == cmake::AUTHOR_WARNING || t == cmake::AUTHOR_ERROR)
-    {
+  if (t == cmake::AUTHOR_WARNING || t == cmake::AUTHOR_ERROR) {
     warningsAsErrors = this->GetDevWarningsAsErrors();
-    if (warningsAsErrors && t == cmake::AUTHOR_WARNING)
-      {
+    if (warningsAsErrors && t == cmake::AUTHOR_WARNING) {
       t = cmake::AUTHOR_ERROR;
-      }
-    else if (!warningsAsErrors && t == cmake::AUTHOR_ERROR)
-      {
+    } else if (!warningsAsErrors && t == cmake::AUTHOR_ERROR) {
       t = cmake::AUTHOR_WARNING;
-      }
     }
-  else if (t == cmake::DEPRECATION_WARNING || t == cmake::DEPRECATION_ERROR)
-    {
+  } else if (t == cmake::DEPRECATION_WARNING ||
+             t == cmake::DEPRECATION_ERROR) {
     warningsAsErrors = this->GetDeprecatedWarningsAsErrors();
-    if (warningsAsErrors && t == cmake::DEPRECATION_WARNING)
-      {
+    if (warningsAsErrors && t == cmake::DEPRECATION_WARNING) {
       t = cmake::DEPRECATION_ERROR;
-      }
-    else if (!warningsAsErrors && t == cmake::DEPRECATION_ERROR)
-      {
+    } else if (!warningsAsErrors && t == cmake::DEPRECATION_ERROR) {
       t = cmake::DEPRECATION_WARNING;
-      }
     }
+  }
 
   return t;
 }
@@ -2615,34 +2204,23 @@ bool cmake::IsMessageTypeVisible(cmake::MessageType t)
 {
   bool isVisible = true;
 
-  if(t == cmake::DEPRECATION_ERROR)
-    {
-    if(!this->GetDeprecatedWarningsAsErrors())
-      {
+  if (t == cmake::DEPRECATION_ERROR) {
+    if (!this->GetDeprecatedWarningsAsErrors()) {
       isVisible = false;
-      }
     }
-  else if (t == cmake::DEPRECATION_WARNING)
-    {
-    if (this->GetSuppressDeprecatedWarnings())
-      {
+  } else if (t == cmake::DEPRECATION_WARNING) {
+    if (this->GetSuppressDeprecatedWarnings()) {
       isVisible = false;
-      }
     }
-  else if (t == cmake::AUTHOR_ERROR)
-    {
-    if (!this->GetDevWarningsAsErrors())
-      {
+  } else if (t == cmake::AUTHOR_ERROR) {
+    if (!this->GetDevWarningsAsErrors()) {
       isVisible = false;
-      }
     }
-  else if (t == cmake::AUTHOR_WARNING)
-    {
-    if (this->GetSuppressDevWarnings())
-      {
+  } else if (t == cmake::AUTHOR_WARNING) {
+    if (this->GetSuppressDevWarnings()) {
       isVisible = false;
-      }
     }
+  }
 
   return isVisible;
 }
@@ -2650,126 +2228,95 @@ bool cmake::IsMessageTypeVisible(cmake::MessageType t)
 bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg)
 {
   // Construct the message header.
-  if(t == cmake::FATAL_ERROR)
-    {
+  if (t == cmake::FATAL_ERROR) {
     msg << "CMake Error";
-    }
-  else if(t == cmake::INTERNAL_ERROR)
-    {
+  } else if (t == cmake::INTERNAL_ERROR) {
     msg << "CMake Internal Error (please report a bug)";
-    }
-  else if(t == cmake::LOG)
-    {
+  } else if (t == cmake::LOG) {
     msg << "CMake Debug Log";
-    }
-  else if(t == cmake::DEPRECATION_ERROR)
-    {
+  } else if (t == cmake::DEPRECATION_ERROR) {
     msg << "CMake Deprecation Error";
-    }
-  else if (t == cmake::DEPRECATION_WARNING)
-    {
+  } else if (t == cmake::DEPRECATION_WARNING) {
     msg << "CMake Deprecation Warning";
-    }
-  else if (t == cmake::AUTHOR_WARNING)
-    {
+  } else if (t == cmake::AUTHOR_WARNING) {
     msg << "CMake Warning (dev)";
-    }
-  else if (t == cmake::AUTHOR_ERROR)
-    {
+  } else if (t == cmake::AUTHOR_ERROR) {
     msg << "CMake Error (dev)";
-    }
-  else
-    {
+  } else {
     msg << "CMake Warning";
-    }
+  }
   return true;
 }
 
 void printMessageText(std::ostream& msg, std::string const& text)
 {
-   msg << ":\n";
-   cmDocumentationFormatter formatter;
-   formatter.SetIndent("  ");
-   formatter.PrintFormatted(msg, text.c_str());
+  msg << ":\n";
+  cmDocumentationFormatter formatter;
+  formatter.SetIndent("  ");
+  formatter.PrintFormatted(msg, text.c_str());
 }
 
 void displayMessage(cmake::MessageType t, std::ostringstream& msg)
 {
 
   // Add a note about warning suppression.
-  if(t == cmake::AUTHOR_WARNING)
-    {
-    msg <<
-      "This warning is for project developers.  Use -Wno-dev to suppress it.";
-    }
-  else if (t == cmake::AUTHOR_ERROR)
-    {
-    msg <<
-      "This error is for project developers. Use -Wno-error=dev to suppress "
-      "it.";
-    }
+  if (t == cmake::AUTHOR_WARNING) {
+    msg << "This warning is for project developers.  Use -Wno-dev to suppress "
+           "it.";
+  } else if (t == cmake::AUTHOR_ERROR) {
+    msg << "This error is for project developers. Use -Wno-error=dev to "
+           "suppress "
+           "it.";
+  }
 
   // Add a terminating blank line.
   msg << "\n";
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   // Add a C++ stack trace to internal errors.
-  if(t == cmake::INTERNAL_ERROR)
-    {
-    std::string stack = cmsys::SystemInformation::GetProgramStack(0,0);
-    if(!stack.empty())
-      {
-      if(cmHasLiteralPrefix(stack, "WARNING:"))
-        {
+  if (t == cmake::INTERNAL_ERROR) {
+    std::string stack = cmsys::SystemInformation::GetProgramStack(0, 0);
+    if (!stack.empty()) {
+      if (cmHasLiteralPrefix(stack, "WARNING:")) {
         stack = "Note:" + stack.substr(8);
-        }
-      msg << stack << "\n";
       }
+      msg << stack << "\n";
     }
+  }
 #endif
 
   // Output the message.
-  if(t == cmake::FATAL_ERROR
-     || t == cmake::INTERNAL_ERROR
-     || t == cmake::DEPRECATION_ERROR
-     || t == cmake::AUTHOR_ERROR)
-    {
+  if (t == cmake::FATAL_ERROR || t == cmake::INTERNAL_ERROR ||
+      t == cmake::DEPRECATION_ERROR || t == cmake::AUTHOR_ERROR) {
     cmSystemTools::SetErrorOccured();
     cmSystemTools::Message(msg.str().c_str(), "Error");
-    }
-  else
-    {
+  } else {
     cmSystemTools::Message(msg.str().c_str(), "Warning");
-    }
+  }
 }
 
 void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
-                         cmListFileBacktrace const& bt,
-                         bool force)
+                         cmListFileBacktrace const& bt, bool force)
 {
   cmListFileBacktrace backtrace = bt;
 
-  if (!force)
-    {
+  if (!force) {
     // override the message type, if needed, for warnings and errors
     cmake::MessageType override = this->ConvertMessageType(t);
-    if (override != t)
-      {
+    if (override != t) {
       t = override;
       force = true;
-      }
     }
+  }
 
-  if (!force && !this->IsMessageTypeVisible(t))
-    {
+  if (!force && !this->IsMessageTypeVisible(t)) {
     return;
-    }
+  }
 
   std::ostringstream msg;
-  if (!this->PrintMessagePreamble(t, msg))
-    {
+  if (!this->PrintMessagePreamble(t, msg)) {
     return;
-    }
+  }
 
   // Add the immediate context.
   backtrace.PrintTitle(msg);
@@ -2785,103 +2332,83 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
 std::vector<std::string> cmake::GetDebugConfigs()
 {
   std::vector<std::string> configs;
-  if(const char* config_list =
-                      this->State->GetGlobalProperty("DEBUG_CONFIGURATIONS"))
-    {
+  if (const char* config_list =
+        this->State->GetGlobalProperty("DEBUG_CONFIGURATIONS")) {
     // Expand the specified list and convert to upper-case.
     cmSystemTools::ExpandListArgument(config_list, configs);
-    std::transform(configs.begin(),
-                   configs.end(),
-                   configs.begin(),
+    std::transform(configs.begin(), configs.end(), configs.begin(),
                    cmSystemTools::UpperCase);
-    }
+  }
   // If no configurations were specified, use a default list.
-  if(configs.empty())
-    {
+  if (configs.empty()) {
     configs.push_back("DEBUG");
-    }
+  }
   return configs;
 }
 
-
-int cmake::Build(const std::string& dir,
-                 const std::string& target,
+int cmake::Build(const std::string& dir, const std::string& target,
                  const std::string& config,
-                 const std::vector<std::string>& nativeOptions,
-                 bool clean)
+                 const std::vector<std::string>& nativeOptions, bool clean)
 {
 
   this->SetHomeDirectory("");
   this->SetHomeOutputDirectory("");
-  if(!cmSystemTools::FileIsDirectory(dir))
-    {
+  if (!cmSystemTools::FileIsDirectory(dir)) {
     std::cerr << "Error: " << dir << " is not a directory\n";
     return 1;
-    }
+  }
   std::string cachePath = dir;
   cmSystemTools::ConvertToUnixSlashes(cachePath);
   std::string cacheFile = cachePath;
   cacheFile += "/CMakeCache.txt";
-  if(!cmSystemTools::FileExists(cacheFile.c_str()))
-    {
+  if (!cmSystemTools::FileExists(cacheFile.c_str())) {
     // search in parent directories for cache
     std::string cmakeFiles = cachePath;
     cmakeFiles += "/CMakeFiles";
-    if(cmSystemTools::FileExists(cmakeFiles.c_str()))
-      {
+    if (cmSystemTools::FileExists(cmakeFiles.c_str())) {
       std::string cachePathFound =
-        cmSystemTools::FileExistsInParentDirectories(
-          "CMakeCache.txt", cachePath.c_str(), "/");
-      if(!cachePathFound.empty())
-        {
+        cmSystemTools::FileExistsInParentDirectories("CMakeCache.txt",
+                                                     cachePath.c_str(), "/");
+      if (!cachePathFound.empty()) {
         cachePath = cmSystemTools::GetFilenamePath(cachePathFound);
-        }
       }
     }
+  }
 
-  if(!this->LoadCache(cachePath))
-    {
+  if (!this->LoadCache(cachePath)) {
     std::cerr << "Error: could not load cache\n";
     return 1;
-    }
+  }
   const char* cachedGenerator =
-      this->State->GetCacheEntryValue("CMAKE_GENERATOR");
-  if(!cachedGenerator)
-    {
+    this->State->GetCacheEntryValue("CMAKE_GENERATOR");
+  if (!cachedGenerator) {
     std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
     return 1;
-    }
+  }
   cmsys::auto_ptr<cmGlobalGenerator> gen(
     this->CreateGlobalGenerator(cachedGenerator));
-  if(!gen.get())
-    {
-    std::cerr << "Error: could create CMAKE_GENERATOR \""
-              << cachedGenerator << "\"\n";
+  if (!gen.get()) {
+    std::cerr << "Error: could create CMAKE_GENERATOR \"" << cachedGenerator
+              << "\"\n";
     return 1;
-    }
+  }
   std::string output;
   std::string projName;
   const char* cachedProjectName =
-      this->State->GetCacheEntryValue("CMAKE_PROJECT_NAME");
-  if(!cachedProjectName)
-    {
+    this->State->GetCacheEntryValue("CMAKE_PROJECT_NAME");
+  if (!cachedProjectName) {
     std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
     return 1;
-    }
+  }
   projName = cachedProjectName;
   bool verbose = false;
   const char* cachedVerbose =
-      this->State->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
-  if(cachedVerbose)
-    {
+    this->State->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
+  if (cachedVerbose) {
     verbose = cmSystemTools::IsOn(cachedVerbose);
-    }
-  return gen->Build("", dir,
-                    projName, target,
-                    output,
-                    "",
-                    config, clean, false, verbose, 0,
-                    cmSystemTools::OUTPUT_PASSTHROUGH,
+  }
+  return gen->Build("", dir, projName, target, output, "", config, clean,
+                    false, verbose, 0, cmSystemTools::OUTPUT_PASSTHROUGH,
                     nativeOptions);
 }
 
@@ -2889,10 +2416,9 @@ void cmake::WatchUnusedCli(const std::string& var)
 {
 #ifdef CMAKE_BUILD_WITH_CMAKE
   this->VariableWatch->AddWatch(var, cmWarnUnusedCliWarning, this);
-  if(this->UsedCliVariables.find(var) == this->UsedCliVariables.end())
-    {
+  if (this->UsedCliVariables.find(var) == this->UsedCliVariables.end()) {
     this->UsedCliVariables[var] = false;
-    }
+  }
 #endif
 }
 
@@ -2910,20 +2436,17 @@ void cmake::RunCheckForUnusedVariables()
   bool haveUnused = false;
   std::ostringstream msg;
   msg << "Manually-specified variables were not used by the project:";
-  for(std::map<std::string, bool>::const_iterator
-        it = this->UsedCliVariables.begin();
-      it != this->UsedCliVariables.end(); ++it)
-    {
-    if(!it->second)
-      {
+  for (std::map<std::string, bool>::const_iterator it =
+         this->UsedCliVariables.begin();
+       it != this->UsedCliVariables.end(); ++it) {
+    if (!it->second) {
       haveUnused = true;
       msg << "\n  " << it->first;
-      }
     }
-  if(haveUnused)
-    {
+  }
+  if (haveUnused) {
     this->IssueMessage(cmake::WARNING, msg.str());
-    }
+  }
 #endif
 }
 
@@ -2933,16 +2456,13 @@ bool cmake::GetSuppressDevWarnings(cmMakefile const* mf)
    * The suppression CMake variable may be set in the CMake configuration file
    * itself, so we have to check what its set to in the makefile if we can.
    */
-  if (mf)
-    {
+  if (mf) {
     return mf->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
-    }
-  else
-    {
-    const char* cacheEntryValue = this->State->GetCacheEntryValue(
-      "CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
+  } else {
+    const char* cacheEntryValue =
+      this->State->GetCacheEntryValue("CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
     return cmSystemTools::IsOn(cacheEntryValue);
-    }
+  }
 }
 
 void cmake::SetSuppressDevWarnings(bool b)
@@ -2950,15 +2470,13 @@ void cmake::SetSuppressDevWarnings(bool b)
   std::string value;
 
   // equivalent to -Wno-dev
-  if (b)
-    {
+  if (b) {
     value = "TRUE";
-    }
+  }
   // equivalent to -Wdev
-  else
-    {
+  else {
     value = "FALSE";
-    }
+  }
 
   this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", value.c_str(),
                       "Suppress Warnings that are meant for"
@@ -2972,17 +2490,14 @@ bool cmake::GetSuppressDeprecatedWarnings(cmMakefile const* mf)
    * The suppression CMake variable may be set in the CMake configuration file
    * itself, so we have to check what its set to in the makefile if we can.
    */
-  if (mf)
-    {
+  if (mf) {
     return (mf->IsSet("CMAKE_WARN_DEPRECATED") &&
             !mf->IsOn("CMAKE_WARN_DEPRECATED"));
-    }
-  else
-    {
-    const char* cacheEntryValue = this->State->GetCacheEntryValue(
-      "CMAKE_WARN_DEPRECATED");
+  } else {
+    const char* cacheEntryValue =
+      this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
     return cacheEntryValue && cmSystemTools::IsOff(cacheEntryValue);
-    }
+  }
 }
 
 void cmake::SetSuppressDeprecatedWarnings(bool b)
@@ -2990,15 +2505,13 @@ void cmake::SetSuppressDeprecatedWarnings(bool b)
   std::string value;
 
   // equivalent to -Wno-deprecated
-  if (b)
-    {
+  if (b) {
     value = "FALSE";
-    }
+  }
   // equivalent to -Wdeprecated
-  else
-    {
+  else {
     value = "TRUE";
-    }
+  }
 
   this->AddCacheEntry("CMAKE_WARN_DEPRECATED", value.c_str(),
                       "Whether to issue warnings for deprecated "
@@ -3008,17 +2521,14 @@ void cmake::SetSuppressDeprecatedWarnings(bool b)
 
 bool cmake::GetDevWarningsAsErrors(cmMakefile const* mf)
 {
-  if (mf)
-    {
+  if (mf) {
     return (mf->IsSet("CMAKE_SUPPRESS_DEVELOPER_ERRORS") &&
             !mf->IsOn("CMAKE_SUPPRESS_DEVELOPER_ERRORS"));
-    }
-  else
-    {
-    const char* cacheEntryValue = this->State->GetCacheEntryValue(
-      "CMAKE_SUPPRESS_DEVELOPER_ERRORS");
+  } else {
+    const char* cacheEntryValue =
+      this->State->GetCacheEntryValue("CMAKE_SUPPRESS_DEVELOPER_ERRORS");
     return cacheEntryValue && cmSystemTools::IsOff(cacheEntryValue);
-    }
+  }
 }
 
 void cmake::SetDevWarningsAsErrors(bool b)
@@ -3026,15 +2536,13 @@ void cmake::SetDevWarningsAsErrors(bool b)
   std::string value;
 
   // equivalent to -Werror=dev
-  if (b)
-    {
+  if (b) {
     value = "FALSE";
-    }
+  }
   // equivalent to -Wno-error=dev
-  else
-    {
+  else {
     value = "TRUE";
-    }
+  }
 
   this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_ERRORS", value.c_str(),
                       "Suppress errors that are meant for"
@@ -3044,16 +2552,13 @@ void cmake::SetDevWarningsAsErrors(bool b)
 
 bool cmake::GetDeprecatedWarningsAsErrors(cmMakefile const* mf)
 {
-  if (mf)
-    {
+  if (mf) {
     return mf->IsOn("CMAKE_ERROR_DEPRECATED");
-    }
-  else
-    {
-    const char* cacheEntryValue = this->State->GetCacheEntryValue(
-      "CMAKE_ERROR_DEPRECATED");
+  } else {
+    const char* cacheEntryValue =
+      this->State->GetCacheEntryValue("CMAKE_ERROR_DEPRECATED");
     return cmSystemTools::IsOn(cacheEntryValue);
-    }
+  }
 }
 
 void cmake::SetDeprecatedWarningsAsErrors(bool b)
@@ -3061,15 +2566,13 @@ void cmake::SetDeprecatedWarningsAsErrors(bool b)
   std::string value;
 
   // equivalent to -Werror=deprecated
-  if (b)
-    {
+  if (b) {
     value = "TRUE";
-    }
+  }
   // equivalent to -Wno-error=deprecated
-  else
-    {
+  else {
     value = "FALSE";
-    }
+  }
 
   this->AddCacheEntry("CMAKE_ERROR_DEPRECATED", value.c_str(),
                       "Whether to issue deprecation errors for macros"
diff --git a/Source/cmake.h b/Source/cmake.h
index e41ba56..266c33d 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -58,9 +58,10 @@ class cmGeneratedFileStream;
 
 class cmake
 {
- public:
+public:
   enum MessageType
-  { AUTHOR_WARNING,
+  {
+    AUTHOR_WARNING,
     AUTHOR_ERROR,
     FATAL_ERROR,
     INTERNAL_ERROR,
@@ -82,12 +83,12 @@ class cmake
   enum WorkingMode
   {
     NORMAL_MODE, ///< Cmake runs to create project files
-    /** \brief Script mode (started by using -P).
-     *
-     * In script mode there is no generator and no cache. Also,
-     * languages are not enabled, so add_executable and things do
-     * nothing.
-     */
+                 /** \brief Script mode (started by using -P).
+                  *
+                  * In script mode there is no generator and no cache. Also,
+                  * languages are not enabled, so add_executable and things do
+                  * nothing.
+                  */
     SCRIPT_MODE,
     /** \brief A pkg-config like mode
      *
@@ -100,10 +101,10 @@ class cmake
   };
 
   struct GeneratorInfo
-    {
+  {
     std::string name;
     bool supportsToolset;
-    };
+  };
 
   typedef std::map<std::string, cmInstalledFile> InstalledFilesMap;
 
@@ -112,9 +113,11 @@ class cmake
   /// Destructor
   ~cmake();
 
-  static const char *GetCMakeFilesDirectory() {return "/CMakeFiles";}
-  static const char *GetCMakeFilesDirectoryPostSlash() {
-    return "CMakeFiles/";}
+  static const char* GetCMakeFilesDirectory() { return "/CMakeFiles"; }
+  static const char* GetCMakeFilesDirectoryPostSlash()
+  {
+    return "CMakeFiles/";
+  }
 
   //@{
   /**
@@ -131,9 +134,11 @@ class cmake
   /**
    * Handle a command line invocation of cmake.
    */
-  int Run(const std::vector<std::string>&args)
-    { return this->Run(args, false); }
-  int Run(const std::vector<std::string>&args, bool noconfigure);
+  int Run(const std::vector<std::string>& args)
+  {
+    return this->Run(args, false);
+  }
+  int Run(const std::vector<std::string>& args, bool noconfigure);
 
   /**
    * Run the global generator Generate step.
@@ -150,10 +155,9 @@ class cmake
   int ActualConfigure();
 
   ///! Break up a line like VAR:type="value" into var, type and value
-  static bool ParseCacheEntry(const std::string& entry,
-                         std::string& var,
-                         std::string& value,
-                         cmState::CacheEntryType& type);
+  static bool ParseCacheEntry(const std::string& entry, std::string& var,
+                              std::string& value,
+                              cmState::CacheEntryType& type);
 
   int LoadCache();
   bool LoadCache(const std::string& path);
@@ -168,40 +172,54 @@ class cmake
   cmGlobalGenerator* CreateGlobalGenerator(const std::string& name);
 
   ///! Return the global generator assigned to this instance of cmake
-  cmGlobalGenerator* GetGlobalGenerator()     { return this->GlobalGenerator; }
+  cmGlobalGenerator* GetGlobalGenerator() { return this->GlobalGenerator; }
   ///! Return the global generator assigned to this instance of cmake, const
   const cmGlobalGenerator* GetGlobalGenerator() const
-                                              { return this->GlobalGenerator; }
+  {
+    return this->GlobalGenerator;
+  }
 
   ///! Return the global generator assigned to this instance of cmake
-  void SetGlobalGenerator(cmGlobalGenerator *);
+  void SetGlobalGenerator(cmGlobalGenerator*);
 
   ///! Get the names of the current registered generators
   void GetRegisteredGenerators(std::vector<GeneratorInfo>& generators);
 
   ///! Set the name of the selected generator-specific platform.
   void SetGeneratorPlatform(std::string const& ts)
-    { this->GeneratorPlatform = ts; }
+  {
+    this->GeneratorPlatform = ts;
+  }
 
   ///! Get the name of the selected generator-specific platform.
   std::string const& GetGeneratorPlatform() const
-    { return this->GeneratorPlatform; }
+  {
+    return this->GeneratorPlatform;
+  }
 
   ///! Set the name of the selected generator-specific toolset.
   void SetGeneratorToolset(std::string const& ts)
-    { this->GeneratorToolset = ts; }
+  {
+    this->GeneratorToolset = ts;
+  }
 
   ///! Get the name of the selected generator-specific toolset.
   std::string const& GetGeneratorToolset() const
-    { return this->GeneratorToolset; }
+  {
+    return this->GeneratorToolset;
+  }
 
   ///! get the cmCachemManager used by this invocation of cmake
-  cmCacheManager *GetCacheManager() { return this->CacheManager; }
+  cmCacheManager* GetCacheManager() { return this->CacheManager; }
 
   const std::vector<std::string>& GetSourceExtensions() const
-    {return this->SourceFileExtensions;}
+  {
+    return this->SourceFileExtensions;
+  }
   const std::vector<std::string>& GetHeaderExtensions() const
-    {return this->HeaderFileExtensions;}
+  {
+    return this->HeaderFileExtensions;
+  }
 
   /**
    * Given a variable name, return its value (as a string).
@@ -209,8 +227,7 @@ class cmake
   const char* GetCacheDefinition(const std::string&) const;
   ///! Add an entry into the cache
   void AddCacheEntry(const std::string& key, const char* value,
-                     const char* helpString,
-                     int type);
+                     const char* helpString, int type);
 
   /**
    * Get the system information and write it to the file specified
@@ -228,8 +245,7 @@ class cmake
   ///! Parse command line arguments that might set cache values
   bool SetCacheArgs(const std::vector<std::string>&);
 
-  typedef  void (*ProgressCallbackType)
-    (const char*msg, float progress, void *);
+  typedef void (*ProgressCallbackType)(const char* msg, float progress, void*);
   /**
    *  Set the function used by GUIs to receive progress updates
    *  Function gets passed: message as a const char*, a progress
@@ -237,10 +253,10 @@ class cmake
    *  number provided may be negative in cases where a message is
    *  to be displayed without any progress percentage.
    */
-  void SetProgressCallback(ProgressCallbackType f, void* clientData=0);
+  void SetProgressCallback(ProgressCallbackType f, void* clientData = 0);
 
   ///! this is called by generators to update the progress
-  void UpdateProgress(const char *msg, float prog);
+  void UpdateProgress(const char* msg, float prog);
 
   ///! Get the variable watch object
   cmVariableWatch* GetVariableWatch() { return this->VariableWatch; }
@@ -248,20 +264,22 @@ class cmake
   void GetGeneratorDocumentation(std::vector<cmDocumentationEntry>&);
 
   ///! Set/Get a property of this target file
-  void SetProperty(const std::string& prop, const char *value);
-  void AppendProperty(const std::string& prop,
-                      const char *value,bool asString=false);
-  const char *GetProperty(const std::string& prop);
+  void SetProperty(const std::string& prop, const char* value);
+  void AppendProperty(const std::string& prop, const char* value,
+                      bool asString = false);
+  const char* GetProperty(const std::string& prop);
   bool GetPropertyAsBool(const std::string& prop);
 
   ///! Get or create an cmInstalledFile instance and return a pointer to it
-  cmInstalledFile *GetOrCreateInstalledFile(
-    cmMakefile* mf, const std::string& name);
+  cmInstalledFile* GetOrCreateInstalledFile(cmMakefile* mf,
+                                            const std::string& name);
 
   cmInstalledFile const* GetInstalledFile(const std::string& name) const;
 
   InstalledFilesMap const& GetInstalledFiles() const
-    { return this->InstalledFiles; }
+  {
+    return this->InstalledFiles;
+  }
 
   ///! Do all the checks before running configure
   int DoPreConfigureChecks();
@@ -270,8 +288,8 @@ class cmake
   WorkingMode GetWorkingMode() { return this->CurrentWorkingMode; }
 
   ///! Debug the try compile stuff by not deleting the files
-  bool GetDebugTryCompile(){return this->DebugTryCompile;}
-  void DebugTryCompileOn(){this->DebugTryCompile = true;}
+  bool GetDebugTryCompile() { return this->DebugTryCompile; }
+  void DebugTryCompileOn() { this->DebugTryCompile = true; }
 
   /**
    * Generate CMAKE_ROOT and CMAKE_COMMAND cache entries
@@ -285,21 +303,21 @@ class cmake
 
   // Do we want debug output during the cmake run.
   bool GetDebugOutput() { return this->DebugOutput; }
-  void SetDebugOutputOn(bool b) { this->DebugOutput = b;}
+  void SetDebugOutputOn(bool b) { this->DebugOutput = b; }
 
   // Do we want trace output during the cmake run.
-  bool GetTrace() { return this->Trace;}
-  void SetTrace(bool b) {  this->Trace = b;}
-  bool GetTraceExpand() { return this->TraceExpand;}
-  void SetTraceExpand(bool b) {  this->TraceExpand = b;}
-  bool GetWarnUninitialized() { return this->WarnUninitialized;}
-  void SetWarnUninitialized(bool b) {  this->WarnUninitialized = b;}
-  bool GetWarnUnused() { return this->WarnUnused;}
-  void SetWarnUnused(bool b) {  this->WarnUnused = b;}
-  bool GetWarnUnusedCli() { return this->WarnUnusedCli;}
-  void SetWarnUnusedCli(bool b) {  this->WarnUnusedCli = b;}
-  bool GetCheckSystemVars() { return this->CheckSystemVars;}
-  void SetCheckSystemVars(bool b) {  this->CheckSystemVars = b;}
+  bool GetTrace() { return this->Trace; }
+  void SetTrace(bool b) { this->Trace = b; }
+  bool GetTraceExpand() { return this->TraceExpand; }
+  void SetTraceExpand(bool b) { this->TraceExpand = b; }
+  bool GetWarnUninitialized() { return this->WarnUninitialized; }
+  void SetWarnUninitialized(bool b) { this->WarnUninitialized = b; }
+  bool GetWarnUnused() { return this->WarnUnused; }
+  void SetWarnUnused(bool b) { this->WarnUnused = b; }
+  bool GetWarnUnusedCli() { return this->WarnUnusedCli; }
+  void SetWarnUnusedCli(bool b) { this->WarnUnusedCli = b; }
+  bool GetCheckSystemVars() { return this->CheckSystemVars; }
+  void SetCheckSystemVars(bool b) { this->CheckSystemVars = b; }
 
   void MarkCliAsUsed(const std::string& variable);
 
@@ -308,9 +326,13 @@ class cmake
   std::vector<std::string> GetDebugConfigs();
 
   void SetCMakeEditCommand(std::string const& s)
-    { this->CMakeEditCommand = s; }
+  {
+    this->CMakeEditCommand = s;
+  }
   std::string const& GetCMakeEditCommand() const
-    { return this->CMakeEditCommand; }
+  {
+    return this->CMakeEditCommand;
+  }
 
   /*
    * Get the state of the suppression of developer (author) warnings.
@@ -357,35 +379,38 @@ class cmake
   void SetDeprecatedWarningsAsErrors(bool v);
 
   /** Display a message to the user.  */
-  void IssueMessage(cmake::MessageType t, std::string const& text,
-        cmListFileBacktrace const& backtrace = cmListFileBacktrace(),
-        bool force = false);
+  void IssueMessage(
+    cmake::MessageType t, std::string const& text,
+    cmListFileBacktrace const& backtrace = cmListFileBacktrace(),
+    bool force = false);
 
   ///! run the --build option
-  int Build(const std::string& dir,
-            const std::string& target,
+  int Build(const std::string& dir, const std::string& target,
             const std::string& config,
-            const std::vector<std::string>& nativeOptions,
-            bool clean);
+            const std::vector<std::string>& nativeOptions, bool clean);
 
   void UnwatchUnusedCli(const std::string& var);
   void WatchUnusedCli(const std::string& var);
 
   cmState* GetState() const { return this->State; }
   void SetCurrentSnapshot(cmState::Snapshot snapshot)
-  { this->CurrentSnapshot = snapshot; }
+  {
+    this->CurrentSnapshot = snapshot;
+  }
   cmState::Snapshot GetCurrentSnapshot() const
-  { return this->CurrentSnapshot; }
+  {
+    return this->CurrentSnapshot;
+  }
 
 protected:
   void RunCheckForUnusedVariables();
   void InitializeProperties();
   int HandleDeleteCacheVariables(const std::string& var);
 
-  typedef
-     cmExternalMakefileProjectGenerator* (*CreateExtraGeneratorFunctionType)();
-  typedef std::map<std::string,
-                CreateExtraGeneratorFunctionType> RegisteredExtraGeneratorsMap;
+  typedef cmExternalMakefileProjectGenerator* (
+    *CreateExtraGeneratorFunctionType)();
+  typedef std::map<std::string, CreateExtraGeneratorFunctionType>
+    RegisteredExtraGeneratorsMap;
   typedef std::vector<cmGlobalGeneratorFactory*> RegisteredGeneratorsVector;
   RegisteredGeneratorsVector Generators;
   RegisteredExtraGeneratorsMap ExtraGenerators;
@@ -395,14 +420,14 @@ protected:
   void AddExtraGenerator(const std::string& name,
                          CreateExtraGeneratorFunctionType newFunction);
 
-  cmGlobalGenerator *GlobalGenerator;
-  cmCacheManager *CacheManager;
+  cmGlobalGenerator* GlobalGenerator;
+  cmCacheManager* CacheManager;
   std::map<std::string, DiagLevel> DiagLevels;
   std::string GeneratorPlatform;
   std::string GeneratorToolset;
 
   ///! read in a cmake list file to initialize the cache
-  void ReadListFile(const std::vector<std::string>& args, const char *path);
+  void ReadListFile(const std::vector<std::string>& args, const char* path);
   bool FindPackage(const std::vector<std::string>& args);
 
   ///! Check if CMAKE_CACHEFILE_DIR is set. If it is not, delete the log file.
@@ -426,8 +451,8 @@ protected:
   cmVariableWatch* VariableWatch;
 
 private:
-  cmake(const cmake&);  // Not implemented.
-  void operator=(const cmake&);  // Not implemented.
+  cmake(const cmake&);          // Not implemented.
+  void operator=(const cmake&); // Not implemented.
   ProgressCallbackType ProgressCallback;
   void* ProgressCallbackClientData;
   bool Verbose;
@@ -479,87 +504,91 @@ private:
   bool PrintMessagePreamble(cmake::MessageType t, std::ostream& msg);
 };
 
-#define CMAKE_STANDARD_OPTIONS_TABLE \
-  {"-C <initial-cache>", "Pre-load a script to populate the cache."}, \
-  {"-D <var>[:<type>]=<value>", "Create a cmake cache entry."}, \
-  {"-U <globbing_expr>", "Remove matching entries from CMake cache."}, \
-  {"-G <generator-name>", "Specify a build system generator."},\
-  {"-T <toolset-name>", "Specify toolset name if supported by generator."}, \
-  {"-A <platform-name>", "Specify platform name if supported by generator."}, \
-  {"-Wdev", "Enable developer warnings."},\
-  {"-Wno-dev", "Suppress developer warnings."},\
-  {"-Werror=dev", "Make developer warnings errors."},\
-  {"-Wno-error=dev", "Make developer warnings not errors."},\
-  {"-Wdeprecated", "Enable deprecation warnings."},\
-  {"-Wno-deprecated", "Suppress deprecation warnings."},\
-  {"-Werror=deprecated", "Make deprecated macro and function warnings " \
-                         "errors."},\
-  {"-Wno-error=deprecated", "Make deprecated macro and function warnings " \
-                            "not errors."}
-
-#define FOR_EACH_C_FEATURE(F) \
-  F(c_function_prototypes) \
-  F(c_restrict) \
-  F(c_static_assert) \
+#define CMAKE_STANDARD_OPTIONS_TABLE                                          \
+  { "-C <initial-cache>", "Pre-load a script to populate the cache." },       \
+    { "-D <var>[:<type>]=<value>", "Create a cmake cache entry." },           \
+    { "-U <globbing_expr>", "Remove matching entries from CMake cache." },    \
+    { "-G <generator-name>", "Specify a build system generator." },           \
+    { "-T <toolset-name>",                                                    \
+      "Specify toolset name if supported by generator." },                    \
+    { "-A <platform-name>",                                                   \
+      "Specify platform name if supported by generator." },                   \
+    { "-Wdev", "Enable developer warnings." },                                \
+    { "-Wno-dev", "Suppress developer warnings." },                           \
+    { "-Werror=dev", "Make developer warnings errors." },                     \
+    { "-Wno-error=dev", "Make developer warnings not errors." },              \
+    { "-Wdeprecated", "Enable deprecation warnings." },                       \
+    { "-Wno-deprecated", "Suppress deprecation warnings." },                  \
+    { "-Werror=deprecated", "Make deprecated macro and function warnings "    \
+                            "errors." },                                      \
+  {                                                                           \
+    "-Wno-error=deprecated", "Make deprecated macro and function warnings "   \
+                             "not errors."                                    \
+  }
+
+#define FOR_EACH_C_FEATURE(F)                                                 \
+  F(c_function_prototypes)                                                    \
+  F(c_restrict)                                                               \
+  F(c_static_assert)                                                          \
   F(c_variadic_macros)
 
-#define FOR_EACH_CXX_FEATURE(F) \
-  F(cxx_aggregate_default_initializers) \
-  F(cxx_alias_templates) \
-  F(cxx_alignas) \
-  F(cxx_alignof) \
-  F(cxx_attributes) \
-  F(cxx_attribute_deprecated) \
-  F(cxx_auto_type) \
-  F(cxx_binary_literals) \
-  F(cxx_constexpr) \
-  F(cxx_contextual_conversions) \
-  F(cxx_decltype) \
-  F(cxx_decltype_auto) \
-  F(cxx_decltype_incomplete_return_types) \
-  F(cxx_default_function_template_args) \
-  F(cxx_defaulted_functions) \
-  F(cxx_defaulted_move_initializers) \
-  F(cxx_delegating_constructors) \
-  F(cxx_deleted_functions) \
-  F(cxx_digit_separators) \
-  F(cxx_enum_forward_declarations) \
-  F(cxx_explicit_conversions) \
-  F(cxx_extended_friend_declarations) \
-  F(cxx_extern_templates) \
-  F(cxx_final) \
-  F(cxx_func_identifier) \
-  F(cxx_generalized_initializers) \
-  F(cxx_generic_lambdas) \
-  F(cxx_inheriting_constructors) \
-  F(cxx_inline_namespaces) \
-  F(cxx_lambdas) \
-  F(cxx_lambda_init_captures) \
-  F(cxx_local_type_template_args) \
-  F(cxx_long_long_type) \
-  F(cxx_noexcept) \
-  F(cxx_nonstatic_member_init) \
-  F(cxx_nullptr) \
-  F(cxx_override) \
-  F(cxx_range_for) \
-  F(cxx_raw_string_literals) \
-  F(cxx_reference_qualified_functions) \
-  F(cxx_relaxed_constexpr) \
-  F(cxx_return_type_deduction) \
-  F(cxx_right_angle_brackets) \
-  F(cxx_rvalue_references) \
-  F(cxx_sizeof_member) \
-  F(cxx_static_assert) \
-  F(cxx_strong_enums) \
-  F(cxx_template_template_parameters) \
-  F(cxx_thread_local) \
-  F(cxx_trailing_return_types) \
-  F(cxx_unicode_literals) \
-  F(cxx_uniform_initialization) \
-  F(cxx_unrestricted_unions) \
-  F(cxx_user_literals) \
-  F(cxx_variable_templates) \
-  F(cxx_variadic_macros) \
+#define FOR_EACH_CXX_FEATURE(F)                                               \
+  F(cxx_aggregate_default_initializers)                                       \
+  F(cxx_alias_templates)                                                      \
+  F(cxx_alignas)                                                              \
+  F(cxx_alignof)                                                              \
+  F(cxx_attributes)                                                           \
+  F(cxx_attribute_deprecated)                                                 \
+  F(cxx_auto_type)                                                            \
+  F(cxx_binary_literals)                                                      \
+  F(cxx_constexpr)                                                            \
+  F(cxx_contextual_conversions)                                               \
+  F(cxx_decltype)                                                             \
+  F(cxx_decltype_auto)                                                        \
+  F(cxx_decltype_incomplete_return_types)                                     \
+  F(cxx_default_function_template_args)                                       \
+  F(cxx_defaulted_functions)                                                  \
+  F(cxx_defaulted_move_initializers)                                          \
+  F(cxx_delegating_constructors)                                              \
+  F(cxx_deleted_functions)                                                    \
+  F(cxx_digit_separators)                                                     \
+  F(cxx_enum_forward_declarations)                                            \
+  F(cxx_explicit_conversions)                                                 \
+  F(cxx_extended_friend_declarations)                                         \
+  F(cxx_extern_templates)                                                     \
+  F(cxx_final)                                                                \
+  F(cxx_func_identifier)                                                      \
+  F(cxx_generalized_initializers)                                             \
+  F(cxx_generic_lambdas)                                                      \
+  F(cxx_inheriting_constructors)                                              \
+  F(cxx_inline_namespaces)                                                    \
+  F(cxx_lambdas)                                                              \
+  F(cxx_lambda_init_captures)                                                 \
+  F(cxx_local_type_template_args)                                             \
+  F(cxx_long_long_type)                                                       \
+  F(cxx_noexcept)                                                             \
+  F(cxx_nonstatic_member_init)                                                \
+  F(cxx_nullptr)                                                              \
+  F(cxx_override)                                                             \
+  F(cxx_range_for)                                                            \
+  F(cxx_raw_string_literals)                                                  \
+  F(cxx_reference_qualified_functions)                                        \
+  F(cxx_relaxed_constexpr)                                                    \
+  F(cxx_return_type_deduction)                                                \
+  F(cxx_right_angle_brackets)                                                 \
+  F(cxx_rvalue_references)                                                    \
+  F(cxx_sizeof_member)                                                        \
+  F(cxx_static_assert)                                                        \
+  F(cxx_strong_enums)                                                         \
+  F(cxx_template_template_parameters)                                         \
+  F(cxx_thread_local)                                                         \
+  F(cxx_trailing_return_types)                                                \
+  F(cxx_unicode_literals)                                                     \
+  F(cxx_uniform_initialization)                                               \
+  F(cxx_unrestricted_unions)                                                  \
+  F(cxx_user_literals)                                                        \
+  F(cxx_variable_templates)                                                   \
+  F(cxx_variadic_macros)                                                      \
   F(cxx_variadic_templates)
 
 #endif
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index 5f086d5..056671a 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -28,65 +28,57 @@
 #include <cmsys/Encoding.hxx>
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
-static const char * cmDocumentationName[][2] =
-{
-  {0,
-   "  cmake - Cross-Platform Makefile Generator."},
-  {0,0}
+static const char* cmDocumentationName[][2] = {
+  { 0, "  cmake - Cross-Platform Makefile Generator." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationUsage[][2] =
-{
-  {0,
-   "  cmake [options] <path-to-source>\n"
-   "  cmake [options] <path-to-existing-build>"},
-  {0,
-   "Specify a source directory to (re-)generate a build system for "
-   "it in the current working directory.  Specify an existing build "
-   "directory to re-generate its build system."},
-  {0,0}
+static const char* cmDocumentationUsage[][2] = {
+  { 0, "  cmake [options] <path-to-source>\n"
+       "  cmake [options] <path-to-existing-build>" },
+  { 0, "Specify a source directory to (re-)generate a build system for "
+       "it in the current working directory.  Specify an existing build "
+       "directory to re-generate its build system." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationUsageNote[][2] =
-{
-  {0,
-   "Run 'cmake --help' for more information."},
-  {0,0}
+static const char* cmDocumentationUsageNote[][2] = {
+  { 0, "Run 'cmake --help' for more information." },
+  { 0, 0 }
 };
 
-#define CMAKE_BUILD_OPTIONS                                             \
-  "  <dir>          = Project binary directory to be built.\n"          \
-  "  --target <tgt> = Build <tgt> instead of default targets.\n"        \
-  "                   May only be specified once.\n"                    \
-  "  --config <cfg> = For multi-configuration tools, choose <cfg>.\n"   \
-  "  --clean-first  = Build target 'clean' first, then build.\n"        \
-  "                   (To clean only, use --target 'clean'.)\n"         \
-  "  --use-stderr   = Ignored.  Behavior is default in CMake >= 3.0.\n" \
+#define CMAKE_BUILD_OPTIONS                                                   \
+  "  <dir>          = Project binary directory to be built.\n"                \
+  "  --target <tgt> = Build <tgt> instead of default targets.\n"              \
+  "                   May only be specified once.\n"                          \
+  "  --config <cfg> = For multi-configuration tools, choose <cfg>.\n"         \
+  "  --clean-first  = Build target 'clean' first, then build.\n"              \
+  "                   (To clean only, use --target 'clean'.)\n"               \
+  "  --use-stderr   = Ignored.  Behavior is default in CMake >= 3.0.\n"       \
   "  --             = Pass remaining options to the native tool.\n"
 
-static const char * cmDocumentationOptions[][2] =
-{
+static const char* cmDocumentationOptions[][2] = {
   CMAKE_STANDARD_OPTIONS_TABLE,
-  {"-E", "CMake command mode."},
-  {"-L[A][H]", "List non-advanced cached variables."},
-  {"--build <dir>", "Build a CMake-generated project binary tree."},
-  {"-N", "View mode only."},
-  {"-P <file>", "Process script mode."},
-  {"--find-package", "Run in pkg-config like mode."},
-  {"--graphviz=[file]", "Generate graphviz of dependencies, see "
-   "CMakeGraphVizOptions.cmake for more."},
-  {"--system-information [file]", "Dump information about this system."},
-  {"--debug-trycompile", "Do not delete the try_compile build tree. Only "
-   "useful on one try_compile at a time."},
-  {"--debug-output", "Put cmake in a debug mode."},
-  {"--trace", "Put cmake in trace mode."},
-  {"--trace-expand", "Put cmake in trace mode with variable expansion."},
-  {"--warn-uninitialized", "Warn about uninitialized values."},
-  {"--warn-unused-vars", "Warn about unused variables."},
-  {"--no-warn-unused-cli", "Don't warn about command line options."},
-  {"--check-system-vars", "Find problems with variable usage in system "
-   "files."},
-  {0,0}
+  { "-E", "CMake command mode." },
+  { "-L[A][H]", "List non-advanced cached variables." },
+  { "--build <dir>", "Build a CMake-generated project binary tree." },
+  { "-N", "View mode only." },
+  { "-P <file>", "Process script mode." },
+  { "--find-package", "Run in pkg-config like mode." },
+  { "--graphviz=[file]", "Generate graphviz of dependencies, see "
+                         "CMakeGraphVizOptions.cmake for more." },
+  { "--system-information [file]", "Dump information about this system." },
+  { "--debug-trycompile", "Do not delete the try_compile build tree. Only "
+                          "useful on one try_compile at a time." },
+  { "--debug-output", "Put cmake in a debug mode." },
+  { "--trace", "Put cmake in trace mode." },
+  { "--trace-expand", "Put cmake in trace mode with variable expansion." },
+  { "--warn-uninitialized", "Warn about uninitialized values." },
+  { "--warn-unused-vars", "Warn about unused variables." },
+  { "--no-warn-unused-cli", "Don't warn about command line options." },
+  { "--check-system-vars", "Find problems with variable usage in system "
+                           "files." },
+  { 0, 0 }
 };
 
 #endif
@@ -103,67 +95,59 @@ static int do_command(int ac, char const* const* av)
 int do_cmake(int ac, char const* const* av);
 static int do_build(int ac, char const* const* av);
 
-static cmMakefile* cmakemainGetMakefile(void *clientdata)
+static cmMakefile* cmakemainGetMakefile(void* clientdata)
 {
-  cmake* cm = (cmake *)clientdata;
-  if(cm && cm->GetDebugOutput())
-    {
-    cmGlobalGenerator* gg=cm->GetGlobalGenerator();
-    if (gg)
-      {
+  cmake* cm = (cmake*)clientdata;
+  if (cm && cm->GetDebugOutput()) {
+    cmGlobalGenerator* gg = cm->GetGlobalGenerator();
+    if (gg) {
       return gg->GetCurrentMakefile();
-      }
     }
+  }
   return 0;
 }
 
-static std::string cmakemainGetStack(void *clientdata)
+static std::string cmakemainGetStack(void* clientdata)
 {
   std::string msg;
-  cmMakefile* mf=cmakemainGetMakefile(clientdata);
-  if (mf)
-    {
+  cmMakefile* mf = cmakemainGetMakefile(clientdata);
+  if (mf) {
     msg = mf->FormatListFileStack();
-    if (!msg.empty())
-      {
+    if (!msg.empty()) {
       msg = "\n   Called from: " + msg;
-      }
     }
+  }
 
   return msg;
 }
 
 static void cmakemainMessageCallback(const char* m, const char*, bool&,
-                                     void *clientdata)
+                                     void* clientdata)
 {
   std::cerr << m << cmakemainGetStack(clientdata) << std::endl << std::flush;
 }
 
-static void cmakemainProgressCallback(const char *m, float prog,
+static void cmakemainProgressCallback(const char* m, float prog,
                                       void* clientdata)
 {
   cmMakefile* mf = cmakemainGetMakefile(clientdata);
   std::string dir;
-  if ((mf) && (strstr(m, "Configuring")==m) && (prog<0))
-    {
+  if ((mf) && (strstr(m, "Configuring") == m) && (prog < 0)) {
     dir = " ";
     dir += mf->GetCurrentSourceDirectory();
-    }
-  else if ((mf) && (strstr(m, "Generating")==m))
-    {
+  } else if ((mf) && (strstr(m, "Generating") == m)) {
     dir = " ";
     dir += mf->GetCurrentBinaryDirectory();
-    }
+  }
 
-  if ((prog < 0) || (!dir.empty()))
-    {
-    std::cout << "-- " << m << dir << cmakemainGetStack(clientdata)<<std::endl;
-    }
+  if ((prog < 0) || (!dir.empty())) {
+    std::cout << "-- " << m << dir << cmakemainGetStack(clientdata)
+              << std::endl;
+  }
 
   std::cout.flush();
 }
 
-
 int main(int ac, char const* const* av)
 {
   cmsys::Encoding::CommandLineArguments args =
@@ -173,17 +157,13 @@ int main(int ac, char const* const* av)
 
   cmSystemTools::EnableMSVCDebugHook();
   cmSystemTools::FindCMakeResources(av[0]);
-  if(ac > 1)
-    {
-    if(strcmp(av[1], "--build") == 0)
-      {
+  if (ac > 1) {
+    if (strcmp(av[1], "--build") == 0) {
       return do_build(ac, av);
-      }
-    else if(strcmp(av[1], "-E") == 0)
-      {
+    } else if (strcmp(av[1], "-E") == 0) {
       return do_command(ac, av);
-      }
     }
+  }
   int ret = do_cmake(ac, av);
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmDynamicLoader::FlushCache();
@@ -193,18 +173,16 @@ int main(int ac, char const* const* av)
 
 int do_cmake(int ac, char const* const* av)
 {
-  if (cmSystemTools::GetCurrentWorkingDirectory().empty())
-    {
+  if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
     std::cerr << "Current working directory cannot be established."
               << std::endl;
     return 1;
-    }
+  }
 
 #ifdef CMAKE_BUILD_WITH_CMAKE
   cmDocumentation doc;
   doc.addCMakeStandardDocSections();
-  if(doc.CheckOptions(ac, av))
-    {
+  if (doc.CheckOptions(ac, av)) {
     // Construct and print requested documentation.
     cmake hcm;
     hcm.SetHomeDirectory("");
@@ -221,25 +199,23 @@ int do_cmake(int ac, char const* const* av)
     hcm.GetGeneratorDocumentation(generators);
 
     doc.SetName("cmake");
-    doc.SetSection("Name",cmDocumentationName);
-    doc.SetSection("Usage",cmDocumentationUsage);
-    if ( ac == 1 )
-      {
-      doc.AppendSection("Usage",cmDocumentationUsageNote);
-      }
-    doc.AppendSection("Generators",generators);
-    doc.PrependSection("Options",cmDocumentationOptions);
-
-    return doc.PrintRequestedDocumentation(std::cout)? 0:1;
+    doc.SetSection("Name", cmDocumentationName);
+    doc.SetSection("Usage", cmDocumentationUsage);
+    if (ac == 1) {
+      doc.AppendSection("Usage", cmDocumentationUsageNote);
     }
+    doc.AppendSection("Generators", generators);
+    doc.PrependSection("Options", cmDocumentationOptions);
+
+    return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
+  }
 #else
-  if ( ac == 1 )
-    {
-    std::cout <<
-      "Bootstrap CMake should not be used outside CMake build process."
-              << std::endl;
+  if (ac == 1) {
+    std::cout
+      << "Bootstrap CMake should not be used outside CMake build process."
+      << std::endl;
     return 0;
-    }
+  }
 #endif
 
   bool sysinfo = false;
@@ -249,10 +225,8 @@ int do_cmake(int ac, char const* const* av)
   bool view_only = false;
   cmake::WorkingMode workingMode = cmake::NORMAL_MODE;
   std::vector<std::string> args;
-  for(int i =0; i < ac; ++i)
-    {
-    if(strcmp(av[i], "-i") == 0)
-      {
+  for (int i = 0; i < ac; ++i) {
+    if (strcmp(av[i], "-i") == 0) {
       /* clang-format off */
       std::cerr <<
         "The \"cmake -i\" wizard mode is no longer supported.\n"
@@ -260,117 +234,85 @@ int do_cmake(int ac, char const* const* av)
         "Use cmake-gui or ccmake for an interactive dialog.\n";
       /* clang-format on */
       return 1;
-      }
-    else if(strcmp(av[i], "--system-information") == 0)
-      {
+    } else if (strcmp(av[i], "--system-information") == 0) {
       sysinfo = true;
-      }
-    else if (strcmp(av[i], "-N") == 0)
-      {
+    } else if (strcmp(av[i], "-N") == 0) {
       view_only = true;
-      }
-    else if (strcmp(av[i], "-L") == 0)
-      {
+    } else if (strcmp(av[i], "-L") == 0) {
       list_cached = true;
-      }
-    else if (strcmp(av[i], "-LA") == 0)
-      {
+    } else if (strcmp(av[i], "-LA") == 0) {
       list_all_cached = true;
-      }
-    else if (strcmp(av[i], "-LH") == 0)
-      {
+    } else if (strcmp(av[i], "-LH") == 0) {
       list_cached = true;
       list_help = true;
-      }
-    else if (strcmp(av[i], "-LAH") == 0)
-      {
+    } else if (strcmp(av[i], "-LAH") == 0) {
       list_all_cached = true;
       list_help = true;
-      }
-    else if (cmHasLiteralPrefix(av[i], "-P"))
-      {
-      if ( i == ac -1 )
-        {
+    } else if (cmHasLiteralPrefix(av[i], "-P")) {
+      if (i == ac - 1) {
         cmSystemTools::Error("No script specified for argument -P");
-        }
-      else
-        {
+      } else {
         workingMode = cmake::SCRIPT_MODE;
         args.push_back(av[i]);
         i++;
         args.push_back(av[i]);
-        }
       }
-    else if (cmHasLiteralPrefix(av[i], "--find-package"))
-      {
+    } else if (cmHasLiteralPrefix(av[i], "--find-package")) {
       workingMode = cmake::FIND_PACKAGE_MODE;
       args.push_back(av[i]);
-      }
-    else
-      {
+    } else {
       args.push_back(av[i]);
-      }
     }
-  if (sysinfo)
-    {
+  }
+  if (sysinfo) {
     cmake cm;
     cm.SetHomeDirectory("");
     cm.SetHomeOutputDirectory("");
     int ret = cm.GetSystemInformation(args);
     return ret;
-    }
+  }
   cmake cm;
   cm.SetHomeDirectory("");
   cm.SetHomeOutputDirectory("");
-  cmSystemTools::SetMessageCallback(cmakemainMessageCallback, (void *)&cm);
-  cm.SetProgressCallback(cmakemainProgressCallback, (void *)&cm);
+  cmSystemTools::SetMessageCallback(cmakemainMessageCallback, (void*)&cm);
+  cm.SetProgressCallback(cmakemainProgressCallback, (void*)&cm);
   cm.SetWorkingMode(workingMode);
 
   int res = cm.Run(args, view_only);
-  if ( list_cached || list_all_cached )
-    {
+  if (list_cached || list_all_cached) {
     std::cout << "-- Cache values" << std::endl;
     std::vector<std::string> keys = cm.GetState()->GetCacheEntryKeys();
     for (std::vector<std::string>::const_iterator it = keys.begin();
-        it != keys.end(); ++it)
-      {
+         it != keys.end(); ++it) {
       cmState::CacheEntryType t = cm.GetState()->GetCacheEntryType(*it);
       if (t != cmState::INTERNAL && t != cmState::STATIC &&
-          t != cmState::UNINITIALIZED)
-        {
+          t != cmState::UNINITIALIZED) {
         const char* advancedProp =
-            cm.GetState()->GetCacheEntryProperty(*it, "ADVANCED");
-        if ( list_all_cached || !advancedProp)
-          {
-          if ( list_help )
-            {
+          cm.GetState()->GetCacheEntryProperty(*it, "ADVANCED");
+        if (list_all_cached || !advancedProp) {
+          if (list_help) {
             std::cout << "// "
                       << cm.GetState()->GetCacheEntryProperty(*it,
-                                                   "HELPSTRING") << std::endl;
-            }
-          std::cout << *it << ":" <<
-            cmState::CacheEntryTypeToString(t)
-            << "=" << cm.GetState()->GetCacheEntryValue(*it)
-            << std::endl;
-          if ( list_help )
-            {
+                                                              "HELPSTRING")
+                      << std::endl;
+          }
+          std::cout << *it << ":" << cmState::CacheEntryTypeToString(t) << "="
+                    << cm.GetState()->GetCacheEntryValue(*it) << std::endl;
+          if (list_help) {
             std::cout << std::endl;
-            }
           }
         }
       }
     }
+  }
 
   // Always return a non-negative value.  Windows tools do not always
   // interpret negative return values as errors.
-  if(res != 0)
-    {
+  if (res != 0) {
     return 1;
-    }
-  else
-    {
+  } else {
     return 0;
-    }
+  }
 }
 
 static int do_build(int ac, char const* const* av)
@@ -386,49 +328,38 @@ static int do_build(int ac, char const* const* av)
   bool clean = false;
   bool hasTarget = false;
 
-  enum Doing { DoingNone, DoingDir, DoingTarget, DoingConfig, DoingNative};
+  enum Doing
+  {
+    DoingNone,
+    DoingDir,
+    DoingTarget,
+    DoingConfig,
+    DoingNative
+  };
   Doing doing = DoingDir;
-  for(int i=2; i < ac; ++i)
-    {
-    if(doing == DoingNative)
-      {
+  for (int i = 2; i < ac; ++i) {
+    if (doing == DoingNative) {
       nativeOptions.push_back(av[i]);
-      }
-    else if(strcmp(av[i], "--target") == 0)
-      {
-      if (!hasTarget)
-        {
+    } else if (strcmp(av[i], "--target") == 0) {
+      if (!hasTarget) {
         doing = DoingTarget;
         hasTarget = true;
-        }
-      else
-        {
+      } else {
         std::cerr << "'--target' may not be specified more than once.\n\n";
         dir = "";
         break;
-        }
       }
-    else if(strcmp(av[i], "--config") == 0)
-      {
+    } else if (strcmp(av[i], "--config") == 0) {
       doing = DoingConfig;
-      }
-    else if(strcmp(av[i], "--clean-first") == 0)
-      {
+    } else if (strcmp(av[i], "--clean-first") == 0) {
       clean = true;
       doing = DoingNone;
-      }
-    else if(strcmp(av[i], "--use-stderr") == 0)
-      {
+    } else if (strcmp(av[i], "--use-stderr") == 0) {
       /* tolerate legacy option */
-      }
-    else if(strcmp(av[i], "--") == 0)
-      {
+    } else if (strcmp(av[i], "--") == 0) {
       doing = DoingNative;
-      }
-    else
-      {
-      switch (doing)
-        {
+    } else {
+      switch (doing) {
         case DoingDir:
           dir = cmSystemTools::CollapseFullPath(av[i]);
           doing = DoingNone;
@@ -445,11 +376,10 @@ static int do_build(int ac, char const* const* av)
           std::cerr << "Unknown argument " << av[i] << std::endl;
           dir = "";
           break;
-        }
       }
     }
-  if(dir.empty())
-    {
+  }
+  if (dir.empty()) {
     /* clang-format off */
     std::cerr <<
       "Usage: cmake --build <dir> [options] [-- [native-options]]\n"
@@ -458,7 +388,7 @@ static int do_build(int ac, char const* const* av)
       ;
     /* clang-format on */
     return 1;
-    }
+  }
 
   cmake cm;
   return cm.Build(dir, target, config, nativeOptions, clean);
diff --git a/Source/cmakexbuild.cxx b/Source/cmakexbuild.cxx
index 1385ff7..bdbc4da 100644
--- a/Source/cmakexbuild.cxx
+++ b/Source/cmakexbuild.cxx
@@ -32,62 +32,49 @@ int RunXCode(std::vector<const char*>& argv, bool& hitbug)
   std::vector<char> err;
   std::string line;
   int pipe = cmSystemTools::WaitForLine(cp, line, 100.0, out, err);
-  while(pipe != cmsysProcess_Pipe_None)
-    {
-    if(line.find("/bin/sh: bad interpreter: Text file busy")
-       != line.npos)
-      {
+  while (pipe != cmsysProcess_Pipe_None) {
+    if (line.find("/bin/sh: bad interpreter: Text file busy") != line.npos) {
       hitbug = true;
       std::cerr << "Hit xcodebuild bug : " << line << "\n";
-      }
+    }
     // if the bug is hit, no more output should be generated
     // because it may contain bogus errors
     // also remove all output with setenv in it to tone down
     // the verbosity of xcodebuild
-    if(!hitbug && (line.find("setenv") == line.npos))
-      {
-      if(pipe == cmsysProcess_Pipe_STDERR)
-        {
+    if (!hitbug && (line.find("setenv") == line.npos)) {
+      if (pipe == cmsysProcess_Pipe_STDERR) {
         std::cerr << line << "\n";
-        }
-      else if(pipe == cmsysProcess_Pipe_STDOUT)
-        {
+      } else if (pipe == cmsysProcess_Pipe_STDOUT) {
         std::cout << line << "\n";
-        }
       }
-    pipe = cmSystemTools::WaitForLine(cp, line, 100, out, err);
     }
+    pipe = cmSystemTools::WaitForLine(cp, line, 100, out, err);
+  }
   cmsysProcess_WaitForExit(cp, 0);
-  if(cmsysProcess_GetState(cp) == cmsysProcess_State_Exited)
-    {
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Exited) {
     return cmsysProcess_GetExitValue(cp);
-    }
-  if(cmsysProcess_GetState(cp) == cmsysProcess_State_Error)
-    {
+  }
+  if (cmsysProcess_GetState(cp) == cmsysProcess_State_Error) {
     return -1;
-    }
+  }
   return -1;
 }
 
-int main(int ac, char*av[])
+int main(int ac, char* av[])
 {
   std::vector<const char*> argv;
   argv.push_back("xcodebuild");
-  for(int i =1; i < ac; i++)
-    {
+  for (int i = 1; i < ac; i++) {
     argv.push_back(av[i]);
-    }
+  }
   argv.push_back(0);
   bool hitbug = true;
   int ret = 0;
-  while(hitbug)
-    {
+  while (hitbug) {
     ret = RunXCode(argv, hitbug);
-    }
-  if(ret < 0)
-    {
+  }
+  if (ret < 0) {
     return 255;
-    }
+  }
   return ret;
 }
-
diff --git a/Source/cmcldeps.cxx b/Source/cmcldeps.cxx
index 644da1d..8b0cede 100644
--- a/Source/cmcldeps.cxx
+++ b/Source/cmcldeps.cxx
@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 // Wrapper around cl that adds /showIncludes to command line, and uses that to
 // generate .d files that match the style from gcc -MD.
 //
@@ -27,9 +26,12 @@
 
 // We don't want any wildcard expansion.
 // See http://msdn.microsoft.com/en-us/library/zay8tzh6(v=vs.85).aspx
-void _setargv() {}
+void _setargv()
+{
+}
 
-static void Fatal(const char* msg, ...) {
+static void Fatal(const char* msg, ...)
+{
   va_list ap;
   fprintf(stderr, "ninja: FATAL: ");
   va_start(ap, msg);
@@ -43,20 +45,23 @@ static void Fatal(const char* msg, ...) {
   ExitProcess(1);
 }
 
-static void usage(const char* msg) {
+static void usage(const char* msg)
+{
   Fatal("%s\n\nusage:\n    "
-          "cmcldeps "
-          "<language C, CXX or RC>  "
-          "<source file path>  "
-          "<output path for *.d file>  "
-          "<output path for *.obj file>  "
-          "<prefix of /showIncludes>  "
-          "<path to cl.exe>  "
-          "<path to tool (cl or rc)>  "
-          "<rest of command ...>\n", msg);
+        "cmcldeps "
+        "<language C, CXX or RC>  "
+        "<source file path>  "
+        "<output path for *.d file>  "
+        "<output path for *.obj file>  "
+        "<prefix of /showIncludes>  "
+        "<path to cl.exe>  "
+        "<path to tool (cl or rc)>  "
+        "<rest of command ...>\n",
+        msg);
 }
 
-static std::string trimLeadingSpace(const std::string& cmdline) {
+static std::string trimLeadingSpace(const std::string& cmdline)
+{
   int i = 0;
   for (; cmdline[i] == ' '; ++i)
     ;
@@ -64,7 +69,8 @@ static std::string trimLeadingSpace(const std::string& cmdline) {
 }
 
 static void replaceAll(std::string& str, const std::string& search,
-                                         const std::string& repl) {
+                       const std::string& repl)
+{
   std::string::size_type pos = 0;
   while ((pos = str.find(search, pos)) != std::string::npos) {
     str.replace(pos, search.size(), repl);
@@ -72,13 +78,15 @@ static void replaceAll(std::string& str, const std::string& search,
   }
 }
 
-bool startsWith(const std::string& str, const std::string& what) {
+bool startsWith(const std::string& str, const std::string& what)
+{
   return str.compare(0, what.size(), what) == 0;
 }
 
 // Strips one argument from the cmdline and returns it. "surrounding quotes"
 // are removed from the argument if there were any.
-static std::string getArg(std::string& cmdline) {
+static std::string getArg(std::string& cmdline)
+{
   std::string ret;
   bool in_quoted = false;
   unsigned int i = 0;
@@ -101,15 +109,12 @@ static std::string getArg(std::string& cmdline) {
   return ret;
 }
 
-static void parseCommandLine(LPWSTR wincmdline,
-                             std::string& lang,
-                             std::string& srcfile,
-                             std::string& dfile,
-                             std::string& objfile,
-                             std::string& prefix,
-                             std::string& clpath,
-                             std::string& binpath,
-                             std::string& rest) {
+static void parseCommandLine(LPWSTR wincmdline, std::string& lang,
+                             std::string& srcfile, std::string& dfile,
+                             std::string& objfile, std::string& prefix,
+                             std::string& clpath, std::string& binpath,
+                             std::string& rest)
+{
   std::string cmdline = cmsys::Encoding::ToNarrow(wincmdline);
   /* self */ getArg(cmdline);
   lang = getArg(cmdline);
@@ -124,13 +129,15 @@ static void parseCommandLine(LPWSTR wincmdline,
 
 // Not all backslashes need to be escaped in a depfile, but it's easier that
 // way.  See the re2c grammar in ninja's source code for more info.
-static void escapePath(std::string &path) {
+static void escapePath(std::string& path)
+{
   replaceAll(path, "\\", "\\\\");
   replaceAll(path, " ", "\\ ");
 }
 
 static void outputDepFile(const std::string& dfile, const std::string& objfile,
-        std::vector<std::string>& incs) {
+                          std::vector<std::string>& incs)
+{
 
   if (dfile.empty())
     return;
@@ -169,13 +176,14 @@ static void outputDepFile(const std::string& dfile, const std::string& objfile,
   fclose(out);
 }
 
-
-bool contains(const std::string& str, const std::string& what) {
+bool contains(const std::string& str, const std::string& what)
+{
   return str.find(what) != std::string::npos;
 }
 
 std::string replace(const std::string& str, const std::string& what,
-                    const std::string& replacement) {
+                    const std::string& replacement)
+{
   size_t pos = str.find(what);
   if (pos == std::string::npos)
     return str;
@@ -183,15 +191,10 @@ std::string replace(const std::string& str, const std::string& what,
   return replaced.replace(pos, what.size(), replacement);
 }
 
-
-
-static int process( const std::string& srcfilename,
-                    const std::string& dfile,
-                    const std::string& objfile,
-                    const std::string& prefix,
-                    const std::string& cmd,
-                    const std::string& dir = "",
-                    bool quiet = false)
+static int process(const std::string& srcfilename, const std::string& dfile,
+                   const std::string& objfile, const std::string& prefix,
+                   const std::string& cmd, const std::string& dir = "",
+                   bool quiet = false)
 {
   std::string output;
   // break up command line into a vector
@@ -199,16 +202,15 @@ static int process( const std::string& srcfilename,
   cmSystemTools::ParseWindowsCommandLine(cmd.c_str(), args);
   // convert to correct vector type for RunSingleCommand
   std::vector<std::string> command;
-  for(std::vector<std::string>::iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = args.begin(); i != args.end();
+       ++i) {
     command.push_back(i->c_str());
-    }
+  }
   // run the command
   int exit_code = 0;
-  bool run = cmSystemTools::RunSingleCommand(command, &output, &output,
-                                             &exit_code, dir.c_str(),
-                                             cmSystemTools::OUTPUT_NONE);
+  bool run =
+    cmSystemTools::RunSingleCommand(command, &output, &output, &exit_code,
+                                    dir.c_str(), cmSystemTools::OUTPUT_NONE);
 
   // process the include directives and output everything else
   std::stringstream ss(output);
@@ -239,8 +241,8 @@ static int process( const std::string& srcfilename,
   return exit_code;
 }
 
-
-int main() {
+int main()
+{
 
   // Use the Win32 API instead of argc/argv so we can avoid interpreting the
   // rest of command line after the .d and .obj. Custom parsing seemed
@@ -249,18 +251,18 @@ int main() {
   // the same command line verbatim.
 
   std::string lang, srcfile, dfile, objfile, prefix, cl, binpath, rest;
-  parseCommandLine(GetCommandLineW(), lang, srcfile, dfile, objfile,
-                                     prefix, cl, binpath, rest);
+  parseCommandLine(GetCommandLineW(), lang, srcfile, dfile, objfile, prefix,
+                   cl, binpath, rest);
 
   // needed to suppress filename output of msvc tools
   std::string srcfilename;
   {
-  std::string::size_type pos = srcfile.rfind("\\");
-  if (pos == std::string::npos) {
-    srcfilename = srcfile;
-  } else {
-    srcfilename = srcfile.substr(pos + 1);
-  }
+    std::string::size_type pos = srcfile.rfind("\\");
+    if (pos == std::string::npos) {
+      srcfilename = srcfile;
+    } else {
+      srcfilename = srcfile.substr(pos + 1);
+    }
   }
 
   std::string nol = " /nologo ";
@@ -286,21 +288,21 @@ int main() {
     // call cl in object dir so the .i is generated there
     std::string objdir;
     {
-    std::string::size_type pos = objfile.rfind("\\");
-    if (pos != std::string::npos) {
-      objdir = objfile.substr(0, pos);
-    }
+      std::string::size_type pos = objfile.rfind("\\");
+      if (pos != std::string::npos) {
+        objdir = objfile.substr(0, pos);
+      }
     }
 
     // extract dependencies with cl.exe
-    int exit_code = process(srcfilename, dfile, objfile,
-                            prefix, cl + nol + show + clrest, objdir, true);
+    int exit_code = process(srcfilename, dfile, objfile, prefix,
+                            cl + nol + show + clrest, objdir, true);
 
     if (exit_code != 0)
       return exit_code;
 
     // compile rc file with rc.exe
-    return process(srcfilename, "" , objfile, prefix, binpath + " " + rest);
+    return process(srcfilename, "", objfile, prefix, binpath + " " + rest);
   }
 
   usage("Invalid language specified.");
diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx
index 7c07131..891b291 100644
--- a/Source/cmcmd.cxx
+++ b/Source/cmcmd.cxx
@@ -19,7 +19,7 @@
 #include "cmVersion.h"
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-# include "cmDependsFortran.h" // For -E cmake_copy_f90_mod callback.
+#include "cmDependsFortran.h" // For -E cmake_copy_f90_mod callback.
 #endif
 
 #include <cmsys/Directory.hxx>
@@ -47,12 +47,12 @@ void CMakeCommandUsage(const char* program)
   /* clang-format off */
   errorStream
     << "cmake version " << cmVersion::GetCMakeVersion() << "\n";
-  /* clang-format on */
+/* clang-format on */
 #else
   /* clang-format off */
   errorStream
     << "cmake bootstrap\n";
-  /* clang-format on */
+/* clang-format on */
 #endif
   // If you add new commands, change here,
   // and in cmakemain.cxx in the options table
@@ -108,286 +108,227 @@ void CMakeCommandUsage(const char* program)
 static bool cmTarFilesFrom(std::string const& file,
                            std::vector<std::string>& files)
 {
-  if (cmSystemTools::FileIsDirectory(file))
-    {
+  if (cmSystemTools::FileIsDirectory(file)) {
     std::ostringstream e;
     e << "-E tar --files-from= file '" << file << "' is a directory";
     cmSystemTools::Error(e.str().c_str());
     return false;
-    }
+  }
   cmsys::ifstream fin(file.c_str());
-  if (!fin)
-    {
+  if (!fin) {
     std::ostringstream e;
     e << "-E tar --files-from= file '" << file << "' not found";
     cmSystemTools::Error(e.str().c_str());
     return false;
-    }
+  }
   std::string line;
-  while (cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if (line.empty())
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty()) {
       continue;
-      }
-    if (cmHasLiteralPrefix(line, "--add-file="))
-      {
+    }
+    if (cmHasLiteralPrefix(line, "--add-file=")) {
       files.push_back(line.substr(11));
-      }
-    else if (cmHasLiteralPrefix(line, "-"))
-      {
+    } else if (cmHasLiteralPrefix(line, "-")) {
       std::ostringstream e;
       e << "-E tar --files-from='" << file << "' file invalid line:\n"
         << line << "\n";
       cmSystemTools::Error(e.str().c_str());
       return false;
-      }
-    else
-      {
+    } else {
       files.push_back(line);
-      }
     }
+  }
   return true;
 }
 
 int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
 {
   // IF YOU ADD A NEW COMMAND, DOCUMENT IT ABOVE and in cmakemain.cxx
-  if (args.size() > 1)
-    {
+  if (args.size() > 1) {
     // Copy file
-    if (args[1] == "copy" && args.size() > 3)
-      {
+    if (args[1] == "copy" && args.size() > 3) {
       // If multiple source files specified,
       // then destination must be directory
       if ((args.size() > 4) &&
-          (!cmSystemTools::FileIsDirectory(args[args.size() - 1])))
-        {
+          (!cmSystemTools::FileIsDirectory(args[args.size() - 1]))) {
         std::cerr << "Error: Target (for copy command) \""
-                  << args[args.size() - 1]
-                  << "\" is not a directory.\n";
+                  << args[args.size() - 1] << "\" is not a directory.\n";
         return 1;
-        }
+      }
       // If error occurs we want to continue copying next files.
       bool return_value = 0;
-      for (std::string::size_type cc = 2; cc < args.size() - 1; cc ++)
-        {
-        if(!cmSystemTools::cmCopyFile(args[cc].c_str(),
-            args[args.size() - 1].c_str()))
-          {
-          std::cerr << "Error copying file \"" << args[cc]
-                    << "\" to \"" << args[args.size() - 1] << "\".\n";
+      for (std::string::size_type cc = 2; cc < args.size() - 1; cc++) {
+        if (!cmSystemTools::cmCopyFile(args[cc].c_str(),
+                                       args[args.size() - 1].c_str())) {
+          std::cerr << "Error copying file \"" << args[cc] << "\" to \""
+                    << args[args.size() - 1] << "\".\n";
           return_value = 1;
-          }
         }
-      return return_value;
       }
+      return return_value;
+    }
 
     // Copy file if different.
-    if (args[1] == "copy_if_different" && args.size() > 3)
-      {
+    if (args[1] == "copy_if_different" && args.size() > 3) {
       // If multiple source files specified,
       // then destination must be directory
       if ((args.size() > 4) &&
-          (!cmSystemTools::FileIsDirectory(args[args.size() - 1])))
-        {
+          (!cmSystemTools::FileIsDirectory(args[args.size() - 1]))) {
         std::cerr << "Error: Target (for copy_if_different command) \""
-                  << args[args.size() - 1]
-                  << "\" is not a directory.\n";
+                  << args[args.size() - 1] << "\" is not a directory.\n";
         return 1;
-        }
+      }
       // If error occurs we want to continue copying next files.
       bool return_value = 0;
-      for (std::string::size_type cc = 2; cc < args.size() - 1; cc ++)
-        {
-        if(!cmSystemTools::CopyFileIfDifferent(args[cc].c_str(),
-            args[args.size() - 1].c_str()))
-          {
-          std::cerr << "Error copying file (if different) from \""
-                    << args[cc] << "\" to \"" << args[args.size() - 1]
-                    << "\".\n";
+      for (std::string::size_type cc = 2; cc < args.size() - 1; cc++) {
+        if (!cmSystemTools::CopyFileIfDifferent(
+              args[cc].c_str(), args[args.size() - 1].c_str())) {
+          std::cerr << "Error copying file (if different) from \"" << args[cc]
+                    << "\" to \"" << args[args.size() - 1] << "\".\n";
           return_value = 1;
-          }
         }
-      return return_value;
       }
+      return return_value;
+    }
 
     // Copy directory content
-    if (args[1] == "copy_directory" && args.size() > 3)
-      {
+    if (args[1] == "copy_directory" && args.size() > 3) {
       // If error occurs we want to continue copying next files.
       bool return_value = 0;
-      for (std::string::size_type cc = 2; cc < args.size() - 1; cc ++)
-        {
-        if(!cmSystemTools::CopyADirectory(args[cc].c_str(),
-            args[args.size() - 1].c_str()))
-          {
-          std::cerr << "Error copying directory from \""
-                    << args[cc] << "\" to \"" << args[args.size() - 1]
-                    << "\".\n";
+      for (std::string::size_type cc = 2; cc < args.size() - 1; cc++) {
+        if (!cmSystemTools::CopyADirectory(args[cc].c_str(),
+                                           args[args.size() - 1].c_str())) {
+          std::cerr << "Error copying directory from \"" << args[cc]
+                    << "\" to \"" << args[args.size() - 1] << "\".\n";
           return_value = 1;
-          }
         }
-      return return_value;
       }
+      return return_value;
+    }
 
     // Rename a file or directory
-    if (args[1] == "rename" && args.size() == 4)
-      {
-      if(!cmSystemTools::RenameFile(args[2].c_str(), args[3].c_str()))
-        {
+    if (args[1] == "rename" && args.size() == 4) {
+      if (!cmSystemTools::RenameFile(args[2].c_str(), args[3].c_str())) {
         std::string e = cmSystemTools::GetLastSystemError();
-        std::cerr << "Error renaming from \""
-                  << args[2] << "\" to \"" << args[3]
-                  << "\": " << e << "\n";
+        std::cerr << "Error renaming from \"" << args[2] << "\" to \""
+                  << args[3] << "\": " << e << "\n";
         return 1;
-        }
-      return 0;
       }
+      return 0;
+    }
 
     // Compare files
-    if (args[1] == "compare_files" && args.size() == 4)
-      {
-      if(cmSystemTools::FilesDiffer(args[2], args[3]))
-        {
-        std::cerr << "Files \""
-                  << args[2] << "\" to \"" << args[3]
+    if (args[1] == "compare_files" && args.size() == 4) {
+      if (cmSystemTools::FilesDiffer(args[2], args[3])) {
+        std::cerr << "Files \"" << args[2] << "\" to \"" << args[3]
                   << "\" are different.\n";
         return 1;
-        }
-      return 0;
       }
+      return 0;
+    }
 
 #if defined(_WIN32) && defined(CMAKE_BUILD_WITH_CMAKE)
-    else if(args[1] == "__create_def")
-      {
-      if(args.size() < 4)
-        {
-        std::cerr <<
-          "__create_def Usage: -E __create_def outfile.def objlistfile\n";
+    else if (args[1] == "__create_def") {
+      if (args.size() < 4) {
+        std::cerr
+          << "__create_def Usage: -E __create_def outfile.def objlistfile\n";
         return 1;
-        }
+      }
       FILE* fout = cmsys::SystemTools::Fopen(args[2].c_str(), "w+");
-      if(!fout)
-        {
+      if (!fout) {
         std::cerr << "could not open output .def file: " << args[2].c_str()
                   << "\n";
         return 1;
-        }
-      cmsys::ifstream fin(args[3].c_str(),
-                          std::ios::in | std::ios::binary);
-      if(!fin)
-        {
+      }
+      cmsys::ifstream fin(args[3].c_str(), std::ios::in | std::ios::binary);
+      if (!fin) {
         std::cerr << "could not open object list file: " << args[3].c_str()
                   << "\n";
         return 1;
-        }
+      }
       std::string objfile;
       bindexplib deffile;
-      while(cmSystemTools::GetLineFromStream(fin, objfile))
-        {
-        if( !deffile.AddObjectFile(objfile.c_str()))
-          {
+      while (cmSystemTools::GetLineFromStream(fin, objfile)) {
+        if (!deffile.AddObjectFile(objfile.c_str())) {
           return 1;
-          }
         }
+      }
       deffile.WriteFile(fout);
       fclose(fout);
       return 0;
-      }
+    }
 #endif
     // run include what you use command and then run the compile
     // command. This is an internal undocumented option and should
     // only be used by CMake itself when running iwyu.
-    else if (args[1] == "__run_iwyu")
-      {
-      if (args.size() < 3)
-        {
+    else if (args[1] == "__run_iwyu") {
+      if (args.size() < 3) {
         std::cerr << "__run_iwyu Usage: -E __run_iwyu [--iwyu=/path/iwyu]"
-          " [--tidy=/path/tidy] -- compile command\n";
+                     " [--tidy=/path/tidy] -- compile command\n";
         return 1;
-        }
+      }
       bool doing_options = true;
       std::vector<std::string> orig_cmd;
       std::string iwyu;
       std::string tidy;
       std::string sourceFile;
-      for (std::string::size_type cc = 2; cc < args.size(); cc ++)
-        {
+      for (std::string::size_type cc = 2; cc < args.size(); cc++) {
         std::string const& arg = args[cc];
-        if (arg == "--")
-          {
+        if (arg == "--") {
           doing_options = false;
-          }
-        else if (doing_options && cmHasLiteralPrefix(arg, "--iwyu="))
-          {
+        } else if (doing_options && cmHasLiteralPrefix(arg, "--iwyu=")) {
           iwyu = arg.substr(7);
-          }
-        else if (doing_options && cmHasLiteralPrefix(arg, "--tidy="))
-          {
+        } else if (doing_options && cmHasLiteralPrefix(arg, "--tidy=")) {
           tidy = arg.substr(7);
-          }
-        else if (doing_options && cmHasLiteralPrefix(arg, "--source="))
-          {
+        } else if (doing_options && cmHasLiteralPrefix(arg, "--source=")) {
           sourceFile = arg.substr(9);
-          }
-        else if (doing_options)
-          {
+        } else if (doing_options) {
           std::cerr << "__run_iwyu given unknown argument: " << arg << "\n";
           return 1;
-          }
-        else
-          {
+        } else {
           orig_cmd.push_back(arg);
-          }
         }
-      if (tidy.empty() && iwyu.empty())
-        {
+      }
+      if (tidy.empty() && iwyu.empty()) {
         std::cerr << "__run_iwyu missing --tidy= or --iwyu=\n";
         return 1;
-        }
-      if (!tidy.empty() && sourceFile.empty())
-        {
+      }
+      if (!tidy.empty() && sourceFile.empty()) {
         std::cerr << "__run_iwyu --tidy= requires --source=\n";
         return 1;
-        }
-      if (orig_cmd.empty())
-        {
+      }
+      if (orig_cmd.empty()) {
         std::cerr << "__run_iwyu missing compile command after --\n";
         return 1;
-        }
+      }
 
       int ret = 0;
 
-      if (!iwyu.empty())
-        {
+      if (!iwyu.empty()) {
         // Construct the iwyu command line by taking what was given
         // and adding all the arguments we give to the compiler.
         std::vector<std::string> iwyu_cmd;
         cmSystemTools::ExpandListArgument(iwyu, iwyu_cmd, true);
-        iwyu_cmd.insert(iwyu_cmd.end(), orig_cmd.begin()+1, orig_cmd.end());
+        iwyu_cmd.insert(iwyu_cmd.end(), orig_cmd.begin() + 1, orig_cmd.end());
 
         // Run the iwyu command line.  Capture its stderr and hide its stdout.
         std::string stdErr;
-        if(!cmSystemTools::RunSingleCommand(iwyu_cmd, 0, &stdErr, &ret,
-                                            0, cmSystemTools::OUTPUT_NONE))
-          {
-          std::cerr << "Error running '" << iwyu_cmd[0] << "': "
-                    << stdErr << "\n";
+        if (!cmSystemTools::RunSingleCommand(iwyu_cmd, 0, &stdErr, &ret, 0,
+                                             cmSystemTools::OUTPUT_NONE)) {
+          std::cerr << "Error running '" << iwyu_cmd[0] << "': " << stdErr
+                    << "\n";
           return 1;
-          }
+        }
 
         // Warn if iwyu reported anything.
-        if(stdErr.find("should remove these lines:") != stdErr.npos
-           || stdErr.find("should add these lines:") != stdErr.npos)
-          {
+        if (stdErr.find("should remove these lines:") != stdErr.npos ||
+            stdErr.find("should add these lines:") != stdErr.npos) {
           std::cerr << "Warning: include-what-you-use reported diagnostics:\n"
                     << stdErr << "\n";
-          }
         }
+      }
 
-      if (!tidy.empty())
-        {
+      if (!tidy.empty()) {
         // Construct the clang-tidy command line by taking what was given
         // and adding our compiler command line.  The clang-tidy tool will
         // automatically skip over the compiler itself and extract the
@@ -400,219 +341,176 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
 
         // Run the tidy command line.  Capture its stdout and hide its stderr.
         std::string stdOut;
-        if(!cmSystemTools::RunSingleCommand(tidy_cmd, &stdOut, 0, &ret, 0,
-                                            cmSystemTools::OUTPUT_NONE))
-          {
+        if (!cmSystemTools::RunSingleCommand(tidy_cmd, &stdOut, 0, &ret, 0,
+                                             cmSystemTools::OUTPUT_NONE)) {
           std::cerr << "Error running '" << tidy_cmd[0] << "'\n";
           return 1;
-          }
+        }
 
         // Output the stdout from clang-tidy to stderr
         std::cerr << stdOut;
-        }
+      }
 
       // Now run the real compiler command and return its result value.
-      if(!cmSystemTools::RunSingleCommand(orig_cmd, 0, 0, &ret, 0,
-                                          cmSystemTools::OUTPUT_PASSTHROUGH))
-        {
+      if (!cmSystemTools::RunSingleCommand(
+            orig_cmd, 0, 0, &ret, 0, cmSystemTools::OUTPUT_PASSTHROUGH)) {
         std::cerr << "Error running '" << orig_cmd[0] << "'\n";
         return 1;
-        }
-      return ret;
       }
+      return ret;
+    }
 
     // Echo string
-    else if (args[1] == "echo" )
-      {
+    else if (args[1] == "echo") {
       std::cout << cmJoin(cmMakeRange(args).advance(2), " ") << std::endl;
       return 0;
-      }
+    }
 
     // Echo string no new line
-    else if (args[1] == "echo_append" )
-      {
+    else if (args[1] == "echo_append") {
       std::cout << cmJoin(cmMakeRange(args).advance(2), " ");
       return 0;
-      }
+    }
 
-    else if (args[1] == "env" )
-      {
+    else if (args[1] == "env") {
       std::vector<std::string>::const_iterator ai = args.begin() + 2;
       std::vector<std::string>::const_iterator ae = args.end();
-      for(; ai != ae; ++ai)
-        {
+      for (; ai != ae; ++ai) {
         std::string const& a = *ai;
-        if(cmHasLiteralPrefix(a, "--unset="))
-          {
+        if (cmHasLiteralPrefix(a, "--unset=")) {
           // Unset environment variable.
           cmSystemTools::UnPutEnv(a.c_str() + 8);
-          }
-        else if(!a.empty() && a[0] == '-')
-          {
+        } else if (!a.empty() && a[0] == '-') {
           // Environment variable and command names cannot start in '-',
           // so this must be an unknown option.
           std::cerr << "cmake -E env: unknown option '" << a << "'"
                     << std::endl;
           return 1;
-          }
-        else if(a.find("=") != a.npos)
-          {
+        } else if (a.find("=") != a.npos) {
           // Set environment variable.
           cmSystemTools::PutEnv(a);
-          }
-        else
-          {
+        } else {
           // This is the beginning of the command.
           break;
-          }
         }
+      }
 
-      if(ai == ae)
-        {
+      if (ai == ae) {
         std::cerr << "cmake -E env: no command given" << std::endl;
         return 1;
-        }
+      }
 
       // Execute command from remaining arguments.
       std::vector<std::string> cmd(ai, ae);
       int retval;
-      if(cmSystemTools::RunSingleCommand(
-           cmd, 0, 0, &retval, NULL, cmSystemTools::OUTPUT_PASSTHROUGH))
-        {
+      if (cmSystemTools::RunSingleCommand(cmd, 0, 0, &retval, NULL,
+                                          cmSystemTools::OUTPUT_PASSTHROUGH)) {
         return retval;
-        }
-      return 1;
       }
+      return 1;
+    }
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
-    else if (args[1] == "environment" )
-      {
+    else if (args[1] == "environment") {
       std::vector<std::string> env = cmSystemTools::GetEnvironmentVariables();
       std::vector<std::string>::iterator it;
-      for ( it = env.begin(); it != env.end(); ++ it )
-        {
+      for (it = env.begin(); it != env.end(); ++it) {
         std::cout << *it << std::endl;
-        }
-      return 0;
       }
+      return 0;
+    }
 #endif
 
-    else if (args[1] == "make_directory" && args.size() > 2)
-      {
+    else if (args[1] == "make_directory" && args.size() > 2) {
       // If error occurs we want to continue copying next files.
       bool return_value = 0;
-      for (std::string::size_type cc = 2; cc < args.size(); cc ++)
-        {
-        if(!cmSystemTools::MakeDirectory(args[cc].c_str()))
-          {
-          std::cerr << "Error creating directory \""
-                    << args[cc] << "\".\n";
+      for (std::string::size_type cc = 2; cc < args.size(); cc++) {
+        if (!cmSystemTools::MakeDirectory(args[cc].c_str())) {
+          std::cerr << "Error creating directory \"" << args[cc] << "\".\n";
           return_value = 1;
-          }
         }
-      return return_value;
       }
+      return return_value;
+    }
 
-    else if (args[1] == "remove_directory" && args.size() == 3)
-      {
-      if(cmSystemTools::FileIsDirectory(args[2]) &&
-         !cmSystemTools::RemoveADirectory(args[2]))
-        {
-        std::cerr << "Error removing directory \"" << args[2]
-                  << "\".\n";
+    else if (args[1] == "remove_directory" && args.size() == 3) {
+      if (cmSystemTools::FileIsDirectory(args[2]) &&
+          !cmSystemTools::RemoveADirectory(args[2])) {
+        std::cerr << "Error removing directory \"" << args[2] << "\".\n";
         return 1;
-        }
-      return 0;
       }
+      return 0;
+    }
 
     // Remove file
-    else if (args[1] == "remove" && args.size() > 2)
-      {
+    else if (args[1] == "remove" && args.size() > 2) {
       bool force = false;
-      for (std::string::size_type cc = 2; cc < args.size(); cc ++)
-        {
-        if(args[cc] == "\\-f" || args[cc] == "-f")
-          {
+      for (std::string::size_type cc = 2; cc < args.size(); cc++) {
+        if (args[cc] == "\\-f" || args[cc] == "-f") {
           force = true;
-          }
-        else
-          {
+        } else {
           // Complain if the file could not be removed, still exists,
           // and the -f option was not given.
-          if(!cmSystemTools::RemoveFile(args[cc]) && !force &&
-             cmSystemTools::FileExists(args[cc].c_str()))
-            {
+          if (!cmSystemTools::RemoveFile(args[cc]) && !force &&
+              cmSystemTools::FileExists(args[cc].c_str())) {
             return 1;
-            }
           }
         }
-      return 0;
       }
+      return 0;
+    }
     // Touch file
-    else if (args[1] == "touch" && args.size() > 2)
-      {
-      for (std::string::size_type cc = 2; cc < args.size(); cc ++)
-        {
-        if(!cmSystemTools::Touch(args[cc], true))
-          {
+    else if (args[1] == "touch" && args.size() > 2) {
+      for (std::string::size_type cc = 2; cc < args.size(); cc++) {
+        if (!cmSystemTools::Touch(args[cc], true)) {
           return 1;
-          }
         }
-      return 0;
       }
+      return 0;
+    }
     // Touch file
-    else if (args[1] == "touch_nocreate" && args.size() > 2)
-      {
-      for (std::string::size_type cc = 2; cc < args.size(); cc ++)
-        {
+    else if (args[1] == "touch_nocreate" && args.size() > 2) {
+      for (std::string::size_type cc = 2; cc < args.size(); cc++) {
         // Complain if the file could not be removed, still exists,
         // and the -f option was not given.
-        if(!cmSystemTools::Touch(args[cc], false))
-          {
+        if (!cmSystemTools::Touch(args[cc], false)) {
           return 1;
-          }
         }
-      return 0;
       }
+      return 0;
+    }
 
     // Sleep command
-    else if (args[1] == "sleep" && args.size() > 2)
-      {
+    else if (args[1] == "sleep" && args.size() > 2) {
       double total = 0;
-      for(size_t i = 2; i < args.size(); ++i)
-        {
+      for (size_t i = 2; i < args.size(); ++i) {
         double num = 0.0;
         char unit;
         char extra;
         int n = sscanf(args[i].c_str(), "%lg%c%c", &num, &unit, &extra);
-        if((n == 1 || (n == 2 && unit == 's')) && num >= 0)
-          {
+        if ((n == 1 || (n == 2 && unit == 's')) && num >= 0) {
           total += num;
-          }
-        else
-          {
+        } else {
           std::cerr << "Unknown sleep time format \"" << args[i] << "\".\n";
           return 1;
-          }
         }
-      if(total > 0)
-        {
-        cmSystemTools::Delay(static_cast<unsigned int>(total*1000));
-        }
-      return 0;
       }
+      if (total > 0) {
+        cmSystemTools::Delay(static_cast<unsigned int>(total * 1000));
+      }
+      return 0;
+    }
 
     // Clock command
-    else if (args[1] == "time" && args.size() > 2)
-      {
-      std::vector<std::string> command(args.begin()+2, args.end());
+    else if (args[1] == "time" && args.size() > 2) {
+      std::vector<std::string> command(args.begin() + 2, args.end());
 
       clock_t clock_start, clock_finish;
       time_t time_start, time_finish;
 
       time(&time_start);
       clock_start = clock();
-      int ret =0;
+      int ret = 0;
       cmSystemTools::RunSingleCommand(command, 0, 0, &ret);
 
       clock_finish = clock();
@@ -620,184 +518,159 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
 
       double clocks_per_sec = static_cast<double>(CLOCKS_PER_SEC);
       std::cout << "Elapsed time: "
-        << static_cast<long>(time_finish - time_start) << " s. (time)"
-        << ", "
-        << static_cast<double>(clock_finish - clock_start) / clocks_per_sec
-        << " s. (clock)"
-        << "\n";
+                << static_cast<long>(time_finish - time_start) << " s. (time)"
+                << ", "
+                << static_cast<double>(clock_finish - clock_start) /
+          clocks_per_sec
+                << " s. (clock)"
+                << "\n";
       return ret;
-      }
+    }
     // Command to calculate the md5sum of a file
-    else if (args[1] == "md5sum" && args.size() >= 3)
-      {
+    else if (args[1] == "md5sum" && args.size() >= 3) {
       char md5out[32];
       int retval = 0;
-      for (std::string::size_type cc = 2; cc < args.size(); cc ++)
-        {
-        const char *filename = args[cc].c_str();
+      for (std::string::size_type cc = 2; cc < args.size(); cc++) {
+        const char* filename = args[cc].c_str();
         // Cannot compute md5sum of a directory
-        if(cmSystemTools::FileIsDirectory(filename))
-          {
+        if (cmSystemTools::FileIsDirectory(filename)) {
           std::cerr << "Error: " << filename << " is a directory" << std::endl;
           retval++;
-          }
-        else if(!cmSystemTools::ComputeFileMD5(filename, md5out))
-          {
+        } else if (!cmSystemTools::ComputeFileMD5(filename, md5out)) {
           // To mimic md5sum behavior in a shell:
           std::cerr << filename << ": No such file or directory" << std::endl;
           retval++;
-          }
-        else
-          {
-          std::cout << std::string(md5out,32) << "  " << filename << std::endl;
-          }
+        } else {
+          std::cout << std::string(md5out, 32) << "  " << filename
+                    << std::endl;
         }
-      return retval;
       }
+      return retval;
+    }
 
     // Command to change directory and run a program.
-    else if (args[1] == "chdir" && args.size() >= 4)
-      {
+    else if (args[1] == "chdir" && args.size() >= 4) {
       std::string directory = args[2];
-      if(!cmSystemTools::FileExists(directory.c_str()))
-        {
+      if (!cmSystemTools::FileExists(directory.c_str())) {
         cmSystemTools::Error("Directory does not exist for chdir command: ",
                              args[2].c_str());
         return 1;
-        }
+      }
 
       std::string command =
         cmWrap('"', cmMakeRange(args).advance(3), '"', " ");
       int retval = 0;
       int timeout = 0;
-      if ( cmSystemTools::RunSingleCommand(command.c_str(), 0, 0, &retval,
-             directory.c_str(), cmSystemTools::OUTPUT_PASSTHROUGH, timeout) )
-        {
+      if (cmSystemTools::RunSingleCommand(
+            command.c_str(), 0, 0, &retval, directory.c_str(),
+            cmSystemTools::OUTPUT_PASSTHROUGH, timeout)) {
         return retval;
-        }
+      }
 
       return 1;
-      }
+    }
 
     // Command to start progress for a build
-    else if (args[1] == "cmake_progress_start" && args.size() == 4)
-      {
+    else if (args[1] == "cmake_progress_start" && args.size() == 4) {
       // basically remove the directory
       std::string dirName = args[2];
       dirName += "/Progress";
       cmSystemTools::RemoveADirectory(dirName);
 
       // is the last argument a filename that exists?
-      FILE *countFile = cmsys::SystemTools::Fopen(args[3],"r");
+      FILE* countFile = cmsys::SystemTools::Fopen(args[3], "r");
       int count;
-      if (countFile)
-        {
-        if (1!=fscanf(countFile,"%i",&count))
-          {
+      if (countFile) {
+        if (1 != fscanf(countFile, "%i", &count)) {
           cmSystemTools::Message("Could not read from count file.");
-          }
-        fclose(countFile);
         }
-      else
-        {
+        fclose(countFile);
+      } else {
         count = atoi(args[3].c_str());
-        }
-      if (count)
-        {
+      }
+      if (count) {
         cmSystemTools::MakeDirectory(dirName.c_str());
         // write the count into the directory
         std::string fName = dirName;
         fName += "/count.txt";
-        FILE *progFile = cmsys::SystemTools::Fopen(fName,"w");
-        if (progFile)
-          {
-          fprintf(progFile,"%i\n",count);
+        FILE* progFile = cmsys::SystemTools::Fopen(fName, "w");
+        if (progFile) {
+          fprintf(progFile, "%i\n", count);
           fclose(progFile);
-          }
         }
-      return 0;
       }
+      return 0;
+    }
 
     // Command to report progress for a build
-    else if (args[1] == "cmake_progress_report" && args.size() >= 3)
-      {
+    else if (args[1] == "cmake_progress_report" && args.size() >= 3) {
       // This has been superseded by cmake_echo_color --progress-*
       // options.  We leave it here to avoid errors if somehow this
       // is invoked by an existing makefile without regenerating.
       return 0;
-      }
+    }
 
     // Command to create a symbolic link.  Fails on platforms not
     // supporting them.
-    else if (args[1] == "create_symlink" && args.size() == 4)
-      {
+    else if (args[1] == "create_symlink" && args.size() == 4) {
       const char* destinationFileName = args[3].c_str();
-      if((cmSystemTools::FileExists(destinationFileName) ||
-          cmSystemTools::FileIsSymlink(destinationFileName)) &&
-         !cmSystemTools::RemoveFile(destinationFileName))
-        {
+      if ((cmSystemTools::FileExists(destinationFileName) ||
+           cmSystemTools::FileIsSymlink(destinationFileName)) &&
+          !cmSystemTools::RemoveFile(destinationFileName)) {
         std::string emsg = cmSystemTools::GetLastSystemError();
-        std::cerr <<
-          "failed to create symbolic link '" << destinationFileName <<
-          "' because existing path cannot be removed: " << emsg << "\n";
+        std::cerr << "failed to create symbolic link '" << destinationFileName
+                  << "' because existing path cannot be removed: " << emsg
+                  << "\n";
         return 1;
-        }
-      if(!cmSystemTools::CreateSymlink(args[2], args[3]))
-        {
+      }
+      if (!cmSystemTools::CreateSymlink(args[2], args[3])) {
         std::string emsg = cmSystemTools::GetLastSystemError();
-        std::cerr <<
-          "failed to create symbolic link '" << destinationFileName <<
-          "': " << emsg << "\n";
+        std::cerr << "failed to create symbolic link '" << destinationFileName
+                  << "': " << emsg << "\n";
         return 1;
-        }
-      return 0;
       }
+      return 0;
+    }
 
     // Internal CMake shared library support.
-    else if (args[1] == "cmake_symlink_library" && args.size() == 5)
-      {
+    else if (args[1] == "cmake_symlink_library" && args.size() == 5) {
       return cmcmd::SymlinkLibrary(args);
-      }
+    }
     // Internal CMake versioned executable support.
-    else if (args[1] == "cmake_symlink_executable" && args.size() == 4)
-      {
+    else if (args[1] == "cmake_symlink_executable" && args.size() == 4) {
       return cmcmd::SymlinkExecutable(args);
-      }
+    }
 
 #if defined(CMAKE_HAVE_VS_GENERATORS)
     // Internal CMake support for calling Visual Studio macros.
-    else if (args[1] == "cmake_call_visual_studio_macro" && args.size() >= 4)
-      {
+    else if (args[1] == "cmake_call_visual_studio_macro" && args.size() >= 4) {
       // args[2] = full path to .sln file or "ALL"
       // args[3] = name of Visual Studio macro to call
       // args[4..args.size()-1] = [optional] args for Visual Studio macro
 
       std::string macroArgs;
 
-      if (args.size() > 4)
-        {
+      if (args.size() > 4) {
         macroArgs = args[4];
 
-        for (size_t i = 5; i < args.size(); ++i)
-          {
+        for (size_t i = 5; i < args.size(); ++i) {
           macroArgs += " ";
           macroArgs += args[i];
-          }
         }
-
-      return cmCallVisualStudioMacro::CallMacro(args[2], args[3],
-        macroArgs, true);
       }
+
+      return cmCallVisualStudioMacro::CallMacro(args[2], args[3], macroArgs,
+                                                true);
+    }
 #endif
 
     // Internal CMake dependency scanning support.
-    else if (args[1] == "cmake_depends" && args.size() >= 6)
-      {
+    else if (args[1] == "cmake_depends" && args.size() >= 6) {
       // Use the make system's VERBOSE environment variable to enable
       // verbose output. This can be skipped by also setting CMAKE_NO_VERBOSE
       // (which is set by the Eclipse and KDevelop generators).
-      bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != 0)
-                       && (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == 0));
+      bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != 0) &&
+                      (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == 0));
 
       // Create a cmake object instance to process dependencies.
       cmake cm;
@@ -808,8 +681,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
       std::string startOutDir;
       std::string depInfo;
       bool color = false;
-      if(args.size() >= 8)
-        {
+      if (args.size() >= 8) {
         // Full signature:
         //
         //   -E cmake_depends <generator>
@@ -824,17 +696,13 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
         homeOutDir = args[5];
         startOutDir = args[6];
         depInfo = args[7];
-        if(args.size() >= 9 &&
-           args[8].length() >= 8 &&
-           args[8].substr(0, 8) == "--color=")
-          {
+        if (args.size() >= 9 && args[8].length() >= 8 &&
+            args[8].substr(0, 8) == "--color=") {
           // Enable or disable color based on the switch value.
           color = (args[8].size() == 8 ||
                    cmSystemTools::IsOn(args[8].substr(8).c_str()));
-          }
         }
-      else
-        {
+      } else {
         // Support older signature for existing makefiles:
         //
         //   -E cmake_depends <generator>
@@ -849,7 +717,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
         homeOutDir = args[3];
         startOutDir = args[3];
         depInfo = args[5];
-        }
+      }
 
       // Create a local generator configured for the directory in
       // which dependencies will be scanned.
@@ -860,74 +728,56 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
       cm.SetHomeDirectory(homeDir);
       cm.SetHomeOutputDirectory(homeOutDir);
       cm.GetCurrentSnapshot().SetDefaultDefinitions();
-      if(cmGlobalGenerator* ggd = cm.CreateGlobalGenerator(gen))
-        {
+      if (cmGlobalGenerator* ggd = cm.CreateGlobalGenerator(gen)) {
         cm.SetGlobalGenerator(ggd);
         cmState::Snapshot snapshot = cm.GetCurrentSnapshot();
         snapshot.GetDirectory().SetCurrentBinary(startOutDir);
         snapshot.GetDirectory().SetCurrentSource(startDir);
         cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(ggd, snapshot));
         cmsys::auto_ptr<cmLocalGenerator> lgd(
-              ggd->CreateLocalGenerator(mf.get()));
+          ggd->CreateLocalGenerator(mf.get()));
 
         // Actually scan dependencies.
-        return lgd->UpdateDependencies(depInfo.c_str(),
-                                       verbose, color)? 0 : 2;
-        }
-      return 1;
+        return lgd->UpdateDependencies(depInfo.c_str(), verbose, color) ? 0
+                                                                        : 2;
       }
+      return 1;
+    }
 
     // Internal CMake link script support.
-    else if (args[1] == "cmake_link_script" && args.size() >= 3)
-      {
+    else if (args[1] == "cmake_link_script" && args.size() >= 3) {
       return cmcmd::ExecuteLinkScript(args);
-      }
+    }
 
     // Internal CMake unimplemented feature notification.
-    else if (args[1] == "cmake_unimplemented_variable")
-      {
+    else if (args[1] == "cmake_unimplemented_variable") {
       std::cerr << "Feature not implemented for this platform.";
-      if(args.size() == 3)
-        {
+      if (args.size() == 3) {
         std::cerr << "  Variable " << args[2] << " is not set.";
-        }
+      }
       std::cerr << std::endl;
       return 1;
-      }
-    else if (args[1] == "vs_link_exe")
-      {
+    } else if (args[1] == "vs_link_exe") {
       return cmcmd::VisualStudioLink(args, 1);
-      }
-    else if (args[1] == "vs_link_dll")
-      {
+    } else if (args[1] == "vs_link_dll") {
       return cmcmd::VisualStudioLink(args, 2);
-      }
+    }
     // Internal CMake color makefile support.
-    else if (args[1] == "cmake_echo_color")
-      {
+    else if (args[1] == "cmake_echo_color") {
       return cmcmd::ExecuteEchoColor(args);
-      }
+    }
 #ifdef CMAKE_BUILD_WITH_CMAKE
-    else if (args[1] == "cmake_autogen" && args.size() >= 4)
-      {
-        cmQtAutoGenerators autogen;
-        std::string const& config = args[3];
-        bool autogenSuccess = autogen.Run(args[2], config);
-        return autogenSuccess ? 0 : 1;
-      }
+    else if (args[1] == "cmake_autogen" && args.size() >= 4) {
+      cmQtAutoGenerators autogen;
+      std::string const& config = args[3];
+      bool autogenSuccess = autogen.Run(args[2], config);
+      return autogenSuccess ? 0 : 1;
+    }
 #endif
 
     // Tar files
-    else if (args[1] == "tar" && args.size() > 3)
-      {
-      const char* knownFormats[] =
-        {
-        "7zip",
-        "gnutar",
-        "pax",
-        "paxr",
-        "zip"
-        };
+    else if (args[1] == "tar" && args.size() > 3) {
+      const char* knownFormats[] = { "7zip", "gnutar", "pax", "paxr", "zip" };
 
       std::string flags = args[2];
       std::string outFile = args[3];
@@ -935,112 +785,82 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
       std::string mtime;
       std::string format;
       bool doing_options = true;
-      for (std::string::size_type cc = 4; cc < args.size(); cc ++)
-        {
+      for (std::string::size_type cc = 4; cc < args.size(); cc++) {
         std::string const& arg = args[cc];
-        if (doing_options && cmHasLiteralPrefix(arg, "--"))
-          {
-          if (arg == "--")
-            {
+        if (doing_options && cmHasLiteralPrefix(arg, "--")) {
+          if (arg == "--") {
             doing_options = false;
-            }
-          else if (cmHasLiteralPrefix(arg, "--mtime="))
-            {
+          } else if (cmHasLiteralPrefix(arg, "--mtime=")) {
             mtime = arg.substr(8);
-            }
-          else if (cmHasLiteralPrefix(arg, "--files-from="))
-            {
+          } else if (cmHasLiteralPrefix(arg, "--files-from=")) {
             std::string const& files_from = arg.substr(13);
-            if (!cmTarFilesFrom(files_from, files))
-              {
+            if (!cmTarFilesFrom(files_from, files)) {
               return 1;
-              }
             }
-          else if (cmHasLiteralPrefix(arg, "--format="))
-            {
+          } else if (cmHasLiteralPrefix(arg, "--format=")) {
             format = arg.substr(9);
-            bool isKnown = std::find(cmArrayBegin(knownFormats),
-              cmArrayEnd(knownFormats), format) != cmArrayEnd(knownFormats);
+            bool isKnown =
+              std::find(cmArrayBegin(knownFormats), cmArrayEnd(knownFormats),
+                        format) != cmArrayEnd(knownFormats);
 
-            if(!isKnown)
-              {
+            if (!isKnown) {
               cmSystemTools::Error("Unknown -E tar --format= argument: ",
-                format.c_str());
+                                   format.c_str());
               return 1;
-              }
             }
-          else
-            {
+          } else {
             cmSystemTools::Error("Unknown option to -E tar: ", arg.c_str());
             return 1;
-            }
           }
-        else
-          {
+        } else {
           files.push_back(arg);
-          }
         }
+      }
       cmSystemTools::cmTarCompression compress =
         cmSystemTools::TarCompressNone;
       bool verbose = false;
       int nCompress = 0;
-      if ( flags.find_first_of('j') != flags.npos )
-        {
+      if (flags.find_first_of('j') != flags.npos) {
         compress = cmSystemTools::TarCompressBZip2;
         ++nCompress;
-        }
-      if ( flags.find_first_of('J') != flags.npos )
-        {
+      }
+      if (flags.find_first_of('J') != flags.npos) {
         compress = cmSystemTools::TarCompressXZ;
         ++nCompress;
-        }
-      if ( flags.find_first_of('z') != flags.npos )
-        {
+      }
+      if (flags.find_first_of('z') != flags.npos) {
         compress = cmSystemTools::TarCompressGZip;
         ++nCompress;
-        }
-      if ( (format == "7zip" || format == "zip") && nCompress > 0 )
-        {
+      }
+      if ((format == "7zip" || format == "zip") && nCompress > 0) {
         cmSystemTools::Error("Can not use compression flags with format: ",
-          format.c_str());
+                             format.c_str());
         return 1;
-        }
-      else if ( nCompress > 1 )
-        {
+      } else if (nCompress > 1) {
         cmSystemTools::Error("Can only compress a tar file one way; "
                              "at most one flag of z, j, or J may be used");
         return 1;
-        }
-      if ( flags.find_first_of('v') != flags.npos )
-        {
+      }
+      if (flags.find_first_of('v') != flags.npos) {
         verbose = true;
-        }
+      }
 
-      if ( flags.find_first_of('t') != flags.npos )
-        {
-        if ( !cmSystemTools::ListTar(outFile.c_str(), verbose) )
-          {
+      if (flags.find_first_of('t') != flags.npos) {
+        if (!cmSystemTools::ListTar(outFile.c_str(), verbose)) {
           cmSystemTools::Error("Problem listing tar: ", outFile.c_str());
           return 1;
-          }
         }
-      else if ( flags.find_first_of('c') != flags.npos )
-        {
-        if ( !cmSystemTools::CreateTar(
-               outFile.c_str(), files, compress, verbose, mtime, format) )
-          {
+      } else if (flags.find_first_of('c') != flags.npos) {
+        if (!cmSystemTools::CreateTar(outFile.c_str(), files, compress,
+                                      verbose, mtime, format)) {
           cmSystemTools::Error("Problem creating tar: ", outFile.c_str());
           return 1;
-          }
         }
-      else if ( flags.find_first_of('x') != flags.npos )
-        {
-        if ( !cmSystemTools::ExtractTar(
-            outFile.c_str(), verbose) )
-          {
+      } else if (flags.find_first_of('x') != flags.npos) {
+        if (!cmSystemTools::ExtractTar(outFile.c_str(), verbose)) {
           cmSystemTools::Error("Problem extracting tar: ", outFile.c_str());
           return 1;
-          }
+        }
 #ifdef WIN32
         // OK, on windows 7 after we untar some files,
         // sometimes we can not rename the directory after
@@ -1050,56 +870,48 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
         // is set in the env, its value will be used instead of 100.
         int delay = 100;
         const char* delayVar = cmSystemTools::GetEnv("CMAKE_UNTAR_DELAY");
-        if(delayVar)
-          {
+        if (delayVar) {
           delay = atoi(delayVar);
-          }
-        if(delay)
-          {
+        }
+        if (delay) {
           cmSystemTools::Delay(delay);
-          }
-#endif
         }
-      return 0;
+#endif
       }
+      return 0;
+    }
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
     // Internal CMake Fortran module support.
-    else if (args[1] == "cmake_copy_f90_mod" && args.size() >= 4)
-      {
-      return cmDependsFortran::CopyModule(args)? 0 : 1;
-      }
+    else if (args[1] == "cmake_copy_f90_mod" && args.size() >= 4) {
+      return cmDependsFortran::CopyModule(args) ? 0 : 1;
+    }
 #endif
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
     // Write registry value
-    else if (args[1] == "write_regv" && args.size() > 3)
-      {
+    else if (args[1] == "write_regv" && args.size() > 3) {
       return cmSystemTools::WriteRegistryValue(args[2].c_str(),
-                                               args[3].c_str()) ? 0 : 1;
-      }
+                                               args[3].c_str())
+        ? 0
+        : 1;
+    }
 
     // Delete registry value
-    else if (args[1] == "delete_regv" && args.size() > 2)
-      {
+    else if (args[1] == "delete_regv" && args.size() > 2) {
       return cmSystemTools::DeleteRegistryValue(args[2].c_str()) ? 0 : 1;
-      }
+    }
     // Remove file
-    else if (args[1] == "comspec" && args.size() > 2)
-      {
+    else if (args[1] == "comspec" && args.size() > 2) {
       std::cerr << "Win9x helper \"cmake -E comspec\" no longer supported\n";
       return 1;
-      }
-    else if (args[1] == "env_vs8_wince" && args.size() == 3)
-      {
+    } else if (args[1] == "env_vs8_wince" && args.size() == 3) {
       return cmcmd::WindowsCEEnvironment("8.0", args[2]);
-      }
-    else if (args[1] == "env_vs9_wince" && args.size() == 3)
-      {
+    } else if (args[1] == "env_vs9_wince" && args.size() == 3) {
       return cmcmd::WindowsCEEnvironment("9.0", args[2]);
-      }
-#endif
     }
+#endif
+  }
 
   ::CMakeCommandUsage(args[0].c_str());
   return 1;
@@ -1111,22 +923,18 @@ int cmcmd::SymlinkLibrary(std::vector<std::string>& args)
   std::string realName = args[2];
   std::string soName = args[3];
   std::string name = args[4];
-  if(soName != realName)
-    {
-    if(!cmcmd::SymlinkInternal(realName, soName))
-      {
+  if (soName != realName) {
+    if (!cmcmd::SymlinkInternal(realName, soName)) {
       cmSystemTools::ReportLastSystemError("cmake_symlink_library");
       result = 1;
-      }
     }
-  if(name != soName)
-    {
-    if(!cmcmd::SymlinkInternal(soName, name))
-      {
+  }
+  if (name != soName) {
+    if (!cmcmd::SymlinkInternal(soName, name)) {
       cmSystemTools::ReportLastSystemError("cmake_symlink_library");
       result = 1;
-      }
     }
+  }
   return result;
 }
 
@@ -1135,24 +943,21 @@ int cmcmd::SymlinkExecutable(std::vector<std::string>& args)
   int result = 0;
   std::string realName = args[2];
   std::string name = args[3];
-  if(name != realName)
-    {
-    if(!cmcmd::SymlinkInternal(realName, name))
-      {
+  if (name != realName) {
+    if (!cmcmd::SymlinkInternal(realName, name)) {
       cmSystemTools::ReportLastSystemError("cmake_symlink_executable");
       result = 1;
-      }
     }
+  }
   return result;
 }
 
 bool cmcmd::SymlinkInternal(std::string const& file, std::string const& link)
 {
-  if(cmSystemTools::FileExists(link.c_str()) ||
-     cmSystemTools::FileIsSymlink(link))
-    {
+  if (cmSystemTools::FileExists(link.c_str()) ||
+      cmSystemTools::FileIsSymlink(link)) {
     cmSystemTools::RemoveFile(link);
-    }
+  }
 #if defined(_WIN32) && !defined(__CYGWIN__)
   return cmSystemTools::CopyFileAlways(file.c_str(), link.c_str());
 #else
@@ -1161,62 +966,51 @@ bool cmcmd::SymlinkInternal(std::string const& file, std::string const& link)
 #endif
 }
 
-static void cmcmdProgressReport(std::string const& dir,
-                                std::string const& num)
+static void cmcmdProgressReport(std::string const& dir, std::string const& num)
 {
   std::string dirName = dir;
   dirName += "/Progress";
   std::string fName;
-  FILE *progFile;
+  FILE* progFile;
 
   // read the count
   fName = dirName;
   fName += "/count.txt";
-  progFile = cmsys::SystemTools::Fopen(fName,"r");
+  progFile = cmsys::SystemTools::Fopen(fName, "r");
   int count = 0;
-  if (!progFile)
-    {
+  if (!progFile) {
     return;
-    }
-  else
-    {
-    if (1!=fscanf(progFile,"%i",&count))
-      {
+  } else {
+    if (1 != fscanf(progFile, "%i", &count)) {
       cmSystemTools::Message("Could not read from progress file.");
-      }
-    fclose(progFile);
     }
+    fclose(progFile);
+  }
   const char* last = num.c_str();
-  for(const char* c = last;; ++c)
-    {
-    if (*c == ',' || *c == '\0')
-      {
-      if (c != last)
-        {
+  for (const char* c = last;; ++c) {
+    if (*c == ',' || *c == '\0') {
+      if (c != last) {
         fName = dirName;
         fName += "/";
-        fName.append(last, c-last);
-        progFile = cmsys::SystemTools::Fopen(fName,"w");
-        if (progFile)
-          {
-          fprintf(progFile,"empty");
+        fName.append(last, c - last);
+        progFile = cmsys::SystemTools::Fopen(fName, "w");
+        if (progFile) {
+          fprintf(progFile, "empty");
           fclose(progFile);
-          }
         }
-      if(*c == '\0')
-        {
+      }
+      if (*c == '\0') {
         break;
-        }
-      last = c + 1;
       }
+      last = c + 1;
     }
-  int fileNum = static_cast<int>
-    (cmsys::Directory::GetNumberOfFilesInDirectory(dirName));
-  if (count > 0)
-    {
+  }
+  int fileNum =
+    static_cast<int>(cmsys::Directory::GetNumberOfFilesInDirectory(dirName));
+  if (count > 0) {
     // print the progress
-    fprintf(stdout,"[%3i%%] ",((fileNum-3)*100)/count);
-    }
+    fprintf(stdout, "[%3i%%] ", ((fileNum - 3) * 100) / count);
+  }
 }
 
 int cmcmd::ExecuteEchoColor(std::vector<std::string>& args)
@@ -1229,91 +1023,54 @@ int cmcmd::ExecuteEchoColor(std::vector<std::string>& args)
   int color = cmsysTerminal_Color_Normal;
   bool newline = true;
   std::string progressDir;
-  for(unsigned int i=2; i < args.size(); ++i)
-    {
-    if(args[i].find("--switch=") == 0)
-      {
+  for (unsigned int i = 2; i < args.size(); ++i) {
+    if (args[i].find("--switch=") == 0) {
       // Enable or disable color based on the switch value.
       std::string value = args[i].substr(9);
-      if(!value.empty())
-        {
-        if(cmSystemTools::IsOn(value.c_str()))
-          {
+      if (!value.empty()) {
+        if (cmSystemTools::IsOn(value.c_str())) {
           enabled = true;
-          }
-        else
-          {
+        } else {
           enabled = false;
-          }
         }
       }
-    else if(cmHasLiteralPrefix(args[i], "--progress-dir="))
-      {
+    } else if (cmHasLiteralPrefix(args[i], "--progress-dir=")) {
       progressDir = args[i].substr(15);
-      }
-    else if(cmHasLiteralPrefix(args[i], "--progress-num="))
-      {
-      if (!progressDir.empty())
-        {
+    } else if (cmHasLiteralPrefix(args[i], "--progress-num=")) {
+      if (!progressDir.empty()) {
         std::string const& progressNum = args[i].substr(15);
         cmcmdProgressReport(progressDir, progressNum);
-        }
       }
-    else if(args[i] == "--normal")
-      {
+    } else if (args[i] == "--normal") {
       color = cmsysTerminal_Color_Normal;
-      }
-    else if(args[i] == "--black")
-      {
+    } else if (args[i] == "--black") {
       color = cmsysTerminal_Color_ForegroundBlack;
-      }
-    else if(args[i] == "--red")
-      {
+    } else if (args[i] == "--red") {
       color = cmsysTerminal_Color_ForegroundRed;
-      }
-    else if(args[i] == "--green")
-      {
+    } else if (args[i] == "--green") {
       color = cmsysTerminal_Color_ForegroundGreen;
-      }
-    else if(args[i] == "--yellow")
-      {
+    } else if (args[i] == "--yellow") {
       color = cmsysTerminal_Color_ForegroundYellow;
-      }
-    else if(args[i] == "--blue")
-      {
+    } else if (args[i] == "--blue") {
       color = cmsysTerminal_Color_ForegroundBlue;
-      }
-    else if(args[i] == "--magenta")
-      {
+    } else if (args[i] == "--magenta") {
       color = cmsysTerminal_Color_ForegroundMagenta;
-      }
-    else if(args[i] == "--cyan")
-      {
+    } else if (args[i] == "--cyan") {
       color = cmsysTerminal_Color_ForegroundCyan;
-      }
-    else if(args[i] == "--white")
-      {
+    } else if (args[i] == "--white") {
       color = cmsysTerminal_Color_ForegroundWhite;
-      }
-    else if(args[i] == "--bold")
-      {
+    } else if (args[i] == "--bold") {
       color |= cmsysTerminal_Color_ForegroundBold;
-      }
-    else if(args[i] == "--no-newline")
-      {
+    } else if (args[i] == "--no-newline") {
       newline = false;
-      }
-    else if(args[i] == "--newline")
-      {
+    } else if (args[i] == "--newline") {
       newline = true;
-      }
-    else
-      {
+    } else {
       // Color is enabled.  Print with the current color.
-      cmSystemTools::MakefileColorEcho(color, args[i].c_str(),
-                                       newline, enabled);
-      }
+      cmSystemTools::MakefileColorEcho(color, args[i].c_str(), newline,
+                                       enabled);
     }
+  }
 
   return 0;
 }
@@ -1326,25 +1083,21 @@ int cmcmd::ExecuteLinkScript(std::vector<std::string>& args)
   //   argv[2] == <link-script-name>
   //   argv[3] == --verbose=?
   bool verbose = false;
-  if(args.size() >= 4)
-    {
-    if(args[3].find("--verbose=") == 0)
-      {
-      if(!cmSystemTools::IsOff(args[3].substr(10).c_str()))
-        {
+  if (args.size() >= 4) {
+    if (args[3].find("--verbose=") == 0) {
+      if (!cmSystemTools::IsOff(args[3].substr(10).c_str())) {
         verbose = true;
-        }
       }
     }
+  }
 
   // Allocate a process instance.
   cmsysProcess* cp = cmsysProcess_New();
-  if(!cp)
-    {
+  if (!cp) {
     std::cerr << "Error allocating process instance in link script."
               << std::endl;
     return 1;
-    }
+  }
 
   // Children should share stdout and stderr with this process.
   cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDOUT, 1);
@@ -1355,50 +1108,42 @@ int cmcmd::ExecuteLinkScript(std::vector<std::string>& args)
 
   // Read command lines from the script.
   cmsys::ifstream fin(args[2].c_str());
-  if(!fin)
-    {
-    std::cerr << "Error opening link script \""
-              << args[2] << "\"" << std::endl;
+  if (!fin) {
+    std::cerr << "Error opening link script \"" << args[2] << "\""
+              << std::endl;
     return 1;
-    }
+  }
 
   // Run one command at a time.
   std::string command;
   int result = 0;
-  while(result == 0 && cmSystemTools::GetLineFromStream(fin, command))
-    {
+  while (result == 0 && cmSystemTools::GetLineFromStream(fin, command)) {
     // Skip empty command lines.
-    if(command.find_first_not_of(" \t") == command.npos)
-      {
+    if (command.find_first_not_of(" \t") == command.npos) {
       continue;
-      }
+    }
 
     // Setup this command line.
-    const char* cmd[2] = {command.c_str(), 0};
+    const char* cmd[2] = { command.c_str(), 0 };
     cmsysProcess_SetCommand(cp, cmd);
 
     // Report the command if verbose output is enabled.
-    if(verbose)
-      {
+    if (verbose) {
       std::cout << command << std::endl;
-      }
+    }
 
     // Run the command and wait for it to exit.
     cmsysProcess_Execute(cp);
     cmsysProcess_WaitForExit(cp, 0);
 
     // Report failure if any.
-    switch(cmsysProcess_GetState(cp))
-      {
-      case cmsysProcess_State_Exited:
-        {
+    switch (cmsysProcess_GetState(cp)) {
+      case cmsysProcess_State_Exited: {
         int value = cmsysProcess_GetExitValue(cp);
-        if(value != 0)
-          {
+        if (value != 0) {
           result = value;
-          }
         }
-        break;
+      } break;
       case cmsysProcess_State_Exception:
         std::cerr << "Error running link command: "
                   << cmsysProcess_GetExceptionString(cp) << std::endl;
@@ -1411,8 +1156,8 @@ int cmcmd::ExecuteLinkScript(std::vector<std::string>& args)
         break;
       default:
         break;
-      };
-    }
+    };
+  }
 
   // Free the process instance.
   cmsysProcess_Delete(cp);
@@ -1426,15 +1171,14 @@ int cmcmd::WindowsCEEnvironment(const char* version, const std::string& name)
 #if defined(CMAKE_HAVE_VS_GENERATORS)
   cmVisualStudioWCEPlatformParser parser(name.c_str());
   parser.ParseVersion(version);
-  if (parser.Found())
-    {
+  if (parser.Found()) {
     std::cout << "@echo off" << std::endl;
     std::cout << "echo Environment Selection: " << name << std::endl;
     std::cout << "set PATH=" << parser.GetPathDirectories() << std::endl;
-    std::cout << "set INCLUDE=" << parser.GetIncludeDirectories() <<std::endl;
-    std::cout << "set LIB=" << parser.GetLibraryDirectories() <<std::endl;
+    std::cout << "set INCLUDE=" << parser.GetIncludeDirectories() << std::endl;
+    std::cout << "set LIB=" << parser.GetLibraryDirectories() << std::endl;
     return 0;
-    }
+  }
 #else
   (void)version;
 #endif
@@ -1456,16 +1200,19 @@ class cmVSLink
   std::string ManifestFileRC;
   std::string ManifestFileRes;
   std::string TargetFile;
+
 public:
   cmVSLink(int type, bool verbose)
     : Type(type)
     , Verbose(verbose)
     , Incremental(false)
     , LinkGeneratesManifest(true)
-    {}
+  {
+  }
   bool Parse(std::vector<std::string>::const_iterator argBeg,
              std::vector<std::string>::const_iterator argEnd);
   int Link();
+
 private:
   int LinkIncremental();
   int LinkNonIncremental();
@@ -1477,82 +1224,65 @@ private:
 // still works.
 int cmcmd::VisualStudioLink(std::vector<std::string>& args, int type)
 {
-  if(args.size() < 2)
-    {
+  if (args.size() < 2) {
     return -1;
-    }
-  bool verbose = cmSystemTools::GetEnv("VERBOSE")? true:false;
+  }
+  bool verbose = cmSystemTools::GetEnv("VERBOSE") ? true : false;
   std::vector<std::string> expandedArgs;
-  for(std::vector<std::string>::iterator i = args.begin();
-      i != args.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = args.begin(); i != args.end();
+       ++i) {
     // check for nmake temporary files
-    if((*i)[0] == '@' && i->find("@CMakeFiles") != 0 )
-      {
+    if ((*i)[0] == '@' && i->find("@CMakeFiles") != 0) {
       cmsys::ifstream fin(i->substr(1).c_str());
       std::string line;
-      while(cmSystemTools::GetLineFromStream(fin,
-                                             line))
-        {
+      while (cmSystemTools::GetLineFromStream(fin, line)) {
         cmSystemTools::ParseWindowsCommandLine(line.c_str(), expandedArgs);
-        }
       }
-    else
-      {
+    } else {
       expandedArgs.push_back(*i);
-      }
     }
+  }
 
   cmVSLink vsLink(type, verbose);
-  if (!vsLink.Parse(expandedArgs.begin()+2, expandedArgs.end()))
-    {
+  if (!vsLink.Parse(expandedArgs.begin() + 2, expandedArgs.end())) {
     return -1;
-    }
+  }
   return vsLink.Link();
 }
 
-static bool RunCommand(const char* comment,
-                       std::vector<std::string>& command,
-                       bool verbose,
-                       int* retCodeOut = 0)
+static bool RunCommand(const char* comment, std::vector<std::string>& command,
+                       bool verbose, int* retCodeOut = 0)
 {
-  if(verbose)
-    {
+  if (verbose) {
     std::cout << comment << ":\n";
     std::cout << cmJoin(command, " ") << "\n";
-    }
+  }
   std::string output;
-  int retCode =0;
+  int retCode = 0;
   // use rc command to create .res file
-  bool res = cmSystemTools::RunSingleCommand(command,
-                                             &output, &output,
-                                             &retCode, 0,
-                                             cmSystemTools::OUTPUT_NONE);
+  bool res = cmSystemTools::RunSingleCommand(
+    command, &output, &output, &retCode, 0, cmSystemTools::OUTPUT_NONE);
   // always print the output of the command, unless
   // it is the dumb rc command banner, but if the command
   // returned an error code then print the output anyway as
   // the banner may be mixed with some other important information.
-  if(output.find("Resource Compiler Version") == output.npos
-     || !res || retCode)
-    {
+  if (output.find("Resource Compiler Version") == output.npos || !res ||
+      retCode) {
     std::cout << output;
-    }
-  if (!res)
-    {
+  }
+  if (!res) {
     std::cout << comment << " failed to run." << std::endl;
     return false;
-    }
+  }
   // if retCodeOut is requested then always return true
   // and set the retCodeOut to retCode
-  if(retCodeOut)
-    {
+  if (retCodeOut) {
     *retCodeOut = retCode;
     return true;
-    }
-  if(retCode != 0)
-    {
+  }
+  if (retCode != 0) {
     std::cout << comment << " failed. with " << retCode << "\n";
-    }
+  }
   return retCode == 0;
 }
 
@@ -1562,97 +1292,71 @@ bool cmVSLink::Parse(std::vector<std::string>::const_iterator argBeg,
   // Parse our own arguments.
   std::string intDir;
   std::vector<std::string>::const_iterator arg = argBeg;
-  while (arg != argEnd && cmHasLiteralPrefix(*arg, "-"))
-    {
-    if (*arg == "--")
-      {
+  while (arg != argEnd && cmHasLiteralPrefix(*arg, "-")) {
+    if (*arg == "--") {
       ++arg;
       break;
-      }
-    else if (*arg == "--manifests")
-      {
-      for (++arg; arg != argEnd && !cmHasLiteralPrefix(*arg, "-"); ++arg)
-        {
+    } else if (*arg == "--manifests") {
+      for (++arg; arg != argEnd && !cmHasLiteralPrefix(*arg, "-"); ++arg) {
         this->UserManifests.push_back(*arg);
-        }
       }
-    else if (cmHasLiteralPrefix(*arg, "--intdir="))
-      {
+    } else if (cmHasLiteralPrefix(*arg, "--intdir=")) {
       intDir = arg->substr(9);
       ++arg;
-      }
-    else
-      {
+    } else {
       std::cerr << "unknown argument '" << *arg << "'\n";
       return false;
-      }
     }
-  if (intDir.empty())
-    {
+  }
+  if (intDir.empty()) {
     return false;
-    }
+  }
 
   // The rest of the arguments form the link command.
-  if (arg == argEnd)
-    {
+  if (arg == argEnd) {
     return false;
-    }
+  }
   this->LinkCommand.insert(this->LinkCommand.begin(), arg, argEnd);
 
   // Parse the link command to extract information we need.
-  for (; arg != argEnd; ++arg)
-    {
-    if (cmSystemTools::Strucmp(arg->c_str(), "/INCREMENTAL:YES") == 0)
-      {
+  for (; arg != argEnd; ++arg) {
+    if (cmSystemTools::Strucmp(arg->c_str(), "/INCREMENTAL:YES") == 0) {
       this->Incremental = true;
-      }
-    else if (cmSystemTools::Strucmp(arg->c_str(), "/INCREMENTAL") == 0)
-      {
+    } else if (cmSystemTools::Strucmp(arg->c_str(), "/INCREMENTAL") == 0) {
       this->Incremental = true;
-      }
-    else if (cmSystemTools::Strucmp(arg->c_str(), "/MANIFEST:NO") == 0)
-      {
+    } else if (cmSystemTools::Strucmp(arg->c_str(), "/MANIFEST:NO") == 0) {
       this->LinkGeneratesManifest = false;
-      }
-    else if (cmHasLiteralPrefix(*arg, "/Fe"))
-      {
+    } else if (cmHasLiteralPrefix(*arg, "/Fe")) {
       this->TargetFile = arg->substr(3);
-      }
-    else if (cmHasLiteralPrefix(*arg, "/out:"))
-      {
+    } else if (cmHasLiteralPrefix(*arg, "/out:")) {
       this->TargetFile = arg->substr(5);
-      }
     }
+  }
 
-  if (this->TargetFile.empty())
-    {
+  if (this->TargetFile.empty()) {
     return false;
-    }
+  }
 
   this->ManifestFile = intDir + "/embed.manifest";
   this->LinkerManifestFile = intDir + "/intermediate.manifest";
 
-  if (this->Incremental)
-    {
+  if (this->Incremental) {
     // We will compile a resource containing the manifest and
     // pass it to the link command.
     this->ManifestFileRC = intDir + "/manifest.rc";
     this->ManifestFileRes = intDir + "/manifest.res";
-    }
-  else if (this->UserManifests.empty())
-    {
+  } else if (this->UserManifests.empty()) {
     // Prior to support for user-specified manifests CMake placed the
     // linker-generated manifest next to the binary (as if it were not to be
     // embedded) when not linking incrementally.  Preserve this behavior.
     this->ManifestFile = this->TargetFile + ".manifest";
     this->LinkerManifestFile = this->ManifestFile;
-    }
+  }
 
-  if (this->LinkGeneratesManifest)
-    {
+  if (this->LinkGeneratesManifest) {
     this->LinkCommand.push_back("/MANIFEST");
     this->LinkCommand.push_back("/MANIFESTFILE:" + this->LinkerManifestFile);
-    }
+  }
 
   return true;
 }
@@ -1660,25 +1364,19 @@ bool cmVSLink::Parse(std::vector<std::string>::const_iterator argBeg,
 int cmVSLink::Link()
 {
   if (this->Incremental &&
-      (this->LinkGeneratesManifest || !this->UserManifests.empty()))
-    {
-    if (this->Verbose)
-      {
+      (this->LinkGeneratesManifest || !this->UserManifests.empty())) {
+    if (this->Verbose) {
       std::cout << "Visual Studio Incremental Link with embedded manifests\n";
-      }
-    return LinkIncremental();
     }
-  if (this->Verbose)
-    {
-    if (!this->Incremental)
-      {
+    return LinkIncremental();
+  }
+  if (this->Verbose) {
+    if (!this->Incremental) {
       std::cout << "Visual Studio Non-Incremental Link\n";
-      }
-    else
-      {
+    } else {
       std::cout << "Visual Studio Incremental Link without manifests\n";
-      }
     }
+  }
   return LinkNonIncremental();
 }
 
@@ -1710,91 +1408,81 @@ int cmVSLink::LinkIncremental()
   // Create a resource file referencing the manifest.
   std::string absManifestFile =
     cmSystemTools::CollapseFullPath(this->ManifestFile);
-  if (this->Verbose)
-    {
+  if (this->Verbose) {
     std::cout << "Create " << this->ManifestFileRC << "\n";
-    }
+  }
   {
-  cmsys::ofstream fout(this->ManifestFileRC.c_str());
-  if (!fout)
-    {
-    return -1;
+    cmsys::ofstream fout(this->ManifestFileRC.c_str());
+    if (!fout) {
+      return -1;
     }
-  fout << this->Type << " /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ "
-    "24 /* RT_MANIFEST */ \"" << absManifestFile << "\"";
+    fout << this->Type << " /* CREATEPROCESS_MANIFEST_RESOURCE_ID */ "
+                          "24 /* RT_MANIFEST */ \""
+         << absManifestFile << "\"";
   }
 
   // If we have not previously generated a manifest file,
   // generate an empty one so the resource compiler succeeds.
-  if (!cmSystemTools::FileExists(this->ManifestFile))
-    {
-    if (this->Verbose)
-      {
+  if (!cmSystemTools::FileExists(this->ManifestFile)) {
+    if (this->Verbose) {
       std::cout << "Create empty: " << this->ManifestFile << "\n";
-      }
-    cmsys::ofstream foutTmp(this->ManifestFile.c_str());
     }
+    cmsys::ofstream foutTmp(this->ManifestFile.c_str());
+  }
 
   // Compile the resource file.
   std::vector<std::string> rcCommand;
   rcCommand.push_back(cmSystemTools::FindProgram("rc.exe"));
   rcCommand.push_back("/fo" + this->ManifestFileRes);
   rcCommand.push_back(this->ManifestFileRC);
-  if (!RunCommand("RC Pass 1", rcCommand, this->Verbose))
-    {
+  if (!RunCommand("RC Pass 1", rcCommand, this->Verbose)) {
     return -1;
-    }
+  }
 
   // Tell the linker to use our manifest compiled into a resource.
   this->LinkCommand.push_back(this->ManifestFileRes);
 
   // Run the link command (possibly generates intermediate manifest).
-  if (!RunCommand("LINK Pass 1", this->LinkCommand, this->Verbose))
-    {
+  if (!RunCommand("LINK Pass 1", this->LinkCommand, this->Verbose)) {
     return -1;
-    }
+  }
 
   // Run the manifest tool to create the final manifest.
   int mtRet = this->RunMT("/out:" + this->ManifestFile, true);
 
   // If mt returns 1090650113 (or 187 on a posix host) then it updated the
   // manifest file so we need to embed it again.  Otherwise we are done.
-  if (mtRet != 1090650113 && mtRet != 187)
-    {
+  if (mtRet != 1090650113 && mtRet != 187) {
     return mtRet;
-    }
+  }
 
   // Compile the resource file again.
-  if (!RunCommand("RC Pass 2", rcCommand, this->Verbose))
-    {
+  if (!RunCommand("RC Pass 2", rcCommand, this->Verbose)) {
     return -1;
-    }
+  }
 
   // Link incrementally again to use the updated resource.
-  if (!RunCommand("FINAL LINK", this->LinkCommand, this->Verbose))
-    {
+  if (!RunCommand("FINAL LINK", this->LinkCommand, this->Verbose)) {
     return -1;
-    }
+  }
   return 0;
 }
 
 int cmVSLink::LinkNonIncremental()
 {
   // Run the link command (possibly generates intermediate manifest).
-  if (!RunCommand("LINK", this->LinkCommand, this->Verbose))
-    {
+  if (!RunCommand("LINK", this->LinkCommand, this->Verbose)) {
     return -1;
-    }
+  }
 
   // If we have no manifest files we are done.
-  if (!this->LinkGeneratesManifest && this->UserManifests.empty())
-    {
+  if (!this->LinkGeneratesManifest && this->UserManifests.empty()) {
     return 0;
-    }
+  }
 
   // Run the manifest tool to embed the final manifest in the binary.
   std::string mtOut =
-    "/outputresource:" + this->TargetFile + (this->Type == 1? ";#1" : ";#2");
+    "/outputresource:" + this->TargetFile + (this->Type == 1 ? ";#1" : ";#2");
   return this->RunMT(mtOut, false);
 }
 
@@ -1804,23 +1492,20 @@ int cmVSLink::RunMT(std::string const& out, bool notify)
   mtCommand.push_back(cmSystemTools::FindProgram("mt.exe"));
   mtCommand.push_back("/nologo");
   mtCommand.push_back("/manifest");
-  if (this->LinkGeneratesManifest)
-    {
+  if (this->LinkGeneratesManifest) {
     mtCommand.push_back(this->LinkerManifestFile);
-    }
-  mtCommand.insert(mtCommand.end(),
-                   this->UserManifests.begin(), this->UserManifests.end());
+  }
+  mtCommand.insert(mtCommand.end(), this->UserManifests.begin(),
+                   this->UserManifests.end());
   mtCommand.push_back(out);
-  if (notify)
-    {
+  if (notify) {
     // Add an undocumented option that enables a special return
     // code to notify us when the manifest is modified.
     mtCommand.push_back("/notify_update");
-    }
+  }
   int mtRet = 0;
-  if (!RunCommand("MT", mtCommand, this->Verbose, &mtRet))
-    {
+  if (!RunCommand("MT", mtCommand, this->Verbose, &mtRet)) {
     return -1;
-    }
+  }
   return mtRet;
 }
diff --git a/Source/cmcmd.h b/Source/cmcmd.h
index 64b2406..8da2103 100644
--- a/Source/cmcmd.h
+++ b/Source/cmcmd.h
@@ -18,14 +18,13 @@
 class cmcmd
 {
 public:
-
   /**
    * Execute commands during the build process. Supports options such
    * as echo, remove file etc.
    */
   static int ExecuteCMakeCommand(std::vector<std::string>&);
-protected:
 
+protected:
   static int SymlinkLibrary(std::vector<std::string>& args);
   static int SymlinkExecutable(std::vector<std::string>& args);
   static bool SymlinkInternal(std::string const& file,
diff --git a/Source/ctest.cxx b/Source/ctest.cxx
index 23b9ec4..4edd62e 100644
--- a/Source/ctest.cxx
+++ b/Source/ctest.cxx
@@ -20,104 +20,99 @@
 #include "CTest/cmCTestScriptHandler.h"
 #include "cmsys/Encoding.hxx"
 
-static const char * cmDocumentationName[][2] =
-{
-  {0,
-   "  ctest - Testing driver provided by CMake."},
-  {0,0}
+static const char* cmDocumentationName[][2] = {
+  { 0, "  ctest - Testing driver provided by CMake." },
+  { 0, 0 }
 };
 
-static const char * cmDocumentationUsage[][2] =
-{
-  {0,
-   "  ctest [options]"},
-  {0,0}
-};
-
-static const char * cmDocumentationOptions[][2] =
-{
-  {"-C <cfg>, --build-config <cfg>", "Choose configuration to test."},
-  {"-V,--verbose", "Enable verbose output from tests."},
-  {"-VV,--extra-verbose", "Enable more verbose output from tests."},
-  {"--debug", "Displaying more verbose internals of CTest."},
-  {"--output-on-failure", "Output anything outputted by the test program "
-    "if the test should fail."},
-  {"--test-output-size-passed <size>", "Limit the output for passed tests "
-    "to <size> bytes"},
-  {"--test-output-size-failed <size>", "Limit the output for failed tests "
-    "to <size> bytes"},
-  {"-F", "Enable failover."},
-  {"-j <jobs>, --parallel <jobs>", "Run the tests in parallel using the "
-   "given number of jobs."},
-  {"-Q,--quiet", "Make ctest quiet."},
-  {"-O <file>, --output-log <file>", "Output to log file"},
-  {"-N,--show-only", "Disable actual execution of tests."},
-  {"-L <regex>, --label-regex <regex>", "Run tests with labels matching "
-   "regular expression."},
-  {"-R <regex>, --tests-regex <regex>", "Run tests matching regular "
-   "expression."},
-  {"-E <regex>, --exclude-regex <regex>", "Exclude tests matching regular "
-   "expression."},
-  {"-LE <regex>, --label-exclude <regex>", "Exclude tests with labels "
-   "matching regular expression."},
-  {"-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test"},
-  {"-D <var>:<type>=<value>", "Define a variable for script mode"},
-  {"-M <model>, --test-model <model>", "Sets the model for a dashboard"},
-  {"-T <action>, --test-action <action>", "Sets the dashboard action to "
-   "perform"},
-  {"--track <track>", "Specify the track to submit dashboard to"},
-  {"-S <script>, --script <script>", "Execute a dashboard for a "
-   "configuration"},
-  {"-SP <script>, --script-new-process <script>", "Execute a dashboard for a "
-   "configuration"},
-  {"-A <file>, --add-notes <file>", "Add a notes file with submission"},
-  {"-I [Start,End,Stride,test#,test#|Test file], --tests-information",
-   "Run a specific number of tests by number."},
-  {"-U, --union", "Take the Union of -I and -R"},
-  {"--rerun-failed", "Run only the tests that failed previously"},
-  {"--repeat-until-fail <n>", "Require each test to run <n> "
-   "times without failing in order to pass"},
-  {"--max-width <width>", "Set the max width for a test name to output"},
-  {"--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1."},
-  {"--no-label-summary", "Disable timing summary information for labels."},
-  {"--build-and-test", "Configure, build and run a test."},
-  {"--build-target", "Specify a specific target to build."},
-  {"--build-nocmake", "Run the build without running cmake first."},
-  {"--build-run-dir", "Specify directory to run programs from."},
-  {"--build-two-config", "Run CMake twice"},
-  {"--build-exe-dir", "Specify the directory for the executable."},
-  {"--build-generator", "Specify the generator to use."},
-  {"--build-generator-platform", "Specify the generator-specific platform."},
-  {"--build-generator-toolset", "Specify the generator-specific toolset."},
-  {"--build-project", "Specify the name of the project to build."},
-  {"--build-makeprogram", "Specify the make program to use."},
-  {"--build-noclean", "Skip the make clean step."},
-  {"--build-config-sample",
-   "A sample executable to use to determine the configuration"},
-  {"--build-options", "Add extra options to the build step."},
-
-  {"--test-command", "The test to run with the --build-and-test option."},
-  {"--test-timeout", "The time limit in seconds, internal use only."},
-  {"--test-load", "CPU load threshold for starting new parallel tests."},
-  {"--tomorrow-tag", "Nightly or experimental starts with next day tag."},
-  {"--ctest-config", "The configuration file used to initialize CTest state "
-   "when submitting dashboards."},
-  {"--overwrite", "Overwrite CTest configuration option."},
-  {"--extra-submit <file>[;<file>]", "Submit extra files to the dashboard."},
-  {"--force-new-ctest-process", "Run child CTest instances as new processes"},
-  {"--schedule-random", "Use a random order for scheduling tests"},
-  {"--submit-index", "Submit individual dashboard tests with specific index"},
-  {"--timeout <seconds>", "Set a global timeout on all tests."},
-  {"--stop-time <time>",
-   "Set a time at which all tests should stop running."},
-  {"--http1.0", "Submit using HTTP 1.0."},
-  {"--no-compress-output", "Do not compress test output when submitting."},
-  {"--print-labels", "Print all available test labels."},
-  {0,0}
+static const char* cmDocumentationUsage[][2] = { { 0, "  ctest [options]" },
+                                                 { 0, 0 } };
+
+static const char* cmDocumentationOptions[][2] = {
+  { "-C <cfg>, --build-config <cfg>", "Choose configuration to test." },
+  { "-V,--verbose", "Enable verbose output from tests." },
+  { "-VV,--extra-verbose", "Enable more verbose output from tests." },
+  { "--debug", "Displaying more verbose internals of CTest." },
+  { "--output-on-failure", "Output anything outputted by the test program "
+                           "if the test should fail." },
+  { "--test-output-size-passed <size>", "Limit the output for passed tests "
+                                        "to <size> bytes" },
+  { "--test-output-size-failed <size>", "Limit the output for failed tests "
+                                        "to <size> bytes" },
+  { "-F", "Enable failover." },
+  { "-j <jobs>, --parallel <jobs>", "Run the tests in parallel using the "
+                                    "given number of jobs." },
+  { "-Q,--quiet", "Make ctest quiet." },
+  { "-O <file>, --output-log <file>", "Output to log file" },
+  { "-N,--show-only", "Disable actual execution of tests." },
+  { "-L <regex>, --label-regex <regex>", "Run tests with labels matching "
+                                         "regular expression." },
+  { "-R <regex>, --tests-regex <regex>", "Run tests matching regular "
+                                         "expression." },
+  { "-E <regex>, --exclude-regex <regex>", "Exclude tests matching regular "
+                                           "expression." },
+  { "-LE <regex>, --label-exclude <regex>", "Exclude tests with labels "
+                                            "matching regular expression." },
+  { "-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test" },
+  { "-D <var>:<type>=<value>", "Define a variable for script mode" },
+  { "-M <model>, --test-model <model>", "Sets the model for a dashboard" },
+  { "-T <action>, --test-action <action>", "Sets the dashboard action to "
+                                           "perform" },
+  { "--track <track>", "Specify the track to submit dashboard to" },
+  { "-S <script>, --script <script>", "Execute a dashboard for a "
+                                      "configuration" },
+  { "-SP <script>, --script-new-process <script>", "Execute a dashboard for a "
+                                                   "configuration" },
+  { "-A <file>, --add-notes <file>", "Add a notes file with submission" },
+  { "-I [Start,End,Stride,test#,test#|Test file], --tests-information",
+    "Run a specific number of tests by number." },
+  { "-U, --union", "Take the Union of -I and -R" },
+  { "--rerun-failed", "Run only the tests that failed previously" },
+  { "--repeat-until-fail <n>", "Require each test to run <n> "
+                               "times without failing in order to pass" },
+  { "--max-width <width>", "Set the max width for a test name to output" },
+  { "--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1." },
+  { "--no-label-summary", "Disable timing summary information for labels." },
+  { "--build-and-test", "Configure, build and run a test." },
+  { "--build-target", "Specify a specific target to build." },
+  { "--build-nocmake", "Run the build without running cmake first." },
+  { "--build-run-dir", "Specify directory to run programs from." },
+  { "--build-two-config", "Run CMake twice" },
+  { "--build-exe-dir", "Specify the directory for the executable." },
+  { "--build-generator", "Specify the generator to use." },
+  { "--build-generator-platform", "Specify the generator-specific platform." },
+  { "--build-generator-toolset", "Specify the generator-specific toolset." },
+  { "--build-project", "Specify the name of the project to build." },
+  { "--build-makeprogram", "Specify the make program to use." },
+  { "--build-noclean", "Skip the make clean step." },
+  { "--build-config-sample",
+    "A sample executable to use to determine the configuration" },
+  { "--build-options", "Add extra options to the build step." },
+
+  { "--test-command", "The test to run with the --build-and-test option." },
+  { "--test-timeout", "The time limit in seconds, internal use only." },
+  { "--test-load", "CPU load threshold for starting new parallel tests." },
+  { "--tomorrow-tag", "Nightly or experimental starts with next day tag." },
+  { "--ctest-config", "The configuration file used to initialize CTest state "
+                      "when submitting dashboards." },
+  { "--overwrite", "Overwrite CTest configuration option." },
+  { "--extra-submit <file>[;<file>]", "Submit extra files to the dashboard." },
+  { "--force-new-ctest-process",
+    "Run child CTest instances as new processes" },
+  { "--schedule-random", "Use a random order for scheduling tests" },
+  { "--submit-index",
+    "Submit individual dashboard tests with specific index" },
+  { "--timeout <seconds>", "Set a global timeout on all tests." },
+  { "--stop-time <time>",
+    "Set a time at which all tests should stop running." },
+  { "--http1.0", "Submit using HTTP 1.0." },
+  { "--no-compress-output", "Do not compress test output when submitting." },
+  { "--print-labels", "Print all available test labels." },
+  { 0, 0 }
 };
 
 // this is a test driver program for cmCTest.
-int main (int argc, char const* const* argv)
+int main(int argc, char const* const* argv)
 {
   cmsys::Encoding::CommandLineArguments encoding_args =
     cmsys::Encoding::CommandLineArguments::Main(argc, argv);
@@ -129,37 +124,34 @@ int main (int argc, char const* const* argv)
   cmSystemTools::FindCMakeResources(argv[0]);
 
   // Dispatch 'ctest --launch' mode directly.
-  if(argc >= 2 && strcmp(argv[1], "--launch") == 0)
-    {
+  if (argc >= 2 && strcmp(argv[1], "--launch") == 0) {
     return cmCTestLaunch::Main(argc, argv);
-    }
+  }
 
   cmCTest inst;
 
-  if (cmSystemTools::GetCurrentWorkingDirectory().empty())
-    {
+  if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
     cmCTestLog(&inst, ERROR_MESSAGE,
-      "Current working directory cannot be established." << std::endl);
+               "Current working directory cannot be established."
+                 << std::endl);
     return 1;
-    }
+  }
 
   // If there is a testing input file, check for documentation options
   // only if there are actually arguments.  We want running without
   // arguments to run tests.
-  if(argc > 1 || !(cmSystemTools::FileExists("CTestTestfile.cmake") ||
-                   cmSystemTools::FileExists("DartTestfile.txt")))
-    {
-    if(argc == 1)
-      {
+  if (argc > 1 ||
+      !(cmSystemTools::FileExists("CTestTestfile.cmake") ||
+        cmSystemTools::FileExists("DartTestfile.txt"))) {
+    if (argc == 1) {
       cmCTestLog(&inst, ERROR_MESSAGE, "*********************************"
-        << std::endl
-        << "No test configuration file found!" << std::endl
-        << "*********************************" << std::endl);
-      }
+                   << std::endl
+                   << "No test configuration file found!" << std::endl
+                   << "*********************************" << std::endl);
+    }
     cmDocumentation doc;
     doc.addCTestStandardDocSections();
-    if(doc.CheckOptions(argc, argv))
-      {
+    if (doc.CheckOptions(argc, argv)) {
       cmake hcm;
       hcm.SetHomeDirectory("");
       hcm.SetHomeOutputDirectory("");
@@ -167,33 +159,31 @@ int main (int argc, char const* const* argv)
 
       // Construct and print requested documentation.
       cmCTestScriptHandler* ch =
-                 static_cast<cmCTestScriptHandler*>(inst.GetHandler("script"));
+        static_cast<cmCTestScriptHandler*>(inst.GetHandler("script"));
       ch->CreateCMake();
 
       doc.SetShowGenerators(false);
       doc.SetName("ctest");
-      doc.SetSection("Name",cmDocumentationName);
-      doc.SetSection("Usage",cmDocumentationUsage);
-      doc.PrependSection("Options",cmDocumentationOptions);
+      doc.SetSection("Name", cmDocumentationName);
+      doc.SetSection("Usage", cmDocumentationUsage);
+      doc.PrependSection("Options", cmDocumentationOptions);
 #ifdef cout
-#  undef cout
+#undef cout
 #endif
-      return doc.PrintRequestedDocumentation(std::cout)? 0:1;
+      return doc.PrintRequestedDocumentation(std::cout) ? 0 : 1;
 #define cout no_cout_use_cmCTestLog
-      }
     }
+  }
 
   // copy the args to a vector
   std::vector<std::string> args;
-  for(int i =0; i < argc; ++i)
-    {
+  for (int i = 0; i < argc; ++i) {
     args.push_back(argv[i]);
-    }
+  }
   // run ctest
   std::string output;
-  int res = inst.Run(args,&output);
+  int res = inst.Run(args, &output);
   cmCTestLog(&inst, OUTPUT, output);
 
   return res;
 }
-